Merge poseidon.mysql.com:/home/tomas/mysql-5.0-telco-gca-single-user (11f05ff3) · Commits · Software / OSDI20 Artifacts / mariadb

ndb/src/kernel/blocks/dbtc/Dbtc.hpp

+8 −3

Original line number	Diff line number	Diff line
		@@ -1838,9 +1838,14 @@ private:
		Uint32 transid2);
		void removeMarkerForFailedAPI(Signal* signal, Uint32 nodeId, Uint32 bucket);

		bool getAllowStartTransaction() const {
		if(getNodeState().getSingleUserMode())
		bool getAllowStartTransaction(Uint32 nodeId) const {
		if (unlikely(getNodeState().getSingleUserMode()))
		{
		if (getNodeState().getSingleUserApi() == nodeId)
		return true;
		else
		return false;
		}
		return getNodeState().startLevel < NodeState::SL_STOPPING_2;
		}

ndb/src/kernel/blocks/dbtc/DbtcMain.cpp

+118 −15

Original line number	Diff line number	Diff line
		@@ -1199,16 +1199,14 @@ void Dbtc::execTCSEIZEREQ(Signal* signal)
		const NodeId senderNodeId = refToNode(tapiBlockref);
		const bool local = senderNodeId == getOwnNodeId() \|\| senderNodeId == 0;

		if(!(senderNodeId == getNodeState().getSingleUserApi()) &&
		!getNodeState().getSingleUserMode()) {
		if(!(sl==NodeState::SL_SINGLEUSER &&
		senderNodeId == getNodeState().getSingleUserApi())) {
		{
		{
		if (!(sl == NodeState::SL_STARTED \|\|
		(sl == NodeState::SL_STARTING && local == true))) {
		jam();

		Uint32 errCode;
		if(!(sl == NodeState::SL_SINGLEUSER && local))
		Uint32 errCode = 0;
		if(!local)
		{
		switch(sl){
		case NodeState::SL_STARTING:
		@@ -1216,6 +1214,9 @@ void Dbtc::execTCSEIZEREQ(Signal* signal)
		break;
		case NodeState::SL_STOPPING_1:
		case NodeState::SL_STOPPING_2:
		if (getNodeState().getSingleUserMode() &&
		getNodeState().getSingleUserApi() == senderNodeId)
		break;
		case NodeState::SL_STOPPING_3:
		case NodeState::SL_STOPPING_4:
		if(getNodeState().stopping.systemShutdown)
		@@ -1224,16 +1225,21 @@ void Dbtc::execTCSEIZEREQ(Signal* signal)
		errCode = ZNODE_SHUTDOWN_IN_PROGRESS;
		break;
		case NodeState::SL_SINGLEUSER:
		if (getNodeState().getSingleUserApi() == senderNodeId)
		break;
		errCode = ZCLUSTER_IN_SINGLEUSER_MODE;
		break;
		default:
		errCode = ZWRONG_STATE;
		break;
		}
		if (errCode)
		{
		signal->theData[0] = tapiPointer;
		signal->theData[1] = errCode;
		sendSignal(tapiBlockref, GSN_TCSEIZEREF, signal, 2, JBB);
		return;
		}
		}//if (!(sl == SL_SINGLEUSER))
		} //if
		}
		@@ -1720,8 +1726,14 @@ Dbtc::TCKEY_abort(Signal* signal, int place)
		* Initialize object before starting error handling
		*/
		initApiConnectRec(signal, apiConnectptr.p, true);
		start_failure:
		switch(getNodeState().startLevel){
		case NodeState::SL_STOPPING_2:
		if (getNodeState().getSingleUserMode())
		{
		terrorCode = ZCLUSTER_IN_SINGLEUSER_MODE;
		break;
		}
		case NodeState::SL_STOPPING_3:
		case NodeState::SL_STOPPING_4:
		if(getNodeState().stopping.systemShutdown)
		@@ -1732,6 +1744,12 @@ Dbtc::TCKEY_abort(Signal* signal, int place)
		case NodeState::SL_SINGLEUSER:
		terrorCode = ZCLUSTER_IN_SINGLEUSER_MODE;
		break;
		case NodeState::SL_STOPPING_1:
		if (getNodeState().getSingleUserMode())
		{
		terrorCode = ZCLUSTER_IN_SINGLEUSER_MODE;
		break;
		}
		default:
		terrorCode = ZWRONG_STATE;
		break;
		@@ -1753,6 +1771,13 @@ Dbtc::TCKEY_abort(Signal* signal, int place)
		return;
		}

		case 60:
		{
		jam();
		initApiConnectRec(signal, apiConnectptr.p, true);
		apiConnectptr.p->m_exec_flag = 1;
		goto start_failure;
		}
		default:
		jam();
		systemErrorLab(signal, __LINE__);
		@@ -2481,6 +2506,7 @@ Dbtc::seizeCacheRecord(Signal* signal)
		/*****************************************************************************/
		void Dbtc::execTCKEYREQ(Signal* signal)
		{
		Uint32 sendersNodeId = refToNode(signal->getSendersBlockRef());
		UintR compare_transid1, compare_transid2;
		UintR titcLenAiInTckeyreq;
		UintR TkeyLength;
		@@ -2526,7 +2552,7 @@ void Dbtc::execTCKEYREQ(Signal* signal)
		regApiPtr->m_exec_flag \|= TexecFlag;
		switch (regApiPtr->apiConnectstate) {
		case CS_CONNECTED:{
		if (TstartFlag == 1 && getAllowStartTransaction() == true){
		if (TstartFlag == 1 && getAllowStartTransaction(sendersNodeId) == true){
		//---------------------------------------------------------------------
		// Initialise API connect record if transaction is started.
		//---------------------------------------------------------------------
		@@ -2534,7 +2560,7 @@ void Dbtc::execTCKEYREQ(Signal* signal)
		initApiConnectRec(signal, regApiPtr);
		regApiPtr->m_exec_flag = TexecFlag;
		} else {
		if(getAllowStartTransaction() == true){
		if(getAllowStartTransaction(sendersNodeId) == true){
		/*------------------------------------------------------------------
		* WE EXPECTED A START TRANSACTION. SINCE NO OPERATIONS HAVE BEEN
		* RECEIVED WE INDICATE THIS BY SETTING FIRST_TC_CONNECT TO RNIL TO
		@@ -2544,9 +2570,9 @@ void Dbtc::execTCKEYREQ(Signal* signal)
		return;
		} else {
		/**
		* getAllowStartTransaction() == false
		* getAllowStartTransaction(sendersNodeId) == false
		*/
		TCKEY_abort(signal, 57);
		TCKEY_abort(signal, TexecFlag ? 60 : 57);
		return;
		}//if
		}
		@@ -6161,9 +6187,11 @@ and otherwise we spread it out 310 ms.
		void Dbtc::timeOutLoopStartLab(Signal* signal, Uint32 api_con_ptr)
		{
		Uint32 end_ptr, time_passed, time_out_value, mask_value;
		Uint32 old_mask_value= 0;
		const Uint32 api_con_sz= capiConnectFilesize;
		const Uint32 tc_timer= ctcTimer;
		const Uint32 time_out_param= ctimeOutValue;
		const Uint32 old_time_out_param= c_abortRec.oldTimeOutValue;

		ctimeOutCheckHeartbeat = tc_timer;

		@@ -6184,11 +6212,39 @@ void Dbtc::timeOutLoopStartLab(Signal* signal, Uint32 api_con_ptr)
		jam();
		mask_value= 31;
		}
		if (time_out_param != old_time_out_param &&
		getNodeState().getSingleUserMode())
		{
		// abort during single user mode, use old_mask_value as flag
		// and calculate value to be used for connections with allowed api
		if (old_time_out_param > 300) {
		jam();
		old_mask_value= 63;
		} else if (old_time_out_param < 30) {
		jam();
		old_mask_value= 7;
		} else {
		jam();
		old_mask_value= 31;
		}
		}
		for ( ; api_con_ptr < end_ptr; api_con_ptr++) {
		Uint32 api_timer= getApiConTimer(api_con_ptr);
		jam();
		if (api_timer != 0) {
		time_out_value= time_out_param + (api_con_ptr & mask_value);
		if (unlikely(old_mask_value)) // abort during single user mode
		{
		apiConnectptr.i = api_con_ptr;
		ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord);
		if (getNodeState().getSingleUserApi() ==
		refToNode(apiConnectptr.p->ndbapiBlockref))
		{
		// api allowed during single user, use original timeout
		time_out_value=
		old_time_out_param + (api_con_ptr & old_mask_value);
		}
		}
		time_passed= tc_timer - api_timer;
		if (time_passed > time_out_value)
		{
		@@ -6805,6 +6861,33 @@ void Dbtc::timeOutFoundFragLab(Signal* signal, UintR TscanConPtr)
		c_scan_frag_pool.getPtr(ptr, TscanConPtr);
		DEBUG(TscanConPtr << " timeOutFoundFragLab: scanFragState = "<< ptr.p->scanFragState);

		const Uint32 time_out_param= ctimeOutValue;
		const Uint32 old_time_out_param= c_abortRec.oldTimeOutValue;

		if (unlikely(time_out_param != old_time_out_param &&
		getNodeState().getSingleUserMode()))
		{
		jam();
		ScanRecordPtr scanptr;
		scanptr.i = ptr.p->scanRec;
		ptrCheckGuard(scanptr, cscanrecFileSize, scanRecord);
		ApiConnectRecordPtr TlocalApiConnectptr;
		TlocalApiConnectptr.i = scanptr.p->scanApiRec;
		ptrCheckGuard(TlocalApiConnectptr, capiConnectFilesize, apiConnectRecord);

		if (refToNode(TlocalApiConnectptr.p->ndbapiBlockref) ==
		getNodeState().getSingleUserApi())
		{
		jam();
		Uint32 val = ctcTimer - ptr.p->scanFragTimer;
		if (val <= old_time_out_param)
		{
		jam();
		goto next;
		}
		}
		}

		/-------------------------------------------------------------------------/
		// The scan fragment has expired its timeout. Check its state to decide
		// what to do.
		@@ -6866,6 +6949,7 @@ void Dbtc::timeOutFoundFragLab(Signal* signal, UintR TscanConPtr)
		break;
		}//switch

		next:
		signal->theData[0] = TcContinueB::ZCONTINUE_TIME_OUT_FRAG_CONTROL;
		signal->theData[1] = TscanConPtr + 1;
		sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);
		@@ -8695,6 +8779,14 @@ void Dbtc::execSCAN_TABREQ(Signal* signal)
		}
		}

		if (getNodeState().startLevel == NodeState::SL_SINGLEUSER &&
		getNodeState().getSingleUserApi() !=
		refToNode(apiConnectptr.p->ndbapiBlockref))
		{
		errCode = ZCLUSTER_IN_SINGLEUSER_MODE;
		goto SCAN_TAB_error;
		}

		seizeTcConnect(signal);
		tcConnectptr.p->apiConnect = apiConnectptr.i;
		tcConnectptr.p->tcConnectstate = OS_WAIT_SCAN;
		@@ -11007,7 +11099,7 @@ void Dbtc::execABORT_ALL_REQ(Signal* signal)
		const Uint32 senderData = req->senderData;
		const BlockReference senderRef = req->senderRef;

		if(getAllowStartTransaction() == true && !getNodeState().getSingleUserMode()){
		if(getAllowStartTransaction(refToNode(senderRef)) == true && !getNodeState().getSingleUserMode()){
		jam();

		ref->senderData = senderData;
		@@ -11435,6 +11527,17 @@ void Dbtc::execTCINDXREQ(Signal* signal)
		regApiPtr->transid[1] = tcIndxReq->transId2;
		}//if

		if (getNodeState().startLevel == NodeState::SL_SINGLEUSER &&
		getNodeState().getSingleUserApi() !=
		refToNode(regApiPtr->ndbapiBlockref))
		{
		terrorCode = ZCLUSTER_IN_SINGLEUSER_MODE;
		regApiPtr->m_exec_flag \|= TcKeyReq::getExecuteFlag(tcIndxRequestInfo);
		apiConnectptr = transPtr;
		abortErrorLab(signal);
		return;
		}

		if (ERROR_INSERTED(8036) \|\| !seizeIndexOperation(regApiPtr, indexOpPtr)) {
		jam();
		// Failed to allocate index operation

ndb/src/ndbapi/ClusterMgr.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -405,7 +405,7 @@ ClusterMgr::execAPI_REGCONF(const Uint32 * theData){

		node.m_state = apiRegConf->nodeState;
		if (node.compatible && (node.m_state.startLevel == NodeState::SL_STARTED \|\|
		node.m_state.startLevel == NodeState::SL_SINGLEUSER)){
		node.m_state.getSingleUserMode())){
		set_node_alive(node, true);
		} else {
		set_node_alive(node, false);

ndb/src/ndbapi/Ndb.cpp

+11 −0

Original line number	Diff line number	Diff line
		@@ -56,6 +56,8 @@ NdbTransaction* Ndb::doConnect(Uint32 tConNode)
		// We have connections now to the desired node. Return
		//****************************************************************************
		DBUG_RETURN(getConnectedNdbTransaction(tConNode));
		} else if (TretCode < 0) {
		DBUG_RETURN(NULL);
		} else if (TretCode != 0) {
		tAnyAlive = 1;
		}//if
		@@ -79,6 +81,8 @@ NdbTransaction* Ndb::doConnect(Uint32 tConNode)
		// We have connections now to the desired node. Return
		//****************************************************************************
		DBUG_RETURN(getConnectedNdbTransaction(tNode));
		} else if (TretCode < 0) {
		DBUG_RETURN(NULL);
		} else if (TretCode != 0) {
		tAnyAlive= 1;
		}//if
		@@ -107,6 +111,8 @@ NdbTransaction* Ndb::doConnect(Uint32 tConNode)
		// We have connections now to the desired node. Return
		//****************************************************************************
		DBUG_RETURN(getConnectedNdbTransaction(tNode));
		} else if (TretCode < 0) {
		DBUG_RETURN(NULL);
		} else if (TretCode != 0) {
		tAnyAlive= 1;
		}//if
		@@ -207,6 +213,11 @@ Ndb::NDB_connect(Uint32 tNode)
		DBUG_PRINT("info",
		("unsuccessful connect tReturnCode %d, tNdbCon->Status() %d",
		tReturnCode, tNdbCon->Status()));
		if (theError.code == 299)
		{
		// single user mode so no need to retry with other node
		DBUG_RETURN(-1);
		}
		DBUG_RETURN(3);
		}//if
		}//Ndb::NDB_connect()

ndb/src/ndbapi/NdbRecAttr.cpp

+193 −189

Original line number	Diff line number	Diff line
		@@ -192,8 +192,7 @@ NdbOut& operator<<(NdbOut& out, const NdbRecAttr &r)
		if (j > 0)
		out << " ";

		switch(r.getType())
		{
		switch(r.getType()){
		case NdbDictionary::Column::Bigunsigned:
		out << r.u_64_value();
		break;
		@@ -222,12 +221,12 @@ NdbOut& operator<<(NdbOut& out, const NdbRecAttr &r)
		out << (int) r.char_value();
		break;
		case NdbDictionary::Column::Binary:
		ndbrecattr_print_string(out,"Binary",r.aRef(),r.arraySize());
		j = r.arraySize();
		ndbrecattr_print_string(out,"Binary", r.aRef(), j);
		break;
		case NdbDictionary::Column::Char:
		ndbrecattr_print_string(out,"Char",r.aRef(),r.arraySize());
		j = length;
		ndbrecattr_print_string(out,"Char", r.aRef(), r.arraySize());
		break;
		case NdbDictionary::Column::Varchar:
		{
		@@ -374,8 +373,13 @@ NdbOut& operator<<(NdbOut& out, const NdbRecAttr &r)
		j = length;
		}
		break;

		case NdbDictionary::Column::Undefined:
		case NdbDictionary::Column::Mediumint:
		case NdbDictionary::Column::Mediumunsigned:
		case NdbDictionary::Column::Longvarbinary:
		unknown:
		default: /* no print functions for the rest, just print type */
		//default: /* no print functions for the rest, just print type */
		out << (int) r.getType();
		j = length;
		if (j > 1)