void
releaseSections(Uint32 secCount, SegmentedSectionPtr ptr[3]){
Uint32 tSec0 = ptr[0].i;
Uint32 tSz0 = ptr[0].sz;
Uint32 tSec1 = ptr[1].i;
Uint32 tSz1 = ptr[1].sz;
Uint32 tSec2 = ptr[2].i;
Uint32 tSz2 = ptr[2].sz;
switch(secCount){
case 3:
g_sectionSegmentPool.releaseList(relSz(tSz2), tSec2,
ptr[2].p->m_lastSegment);
case 2:
g_sectionSegmentPool.releaseList(relSz(tSz1), tSec1,
ptr[1].p->m_lastSegment);
case 1:
g_sectionSegmentPool.releaseList(relSz(tSz0), tSec0,
ptr[0].p->m_lastSegment);
case 0:
return;
}
char msg[40];
sprintf(msg, "secCount=%d", secCount);
ErrorReporter::handleAssert(msg, __FILE__, __LINE__);
}
void
release(SectionSegmentPool & thePool, SegmentedSectionPtr & ptr){
const Uint32 sz = relSz(ptr.sz);
thePool.releaseList(sz,
ptr.i,
ptr.p->m_lastSegment);
}
void
release(SPC_ARG SegmentedSectionPtr & ptr)
{
g_sectionSegmentPool.releaseList(SPC_SEIZE_ARG
relSz(ptr.sz),
ptr.i,
ptr.p->m_lastSegment);
}
void
releaseSection(SPC_ARG Uint32 firstSegmentIVal)
{
if (firstSegmentIVal != RNIL)
{
SectionSegment* p = g_sectionSegmentPool.getPtr(firstSegmentIVal);
g_sectionSegmentPool.releaseList(SPC_SEIZE_ARG
relSz(p->m_sz),
firstSegmentIVal,
p->m_lastSegment);
}
}
void
execute(void * callbackObj,
SignalHeader * const header,
Uint8 prio,
Uint32 * const theData,
LinearSectionPtr ptr[3]){
const Uint32 secCount = header->m_noOfSections;
const Uint32 length = header->theLength;
#ifdef TRACE_DISTRIBUTED
ndbout_c("recv: %s(%d) from (%s, %d)",
getSignalName(header->theVerId_signalNumber),
header->theVerId_signalNumber,
getBlockName(refToBlock(header->theSendersBlockRef)),
refToNode(header->theSendersBlockRef));
#endif
bool ok = true;
Ptr<SectionSegment> secPtr[3];
switch(secCount){
case 3:
ok &= import(secPtr[2], ptr[2].p, ptr[2].sz);
case 2:
ok &= import(secPtr[1], ptr[1].p, ptr[1].sz);
case 1:
ok &= import(secPtr[0], ptr[0].p, ptr[0].sz);
}
/**
* Check that we haven't received a too long signal
*/
ok &= (length + secCount <= 25);
Uint32 secPtrI[3];
if(ok){
/**
* Normal path
*/
secPtrI[0] = secPtr[0].i;
secPtrI[1] = secPtr[1].i;
secPtrI[2] = secPtr[2].i;
globalScheduler.execute(header, prio, theData, secPtrI);
return;
}
/**
* Out of memory
*/
for(Uint32 i = 0; i<secCount; i++){
if(secPtr[i].p != 0){
g_sectionSegmentPool.releaseList(relSz(ptr[i].sz), secPtr[i].i,
secPtr[i].p->m_lastSegment);
}
}
Uint32 gsn = header->theVerId_signalNumber;
Uint32 len = header->theLength;
Uint32 newLen= (len > 22 ? 22 : len);
SignalDroppedRep * rep = (SignalDroppedRep*)theData;
memmove(rep->originalData, theData, (4 * newLen));
rep->originalGsn = gsn;
rep->originalLength = len;
rep->originalSectionCount = secCount;
header->theVerId_signalNumber = GSN_SIGNAL_DROPPED_REP;
header->theLength = newLen + 3;
header->m_noOfSections = 0;
globalScheduler.execute(header, prio, theData, secPtrI);
}
void
release(SegmentedSectionPtr & ptr){
g_sectionSegmentPool.releaseList(relSz(ptr.sz),
ptr.i,
ptr.p->m_lastSegment);
}
