void
DblqhProxy::execLQHADDATTREQ(Signal* signal)
{
const LqhAddAttrReq* req = (const LqhAddAttrReq*)signal->getDataPtr();
Uint32 ssId = req->lqhFragPtr;
Ss_LQHADDATTREQ& ss = ssSeize<Ss_LQHADDATTREQ>(ssId);
const Uint32 reqlength =
LqhAddAttrReq::HeaderLength +
req->noOfAttributes * LqhAddAttrReq::EntryLength;
ndbrequire(signal->getLength() == reqlength);
memcpy(&ss.m_req, req, reqlength << 2);
ss.m_reqlength = reqlength;
/**
* Count LQHFRAGREQ,
* so that I can release CREATE_TAB_REQ after last attribute has been
* processed
*/
Ss_CREATE_TAB_REQ& ss_main = ssFind<Ss_CREATE_TAB_REQ>(ssId);
ndbrequire(ss_main.m_req.noOfAttributes >= req->noOfAttributes);
ss_main.m_req.noOfAttributes -= req->noOfAttributes;
/* Save long section(s) in ss for forwarding to
* workers
*/
SectionHandle handle(this, signal);
saveSections(ss, handle);
sendREQ(signal, ss);
}
void
DblqhProxy::execLQH_TRANSREQ(Signal* signal)
{
jamEntry();
if (!checkNodeFailSequence(signal))
{
jam();
return;
}
const LqhTransReq* req = (const LqhTransReq*)signal->getDataPtr();
Ss_LQH_TRANSREQ& ss = ssSeize<Ss_LQH_TRANSREQ>();
ss.m_req = *req;
ndbrequire(signal->getLength() == LqhTransReq::SignalLength);
sendREQ(signal, ss);
/**
* See if this is a "resend" (i.e multi TC failure)
* and if so, mark "old" record as invalid
*/
Uint32 nodeId = ss.m_req.failedNodeId;
for (Uint32 i = 0; i<NDB_ARRAY_SIZE(c_ss_LQH_TRANSREQ.m_pool); i++)
{
if (c_ss_LQH_TRANSREQ.m_pool[i].m_ssId != 0 &&
c_ss_LQH_TRANSREQ.m_pool[i].m_ssId != ss.m_ssId &&
c_ss_LQH_TRANSREQ.m_pool[i].m_req.failedNodeId == nodeId)
{
jam();
c_ss_LQH_TRANSREQ.m_pool[i].m_valid = false;
}
}
}
void
DblqhProxy::execSTART_RECREQ(Signal* signal)
{
if (refToMain(signal->getSendersBlockRef()) == DBLQH) {
jam();
execSTART_RECREQ_2(signal);
return;
}
const StartRecReq* req = (const StartRecReq*)signal->getDataPtr();
Ss_START_RECREQ& ss = ssSeize<Ss_START_RECREQ>();
ss.m_req = *req;
// seize records for sub-ops
Uint32 i;
for (i = 0; i < ss.m_req2cnt; i++) {
Ss_START_RECREQ_2::Req tmp;
tmp.proxyBlockNo = ss.m_req2[i].m_blockNo;
Uint32 ssId2 = getSsId(&tmp);
Ss_START_RECREQ_2& ss2 = ssSeize<Ss_START_RECREQ_2>(ssId2);
ss.m_req2[i].m_ssId = ssId2;
// set wait-for bitmask in SsParallel
setMask(ss2);
}
ndbrequire(signal->getLength() == StartRecReq::SignalLength);
sendREQ(signal, ss);
}
void
PgmanProxy::execEND_LCP_REQ(Signal* signal)
{
const EndLcpReq* req = (const EndLcpReq*)signal->getDataPtr();
Uint32 ssId = getSsId(req);
Ss_END_LCP_REQ& ss = ssSeize<Ss_END_LCP_REQ>(ssId);
ss.m_req = *req;
const Uint32 sb = refToBlock(ss.m_req.senderRef);
ndbrequire(sb == DBLQH || sb == LGMAN);
if (sb == LGMAN) {
jam();
/*
* At end of UNDO execution. Extra PGMAN worker was used to
* read up TUP pages. Release these pages now.
*/
ReleasePagesReq* req = (ReleasePagesReq*)signal->getDataPtrSend();
req->senderData = ssId;
req->senderRef = reference();
req->requestType = ReleasePagesReq::RT_RELEASE_UNLOCKED;
req->requestData = 0;
sendSignal(extraWorkerRef(), GSN_RELEASE_PAGES_REQ,
signal, ReleasePagesReq::SignalLength, JBB);
return;
}
sendREQ(signal, ss);
}
void
PgmanProxy::execRELEASE_PAGES_CONF(Signal* signal)
{
const ReleasePagesConf* conf = (const ReleasePagesConf*)signal->getDataPtr();
Uint32 ssId = getSsId(conf);
Ss_END_LCP_REQ& ss = ssFind<Ss_END_LCP_REQ>(ssId);
sendREQ(signal, ss);
}
void
DbtcProxy::execTC_CLOPSIZEREQ(Signal* signal)
{
Ss_TC_CLOPSIZEREQ& ss = ssSeize<Ss_TC_CLOPSIZEREQ>(1);
memcpy(ss.m_req, signal->getDataPtr(), 2*4);
sendREQ(signal, ss);
}
void
DblqhProxy::execGCP_SAVEREQ(Signal* signal)
{
const GCPSaveReq* req = (const GCPSaveReq*)signal->getDataPtr();
Uint32 ssId = getSsId(req);
Ss_GCP_SAVEREQ& ss = ssSeize<Ss_GCP_SAVEREQ>(ssId);
ss.m_req = *req;
sendREQ(signal, ss);
}
void
DbtcProxy::execGCP_NOMORETRANS(Signal* signal)
{
Ss_GCP_NOMORETRANS& ss = ssSeize<Ss_GCP_NOMORETRANS>(1);
ss.m_req = *(GCPNoMoreTrans*)signal->getDataPtr();
ss.m_minTcFailNo = ~Uint32(0);
sendREQ(signal, ss);
}
void
DbtcProxy::execALTER_INDX_IMPL_REQ(Signal* signal)
{
const AlterIndxImplReq* req = (const AlterIndxImplReq*)signal->getDataPtr();
Ss_ALTER_INDX_IMPL_REQ& ss = ssSeize<Ss_ALTER_INDX_IMPL_REQ>();
ss.m_req = *req;
ndbrequire(signal->getLength() == AlterIndxImplReq::SignalLength);
sendREQ(signal, ss);
}
void
DbtcProxy::execABORT_ALL_REQ(Signal* signal)
{
const AbortAllReq* req = (const AbortAllReq*)signal->getDataPtr();
Ss_ABORT_ALL_REQ& ss = ssSeize<Ss_ABORT_ALL_REQ>();
ss.m_req = *req;
ndbrequire(signal->getLength() == AbortAllReq::SignalLength);
sendREQ(signal, ss);
}
void
DbtcProxy::execDROP_FK_IMPL_REQ(Signal* signal)
{
const DropFKImplReq* req = (const DropFKImplReq*)signal->getDataPtr();
Ss_DROP_FK_IMPL_REQ& ss = ssSeize<Ss_DROP_FK_IMPL_REQ>();
ss.m_req = *req;
ndbrequire(signal->getLength() == DropFKImplReq::SignalLength);
sendREQ(signal, ss);
}
void
TrpmanProxy::execENABLE_COMREQ(Signal* signal)
{
jamEntry();
Ss_ENABLE_COMREQ& ss = ssSeize<Ss_ENABLE_COMREQ>();
const EnableComReq* req = (const EnableComReq*)signal->getDataPtr();
ss.m_req = *req;
sendREQ(signal, ss);
}
void
TrpmanProxy::execCLOSE_COMREQ(Signal* signal)
{
jamEntry();
Ss_CLOSE_COMREQ& ss = ssSeize<Ss_CLOSE_COMREQ>();
const CloseComReqConf* req = (const CloseComReqConf*)signal->getDataPtr();
ss.m_req = *req;
sendREQ(signal, ss);
}
void
DbgdmProxy::execTAB_COMMITREQ(Signal* signal)
{
Ss_TAB_COMMITREQ& ss = ssSeize<Ss_TAB_COMMITREQ>(1);
const TabCommitReq* req = (const TabCommitReq*)signal->getDataPtr();
ss.m_req = *req;
sendREQ(signal, ss);
}
void
PgmanProxy::execLCP_FRAG_ORD(Signal* signal)
{
const LcpFragOrd* req = (const LcpFragOrd*)signal->getDataPtr();
Uint32 ssId = getSsId(req);
Ss_LCP_FRAG_ORD& ss = ssSeize<Ss_LCP_FRAG_ORD>(ssId);
ss.m_req = *req;
sendREQ(signal, ss);
ssRelease<Ss_LCP_FRAG_ORD>(ssId);
}
void
DbgdmProxy::execTC_SCHVERREQ(Signal* signal)
{
Ss_TC_SCHVERREQ& ss = ssSeize<Ss_TC_SCHVERREQ>(1);
const TcSchVerReq* req = (const TcSchVerReq*)signal->getDataPtr();
ss.m_req = *req;
sendREQ(signal, ss);
}
void
DbgdmProxy::execDROP_TAB_REQ(Signal* signal)
{
const DropTabReq* req = (const DropTabReq*)signal->getDataPtr();
Uint32 ssId = getSsId(req);
Ss_DROP_TAB_REQ& ss = ssSeize<Ss_DROP_TAB_REQ>(ssId);
ss.m_req = *req;
ndbrequire(signal->getLength() == DropTabReq::SignalLength);
sendREQ(signal, ss);
}
void
DblqhProxy::execCREATE_TAB_REQ(Signal* signal)
{
Ss_CREATE_TAB_REQ& ss = ssSeize<Ss_CREATE_TAB_REQ>(1);
const CreateTabReq* req = (const CreateTabReq*)signal->getDataPtr();
ss.m_req = *req;
ndbrequire(signal->getLength() == CreateTabReq::SignalLengthLDM);
sendREQ(signal, ss);
}
void
DbtuxProxy::execINDEX_STAT_IMPL_REQ(Signal* signal)
{
jamEntry();
const IndexStatImplReq* req =
(const IndexStatImplReq*)signal->getDataPtr();
Ss_INDEX_STAT_IMPL_REQ& ss = ssSeize<Ss_INDEX_STAT_IMPL_REQ>();
ss.m_req = *req;
ndbrequire(signal->getLength() == IndexStatImplReq::SignalLength);
sendREQ(signal, ss);
}
void
DbtuxProxy::execINDEX_STAT_REP(Signal* signal)
{
jamEntry();
const IndexStatRep* rep =
(const IndexStatRep*)signal->getDataPtr();
Ss_INDEX_STAT_REP& ss = ssSeize<Ss_INDEX_STAT_REP>();
ss.m_rep = *rep;
ndbrequire(signal->getLength() == IndexStatRep::SignalLength);
sendREQ(signal, ss);
ssRelease<Ss_INDEX_STAT_REP>(ss);
}
void
DblqhProxy::execSTART_RECCONF_2(Signal* signal)
{
ndbrequire(signal->getLength() == Ss_START_RECREQ_2::Conf::SignalLength);
const Ss_START_RECREQ_2::Conf* conf =
(const Ss_START_RECREQ_2::Conf*)signal->getDataPtr();
Uint32 ssId = getSsId(conf);
Ss_START_RECREQ_2& ss = ssFind<Ss_START_RECREQ_2>(ssId);
ss.m_conf = *conf;
// reversed roles
sendREQ(signal, ss);
}
void
DblqhProxy::execDROP_TAB_REQ(Signal* signal)
{
const DropTabReq* req = (const DropTabReq*)signal->getDataPtr();
Uint32 ssId = getSsId(req);
Ss_DROP_TAB_REQ& ss = ssSeize<Ss_DROP_TAB_REQ>(ssId);
ss.m_req = *req;
ndbrequire(signal->getLength() == DropTabReq::SignalLength);
sendREQ(signal, ss);
Uint32 tableId = ss.m_req.tableId;
ndbrequire(tableId < c_tableRecSize);
c_tableRec[tableId] = 0;
}
void
DblqhProxy::execEXEC_SR_1(Signal* signal, GlobalSignalNumber gsn)
{
ndbrequire(signal->getLength() == Ss_EXEC_SR_1::Sig::SignalLength);
const Ss_EXEC_SR_1::Sig* sig =
(const Ss_EXEC_SR_1::Sig*)signal->getDataPtr();
Uint32 ssId = getSsId(sig);
Ss_EXEC_SR_1& ss = ssSeize<Ss_EXEC_SR_1>(ssId);
ss.m_gsn = gsn;
ss.m_sig = *sig;
sendREQ(signal, ss);
ssRelease<Ss_EXEC_SR_1>(ss);
}
void
DbtcProxy::execCREATE_FK_IMPL_REQ(Signal* signal)
{
jamEntry();
if (!assembleFragments(signal))
{
jam();
return;
}
const CreateFKImplReq* req = (const CreateFKImplReq*)signal->getDataPtr();
Ss_CREATE_FK_IMPL_REQ& ss = ssSeize<Ss_CREATE_FK_IMPL_REQ>();
ss.m_req = *req;
SectionHandle handle(this, signal);
saveSections(ss, handle);
sendREQ(signal, ss);
}
void
DbgdmProxy::execALTER_TAB_REQ(Signal* signal)
{
if (!assembleFragments(signal))
{
jam();
return;
}
const AlterTabReq* req = (const AlterTabReq*)signal->getDataPtr();
Uint32 ssId = getSsId(req);
Ss_ALTER_TAB_REQ& ss = ssSeize<Ss_ALTER_TAB_REQ>(ssId);
ss.m_req = *req;
SectionHandle handle(this, signal);
saveSections(ss, handle);
sendREQ(signal, ss);
}
void
DblqhProxy::execLQH_TRANSREQ(Signal* signal)
{
jamEntry();
if (!checkNodeFailSequence(signal))
{
jam();
return;
}
const LqhTransReq* req = (const LqhTransReq*)signal->getDataPtr();
Ss_LQH_TRANSREQ& ss = ssSeize<Ss_LQH_TRANSREQ>();
ss.m_maxInstanceId = 0;
ss.m_req = *req;
if (signal->getLength() < LqhTransReq::SignalLength)
{
/**
* TC that performs take over doesn't suppport taking over one
* TC instance at a time
*/
ss.m_req.instanceId = RNIL;
}
ndbrequire(signal->getLength() <= LqhTransReq::SignalLength);
sendREQ(signal, ss);
/**
* See if this is a "resend" (i.e multi TC failure)
* and if so, mark "old" record as invalid
*/
Uint32 nodeId = ss.m_req.failedNodeId;
for (Uint32 i = 0; i<NDB_ARRAY_SIZE(c_ss_LQH_TRANSREQ.m_pool); i++)
{
if (c_ss_LQH_TRANSREQ.m_pool[i].m_ssId != 0 &&
c_ss_LQH_TRANSREQ.m_pool[i].m_ssId != ss.m_ssId &&
c_ss_LQH_TRANSREQ.m_pool[i].m_req.failedNodeId == nodeId)
{
jam();
c_ss_LQH_TRANSREQ.m_pool[i].m_valid = false;
}
}
}
