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; } } }