inline
void BuildIndxReq::setColumnOrder(Uint32* indexBuf, Uint32 indexLen,
Uint32* keyBuf, Uint32 keyLen,
struct LinearSectionPtr orderPtr[])
{
printf("BuildIndxReq::setColumnOrder: indexLen %u, keyLen %u\n", indexLen, keyLen);
// Copy buffers
MEMCOPY_NO_WORDS(m_sectionBuffer, indexBuf, indexLen);
MEMCOPY_NO_WORDS(m_sectionBuffer + indexLen, keyBuf, keyLen);
orderPtr[INDEX_COLUMNS].p = m_sectionBuffer;
orderPtr[INDEX_COLUMNS].sz = indexLen;
orderPtr[KEY_COLUMNS].p = m_sectionBuffer + indexLen;
orderPtr[KEY_COLUMNS].sz = keyLen;
}
inline
void
copy5(Uint32 i, TestSignal & ts){
TestSignal & dst = g_jobBuffer[i];
MEMCOPY_NO_WORDS(&dst.head.data[0], &ts.head.data[0], 7);
}
void Dbtup::execSEND_PACKED(Signal* signal)
{
Uint16 hostId;
Uint32 i;
Uint32 TpackedListIndex= cpackedListIndex;
jamEntry();
for (i= 0; i < TpackedListIndex; i++) {
jam();
hostId= cpackedList[i];
ndbrequire((hostId - 1) < (MAX_NODES - 1)); // Also check not zero
Uint32 TpacketTA= hostBuffer[hostId].noOfPacketsTA;
if (TpacketTA != 0) {
jam();
BlockReference TBref= numberToRef(API_PACKED, hostId);
Uint32 TpacketLen= hostBuffer[hostId].packetLenTA;
MEMCOPY_NO_WORDS(&signal->theData[0],
&hostBuffer[hostId].packetBufferTA[0],
TpacketLen);
sendSignal(TBref, GSN_TRANSID_AI, signal, TpacketLen, JBB);
hostBuffer[hostId].noOfPacketsTA= 0;
hostBuffer[hostId].packetLenTA= 0;
}
hostBuffer[hostId].inPackedList= false;
}//for
cpackedListIndex= 0;
}
void Dbtup::lcpFlushLogLab(Signal* signal, CheckpointInfoPtr ciPtr)
{
DiskBufferSegmentInfoPtr oldDbsiPtr;
LocalLogInfoPtr lliPtr;
UndoPagePtr oldUndoPagePtr;
UndoPagePtr newUndoPagePtr;
lliPtr.i = ciPtr.p->lcpLocalLogInfoP;
ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
oldDbsiPtr.i = lliPtr.p->lliUndoBufferSegmentP;
ptrCheckGuard(oldDbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
oldDbsiPtr.p->pdxNumDataPages++;
if (clblPageCounter > 0) {
ljam();
clblPageCounter--;
}//if
oldUndoPagePtr.i = lliPtr.p->lliUndoPage;
ptrCheckGuard(oldUndoPagePtr, cnoOfUndoPage, undoPage);
lcpWriteUndoSegment(signal, lliPtr.p, true);
oldDbsiPtr.p->pdxOperation = CHECKPOINT_UNDO_WRITE_FLUSH;
oldDbsiPtr.p->pdxCheckpointInfoP = ciPtr.i;
/* ---------------------------------------------------------------- */
/* SINCE LAST PAGE SENT TO DISK WAS NOT FULL YET WE COPY IT */
/* TO THE NEW LAST PAGE. */
/* ---------------------------------------------------------------- */
newUndoPagePtr.i = lliPtr.p->lliUndoPage;
ptrCheckGuard(newUndoPagePtr, cnoOfUndoPage, undoPage);
ndbrequire(lliPtr.p->lliUndoWord < ZWORDS_ON_PAGE);
MEMCOPY_NO_WORDS(&newUndoPagePtr.p->undoPageWord[0],
&oldUndoPagePtr.p->undoPageWord[0],
lliPtr.p->lliUndoWord);
}//Dbtup::lcpFlushLogLab()
void
Trpman::execENABLE_COMREQ(Signal* signal)
{
jamEntry();
const EnableComReq *enableComReq = (const EnableComReq *)signal->getDataPtr();
/* Need to copy out signal data to not clobber it with sendSignal(). */
BlockReference senderRef = enableComReq->m_senderRef;
Uint32 senderData = enableComReq->m_senderData;
Uint32 nodes[NodeBitmask::Size];
MEMCOPY_NO_WORDS(nodes, enableComReq->m_nodeIds, NodeBitmask::Size);
/* Enable communication with all our NDB blocks to these nodes. */
Uint32 search_from = 1;
for (;;)
{
Uint32 tStartingNode = NodeBitmask::find(nodes, search_from);
if (tStartingNode == NodeBitmask::NotFound)
break;
search_from = tStartingNode + 1;
if (!handles_this_node(tStartingNode))
continue;
globalTransporterRegistry.setIOState(tStartingNode, NoHalt);
setNodeInfo(tStartingNode).m_connected = true;
//-----------------------------------------------------
// Report that the version of the node
//-----------------------------------------------------
signal->theData[0] = NDB_LE_ConnectedApiVersion;
signal->theData[1] = tStartingNode;
signal->theData[2] = getNodeInfo(tStartingNode).m_version;
signal->theData[3] = getNodeInfo(tStartingNode).m_mysql_version;
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 4, JBB);
//-----------------------------------------------------
}
EnableComConf *enableComConf = (EnableComConf *)signal->getDataPtrSend();
enableComConf->m_senderRef = reference();
enableComConf->m_senderData = senderData;
MEMCOPY_NO_WORDS(enableComConf->m_nodeIds, nodes, NodeBitmask::Size);
sendSignal(senderRef, GSN_ENABLE_COMCONF, signal,
EnableComConf::SignalLength, JBA);
}
void Dbtup::bufferTRANSID_AI(Signal* signal, BlockReference aRef,
Uint32 Tlen)
{
if (Tlen == 3)
return;
Uint32 hostId= refToNode(aRef);
Uint32 Theader= ((refToBlock(aRef) << 16)+(Tlen-3));
ndbrequire(hostId < MAX_NODES);
Uint32 TpacketLen= hostBuffer[hostId].packetLenTA;
Uint32 TnoOfPackets= hostBuffer[hostId].noOfPacketsTA;
Uint32 sig0= signal->theData[0];
Uint32 sig1= signal->theData[1];
Uint32 sig2= signal->theData[2];
BlockReference TBref= numberToRef(API_PACKED, hostId);
if ((Tlen + TpacketLen + 1) <= 25) {
// ----------------------------------------------------------------
// There is still space in the buffer. We will copy it into the
// buffer.
// ----------------------------------------------------------------
jam();
updatePackedList(signal, hostId);
} else if (false && TnoOfPackets == 1) {
// ----------------------------------------------------------------
// The buffer is full and there was only one packet buffered. We
// will send this as a normal signal.
// ----------------------------------------------------------------
Uint32 TnewRef= numberToRef((hostBuffer[hostId].packetBufferTA[0] >> 16),
hostId);
MEMCOPY_NO_WORDS(&signal->theData[0],
&hostBuffer[hostId].packetBufferTA[1],
TpacketLen - 1);
sendSignal(TnewRef, GSN_TRANSID_AI, signal, (TpacketLen - 1), JBB);
TpacketLen= 0;
TnoOfPackets= 0;
} else {
void Dbtup::sendTrigAttrInfo(Signal* signal,
Uint32* data,
Uint32 dataLen,
bool executeDirect,
BlockReference receiverReference)
{
TrigAttrInfo* const trigAttrInfo = (TrigAttrInfo *)signal->getDataPtrSend();
Uint32 sigLen;
Uint32 dataIndex = 0;
do {
sigLen = dataLen - dataIndex;
if (sigLen > TrigAttrInfo::DataLength) {
jam();
sigLen = TrigAttrInfo::DataLength;
}
MEMCOPY_NO_WORDS(trigAttrInfo->getData(),
data + dataIndex,
sigLen);
if (executeDirect) {
jam();
EXECUTE_DIRECT(receiverReference,
GSN_TRIG_ATTRINFO,
signal,
TrigAttrInfo::StaticLength + sigLen);
jamEntry();
} else {
jam();
sendSignal(receiverReference,
GSN_TRIG_ATTRINFO,
signal,
TrigAttrInfo::StaticLength + sigLen,
JBB);
}
dataIndex += sigLen;
} while (dataLen != dataIndex);
}
bool Dbtup::storedProcedureAttrInfo(Signal* signal,
Operationrec* regOperPtr,
const Uint32 *data,
Uint32 length,
bool copyProcedure)
{
AttrbufrecPtr regAttrPtr;
Uint32 RnoFree = cnoFreeAttrbufrec;
if (ERROR_INSERTED(4004) && !copyProcedure) {
CLEAR_ERROR_INSERT_VALUE;
storedSeizeAttrinbufrecErrorLab(signal, regOperPtr, ZSTORED_SEIZE_ATTRINBUFREC_ERROR);
return false;
}//if
regOperPtr->currentAttrinbufLen += length;
ndbrequire(regOperPtr->currentAttrinbufLen <= regOperPtr->attrinbufLen);
if ((RnoFree > MIN_ATTRBUF) ||
(copyProcedure)) {
jam();
regAttrPtr.i = cfirstfreeAttrbufrec;
ptrCheckGuard(regAttrPtr, cnoOfAttrbufrec, attrbufrec);
regAttrPtr.p->attrbuf[ZBUF_DATA_LEN] = 0;
cfirstfreeAttrbufrec = regAttrPtr.p->attrbuf[ZBUF_NEXT];
cnoFreeAttrbufrec = RnoFree - 1;
regAttrPtr.p->attrbuf[ZBUF_NEXT] = RNIL;
} else {
jam();
storedSeizeAttrinbufrecErrorLab(signal, regOperPtr, ZSTORED_SEIZE_ATTRINBUFREC_ERROR);
return false;
}//if
if (regOperPtr->firstAttrinbufrec == RNIL) {
jam();
regOperPtr->firstAttrinbufrec = regAttrPtr.i;
}//if
regAttrPtr.p->attrbuf[ZBUF_NEXT] = RNIL;
if (regOperPtr->lastAttrinbufrec != RNIL) {
AttrbufrecPtr tempAttrinbufptr;
jam();
tempAttrinbufptr.i = regOperPtr->lastAttrinbufrec;
ptrCheckGuard(tempAttrinbufptr, cnoOfAttrbufrec, attrbufrec);
tempAttrinbufptr.p->attrbuf[ZBUF_NEXT] = regAttrPtr.i;
}//if
regOperPtr->lastAttrinbufrec = regAttrPtr.i;
regAttrPtr.p->attrbuf[ZBUF_DATA_LEN] = length;
MEMCOPY_NO_WORDS(®AttrPtr.p->attrbuf[0],
data,
length);
if (regOperPtr->currentAttrinbufLen < regOperPtr->attrinbufLen) {
jam();
return true;
}//if
if (ERROR_INSERTED(4005) && !copyProcedure) {
CLEAR_ERROR_INSERT_VALUE;
storedSeizeAttrinbufrecErrorLab(signal, regOperPtr, ZSTORED_SEIZE_ATTRINBUFREC_ERROR);
return false;
}//if
StoredProcPtr storedPtr;
c_storedProcPool.getPtr(storedPtr, (Uint32)regOperPtr->storedProcPtr);
ndbrequire(storedPtr.p->storedCode == ZSCAN_PROCEDURE);
regOperPtr->currentAttrinbufLen = 0;
storedPtr.p->storedLinkFirst = regOperPtr->firstAttrinbufrec;
storedPtr.p->storedLinkLast = regOperPtr->lastAttrinbufrec;
regOperPtr->firstAttrinbufrec = RNIL;
regOperPtr->lastAttrinbufrec = RNIL;
regOperPtr->m_any_value = 0;
set_trans_state(regOperPtr, TRANS_IDLE);
signal->theData[0] = regOperPtr->userpointer;
signal->theData[1] = storedPtr.i;
sendSignal(DBLQH_REF, GSN_STORED_PROCCONF, signal, 2, JBB);
return true;
}//Dbtup::storedProcedureAttrInfo()
// Debugging
void
Trix::execDUMP_STATE_ORD(Signal* signal)
{
jamEntry();
DumpStateOrd * dumpStateOrd = (DumpStateOrd *)signal->getDataPtr();
switch(dumpStateOrd->args[0]) {
case(300): {// ok
// index2 -T; index2 -I -n10000; index2 -c
// all dump 300 0 0 0 0 0 4 2
// select_count INDEX0000
BuildIndxReq * buildIndxReq = (BuildIndxReq *)signal->getDataPtrSend();
MEMCOPY_NO_WORDS(buildIndxReq,
signal->theData + 1,
BuildIndxReq::SignalLength);
buildIndxReq->setUserRef(reference()); // return to me
buildIndxReq->setParallelism(10);
Uint32 indexColumns[1] = {1};
Uint32 keyColumns[1] = {0};
struct LinearSectionPtr orderPtr[2];
buildIndxReq->setColumnOrder(indexColumns, 1, keyColumns, 1, orderPtr);
sendSignal(reference(),
GSN_BUILDINDXREQ,
signal,
BuildIndxReq::SignalLength,
JBB,
orderPtr,
BuildIndxReq::NoOfSections);
break;
}
case(301): { // ok
// index2 -T; index2 -I -n10000; index2 -c -p
// all dump 301 0 0 0 0 0 4 2
// select_count INDEX0000
BuildIndxReq * buildIndxReq = (BuildIndxReq *)signal->getDataPtrSend();
MEMCOPY_NO_WORDS(buildIndxReq,
signal->theData + 1,
BuildIndxReq::SignalLength);
buildIndxReq->setUserRef(reference()); // return to me
buildIndxReq->setParallelism(10);
Uint32 indexColumns[2] = {0, 1};
Uint32 keyColumns[1] = {0};
struct LinearSectionPtr orderPtr[2];
buildIndxReq->setColumnOrder(indexColumns, 2, keyColumns, 1, orderPtr);
sendSignal(reference(),
GSN_BUILDINDXREQ,
signal,
BuildIndxReq::SignalLength,
JBB,
orderPtr,
BuildIndxReq::NoOfSections);
break;
}
case(302): { // ok
// index -T; index -I -n1000; index -c -p
// all dump 302 0 0 0 0 0 4 2
// select_count PNUMINDEX0000
BuildIndxReq * buildIndxReq = (BuildIndxReq *)signal->getDataPtrSend();
MEMCOPY_NO_WORDS(buildIndxReq,
signal->theData + 1,
BuildIndxReq::SignalLength);
buildIndxReq->setUserRef(reference()); // return to me
buildIndxReq->setParallelism(10);
Uint32 indexColumns[3] = {0, 3, 5};
Uint32 keyColumns[1] = {0};
struct LinearSectionPtr orderPtr[2];
buildIndxReq->setColumnOrder(indexColumns, 3, keyColumns, 1, orderPtr);
sendSignal(reference(),
GSN_BUILDINDXREQ,
signal,
BuildIndxReq::SignalLength,
JBB,
orderPtr,
BuildIndxReq::NoOfSections);
break;
}
case(303): { // ok
// index -T -2; index -I -2 -n1000; index -c -p
// all dump 303 0 0 0 0 0 4 2
// select_count PNUMINDEX0000
BuildIndxReq * buildIndxReq = (BuildIndxReq *)signal->getDataPtrSend();
MEMCOPY_NO_WORDS(buildIndxReq,
signal->theData + 1,
BuildIndxReq::SignalLength);
buildIndxReq->setUserRef(reference()); // return to me
buildIndxReq->setParallelism(10);
Uint32 indexColumns[3] = {0, 3, 5};
Uint32 keyColumns[2] = {0, 1};
struct LinearSectionPtr orderPtr[2];
buildIndxReq->setColumnOrder(indexColumns, 3, keyColumns, 2, orderPtr);
sendSignal(reference(),
GSN_BUILDINDXREQ,
signal,
BuildIndxReq::SignalLength,
JBB,
orderPtr,
BuildIndxReq::NoOfSections);
break;
}
case(304): { // ok
// index -T -L; index -I -L -n1000; index -c -p
// all dump 304 0 0 0 0 0 4 2
// select_count PNUMINDEX0000
BuildIndxReq * buildIndxReq = (BuildIndxReq *)signal->getDataPtrSend();
MEMCOPY_NO_WORDS(buildIndxReq,
signal->theData + 1,
BuildIndxReq::SignalLength);
buildIndxReq->setUserRef(reference()); // return to me
buildIndxReq->setParallelism(10);
Uint32 indexColumns[3] = {0, 3, 5};
Uint32 keyColumns[1] = {0};
struct LinearSectionPtr orderPtr[2];
buildIndxReq->setColumnOrder(indexColumns, 3, keyColumns, 1, orderPtr);
sendSignal(reference(),
GSN_BUILDINDXREQ,
signal,
BuildIndxReq::SignalLength,
JBB,
orderPtr,
BuildIndxReq::NoOfSections);
break;
}
case(305): { // ok
// index -T -2 -L; index -I -2 -L -n1000; index -c -p
// all dump 305 0 0 0 0 0 4 2
// select_count PNUMINDEX0000
BuildIndxReq * buildIndxReq = (BuildIndxReq *)signal->getDataPtrSend();
MEMCOPY_NO_WORDS(buildIndxReq,
signal->theData + 1,
BuildIndxReq::SignalLength);
buildIndxReq->setUserRef(reference()); // return to me
buildIndxReq->setParallelism(10);
Uint32 indexColumns[3] = {0, 3, 5};
Uint32 keyColumns[2] = {0, 1};
struct LinearSectionPtr orderPtr[2];
buildIndxReq->setColumnOrder(indexColumns, 3, keyColumns, 2, orderPtr);
sendSignal(reference(),
GSN_BUILDINDXREQ,
signal,
BuildIndxReq::SignalLength,
JBB,
orderPtr,
BuildIndxReq::NoOfSections);
break;
}
default: {
// Ignore
}
}
}
void Dbinfo::execDBINFO_SCANCONF(Signal *signal)
{
const DbinfoScanConf* conf_ptr= (const DbinfoScanConf*)signal->getDataPtr();
// Copy signal on stack
DbinfoScanConf conf= *conf_ptr;
jamEntry();
//printDBINFO_SCAN(stdout, signal->theData, signal->getLength(), 0);
Uint32 signal_length = signal->getLength();
ndbrequire(signal_length ==
DbinfoScanReq::SignalLength+Ndbinfo::ScanCursor::Length);
ndbrequire(conf.cursor_sz == Ndbinfo::ScanCursor::Length);
// Validate tableId
const Uint32 tableId= conf.tableId;
ndbassert(tableId < (Uint32)Ndbinfo::getNumTables());
const Uint32 resultRef = conf.resultRef;
// Copy cursor on stack
ndbrequire(conf.cursor_sz);
Ndbinfo::ScanCursor* cursor =
CAST_PTR(Ndbinfo::ScanCursor, DbinfoScan::getCursorPtrSend(&conf));
if (Ndbinfo::ScanCursor::getHasMoreData(cursor->flags) || conf.returnedRows)
{
// Rate limit break, pass through to API
jam();
ndbrequire(cursor->currRef);
DbinfoScanConf *apiconf = (DbinfoScanConf*) signal->getDataPtrSend();
MEMCOPY_NO_WORDS(apiconf, &conf, signal_length);
sendSignal(resultRef, GSN_DBINFO_SCANCONF, signal, signal_length, JBB);
return;
}
if (find_next(cursor))
{
jam();
ndbrequire(cursor->currRef);
// CONF or REF should be sent back here
cursor->senderRef = reference();
// Send SCANREQ
MEMCOPY_NO_WORDS(signal->getDataPtrSend(),
&conf, signal_length);
sendSignal(cursor->currRef,
GSN_DBINFO_SCANREQ,
signal, signal_length, JBB);
return;
}
// Scan is done, send SCANCONF back to caller
jam();
DbinfoScanConf *apiconf = (DbinfoScanConf*) signal->getDataPtrSend();
MEMCOPY_NO_WORDS(apiconf, &conf, DbinfoScanConf::SignalLength);
// Set cursor_sz back to 0 to indicate end of scan
apiconf->cursor_sz = 0;
sendSignal(resultRef, GSN_DBINFO_SCANCONF, signal,
DbinfoScanConf::SignalLength, JBB);
return;
}
void Dbinfo::execDBINFO_SCANREQ(Signal *signal)
{
jamEntry();
DbinfoScanReq* req_ptr = (DbinfoScanReq*)signal->getDataPtrSend();
const Uint32 senderRef = signal->header.theSendersBlockRef;
// Copy signal on stack
DbinfoScanReq req = *req_ptr;
const Uint32 resultData = req.resultData;
const Uint32 transId0 = req.transId[0];
const Uint32 transId1 = req.transId[1];
const Uint32 resultRef = req.resultRef;
// Validate tableId
const Uint32 tableId = req.tableId;
if (tableId >= (Uint32)Ndbinfo::getNumTables())
{
jam();
DbinfoScanRef *ref= (DbinfoScanRef*)signal->getDataPtrSend();
ref->resultData = resultData;
ref->transId[0] = transId0;
ref->transId[1] = transId1;
ref->resultRef = resultRef;
ref->errorCode= DbinfoScanRef::NoTable;
sendSignal(senderRef, GSN_DBINFO_SCANREF, signal,
DbinfoScanRef::SignalLength, JBB);
return;
}
// TODO Check all scan parameters
Ndbinfo::ScanCursor* cursor =
CAST_PTR(Ndbinfo::ScanCursor, DbinfoScan::getCursorPtrSend(&req));
Uint32 signal_length = signal->getLength();
if (signal_length == DbinfoScanReq::SignalLength)
{
// Initialize cursor
jam();
cursor->senderRef = senderRef;
cursor->saveSenderRef = 0;
cursor->currRef = 0;
cursor->saveCurrRef = 0;
// Reset all data holders
memset(cursor->data, 0, sizeof(cursor->data));
cursor->flags = 0;
cursor->totalRows = 0;
cursor->totalBytes = 0;
req.cursor_sz = Ndbinfo::ScanCursor::Length;
signal_length += req.cursor_sz;
}
ndbrequire(signal_length ==
DbinfoScanReq::SignalLength + Ndbinfo::ScanCursor::Length);
ndbrequire(req.cursor_sz == Ndbinfo::ScanCursor::Length);
switch(tableId)
{
case Ndbinfo::TABLES_TABLEID:
{
jam();
Ndbinfo::Ratelimit rl;
Uint32 tableId = cursor->data[0];
while(tableId < (Uint32)Ndbinfo::getNumTables())
{
jam();
const Ndbinfo::Table& tab = Ndbinfo::getTable(tableId);
Ndbinfo::Row row(signal, req);
row.write_uint32(tableId);
row.write_string(tab.m.name);
row.write_string(tab.m.comment);
ndbinfo_send_row(signal, req, row, rl);
tableId++;
if (rl.need_break(req))
{
jam();
ndbinfo_send_scan_break(signal, req, rl, tableId);
return;
}
}
// All tables sent
req.cursor_sz = 0; // Close cursor
ndbinfo_send_scan_conf(signal, req, rl);
return;
break;
}
case Ndbinfo::COLUMNS_TABLEID:
{
jam();
Ndbinfo::Ratelimit rl;
Uint32 tableId = cursor->data[0];
Uint32 columnId = cursor->data[1];
while(tableId < (Uint32)Ndbinfo::getNumTables())
{
jam();
const Ndbinfo::Table& tab = Ndbinfo::getTable(tableId);
while(columnId < (Uint32)tab.m.ncols)
{
jam();
Ndbinfo::Row row(signal, req);
row.write_uint32(tableId);
row.write_uint32(columnId);
row.write_string(tab.col[columnId].name);
row.write_uint32(tab.col[columnId].coltype);
row.write_string(tab.col[columnId].comment);
ndbinfo_send_row(signal, req, row, rl);
assert(columnId < 256);
columnId++;
if(rl.need_break(req))
{
jam();
ndbinfo_send_scan_break(signal, req, rl, tableId, columnId);
return;
}
}
columnId = 0;
tableId++;
}
// All tables and columns sent
req.cursor_sz = 0; // Close cursor
ndbinfo_send_scan_conf(signal, req, rl);
break;
}
default:
{
jam();
ndbassert(tableId > 1);
//printSignalHeader(stdout, signal->header, 99, 98, true);
//printDBINFO_SCAN(stdout, signal->theData, signal->getLength(), 0);
if (Ndbinfo::ScanCursor::getHasMoreData(cursor->flags) ||
find_next(cursor))
{
jam();
ndbrequire(cursor->currRef);
// CONF or REF should be sent back here
cursor->senderRef = reference();
// Send SCANREQ
MEMCOPY_NO_WORDS(req_ptr,
&req, signal_length);
sendSignal(cursor->currRef,
GSN_DBINFO_SCANREQ,
signal, signal_length, JBB);
}
else
{
// Scan is done, send SCANCONF back to caller
jam();
DbinfoScanConf *apiconf= (DbinfoScanConf*)signal->getDataPtrSend();
MEMCOPY_NO_WORDS(apiconf, &req, DbinfoScanConf::SignalLength);
// Set cursor_sz back to 0 to indicate end of scan
apiconf->cursor_sz = 0;
sendSignal(resultRef, GSN_DBINFO_SCANCONF, signal,
DbinfoScanConf::SignalLength, JBB);
}
break;
}
}
}
/* ---------------------------------------------------------------- */
void Dbtup::lcpSaveDataPageLab(Signal* signal, Uint32 ciIndex)
{
CheckpointInfoPtr ciPtr;
DiskBufferSegmentInfoPtr dbsiPtr;
FragrecordPtr regFragPtr;
LocalLogInfoPtr lliPtr;
UndoPagePtr undoCopyPagePtr;
PagePtr pagePtr;
ciPtr.i = ciIndex;
ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo);
if (ERROR_INSERTED(4000)){
if (ciPtr.p->lcpTabPtr == c_errorInsert4000TableId) {
// Delay writing of data pages during LCP
ndbout << "Delay writing of data pages during LCP" << endl;
signal->theData[0] = ZCONT_SAVE_DP;
signal->theData[1] = ciIndex;
sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 1000, 2);
return;
}//if
}//if
if (clblPageCounter == 0) {
ljam();
signal->theData[0] = ZCONT_SAVE_DP;
signal->theData[1] = ciPtr.i;
sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 100, 2);
return;
} else {
ljam();
clblPageCounter--;
}//if
regFragPtr.i = ciPtr.p->lcpFragmentP;
ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
dbsiPtr.i = ciPtr.p->lcpDataBufferSegmentP;
ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
pagePtr.i = getRealpid(regFragPtr.p, regFragPtr.p->minPageNotWrittenInCheckpoint);
ptrCheckGuard(pagePtr, cnoOfPage, page);
ndbrequire(dbsiPtr.p->pdxNumDataPages < 16);
undoCopyPagePtr.i = dbsiPtr.p->pdxDataPage[dbsiPtr.p->pdxNumDataPages];
ptrCheckGuard(undoCopyPagePtr, cnoOfUndoPage, undoPage);
MEMCOPY_NO_WORDS(&undoCopyPagePtr.p->undoPageWord[0],
&pagePtr.p->pageWord[0],
ZWORDS_ON_PAGE);
regFragPtr.p->minPageNotWrittenInCheckpoint++;
dbsiPtr.p->pdxNumDataPages++;
if (regFragPtr.p->minPageNotWrittenInCheckpoint == regFragPtr.p->maxPageWrittenInCheckpoint) {
/* ---------------------------------------------------------- */
/* ALL PAGES ARE COPIED, TIME TO FINISH THE CHECKPOINT */
/* SAVE THE END POSITIONS OF THE LOG RECORDS SINCE ALL DATA */
/* PAGES ARE NOW SAFE ON DISK AND NO MORE LOGGING WILL APPEAR */
/* ---------------------------------------------------------- */
ljam();
lliPtr.i = ciPtr.p->lcpLocalLogInfoP;
ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
regFragPtr.p->checkpointVersion = RNIL; /* UNDO LOGGING IS SHUT OFF */
lcpWriteListDataPageSegment(signal, dbsiPtr, ciPtr, false);
dbsiPtr.p->pdxOperation = CHECKPOINT_DATA_WRITE_LAST;
} else if (dbsiPtr.p->pdxNumDataPages == ZDB_SEGMENT_SIZE) {
ljam();
lcpWriteListDataPageSegment(signal, dbsiPtr, ciPtr, false);
dbsiPtr.p->pdxOperation = CHECKPOINT_DATA_WRITE;
} else {
ljam();
signal->theData[0] = ZCONT_SAVE_DP;
signal->theData[1] = ciPtr.i;
sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);
}//if
}//Dbtup::lcpSaveDataPageLab()
