void
DblqhProxy::execEXEC_SR_2(Signal* signal, GlobalSignalNumber gsn)
{
ndbrequire(signal->getLength() == Ss_EXEC_SR_2::Sig::SignalLength);
const Ss_EXEC_SR_2::Sig* sig =
(const Ss_EXEC_SR_2::Sig*)signal->getDataPtr();
Uint32 ssId = getSsId(sig);
bool found = false;
Ss_EXEC_SR_2& ss = ssFindSeize<Ss_EXEC_SR_2>(ssId, &found);
if (!found) {
jam();
setMask(ss);
}
ndbrequire(sig->nodeId == getOwnNodeId());
if (ss.m_sigcount == 0) {
jam();
ss.m_gsn = gsn;
ss.m_sig = *sig;
} else {
jam();
ndbrequire(ss.m_gsn == gsn);
ndbrequire(memcmp(&ss.m_sig, sig, sizeof(*sig)) == 0);
}
ss.m_sigcount++;
// reversed roles
recvCONF(signal, ss);
}
void
DbtcProxy::execTC_CLOPSIZECONF(Signal* signal)
{
Uint32 ssId = signal->theData[0];
Ss_TC_CLOPSIZEREQ& ss = ssFind<Ss_TC_CLOPSIZEREQ>(ssId);
recvCONF(signal, ss);
}
void
PgmanProxy::execEND_LCP_CONF(Signal* signal)
{
const EndLcpConf* conf = (EndLcpConf*)signal->getDataPtr();
Uint32 ssId = conf->senderData;
Ss_END_LCP_REQ& ss = ssFind<Ss_END_LCP_REQ>(ssId);
recvCONF(signal, ss);
}
void
DblqhProxy::execLQHADDATTCONF(Signal* signal)
{
const LqhAddAttrConf* conf = (const LqhAddAttrConf*)signal->getDataPtr();
Uint32 ssId = conf->senderData;
Ss_LQHADDATTREQ& ss = ssFind<Ss_LQHADDATTREQ>(ssId);
recvCONF(signal, ss);
}
void
DbgdmProxy::execTC_SCHVERCONF(Signal* signal)
{
const TcSchVerConf* conf = (const TcSchVerConf*)signal->getDataPtr();
Uint32 ssId = conf->senderData;
Ss_TC_SCHVERREQ& ss = ssFind<Ss_TC_SCHVERREQ>(ssId);
recvCONF(signal, ss);
}
void
DbgdmProxy::execPREP_DROP_TAB_CONF(Signal* signal)
{
const PrepDropTabConf* conf = (const PrepDropTabConf*)signal->getDataPtr();
Uint32 ssId = getSsId(conf);
Ss_PREP_DROP_TAB_REQ& ss = ssFind<Ss_PREP_DROP_TAB_REQ>(ssId);
recvCONF(signal, ss);
}
void
DbgdmProxy::execALTER_TAB_CONF(Signal* signal)
{
const AlterTabConf* conf = (const AlterTabConf*)signal->getDataPtr();
Uint32 ssId = getSsId(conf);
Ss_ALTER_TAB_REQ& ss = ssFind<Ss_ALTER_TAB_REQ>(ssId);
recvCONF(signal, ss);
}
void
DbtcProxy::execDROP_FK_IMPL_CONF(Signal* signal)
{
const DropFKImplConf* conf = (const DropFKImplConf*)signal->getDataPtr();
Uint32 ssId = conf->senderData;
Ss_DROP_FK_IMPL_REQ& ss = ssFind<Ss_DROP_FK_IMPL_REQ>(ssId);
recvCONF(signal, ss);
}
void
DbgdmProxy::execTAB_COMMITCONF(Signal* signal)
{
const TabCommitConf* conf = (TabCommitConf*)signal->getDataPtr();
Uint32 ssId = conf->senderData;
Ss_TAB_COMMITREQ& ss = ssFind<Ss_TAB_COMMITREQ>(ssId);
recvCONF(signal, ss);
}
void
DbtcProxy::execALTER_INDX_IMPL_CONF(Signal* signal)
{
const AlterIndxImplConf* conf = (const AlterIndxImplConf*)signal->getDataPtr();
Uint32 ssId = conf->senderData;
Ss_ALTER_INDX_IMPL_REQ& ss = ssFind<Ss_ALTER_INDX_IMPL_REQ>(ssId);
recvCONF(signal, ss);
}
void
DbtcProxy::execABORT_ALL_CONF(Signal* signal)
{
const AbortAllConf* conf = (const AbortAllConf*)signal->getDataPtr();
Uint32 ssId = conf->senderData;
Ss_ABORT_ALL_REQ& ss = ssFind<Ss_ABORT_ALL_REQ>(ssId);
recvCONF(signal, ss);
}
void
DblqhProxy::execCREATE_TAB_CONF(Signal* signal)
{
const CreateTabConf* conf = (const CreateTabConf*)signal->getDataPtr();
Uint32 ssId = conf->senderData;
Ss_CREATE_TAB_REQ& ss = ssFind<Ss_CREATE_TAB_REQ>(ssId);
recvCONF(signal, ss);
}
void
DblqhProxy::execGCP_SAVECONF(Signal* signal)
{
const GCPSaveConf* conf = (const GCPSaveConf*)signal->getDataPtr();
Uint32 ssId = getSsId(conf);
Ss_GCP_SAVEREQ& ss = ssFind<Ss_GCP_SAVEREQ>(ssId);
recvCONF(signal, ss);
}
void
DblqhProxy::execDROP_FRAG_CONF(Signal* signal)
{
const DropFragConf* conf = (const DropFragConf*)signal->getDataPtr();
Uint32 ssId = getSsId(conf);
Ss_DROP_FRAG_REQ& ss = ssFind<Ss_DROP_FRAG_REQ>(ssId);
recvCONF(signal, ss);
}
void
TrpmanProxy::execENABLE_COMCONF(Signal* signal)
{
const EnableComConf* conf = (const EnableComConf*)signal->getDataPtr();
Uint32 ssId = conf->m_senderData;
jamEntry();
Ss_ENABLE_COMREQ& ss = ssFind<Ss_ENABLE_COMREQ>(ssId);
recvCONF(signal, ss);
}
void
TrpmanProxy::execCLOSE_COMCONF(Signal* signal)
{
const CloseComReqConf* conf = (const CloseComReqConf*)signal->getDataPtr();
Uint32 ssId = conf->failNo;
jamEntry();
Ss_CLOSE_COMREQ& ss = ssFind<Ss_CLOSE_COMREQ>(ssId);
recvCONF(signal, ss);
}
void
DbtuxProxy::execINDEX_STAT_IMPL_CONF(Signal* signal)
{
jamEntry();
const IndexStatImplConf* conf =
(const IndexStatImplConf*)signal->getDataPtr();
Uint32 ssId = conf->senderData;
Ss_INDEX_STAT_IMPL_REQ& ss = ssFind<Ss_INDEX_STAT_IMPL_REQ>(ssId);
recvCONF(signal, ss);
}
void
DbtcProxy::execGCP_TCFINISHED(Signal* signal)
{
GCPTCFinished* conf = (GCPTCFinished*)signal->getDataPtr();
Uint32 ssId = conf->senderData;
Ss_GCP_NOMORETRANS& ss = ssFind<Ss_GCP_NOMORETRANS>(ssId);
/* Record minimum handled failure number seen from TC workers */
if (conf->tcFailNo < ss.m_minTcFailNo)
ss.m_minTcFailNo = conf->tcFailNo;
recvCONF(signal, ss);
}
void
DblqhProxy::execSTART_RECREQ_2(Signal* signal)
{
ndbrequire(signal->getLength() == Ss_START_RECREQ_2::Req::SignalLength);
const Ss_START_RECREQ_2::Req* req =
(const Ss_START_RECREQ_2::Req*)signal->getDataPtr();
Uint32 ssId = getSsId(req);
Ss_START_RECREQ_2& ss = ssFind<Ss_START_RECREQ_2>(ssId);
// reversed roles
recvCONF(signal, ss);
}
void
DblqhProxy::execSTART_RECCONF(Signal* signal)
{
const StartRecConf* conf = (const StartRecConf*)signal->getDataPtr();
if (refToMain(signal->getSendersBlockRef()) != DBLQH) {
jam();
execSTART_RECCONF_2(signal);
return;
}
Uint32 ssId = conf->senderData;
Ss_START_RECREQ& ss = ssFind<Ss_START_RECREQ>(ssId);
recvCONF(signal, ss);
}
void
DblqhProxy::execLQH_TRANSCONF(Signal* signal)
{
const LqhTransConf* conf = (const LqhTransConf*)signal->getDataPtr();
Uint32 ssId = conf->tcRef;
Ss_LQH_TRANSREQ& ss = ssFind<Ss_LQH_TRANSREQ>(ssId);
ss.m_conf = *conf;
BlockReference ref = signal->getSendersBlockRef();
ndbrequire(refToMain(ref) == number());
const Uint32 ino = refToInstance(ref);
const Uint32 worker = workerIndex(ino);
ndbrequire(ref == workerRef(worker));
ndbrequire(worker < c_workers);
if (ss.m_valid == false)
{
jam();
/**
* This is an in-flight signal to an old take-over "session"
*/
if (ss.m_conf.operationStatus == LqhTransConf::LastTransConf)
{
jam();
ndbrequire(ss.m_workerMask.get(worker));
ss.m_workerMask.clear(worker);
if (ss.m_workerMask.isclear())
{
jam();
ssRelease<Ss_LQH_TRANSREQ>(ssId);
}
}
return;
}
else if (ss.m_conf.operationStatus == LqhTransConf::LastTransConf)
{
jam();
/**
* When completing(LqhTransConf::LastTransConf) a LQH_TRANSREQ
* also check if one can release obsoleteded records
*
* This could have been done on each LQH_TRANSCONF, but there is no
* urgency, so it's ok todo only on LastTransConf
*/
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 != ssId &&
c_ss_LQH_TRANSREQ.m_pool[i].m_req.failedNodeId == nodeId &&
c_ss_LQH_TRANSREQ.m_pool[i].m_valid == false)
{
jam();
if (c_ss_LQH_TRANSREQ.m_pool[i].m_workerMask.get(worker))
{
jam();
c_ss_LQH_TRANSREQ.m_pool[i].m_workerMask.clear(worker);
if (c_ss_LQH_TRANSREQ.m_pool[i].m_workerMask.isclear())
{
jam();
ssRelease<Ss_LQH_TRANSREQ>(c_ss_LQH_TRANSREQ.m_pool[i].m_ssId);
}
}
}
}
}
recvCONF(signal, ss);
}
