=== modified file 'mysql-test/mysql-test-run.pl' --- a/mysql-test/mysql-test-run.pl 2008-08-10 19:01:25 +0000 +++ b/mysql-test/mysql-test-run.pl 2008-08-26 10:11:03 +0000 @@ -797,11 +797,11 @@ "$glob_basedir/bin"); # Look for language files and charsetsdir, use same share - $path_share= mtr_path_exists("$glob_basedir/share/mysql", - "$glob_basedir/sql/share", - "$glob_basedir/share"); + $path_language= mtr_path_exists("$glob_basedir/share/mysql/english", + "$glob_basedir/sql/share/english", + "$glob_basedir/share/english"); - $path_language= mtr_path_exists("$path_share/english"); + $path_share= dirname($path_language); $path_charsetsdir= mtr_path_exists("$path_share/charsets"); === modified file 'storage/ndb/include/kernel/signaldata/DictSignal.hpp' --- a/storage/ndb/include/kernel/signaldata/DictSignal.hpp 2008-02-06 20:15:14 +0000 +++ b/storage/ndb/include/kernel/signaldata/DictSignal.hpp 2008-08-26 10:07:49 +0000 @@ -81,7 +81,7 @@ * in a later start phase (for non-logged index). On NR, the build * on this node takes place automatically during data copy. */ - RF_NO_BUILD = (1 << 17), + RF_NO_BUILD = (1 << 17) }; === modified file 'storage/ndb/include/ndbapi/NdbIndexScanOperation.hpp' --- a/storage/ndb/include/ndbapi/NdbIndexScanOperation.hpp 2008-08-26 14:05:01 +0000 +++ b/storage/ndb/include/ndbapi/NdbIndexScanOperation.hpp 2008-08-27 14:15:01 +0000 @@ -245,6 +245,7 @@ /* Structure used to collect information about an IndexBound * as it is provided by the old Api setBound() calls */ +public: struct OldApiBoundInfo { Uint32 highestKey; @@ -253,6 +254,7 @@ char* key; }; +private: struct OldApiScanRangeDefinition { /* OldApiBoundInfo used during definition === modified file 'storage/ndb/src/common/transporter/TCP_Transporter.cpp' --- a/storage/ndb/src/common/transporter/TCP_Transporter.cpp 2008-08-26 14:05:01 +0000 +++ b/storage/ndb/src/common/transporter/TCP_Transporter.cpp 2008-08-27 14:15:01 +0000 @@ -163,7 +163,7 @@ int val) { int actual = 0, defval = 0; - socklen_t len = sizeof(actual); + SOCKET_SIZE_TYPE len = sizeof(actual); getsockopt(fd, level, optval, (char*)&defval, &len); === modified file 'storage/ndb/src/kernel/blocks/LocalProxy.cpp' --- a/storage/ndb/src/kernel/blocks/LocalProxy.cpp 2008-08-23 06:11:28 +0000 +++ b/storage/ndb/src/kernel/blocks/LocalProxy.cpp 2008-08-27 08:00:52 +0000 @@ -66,6 +66,16 @@ // GSN_TIME_SIGNAL addRecSignal(GSN_TIME_SIGNAL, &LocalProxy::execTIME_SIGNAL); + + // GSN_CREATE_TRIG_IMPL_REQ + addRecSignal(GSN_CREATE_TRIG_IMPL_REQ, &LocalProxy::execCREATE_TRIG_IMPL_REQ); + addRecSignal(GSN_CREATE_TRIG_IMPL_CONF, &LocalProxy::execCREATE_TRIG_IMPL_CONF); + addRecSignal(GSN_CREATE_TRIG_IMPL_REF, &LocalProxy::execCREATE_TRIG_IMPL_REF); + + // GSN_DROP_TRIG_IMPL_REQ + addRecSignal(GSN_DROP_TRIG_IMPL_REQ, &LocalProxy::execDROP_TRIG_IMPL_REQ); + addRecSignal(GSN_DROP_TRIG_IMPL_CONF, &LocalProxy::execDROP_TRIG_IMPL_CONF); + addRecSignal(GSN_DROP_TRIG_IMPL_REF, &LocalProxy::execDROP_TRIG_IMPL_REF); } LocalProxy::~LocalProxy() @@ -730,4 +740,160 @@ signal, 1, JBB); } +// GSN_CREATE_TRIG_IMPL_REQ + +void +LocalProxy::execCREATE_TRIG_IMPL_REQ(Signal* signal) +{ + if (ssQueue(signal)) + return; + const CreateTrigImplReq* req = (const CreateTrigImplReq*)signal->getDataPtr(); + Ss_CREATE_TRIG_IMPL_REQ& ss = ssSeize(); + ss.m_req = *req; + ndbrequire(signal->getLength() == CreateTrigImplReq::SignalLength); + sendREQ(signal, ss); +} + +void +LocalProxy::sendCREATE_TRIG_IMPL_REQ(Signal* signal, Uint32 ssId) +{ + Ss_CREATE_TRIG_IMPL_REQ& ss = ssFind(ssId); + + CreateTrigImplReq* req = (CreateTrigImplReq*)signal->getDataPtrSend(); + *req = ss.m_req; + req->senderRef = reference(); + req->senderData = ssId; + sendSignal(workerRef(ss.m_worker), GSN_CREATE_TRIG_IMPL_REQ, + signal, CreateTrigImplReq::SignalLength, JBB); +} + +void +LocalProxy::execCREATE_TRIG_IMPL_CONF(Signal* signal) +{ + const CreateTrigImplConf* conf = (const CreateTrigImplConf*)signal->getDataPtr(); + Uint32 ssId = conf->senderData; + Ss_CREATE_TRIG_IMPL_REQ& ss = ssFind(ssId); + recvCONF(signal, ss); +} + +void +LocalProxy::execCREATE_TRIG_IMPL_REF(Signal* signal) +{ + const CreateTrigImplRef* ref = (const CreateTrigImplRef*)signal->getDataPtr(); + Uint32 ssId = ref->senderData; + Ss_CREATE_TRIG_IMPL_REQ& ss = ssFind(ssId); + recvREF(signal, ss, ref->errorCode); +} + +void +LocalProxy::sendCREATE_TRIG_IMPL_CONF(Signal* signal, Uint32 ssId) +{ + Ss_CREATE_TRIG_IMPL_REQ& ss = ssFind(ssId); + BlockReference dictRef = ss.m_req.senderRef; + + if (!lastReply(ss)) + return; + + if (ss.m_error == 0) { + jam(); + CreateTrigImplConf* conf = (CreateTrigImplConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = ss.m_req.senderData; + conf->tableId = ss.m_req.tableId; + conf->triggerId = ss.m_req.triggerId; + conf->triggerInfo = ss.m_req.triggerInfo; + sendSignal(dictRef, GSN_CREATE_TRIG_IMPL_CONF, + signal, CreateTrigImplConf::SignalLength, JBB); + } else { + CreateTrigImplRef* ref = (CreateTrigImplRef*)signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->senderData = ss.m_req.senderData; + ref->tableId = ss.m_req.tableId; + ref->triggerId = ss.m_req.triggerId; + ref->triggerInfo = ss.m_req.triggerInfo; + ref->errorCode = ss.m_error; + sendSignal(dictRef, GSN_CREATE_TRIG_IMPL_REF, + signal, CreateTrigImplRef::SignalLength, JBB); + } + + ssRelease(ssId); +} + +// GSN_DROP_TRIG_IMPL_REQ + +void +LocalProxy::execDROP_TRIG_IMPL_REQ(Signal* signal) +{ + if (ssQueue(signal)) + return; + const DropTrigImplReq* req = (const DropTrigImplReq*)signal->getDataPtr(); + Ss_DROP_TRIG_IMPL_REQ& ss = ssSeize(); + ss.m_req = *req; + ndbrequire(signal->getLength() == DropTrigImplReq::SignalLength); + sendREQ(signal, ss); +} + +void +LocalProxy::sendDROP_TRIG_IMPL_REQ(Signal* signal, Uint32 ssId) +{ + Ss_DROP_TRIG_IMPL_REQ& ss = ssFind(ssId); + + DropTrigImplReq* req = (DropTrigImplReq*)signal->getDataPtrSend(); + *req = ss.m_req; + req->senderRef = reference(); + req->senderData = ssId; + sendSignal(workerRef(ss.m_worker), GSN_DROP_TRIG_IMPL_REQ, + signal, DropTrigImplReq::SignalLength, JBB); +} + +void +LocalProxy::execDROP_TRIG_IMPL_CONF(Signal* signal) +{ + const DropTrigImplConf* conf = (const DropTrigImplConf*)signal->getDataPtr(); + Uint32 ssId = conf->senderData; + Ss_DROP_TRIG_IMPL_REQ& ss = ssFind(ssId); + recvCONF(signal, ss); +} + +void +LocalProxy::execDROP_TRIG_IMPL_REF(Signal* signal) +{ + const DropTrigImplRef* ref = (const DropTrigImplRef*)signal->getDataPtr(); + Uint32 ssId = ref->senderData; + Ss_DROP_TRIG_IMPL_REQ& ss = ssFind(ssId); + recvREF(signal, ss, ref->errorCode); +} + +void +LocalProxy::sendDROP_TRIG_IMPL_CONF(Signal* signal, Uint32 ssId) +{ + Ss_DROP_TRIG_IMPL_REQ& ss = ssFind(ssId); + BlockReference dictRef = ss.m_req.senderRef; + + if (!lastReply(ss)) + return; + + if (ss.m_error == 0) { + jam(); + DropTrigImplConf* conf = (DropTrigImplConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = ss.m_req.senderData; + conf->tableId = ss.m_req.tableId; + conf->triggerId = ss.m_req.triggerId; + sendSignal(dictRef, GSN_DROP_TRIG_IMPL_CONF, + signal, DropTrigImplConf::SignalLength, JBB); + } else { + DropTrigImplRef* ref = (DropTrigImplRef*)signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->senderData = ss.m_req.senderData; + ref->tableId = ss.m_req.tableId; + ref->triggerId = ss.m_req.triggerId; + ref->errorCode = ss.m_error; + sendSignal(dictRef, GSN_DROP_TRIG_IMPL_REF, + signal, DropTrigImplRef::SignalLength, JBB); + } + + ssRelease(ssId); +} + BLOCK_FUNCTIONS(LocalProxy) === modified file 'storage/ndb/src/kernel/blocks/LocalProxy.hpp' --- a/storage/ndb/src/kernel/blocks/LocalProxy.hpp 2008-08-23 06:11:28 +0000 +++ b/storage/ndb/src/kernel/blocks/LocalProxy.hpp 2008-08-27 08:00:52 +0000 @@ -25,6 +25,8 @@ #include #include #include +#include +#include /* * Proxy blocks for MT LQH. @@ -126,6 +128,10 @@ template struct SsPool { Ss m_pool[Ss::poolSize]; + Uint32 m_usage; + SsPool() { + m_usage = 0; + } }; Uint32 c_ssIdSeq; @@ -146,6 +152,7 @@ Ss& ssSeize(Uint32 ssId) { SsPool& sp = Ss::pool(this); ndbrequire(ssId != 0); + ndbrequire(sp.m_usage < Ss::poolSize); Ss* ssptr = 0; for (Uint32 i = 0; i < Ss::poolSize; i++) { Ss& ss = sp.m_pool[i]; @@ -158,6 +165,7 @@ } } ndbrequire(ssptr != 0); + sp.m_usage++; return *ssptr; } @@ -180,6 +188,7 @@ template void ssRelease(Uint32 ssId) { SsPool& sp = Ss::pool(this); + ndbrequire(sp.m_usage != 0); ndbrequire(ssId != 0); Ss* ssptr = 0; for (Uint32 i = 0; i < Ss::poolSize; i++) { @@ -191,6 +200,7 @@ } } ndbrequire(ssptr != 0); + sp.m_usage--; } template @@ -198,6 +208,22 @@ ssRelease(ss.m_ssId); } + /* + * In some cases handle pool full via delayed signal. + * wl4391_todo maybe use CONTINUEB and guard against infinite loop. + */ + template + bool ssQueue(Signal* signal) { + SsPool& sp = Ss::pool(this); + if (sp.m_usage < Ss::poolSize) + return false; + ndbrequire(signal->getNoOfSections() == 0); + GlobalSignalNumber gsn = signal->header.theVerId_signalNumber & 0xFFFF; + sendSignalWithDelay(reference(), gsn, + signal, 10, signal->length()); + return true; + } + // system info Uint32 c_typeOfStart; @@ -395,6 +421,44 @@ SsPool c_ss_TIME_SIGNAL; void execTIME_SIGNAL(Signal*); void sendTIME_SIGNAL(Signal*, Uint32 ssId); + + // GSN_CREATE_TRIG_IMPL_REQ + struct Ss_CREATE_TRIG_IMPL_REQ : SsParallel { + CreateTrigImplReq m_req; + Ss_CREATE_TRIG_IMPL_REQ() { + m_sendREQ = &LocalProxy::sendCREATE_TRIG_IMPL_REQ; + m_sendCONF = &LocalProxy::sendCREATE_TRIG_IMPL_CONF; + } + enum { poolSize = 3 }; + static SsPool& pool(LocalProxy* proxy) { + return proxy->c_ss_CREATE_TRIG_IMPL_REQ; + } + }; + SsPool c_ss_CREATE_TRIG_IMPL_REQ; + void execCREATE_TRIG_IMPL_REQ(Signal*); + void sendCREATE_TRIG_IMPL_REQ(Signal*, Uint32 ssId); + void execCREATE_TRIG_IMPL_CONF(Signal*); + void execCREATE_TRIG_IMPL_REF(Signal*); + void sendCREATE_TRIG_IMPL_CONF(Signal*, Uint32 ssId); + + // GSN_DROP_TRIG_IMPL_REQ + struct Ss_DROP_TRIG_IMPL_REQ : SsParallel { + DropTrigImplReq m_req; + Ss_DROP_TRIG_IMPL_REQ() { + m_sendREQ = &LocalProxy::sendDROP_TRIG_IMPL_REQ; + m_sendCONF = &LocalProxy::sendDROP_TRIG_IMPL_CONF; + } + enum { poolSize = 3 }; + static SsPool& pool(LocalProxy* proxy) { + return proxy->c_ss_DROP_TRIG_IMPL_REQ; + } + }; + SsPool c_ss_DROP_TRIG_IMPL_REQ; + void execDROP_TRIG_IMPL_REQ(Signal*); + void sendDROP_TRIG_IMPL_REQ(Signal*, Uint32 ssId); + void execDROP_TRIG_IMPL_CONF(Signal*); + void execDROP_TRIG_IMPL_REF(Signal*); + void sendDROP_TRIG_IMPL_CONF(Signal*, Uint32 ssId); }; #endif === modified file 'storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp' --- a/storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp 2008-07-25 05:48:32 +0000 +++ b/storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp 2008-08-27 12:32:38 +0000 @@ -1516,9 +1516,14 @@ template inline bool seizeSchemaOp(SchemaOpPtr& op_ptr) { - Uint32 op_key = c_opRecordSequence + 1; + /* + Store node id in high 16 bits to make op_key globally unique + */ + Uint32 op_key = + (getOwnNodeId() << 24) + + (c_opRecordSequence + 1) & 0x00FFFFFF; if (seizeSchemaOp(op_ptr, op_key)) { - c_opRecordSequence = op_key; + c_opRecordSequence++; return true; } return false; === modified file 'storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp' --- a/storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp 2008-08-23 06:32:32 +0000 +++ b/storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp 2008-08-27 07:54:42 +0000 @@ -20376,7 +20376,10 @@ { jamEntry(); - sendSignal(DBTUP_REF, GSN_CREATE_TRIG_IMPL_REQ, signal, + CreateTrigImplReq* req = (CreateTrigImplReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + BlockReference tupRef = calcInstanceBlockRef(DBTUP); + sendSignal(tupRef, GSN_CREATE_TRIG_IMPL_REQ, signal, CreateTrigImplReq::SignalLength, JBB); } @@ -20385,7 +20388,8 @@ { jamEntry(); - sendSignal(DBDICT_REF, GSN_CREATE_TRIG_IMPL_CONF, signal, + BlockReference dictRef = !isNdbMtLqh() ? DBDICT_REF : DBLQH_REF; + sendSignal(dictRef, GSN_CREATE_TRIG_IMPL_CONF, signal, CreateTrigImplConf::SignalLength, JBB); } @@ -20394,7 +20398,8 @@ { jamEntry(); - sendSignal(DBDICT_REF, GSN_CREATE_TRIG_IMPL_REF, signal, + BlockReference dictRef = !isNdbMtLqh() ? DBDICT_REF : DBLQH_REF; + sendSignal(dictRef, GSN_CREATE_TRIG_IMPL_REF, signal, CreateTrigImplRef::SignalLength, JBB); } @@ -20403,7 +20408,10 @@ { jamEntry(); - sendSignal(DBTUP_REF, GSN_DROP_TRIG_IMPL_REQ, signal, + DropTrigImplReq* req = (DropTrigImplReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + BlockReference tupRef = calcInstanceBlockRef(DBTUP); + sendSignal(tupRef, GSN_DROP_TRIG_IMPL_REQ, signal, DropTrigImplReq::SignalLength, JBB); } @@ -20412,7 +20420,8 @@ { jamEntry(); - sendSignal(DBDICT_REF, GSN_DROP_TRIG_IMPL_CONF, signal, + BlockReference dictRef = !isNdbMtLqh() ? DBDICT_REF : DBLQH_REF; + sendSignal(dictRef, GSN_DROP_TRIG_IMPL_CONF, signal, DropTrigImplConf::SignalLength, JBB); } @@ -20421,7 +20430,8 @@ { jamEntry(); - sendSignal(DBDICT_REF, GSN_DROP_TRIG_IMPL_REF, signal, + BlockReference dictRef = !isNdbMtLqh() ? DBDICT_REF : DBLQH_REF; + sendSignal(dictRef, GSN_DROP_TRIG_IMPL_REF, signal, DropTrigImplRef::SignalLength, JBB); } === modified file 'storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp' --- a/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp 2008-08-07 11:52:50 +0000 +++ b/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp 2008-08-27 08:00:52 +0000 @@ -897,9 +897,9 @@ TriggerActionTime::Value triggerActionTime; TriggerEvent::Value triggerEvent; /** - * Receiver block + * Receiver block reference */ - Uint32 m_receiverBlock; + Uint32 m_receiverRef; /** * Monitor all replicas, i.e. trigger will fire on all nodes where tuples === modified file 'storage/ndb/src/kernel/blocks/dbtup/DbtupProxy.cpp' --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupProxy.cpp 2008-08-15 11:01:41 +0000 +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupProxy.cpp 2008-08-27 07:54:42 +0000 @@ -22,6 +22,11 @@ // GSN_DROP_TAB_REQ addRecSignal(GSN_DROP_TAB_REQ, &DbtupProxy::execDROP_TAB_REQ); addRecSignal(GSN_DROP_TAB_CONF, &DbtupProxy::execDROP_TAB_CONF); + + // GSN_BUILD_INDX_IMPL_REQ + addRecSignal(GSN_BUILD_INDX_IMPL_REQ, &DbtupProxy::execBUILD_INDX_IMPL_REQ); + addRecSignal(GSN_BUILD_INDX_IMPL_CONF, &DbtupProxy::execBUILD_INDX_IMPL_CONF); + addRecSignal(GSN_BUILD_INDX_IMPL_REF, &DbtupProxy::execBUILD_INDX_IMPL_REF); } DbtupProxy::~DbtupProxy() @@ -93,4 +98,75 @@ ssRelease(ssId); } +// GSN_BUILD_INDX_IMPL_REQ + +void +DbtupProxy::execBUILD_INDX_IMPL_REQ(Signal* signal) +{ + const BuildIndxImplReq* req = (const BuildIndxImplReq*)signal->getDataPtr(); + Ss_BUILD_INDX_IMPL_REQ& ss = ssSeize(); + ss.m_req = *req; + ndbrequire(signal->getLength() == BuildIndxImplReq::SignalLength); + sendREQ(signal, ss); +} + +void +DbtupProxy::sendBUILD_INDX_IMPL_REQ(Signal* signal, Uint32 ssId) +{ + Ss_BUILD_INDX_IMPL_REQ& ss = ssFind(ssId); + + BuildIndxImplReq* req = (BuildIndxImplReq*)signal->getDataPtrSend(); + *req = ss.m_req; + req->senderRef = reference(); + req->senderData = ssId; + sendSignal(workerRef(ss.m_worker), GSN_BUILD_INDX_IMPL_REQ, + signal, BuildIndxImplReq::SignalLength, JBB); +} + +void +DbtupProxy::execBUILD_INDX_IMPL_CONF(Signal* signal) +{ + const BuildIndxImplConf* conf = (const BuildIndxImplConf*)signal->getDataPtr(); + Uint32 ssId = conf->senderData; + Ss_BUILD_INDX_IMPL_REQ& ss = ssFind(ssId); + recvCONF(signal, ss); +} + +void +DbtupProxy::execBUILD_INDX_IMPL_REF(Signal* signal) +{ + const BuildIndxImplRef* ref = (const BuildIndxImplRef*)signal->getDataPtr(); + Uint32 ssId = ref->senderData; + Ss_BUILD_INDX_IMPL_REQ& ss = ssFind(ssId); + recvREF(signal, ss, ref->errorCode); +} + +void +DbtupProxy::sendBUILD_INDX_IMPL_CONF(Signal* signal, Uint32 ssId) +{ + Ss_BUILD_INDX_IMPL_REQ& ss = ssFind(ssId); + BlockReference dictRef = ss.m_req.senderRef; + + if (!lastReply(ss)) + return; + + if (ss.m_error == 0) { + jam(); + BuildIndxImplConf* conf = (BuildIndxImplConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = ss.m_req.senderData; + sendSignal(dictRef, GSN_BUILD_INDX_IMPL_CONF, + signal, BuildIndxImplConf::SignalLength, JBB); + } else { + BuildIndxImplRef* ref = (BuildIndxImplRef*)signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->senderData = ss.m_req.senderData; + ref->errorCode = ss.m_error; + sendSignal(dictRef, GSN_BUILD_INDX_IMPL_REF, + signal, BuildIndxImplRef::SignalLength, JBB); + } + + ssRelease(ssId); +} + BLOCK_FUNCTIONS(DbtupProxy) === modified file 'storage/ndb/src/kernel/blocks/dbtup/DbtupProxy.hpp' --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupProxy.hpp 2008-08-15 11:01:41 +0000 +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupProxy.hpp 2008-08-27 07:54:42 +0000 @@ -18,6 +18,7 @@ #include #include +#include class DbtupProxy : public LocalProxy { public: @@ -51,6 +52,25 @@ void sendDROP_TAB_REQ(Signal*, Uint32 ssId); void execDROP_TAB_CONF(Signal*); void sendDROP_TAB_CONF(Signal*, Uint32 ssId); + + // GSN_BUILD_INDX_IMPL_REQ + struct Ss_BUILD_INDX_IMPL_REQ : SsParallel { + BuildIndxImplReq m_req; + Ss_BUILD_INDX_IMPL_REQ() { + m_sendREQ = (SsFUNC)&DbtupProxy::sendBUILD_INDX_IMPL_REQ; + m_sendCONF = (SsFUNC)&DbtupProxy::sendBUILD_INDX_IMPL_CONF; + } + enum { poolSize = 1 }; + static SsPool& pool(LocalProxy* proxy) { + return ((DbtupProxy*)proxy)->c_ss_BUILD_INDX_IMPL_REQ; + } + }; + SsPool c_ss_BUILD_INDX_IMPL_REQ; + void execBUILD_INDX_IMPL_REQ(Signal*); + void sendBUILD_INDX_IMPL_REQ(Signal*, Uint32 ssId); + void execBUILD_INDX_IMPL_CONF(Signal*); + void execBUILD_INDX_IMPL_REF(Signal*); + void sendBUILD_INDX_IMPL_CONF(Signal*, Uint32 ssId); }; #endif === modified file 'storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp' --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp 2008-06-05 20:34:20 +0000 +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp 2008-08-27 08:00:52 +0000 @@ -318,7 +318,7 @@ tptr.p->monitorAllAttributes = TriggerInfo::getMonitorAllAttributes(tinfo); tptr.p->monitorReplicas = TriggerInfo::getMonitorReplicas(tinfo); - tptr.p->m_receiverBlock = refToBlock(req->receiverRef); + tptr.p->m_receiverRef = req->receiverRef; if (tptr.p->monitorAllAttributes) { @@ -420,7 +420,7 @@ if (ptr.p->triggerId == triggerId) { if(ttype==TriggerType::SUBSCRIPTION && - sender != ptr.p->m_receiverBlock) + sender != refToBlock(ptr.p->m_receiverRef)) { /** * You can only drop your own triggers for subscription triggers. @@ -874,7 +874,7 @@ } */ Signal* signal= req_struct->signal; - BlockReference ref = trigPtr->m_receiverBlock; + BlockReference ref = trigPtr->m_receiverRef; Uint32* const keyBuffer = &cinBuffer[0]; Uint32* const afterBuffer = &coutBuffer[0]; Uint32* const beforeBuffer = &clogMemBuffer[0]; @@ -886,7 +886,7 @@ ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord); Fragrecord::FragState fragstatus = regFragPtr.p->fragStatus; - if (ref == BACKUP) { + if (refToMain(ref) == BACKUP) { jam(); /* In order for the implementation of BACKUP to work even when changing @@ -953,8 +953,9 @@ case (TriggerType::SUBSCRIPTION_BEFORE): jam(); // Since only backup uses subscription triggers we send to backup directly for now - ref = trigPtr->m_receiverBlock; - executeDirect = true; + ref = trigPtr->m_receiverRef; + // executeDirect = !isNdbMtLqh() || (refToMain(ref) != SUMA); + executeDirect = refToInstance(ref) == instance(); break; case (TriggerType::READ_ONLY_CONSTRAINT): terrorCode = ZREAD_ONLY_CONSTRAINT_VIOLATION; @@ -1174,7 +1175,7 @@ req_struct->m_tuple_ptr= save; ndbrequire(ret != -1); noBeforeWords = ret; - if (trigPtr->m_receiverBlock != SUMA && + if (refToMain(trigPtr->m_receiverRef) != SUMA && (noAfterWords == noBeforeWords) && (memcmp(afterBuffer, beforeBuffer, noAfterWords << 2) == 0)) { //-------------------------------------------------------------------- @@ -1209,7 +1210,7 @@ sigLen); if (executeDirect) { jam(); - EXECUTE_DIRECT(receiverReference, + EXECUTE_DIRECT(refToMain(receiverReference), GSN_TRIG_ATTRINFO, signal, TrigAttrInfo::StaticLength + sigLen); @@ -1275,23 +1276,25 @@ break; case (TriggerType::SUBSCRIPTION_BEFORE): // Only Suma jam(); - // Since only backup uses subscription triggers we - // send to backup directly for now fireTrigOrd->setGCI(req_struct->gci_hi); fireTrigOrd->setHashValue(req_struct->hash_value); fireTrigOrd->m_any_value = regOperPtr->m_any_value; fireTrigOrd->m_gci_lo = req_struct->gci_lo; - EXECUTE_DIRECT(trigPtr->m_receiverBlock, - GSN_FIRE_TRIG_ORD, - signal, - FireTrigOrd::SignalLengthSuma); + if (refToInstance(trigPtr->m_receiverRef) == instance()) + EXECUTE_DIRECT(refToMain(trigPtr->m_receiverRef), + GSN_FIRE_TRIG_ORD, + signal, + FireTrigOrd::SignalLengthSuma); + else + sendSignal(trigPtr->m_receiverRef, GSN_FIRE_TRIG_ORD, + signal, FireTrigOrd::SignalLengthSuma, JBB); break; case (TriggerType::SUBSCRIPTION): jam(); // Since only backup uses subscription triggers we // send to backup directly for now fireTrigOrd->setGCI(req_struct->gci_hi); - EXECUTE_DIRECT(trigPtr->m_receiverBlock, + EXECUTE_DIRECT(refToMain(trigPtr->m_receiverRef), GSN_FIRE_TRIG_ORD, signal, FireTrigOrd::SignalWithGCILength); === modified file 'storage/ndb/src/kernel/blocks/dbtux/DbtuxGen.cpp' --- a/storage/ndb/src/kernel/blocks/dbtux/DbtuxGen.cpp 2008-08-11 11:37:57 +0000 +++ b/storage/ndb/src/kernel/blocks/dbtux/DbtuxGen.cpp 2008-08-27 07:54:42 +0000 @@ -132,7 +132,7 @@ case 1: jam(); CLEAR_ERROR_INSERT_VALUE; - c_tup = (Dbtup*)globalData.getBlock(DBTUP); + c_tup = (Dbtup*)globalData.getBlock(DBTUP, instance()); ndbrequire(c_tup != 0); break; case 3: === modified file 'storage/ndb/src/kernel/blocks/dbtux/DbtuxProxy.cpp' --- a/storage/ndb/src/kernel/blocks/dbtux/DbtuxProxy.cpp 2008-07-26 05:13:40 +0000 +++ b/storage/ndb/src/kernel/blocks/dbtux/DbtuxProxy.cpp 2008-08-27 07:54:42 +0000 @@ -19,6 +19,14 @@ DbtuxProxy::DbtuxProxy(Block_context& ctx) : LocalProxy(DBTUX, ctx) { + // GSN_ALTER_INDX_IMPL_REQ + addRecSignal(GSN_ALTER_INDX_IMPL_REQ, &DbtuxProxy::execALTER_INDX_IMPL_REQ); + addRecSignal(GSN_ALTER_INDX_IMPL_CONF, &DbtuxProxy::execALTER_INDX_IMPL_CONF); + addRecSignal(GSN_ALTER_INDX_IMPL_REF, &DbtuxProxy::execALTER_INDX_IMPL_REF); + + // GSN_DROP_TAB_REQ + addRecSignal(GSN_DROP_TAB_REQ, &DbtuxProxy::execDROP_TAB_REQ); + addRecSignal(GSN_DROP_TAB_CONF, &DbtuxProxy::execDROP_TAB_CONF); } DbtuxProxy::~DbtuxProxy() @@ -31,4 +39,134 @@ return new Dbtux(m_ctx, instanceNo); } +// GSN_ALTER_INDX_IMPL_REQ + +void +DbtuxProxy::execALTER_INDX_IMPL_REQ(Signal* signal) +{ + const AlterIndxImplReq* req = (const AlterIndxImplReq*)signal->getDataPtr(); + Ss_ALTER_INDX_IMPL_REQ& ss = ssSeize(); + ss.m_req = *req; + ndbrequire(signal->getLength() == AlterIndxImplReq::SignalLength); + sendREQ(signal, ss); +} + +void +DbtuxProxy::sendALTER_INDX_IMPL_REQ(Signal* signal, Uint32 ssId) +{ + Ss_ALTER_INDX_IMPL_REQ& ss = ssFind(ssId); + + AlterIndxImplReq* req = (AlterIndxImplReq*)signal->getDataPtrSend(); + *req = ss.m_req; + req->senderRef = reference(); + req->senderData = ssId; + sendSignal(workerRef(ss.m_worker), GSN_ALTER_INDX_IMPL_REQ, + signal, AlterIndxImplReq::SignalLength, JBB); +} + +void +DbtuxProxy::execALTER_INDX_IMPL_CONF(Signal* signal) +{ + const AlterIndxImplConf* conf = (const AlterIndxImplConf*)signal->getDataPtr(); + Uint32 ssId = conf->senderData; + Ss_ALTER_INDX_IMPL_REQ& ss = ssFind(ssId); + recvCONF(signal, ss); +} + +void +DbtuxProxy::execALTER_INDX_IMPL_REF(Signal* signal) +{ + const AlterIndxImplRef* ref = (const AlterIndxImplRef*)signal->getDataPtr(); + Uint32 ssId = ref->senderData; + Ss_ALTER_INDX_IMPL_REQ& ss = ssFind(ssId); + recvREF(signal, ss, ref->errorCode); +} + +void +DbtuxProxy::sendALTER_INDX_IMPL_CONF(Signal* signal, Uint32 ssId) +{ + Ss_ALTER_INDX_IMPL_REQ& ss = ssFind(ssId); + BlockReference dictRef = ss.m_req.senderRef; + + if (!lastReply(ss)) + return; + + if (ss.m_error == 0) { + jam(); + AlterIndxImplConf* conf = (AlterIndxImplConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = ss.m_req.senderData; + sendSignal(dictRef, GSN_ALTER_INDX_IMPL_CONF, + signal, AlterIndxImplConf::SignalLength, JBB); + } else { + AlterIndxImplRef* ref = (AlterIndxImplRef*)signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->senderData = ss.m_req.senderData; + ref->errorCode = ss.m_error; + sendSignal(dictRef, GSN_ALTER_INDX_IMPL_REF, + signal, AlterIndxImplRef::SignalLength, JBB); + } + + ssRelease(ssId); +} + +// GSN_DROP_TAB_REQ + +void +DbtuxProxy::execDROP_TAB_REQ(Signal* signal) +{ + const DropTabReq* req = (const DropTabReq*)signal->getDataPtr(); + Uint32 ssId = getSsId(req); + Ss_DROP_TAB_REQ& ss = ssSeize(ssId); + ss.m_req = *req; + ndbrequire(signal->getLength() == DropTabReq::SignalLength); + sendREQ(signal, ss); +} + +void +DbtuxProxy::sendDROP_TAB_REQ(Signal* signal, Uint32 ssId) +{ + Ss_DROP_TAB_REQ& ss = ssFind(ssId); + + DropTabReq* req = (DropTabReq*)signal->getDataPtrSend(); + *req = ss.m_req; + req->senderRef = reference(); + req->senderData = ssId; // redundant since tableId is used + sendSignal(workerRef(ss.m_worker), GSN_DROP_TAB_REQ, + signal, DropTabReq::SignalLength, JBB); +} + +void +DbtuxProxy::execDROP_TAB_CONF(Signal* signal) +{ + const DropTabConf* conf = (const DropTabConf*)signal->getDataPtr(); + Uint32 ssId = getSsId(conf); + Ss_DROP_TAB_REQ& ss = ssFind(ssId); + recvCONF(signal, ss); +} + +void +DbtuxProxy::sendDROP_TAB_CONF(Signal* signal, Uint32 ssId) +{ + Ss_DROP_TAB_REQ& ss = ssFind(ssId); + BlockReference dictRef = ss.m_req.senderRef; + + if (!lastReply(ss)) + return; + + if (ss.m_error == 0) { + jam(); + DropTabConf* conf = (DropTabConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = ss.m_req.senderData; + conf->tableId = ss.m_req.tableId; + sendSignal(dictRef, GSN_DROP_TAB_CONF, + signal, DropTabConf::SignalLength, JBB); + } else { + ndbrequire(false); + } + + ssRelease(ssId); +} + BLOCK_FUNCTIONS(DbtuxProxy) === modified file 'storage/ndb/src/kernel/blocks/dbtux/DbtuxProxy.hpp' --- a/storage/ndb/src/kernel/blocks/dbtux/DbtuxProxy.hpp 2008-07-26 05:13:40 +0000 +++ b/storage/ndb/src/kernel/blocks/dbtux/DbtuxProxy.hpp 2008-08-27 07:54:42 +0000 @@ -17,6 +17,8 @@ #define NDB_DBTUX_PROXY_HPP #include +#include +#include class DbtuxProxy : public LocalProxy { public: @@ -26,6 +28,49 @@ protected: virtual SimulatedBlock* newWorker(Uint32 instanceNo); + + // GSN_ALTER_INDX_IMPL_REQ + struct Ss_ALTER_INDX_IMPL_REQ : SsParallel { + AlterIndxImplReq m_req; + Ss_ALTER_INDX_IMPL_REQ() { + m_sendREQ = (SsFUNC)&DbtuxProxy::sendALTER_INDX_IMPL_REQ; + m_sendCONF = (SsFUNC)&DbtuxProxy::sendALTER_INDX_IMPL_CONF; + } + enum { poolSize = 1 }; + static SsPool& pool(LocalProxy* proxy) { + return ((DbtuxProxy*)proxy)->c_ss_ALTER_INDX_IMPL_REQ; + } + }; + SsPool c_ss_ALTER_INDX_IMPL_REQ; + void execALTER_INDX_IMPL_REQ(Signal*); + void sendALTER_INDX_IMPL_REQ(Signal*, Uint32 ssId); + void execALTER_INDX_IMPL_CONF(Signal*); + void execALTER_INDX_IMPL_REF(Signal*); + void sendALTER_INDX_IMPL_CONF(Signal*, Uint32 ssId); + + // GSN_DROP_TAB_REQ + struct Ss_DROP_TAB_REQ : SsParallel { + DropTabReq m_req; + Ss_DROP_TAB_REQ() { + m_sendREQ = (SsFUNC)&DbtuxProxy::sendDROP_TAB_REQ; + m_sendCONF = (SsFUNC)&DbtuxProxy::sendDROP_TAB_CONF; + } + enum { poolSize = 1 }; + static SsPool& pool(LocalProxy* proxy) { + return ((DbtuxProxy*)proxy)->c_ss_DROP_TAB_REQ; + } + }; + SsPool c_ss_DROP_TAB_REQ; + Uint32 getSsId(const DropTabReq* req) { + return SsIdBase | req->tableId; + } + Uint32 getSsId(const DropTabConf* conf) { + return SsIdBase | conf->tableId; + } + void execDROP_TAB_REQ(Signal*); + void sendDROP_TAB_REQ(Signal*, Uint32 ssId); + void execDROP_TAB_CONF(Signal*); + void sendDROP_TAB_CONF(Signal*, Uint32 ssId); }; #endif === modified file 'storage/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp' --- a/storage/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp 2008-04-08 13:40:43 +0000 +++ b/storage/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp 2008-08-27 07:54:42 +0000 @@ -558,7 +558,7 @@ sendSignal(scan.m_userRef, GSN_NEXT_SCANCONF, signal, signalLength, JBB); } else { - Uint32 blockNo = refToBlock(scan.m_userRef); + Uint32 blockNo = refToMain(scan.m_userRef); EXECUTE_DIRECT(blockNo, GSN_NEXT_SCANCONF, signal, signalLength); } // next time look for next entry === modified file 'storage/ndb/src/kernel/blocks/suma/Suma.cpp' --- a/storage/ndb/src/kernel/blocks/suma/Suma.cpp 2008-08-13 12:47:22 +0000 +++ b/storage/ndb/src/kernel/blocks/suma/Suma.cpp 2008-08-27 08:00:52 +0000 @@ -233,7 +233,9 @@ if(m_startphase == 3) { jam(); - ndbrequire((m_tup = (Dbtup*)globalData.getBlock(DBTUP)) != 0); + // wl4391_todo something + Uint32 instanceNo = !isNdbMtLqh() ? 0 : 1; + ndbrequire((m_tup = (Dbtup*)globalData.getBlock(DBTUP, instanceNo)) != 0); } if(m_startphase == 5) @@ -1890,6 +1892,7 @@ FragmentDescriptor fd; fd.m_fragDesc.m_nodeId = conf->nodes[0]; fd.m_fragDesc.m_fragmentNo = fragNo; + fd.m_fragDesc.m_lqhInstanceKey = conf->instanceKey; signal->theData[2] = fd.m_dummy; fragBuf.append(&signal->theData[2], 1); } @@ -2139,6 +2142,9 @@ DataBuffer<15>::Head head = m_attributeList; LocalDataBuffer<15> attrBuf(suma.c_dataBufferPool, head); + + Uint32 instanceKey = fd.m_fragDesc.m_lqhInstanceKey; + BlockReference lqhRef = numberToRef(DBLQH, instanceKey, suma.getOwnNodeId()); ScanFragReq * req = (ScanFragReq *)signal->getDataPtrSend(); const Uint32 parallelism = 16; @@ -2173,7 +2179,7 @@ req->batch_size_rows= parallelism; req->batch_size_bytes= 0; - suma.sendSignal(DBLQH_REF, GSN_SCAN_FRAGREQ, signal, + suma.sendSignal(lqhRef, GSN_SCAN_FRAGREQ, signal, ScanFragReq::SignalLength, JBB); signal->theData[0] = ptrI; @@ -2192,12 +2198,12 @@ for(attrBuf.first(it); !it.curr.isNull(); attrBuf.next(it)){ AttributeHeader::init(&signal->theData[dataPos++], * it.data, 0); if(dataPos == 25){ - suma.sendSignal(DBLQH_REF, GSN_ATTRINFO, signal, 25, JBB); + suma.sendSignal(lqhRef, GSN_ATTRINFO, signal, 25, JBB); dataPos = 3; } } if(dataPos != 3){ - suma.sendSignal(DBLQH_REF, GSN_ATTRINFO, signal, dataPos, JBB); + suma.sendSignal(lqhRef, GSN_ATTRINFO, signal, dataPos, JBB); } m_currentNoOfAttributes = attrBuf.getSize(); @@ -2230,7 +2236,7 @@ Ptr syncPtr; c_syncPool.getPtr(syncPtr, senderData); - if(completed != 2){ + if(completed != 2){ // 2==ZSCAN_FRAG_CLOSED jam(); #if PRINT_ONLY @@ -2275,6 +2281,20 @@ ndbrequire(c_subscriptions.find(subPtr, key)); + Uint32 instanceKey; + { + Ptr syncPtr; + c_syncPool.getPtr(syncPtr, syncPtrI); + LocalDataBuffer<15> fragBuf(c_dataBufferPool, syncPtr.p->m_fragments); + DataBuffer<15>::DataBufferIterator fragIt; + bool ok = fragBuf.position(fragIt, syncPtr.p->m_currentFragment); + ndbrequire(ok); + FragmentDescriptor tmp; + tmp.m_dummy = * fragIt.data; + instanceKey = tmp.m_fragDesc.m_lqhInstanceKey; + } + BlockReference lqhRef = numberToRef(DBLQH, instanceKey, getOwnNodeId()); + ScanFragNextReq * req = (ScanFragNextReq *)signal->getDataPtrSend(); req->senderData = syncPtrI; req->closeFlag = 0; @@ -2282,7 +2302,7 @@ req->transId2 = (SUMA << 20) + (getOwnNodeId() << 8); req->batch_size_rows = 16; req->batch_size_bytes = 0; - sendSignal(DBLQH_REF, GSN_SCAN_NEXTREQ, signal, + sendSignal(lqhRef, GSN_SCAN_NEXTREQ, signal, ScanFragNextReq::SignalLength, JBB); } === modified file 'storage/ndb/src/kernel/blocks/suma/Suma.hpp' --- a/storage/ndb/src/kernel/blocks/suma/Suma.hpp 2008-06-25 13:06:41 +0000 +++ b/storage/ndb/src/kernel/blocks/suma/Suma.hpp 2008-08-27 07:54:42 +0000 @@ -113,9 +113,11 @@ void suma_ndbrequire(bool v); + // wl4391_todo big enough for now union FragmentDescriptor { struct { - Uint16 m_fragmentNo; + Uint8 m_fragmentNo; + Uint8 m_lqhInstanceKey; Uint16 m_nodeId; } m_fragDesc; Uint32 m_dummy; === modified file 'storage/ndb/test/run-test/atrt-backtrace.sh' --- a/storage/ndb/test/run-test/atrt-backtrace.sh 2008-08-23 20:29:50 +0000 +++ b/storage/ndb/test/run-test/atrt-backtrace.sh 2008-08-27 06:45:13 +0000 @@ -8,6 +8,11 @@ exit fi +if [ -f `dirname $core`/env.sh ] +then + . `dirname $core`/env.sh +fi + # # gdb command file # @@ -38,11 +43,12 @@ if [ -x $exe ] then - echo "*** $core" >> $out + echo "*** $exe - $core" >> $out eval "gdb -q -batch -x bt.gdb -c $core $exe $outarg" elif [ -x "`which $exe 2> /dev/null`" ] - exe=`which exe` - echo "*** $core" >> $out +then + exe=`which $exe` + echo "*** $exe - $core" >> $out eval "gdb -q -batch -x bt.gdb -c $core $exe $outarg" else eval "echo \"*** $core : cant find exe: $exe\" $outarg" === modified file 'storage/ndb/test/run-test/atrt.hpp' --- a/storage/ndb/test/run-test/atrt.hpp 2008-02-21 13:57:42 +0000 +++ b/storage/ndb/test/run-test/atrt.hpp 2008-08-27 11:42:30 +0000 @@ -32,6 +32,7 @@ ERR_SERVERS_FAILED = 102, ERR_MAX_TIME_ELAPSED = 103, ERR_COMMAND_FAILED = 104, + ERR_FAILED_TO_START = 105 }; struct atrt_host === modified file 'storage/ndb/test/run-test/db.cpp' --- a/storage/ndb/test/run-test/db.cpp 2008-02-21 13:57:42 +0000 +++ b/storage/ndb/test/run-test/db.cpp 2008-08-27 11:42:30 +0000 @@ -460,3 +460,7 @@ } return true; } + +template static int find(atrt_host* obj, Vector& arr); +template static int find(atrt_cluster* obj, Vector& arr); + === modified file 'storage/ndb/test/run-test/main.cpp' --- a/storage/ndb/test/run-test/main.cpp 2008-06-23 16:14:43 +0000 +++ b/storage/ndb/test/run-test/main.cpp 2008-08-27 11:45:57 +0000 @@ -277,7 +277,33 @@ goto end; if (!start(g_config, p_ndb | p_servers)) - goto end; + { + g_logger.info("Failed to start server processes"); + g_logger.info("Gathering logs and saving them as test %u", test_no); + + int tmp; + if(!gather_result(g_config, &tmp)) + goto end; + + if(g_report_file != 0) + { + fprintf(g_report_file, "%s ; %d ; %d ; %d\n", + "start servers", test_no, ERR_FAILED_TO_START, 0); + fflush(g_report_file); + } + + BaseString resdir; + resdir.assfmt("result.%d", test_no); + remove_dir(resdir.c_str(), true); + + if(rename("result", resdir.c_str()) != 0) + { + g_logger.critical("Failed to rename %s as %s", + "result", resdir.c_str()); + goto end; + } + goto end; + } if (!setup_db(g_config)) goto end;