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()