void
DbtcProxy::sendCREATE_FK_IMPL_REQ(Signal* signal, Uint32 ssId,
SectionHandle * handle)
{
Ss_CREATE_FK_IMPL_REQ& ss = ssFind<Ss_CREATE_FK_IMPL_REQ>(ssId);
CreateFKImplReq* req = (CreateFKImplReq*)signal->getDataPtrSend();
*req = ss.m_req;
req->senderRef = reference();
req->senderData = ssId;
sendSignalNoRelease(workerRef(ss.m_worker), GSN_CREATE_FK_IMPL_REQ,
signal, CreateFKImplReq::SignalLength, JBB,
handle);
}
void
DblqhProxy::sendLQHADDATTREQ(Signal* signal, Uint32 ssId, SectionHandle* handle)
{
Ss_LQHADDATTREQ& ss = ssFind<Ss_LQHADDATTREQ>(ssId);
Ss_CREATE_TAB_REQ& ss_main = ssFind<Ss_CREATE_TAB_REQ>(ssId);
LqhAddAttrReq* req = (LqhAddAttrReq*)signal->getDataPtrSend();
const Uint32 reqlength = ss.m_reqlength;
memcpy(req, &ss.m_req, reqlength << 2);
req->lqhFragPtr = ss_main.m_lqhConnectPtr[ss.m_worker];
req->noOfAttributes = ss.m_req.noOfAttributes;
req->senderData = ssId;
req->senderAttrPtr = ss.m_req.senderAttrPtr;
sendSignalNoRelease(workerRef(ss.m_worker), GSN_LQHADDATTREQ,
signal, reqlength, JBB, handle);
}
void
TrpmanProxy::execROUTE_ORD(Signal* signal)
{
RouteOrd* ord = (RouteOrd*)signal->getDataPtr();
Uint32 nodeId = ord->from;
jamEntry();
ndbassert(nodeId != 0);
#ifndef NDBD_MULTITHREADED
Uint32 workerId = 0;
#else
Uint32 workerId = mt_get_recv_thread_idx(nodeId);
#endif
SectionHandle handle(this, signal);
sendSignal(workerRef(workerId), GSN_ROUTE_ORD, signal,
signal->getLength(), JBB, &handle);
}
void
DblqhProxy::completeLCP_1(Signal* signal)
{
ndbrequire(c_lcpRecord.m_state == LcpRecord::L_RUNNING);
c_lcpRecord.m_state = LcpRecord::L_COMPLETING_1;
ndbrequire(c_lcpRecord.m_complete_outstanding == 0);
/**
* send LCP_FRAG_ORD (lastFragmentFlag = true)
* to all LQH instances...
* they will reply with LCP_COMPLETE_REP
*/
LcpFragOrd* ord = (LcpFragOrd*)signal->getDataPtrSend();
ord->lcpId = c_lcpRecord.m_lcpId;
ord->lastFragmentFlag = true;
for (Uint32 i = 0; i<c_workers; i++)
{
jam();
c_lcpRecord.m_complete_outstanding++;
sendSignal(workerRef(i), GSN_LCP_FRAG_ORD, signal,
LcpFragOrd::SignalLength, JBB);
}
/**
* send END_LCP_REQ to all pgman instances (except "extra" pgman)
* they will reply with END_LCP_CONF
*/
EndLcpReq* req = (EndLcpReq*)signal->getDataPtrSend();
req->senderData= 0;
req->senderRef= reference();
req->backupPtr= 0;
req->backupId= c_lcpRecord.m_lcpId;
for (Uint32 i = 0; i<c_workers; i++)
{
jam();
c_lcpRecord.m_complete_outstanding++;
sendSignal(numberToRef(PGMAN, workerInstance(i), getOwnNodeId()),
GSN_END_LCP_REQ, signal, EndLcpReq::SignalLength, JBB);
}
}
void
DbtuxProxy::sendINDEX_STAT_REP(Signal* signal, Uint32 ssId,
SectionHandle*)
{
Ss_INDEX_STAT_REP& ss = ssFind<Ss_INDEX_STAT_REP>(ssId);
IndexStatRep* rep = (IndexStatRep*)signal->getDataPtrSend();
*rep = ss.m_rep;
rep->senderData = reference();
rep->senderData = ssId;
const Uint32 instance = workerInstance(ss.m_worker);
NdbLogPartInfo lpinfo(instance);
ndbrequire(rep->fragId != ZNIL);
if (!lpinfo.partNoOwner(rep->indexId, rep->fragId)) {
jam();
skipReq(ss);
return;
}
sendSignal(workerRef(ss.m_worker), GSN_INDEX_STAT_REP,
signal, IndexStatRep::SignalLength, JBB);
}
void
DblqhProxy::execLCP_FRAG_ORD(Signal* signal)
{
ndbrequire(signal->getLength() == LcpFragOrd::SignalLength);
const LcpFragOrd* req = (const LcpFragOrd*)signal->getDataPtr();
const LcpFragOrd req_copy = *req;
bool lcp_complete_ord = req->lastFragmentFlag;
if (c_lcpRecord.m_state == LcpRecord::L_IDLE)
{
jam();
D("LCP: start" << V(req->lcpId));
c_lcpRecord.m_state = LcpRecord::L_STARTING;
c_lcpRecord.m_lcpId = req->lcpId;
c_lcpRecord.m_lcp_frag_rep_cnt = 0;
c_lcpRecord.m_lcp_frag_ord_cnt = 0;
c_lcpRecord.m_complete_outstanding = 0;
c_lcpRecord.m_lastFragmentFlag = false;
c_lcpRecord.m_empty_lcp_req.clear();
// handle start of LCP in PGMAN and TSMAN
LcpFragOrd* req = (LcpFragOrd*)signal->getDataPtrSend();
*req = req_copy;
EXECUTE_DIRECT(PGMAN, GSN_LCP_FRAG_ORD,
signal, LcpFragOrd::SignalLength);
*req = req_copy;
EXECUTE_DIRECT(TSMAN, GSN_LCP_FRAG_ORD,
signal, LcpFragOrd::SignalLength);
c_lcpRecord.m_state = LcpRecord::L_RUNNING;
}
jam();
D("LCP: continue" << V(req->lcpId) << V(c_lcpRecord.m_lcp_frag_ord_cnt));
ndbrequire(c_lcpRecord.m_state == LcpRecord::L_RUNNING);
ndbrequire(c_lcpRecord.m_lcpId == req->lcpId);
if (lcp_complete_ord)
{
jam();
c_lcpRecord.m_lastFragmentFlag = true;
if (getNoOfOutstanding(c_lcpRecord) == 0)
{
jam();
completeLCP_1(signal);
return;
}
/**
* Wait for all LCP_FRAG_ORD/REP to complete
*/
return;
}
else
{
jam();
c_lcpRecord.m_last_lcp_frag_ord = req_copy;
}
c_lcpRecord.m_lcp_frag_ord_cnt++;
// Forward
ndbrequire(req->tableId < c_tableRecSize);
if (c_tableRec[req->tableId] == 0)
{
jam();
/**
* Send to lqh-0...that will handle it...
*/
sendSignal(workerRef(0),
GSN_LCP_FRAG_ORD, signal, LcpFragOrd::SignalLength, JBB);
}
else
{
jam();
Uint32 instance = getInstanceKey(req->tableId, req->fragmentId);
sendSignal(numberToRef(DBLQH, instance, getOwnNodeId()),
GSN_LCP_FRAG_ORD, signal, LcpFragOrd::SignalLength, JBB);
}
}
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);
}
void
DbtuxProxy::sendINDEX_STAT_IMPL_REQ(Signal* signal, Uint32 ssId,
SectionHandle*)
{
Ss_INDEX_STAT_IMPL_REQ& ss = ssFind<Ss_INDEX_STAT_IMPL_REQ>(ssId);
IndexStatImplReq* req = (IndexStatImplReq*)signal->getDataPtrSend();
*req = ss.m_req;
req->senderRef = reference();
req->senderData = ssId;
const Uint32 instance = workerInstance(ss.m_worker);
NdbLogPartInfo lpinfo(instance);
//XXX remove unused
switch (req->requestType) {
case IndexStatReq::RT_START_MON:
/*
* DICT sets fragId if assigned frag is on this node, or else ZNIL
* to turn off any possible old assignment. In MT-LQH we also have
* to check which worker owns the frag.
*/
if (req->fragId != ZNIL
&& !lpinfo.partNoOwner(req->indexId, req->fragId)) {
jam();
req->fragId = ZNIL;
}
break;
case IndexStatReq::RT_STOP_MON:
/*
* DICT sets fragId to ZNIL always. There is no (pointless) check
* to see if the frag was ever assigned.
*/
ndbrequire(req->fragId == ZNIL);
break;
case IndexStatReq::RT_SCAN_FRAG:
ndbrequire(req->fragId != ZNIL);
if (!lpinfo.partNoOwner(req->indexId, req->fragId)) {
jam();
skipReq(ss);
return;
}
break;
case IndexStatReq::RT_CLEAN_NEW:
case IndexStatReq::RT_CLEAN_OLD:
case IndexStatReq::RT_CLEAN_ALL:
ndbrequire(req->fragId == ZNIL);
break;
case IndexStatReq::RT_DROP_HEAD:
/*
* Only one client can do the PK-delete of the head record. We use
* of course the worker which owns the assigned fragment.
*/
ndbrequire(req->fragId != ZNIL);
if (!lpinfo.partNoOwner(req->indexId, req->fragId)) {
jam();
skipReq(ss);
return;
}
break;
default:
ndbrequire(false);
break;
}
sendSignal(workerRef(ss.m_worker), GSN_INDEX_STAT_IMPL_REQ,
signal, IndexStatImplReq::SignalLength, JBB);
}