int
SHM_Transporter::doSend()
{
struct iovec iov[64];
Uint32 cnt = fetch_send_iovec_data(iov, NDB_ARRAY_SIZE(iov));
if (cnt == 0)
{
return 0;
}
Uint32 sum = 0;
for(Uint32 i = 0; i<cnt; i++)
{
assert(iov[i].iov_len);
sum += iov[i].iov_len;
}
int nBytesSent = writer->writev(iov, cnt);
if (nBytesSent > 0)
{
kill(m_remote_pid, g_ndb_shm_signum);
iovec_data_sent(nBytesSent);
if (Uint32(nBytesSent) == sum && (cnt != NDB_ARRAY_SIZE(iov)))
{
return 0;
}
return 1;
}
return 1;
}
void
Dbtup::execALTER_TAB_CONF(Signal* signal)
{
jamEntry();
AlterTabConf* conf = (AlterTabConf*)signal->getDataPtr();
BuildIndexPtr buildPtr;
buildPtr.i = conf->senderData;
c_buildIndexList.getPtr(buildPtr);
if (buildPtr.p->m_fragNo == 0)
{
jam();
buildIndexOffline_table_readonly(signal, conf->senderData);
return;
}
else
{
jam();
TablerecPtr tablePtr;
(void)tablePtr; // hide unused warning
ndbrequire(buildPtr.p->m_fragNo >= NDB_ARRAY_SIZE(tablePtr.p->fragid));
buildIndexReply(signal, buildPtr.p);
c_buildIndexList.release(buildPtr);
return;
}
}
void
DblqhProxy::execLQH_TRANSREQ(Signal* signal)
{
jamEntry();
if (!checkNodeFailSequence(signal))
{
jam();
return;
}
const LqhTransReq* req = (const LqhTransReq*)signal->getDataPtr();
Ss_LQH_TRANSREQ& ss = ssSeize<Ss_LQH_TRANSREQ>();
ss.m_req = *req;
ndbrequire(signal->getLength() == LqhTransReq::SignalLength);
sendREQ(signal, ss);
/**
* See if this is a "resend" (i.e multi TC failure)
* and if so, mark "old" record as invalid
*/
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 != ss.m_ssId &&
c_ss_LQH_TRANSREQ.m_pool[i].m_req.failedNodeId == nodeId)
{
jam();
c_ss_LQH_TRANSREQ.m_pool[i].m_valid = false;
}
}
}
SimpleSignal::~SimpleSignal() {
if(!deallocSections)
return;
for (Uint32 i = 0; i<NDB_ARRAY_SIZE(ptr); i++)
{
if (ptr[i].p != 0)
{
delete [] ptr[i].p;
}
}
}
SimpleSignal::SimpleSignal(const SimpleSignal& src)
: header(src.header)
{
deallocSections = true;
for (Uint32 i = 0; i<NDB_ARRAY_SIZE(ptr); i++)
{
ptr[i].p = 0;
if (src.ptr[i].p != 0)
{
ptr[i].p = new Uint32[src.ptr[i].sz];
ptr[i].sz = src.ptr[i].sz;
memcpy(ptr[i].p, src.ptr[i].p, 4 * src.ptr[i].sz);
}
}
}
SimpleSignal&
SimpleSignal::operator=(const SimpleSignal& src)
{
deallocSections = true;
header = src.header;
for (Uint32 i = 0; i<NDB_ARRAY_SIZE(ptr); i++)
{
ptr[i].p = 0;
if (src.ptr[i].p != 0)
{
ptr[i].p = new Uint32[src.ptr[i].sz];
ptr[i].sz = src.ptr[i].sz;
memcpy(ptr[i].p, src.ptr[i].p, 4 * src.ptr[i].sz);
}
}
return * this;
}
void
Dbtup::execBUILD_INDX_IMPL_REF(Signal* signal)
{
jamEntry();
BuildIndxImplRef* ref = (BuildIndxImplRef*)signal->getDataPtrSend();
Uint32 ptr = ref->senderData;
Uint32 err = ref->errorCode;
BuildIndexPtr buildPtr;
c_buildIndexList.getPtr(buildPtr, ptr);
ndbrequire(buildPtr.p->m_outstanding);
buildPtr.p->m_outstanding--;
TablerecPtr tablePtr;
(void)tablePtr; // hide unused warning
buildPtr.p->m_errorCode = (BuildIndxImplRef::ErrorCode)err;
// No point in starting any more
buildPtr.p->m_fragNo = NDB_ARRAY_SIZE(tablePtr.p->fragrec);
buildIndexOffline_table_readonly(signal, ptr);
}
int
Dbtup::mt_scan_init(Uint32 tableId, Uint32 fragId,
Local_key* pos, Uint32 * fragPtrI)
{
TablerecPtr tablePtr;
tablePtr.i = tableId;
ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
FragrecordPtr fragPtr;
fragPtr.i = RNIL;
for (Uint32 i = 0; i<NDB_ARRAY_SIZE(tablePtr.p->fragid); i++)
{
if (tablePtr.p->fragid[i] == fragId)
{
fragPtr.i = tablePtr.p->fragrec[i];
break;
}
}
if (fragPtr.i == RNIL)
return -1;
ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
Uint32 fragPageId = 0;
while (fragPageId < fragPtr.p->m_max_page_cnt)
{
Uint32 realPageId= getRealpidCheck(fragPtr.p, fragPageId);
if (realPageId != RNIL)
{
* fragPtrI = fragPtr.i;
pos->m_page_no = realPageId;
pos->m_page_idx = 0;
pos->m_file_no = 0;
return 0;
}
fragPageId++;
}
return 1;
}
void
DblqhProxy::execLQH_TRANSREQ(Signal* signal)
{
jamEntry();
if (!checkNodeFailSequence(signal))
{
jam();
return;
}
const LqhTransReq* req = (const LqhTransReq*)signal->getDataPtr();
Ss_LQH_TRANSREQ& ss = ssSeize<Ss_LQH_TRANSREQ>();
ss.m_maxInstanceId = 0;
ss.m_req = *req;
if (signal->getLength() < LqhTransReq::SignalLength)
{
/**
* TC that performs take over doesn't suppport taking over one
* TC instance at a time
*/
ss.m_req.instanceId = RNIL;
}
ndbrequire(signal->getLength() <= LqhTransReq::SignalLength);
sendREQ(signal, ss);
/**
* See if this is a "resend" (i.e multi TC failure)
* and if so, mark "old" record as invalid
*/
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 != ss.m_ssId &&
c_ss_LQH_TRANSREQ.m_pool[i].m_req.failedNodeId == nodeId)
{
jam();
c_ss_LQH_TRANSREQ.m_pool[i].m_valid = false;
}
}
}
void
Dbtup::buildIndexOffline_table_readonly(Signal* signal, Uint32 buildPtrI)
{
// get build record
BuildIndexPtr buildPtr;
buildPtr.i= buildPtrI;
c_buildIndexList.getPtr(buildPtr);
const BuildIndxImplReq* buildReq =
(const BuildIndxImplReq*)&buildPtr.p->m_request;
// get table
TablerecPtr tablePtr;
tablePtr.i= buildReq->tableId;
ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
for (;buildPtr.p->m_fragNo < NDB_ARRAY_SIZE(tablePtr.p->fragrec);
buildPtr.p->m_fragNo++)
{
jam();
FragrecordPtr fragPtr;
fragPtr.i = tablePtr.p->fragrec[buildPtr.p->m_fragNo];
if (fragPtr.i == RNIL)
{
jam();
continue;
}
ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
mt_BuildIndxReq req;
bzero(&req, sizeof(req));
req.senderRef = reference();
req.senderData = buildPtr.i;
req.tableId = buildReq->tableId;
req.indexId = buildPtr.p->m_indexId;
req.fragId = tablePtr.p->fragid[buildPtr.p->m_fragNo];
SimulatedBlock * tux = globalData.getBlock(DBTUX);
if (instance() != 0)
{
tux = tux->getInstance(instance());
ndbrequire(tux != 0);
}
req.tux_ptr = tux;
req.tup_ptr = this;
req.func_ptr = Dbtux_mt_buildIndexFragment_wrapper_C;
req.buffer_size = 16*32768; // thread-local-buffer
Uint32 * req_ptr = signal->getDataPtrSend();
memcpy(req_ptr, &req, sizeof(req));
sendSignal(NDBFS_REF, GSN_BUILD_INDX_IMPL_REQ, signal,
(sizeof(req) + 15) / 4, JBB);
buildPtr.p->m_outstanding++;
if (buildPtr.p->m_outstanding >= m_max_parallel_index_build)
{
jam();
return;
}
}
if (buildPtr.p->m_outstanding == 0)
{
jam();
AlterTabReq* req = (AlterTabReq*)signal->getDataPtrSend();
/**
* Note: before 7.3.4, 7.2.15, 7.1.30 fifth word and
* up was undefined.
*/
bzero(req, sizeof(*req));
req->senderRef = reference();
req->senderData = buildPtrI;
req->tableId = buildReq->tableId;
req->requestType = AlterTabReq::AlterTableReadWrite;
sendSignal(calcInstanceBlockRef(DBLQH), GSN_ALTER_TAB_REQ, signal,
AlterTabReq::SignalLength, JBB);
return;
}
else
{
jam();
// wait for replies
return;
}
}
void
Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
{
// get build record
BuildIndexPtr buildPtr;
buildPtr.i= buildPtrI;
c_buildIndexList.getPtr(buildPtr);
const BuildIndxImplReq* buildReq= &buildPtr.p->m_request;
// get table
TablerecPtr tablePtr;
tablePtr.i= buildReq->tableId;
ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
const Uint32 firstTupleNo = 0;
const Uint32 tupheadsize = tablePtr.p->m_offsets[MM].m_fix_header_size;
#ifdef TIME_MEASUREMENT
NDB_TICKS start;
NDB_TICKS stop;
Uint64 time_passed;
#endif
do {
// get fragment
FragrecordPtr fragPtr;
if (buildPtr.p->m_fragNo == NDB_ARRAY_SIZE(tablePtr.p->fragrec)) {
jam();
// build ready
buildIndexReply(signal, buildPtr.p);
c_buildIndexList.release(buildPtr);
return;
}
ndbrequire(buildPtr.p->m_fragNo < NDB_ARRAY_SIZE(tablePtr.p->fragrec));
fragPtr.i= tablePtr.p->fragrec[buildPtr.p->m_fragNo];
if (fragPtr.i == RNIL) {
jam();
buildPtr.p->m_fragNo++;
buildPtr.p->m_pageId= 0;
buildPtr.p->m_tupleNo= firstTupleNo;
break;
}
ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
// get page
PagePtr pagePtr;
if (buildPtr.p->m_pageId >= fragPtr.p->m_max_page_cnt)
{
jam();
buildPtr.p->m_fragNo++;
buildPtr.p->m_pageId= 0;
buildPtr.p->m_tupleNo= firstTupleNo;
break;
}
Uint32 realPageId= getRealpidCheck(fragPtr.p, buildPtr.p->m_pageId);
// skip empty page
if (realPageId == RNIL)
{
jam();
goto next_tuple;
}
c_page_pool.getPtr(pagePtr, realPageId);
next_tuple:
// get tuple
Uint32 pageIndex = ~0;
const Tuple_header* tuple_ptr = 0;
pageIndex = buildPtr.p->m_tupleNo * tupheadsize;
if (pageIndex + tupheadsize > Fix_page::DATA_WORDS) {
jam();
buildPtr.p->m_pageId++;
buildPtr.p->m_tupleNo= firstTupleNo;
break;
}
if (realPageId == RNIL)
{
jam();
buildPtr.p->m_tupleNo++;
break;
}
tuple_ptr = (Tuple_header*)&pagePtr.p->m_data[pageIndex];
// skip over free tuple
if (tuple_ptr->m_header_bits & Tuple_header::FREE) {
jam();
buildPtr.p->m_tupleNo++;
break;
}
Uint32 tupVersion= tuple_ptr->get_tuple_version();
OperationrecPtr pageOperPtr;
pageOperPtr.i= tuple_ptr->m_operation_ptr_i;
#ifdef TIME_MEASUREMENT
start = NdbTick_getCurrentTicks();
#endif
// add to index
TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend();
req->errorCode = RNIL;
req->tableId = tablePtr.i;
req->indexId = buildPtr.p->m_indexId;
req->fragId = tablePtr.p->fragid[buildPtr.p->m_fragNo];
req->pageId = realPageId;
req->tupVersion = tupVersion;
req->opInfo = TuxMaintReq::OpAdd;
req->tupFragPtrI = fragPtr.i;
req->fragPageId = buildPtr.p->m_pageId;
req->pageIndex = pageIndex;
if (pageOperPtr.i == RNIL)
{
EXECUTE_DIRECT(buildPtr.p->m_buildRef, GSN_TUX_MAINT_REQ,
signal, TuxMaintReq::SignalLength+2);
}
else
{
/*
If there is an ongoing operation on the tuple then it is either a
copy tuple or an original tuple with an ongoing transaction. In
both cases realPageId and pageOffset refer to the original tuple.
The tuple address stored in TUX will always be the original tuple
but with the tuple version of the tuple we found.
This is necessary to avoid having to update TUX at abort of
update. If an update aborts then the copy tuple is copied to
the original tuple. The build will however have found that
tuple as a copy tuple. The original tuple is stable and is thus
preferrable to store in TUX.
*/
jam();
/**
* Since copy tuples now can't be found on real pages.
* we will here build all copies of the tuple
*
* Note only "real" tupVersion's should be added
* i.e delete's shouldnt be added
* (unless it's the first op, when "original" should be added)
*/
/*
* Start from first operation. This is only to make things more
* clear. It is not required by ordered index implementation.
*/
c_operation_pool.getPtr(pageOperPtr);
while (pageOperPtr.p->prevActiveOp != RNIL)
{
jam();
pageOperPtr.i = pageOperPtr.p->prevActiveOp;
c_operation_pool.getPtr(pageOperPtr);
}
/*
* Do not use req->errorCode as global control.
*/
bool ok = true;
/*
* If first operation is an update, add previous version.
* This version does not appear as the version of any operation.
* At commit this version is removed by executeTuxCommitTriggers.
* At abort it is preserved by executeTuxAbortTriggers.
*/
if (pageOperPtr.p->op_type == ZUPDATE)
{
jam();
req->errorCode = RNIL;
req->tupVersion =
decr_tup_version(pageOperPtr.p->op_struct.bit_field.tupVersion);
EXECUTE_DIRECT(buildPtr.p->m_buildRef, GSN_TUX_MAINT_REQ,
signal, TuxMaintReq::SignalLength+2);
ok = (req->errorCode == 0);
}
/*
* Add versions from all operations.
*
* Each operation has a tuple version. For insert and update it
* is the newly created version. For delete it is the version
* deleted. The existence of operation tuple version implies that
* a corresponding tuple version exists for TUX to read.
*
* We could be in the middle of a commit. The process here makes
* no assumptions about operation commit order. (It should be
* first to last but this is not the place to assert it).
*
* Duplicate versions are possible e.g. a delete in the middle
* may have same version as the previous operation. TUX ignores
* duplicate version errors during index build.
*/
while (pageOperPtr.i != RNIL && ok)
{
jam();
c_operation_pool.getPtr(pageOperPtr);
req->errorCode = RNIL;
req->tupVersion = pageOperPtr.p->op_struct.bit_field.tupVersion;
EXECUTE_DIRECT(buildPtr.p->m_buildRef, GSN_TUX_MAINT_REQ,
signal, TuxMaintReq::SignalLength+2);
pageOperPtr.i = pageOperPtr.p->nextActiveOp;
ok = (req->errorCode == 0);
}
}
jamEntry();
if (req->errorCode != 0) {
switch (req->errorCode) {
case TuxMaintReq::NoMemError:
jam();
buildPtr.p->m_errorCode= BuildIndxImplRef::AllocationFailure;
break;
default:
ndbrequire(false);
break;
}
buildIndexReply(signal, buildPtr.p);
c_buildIndexList.release(buildPtr);
return;
}
#ifdef TIME_MEASUREMENT
stop = NdbTick_getCurrentTicks();
time_passed= NdbTick_Elapsed(start, stop).microSec();
if (time_passed < 1000) {
time_events++;
tot_time_passed += time_passed;
if (time_events == number_events) {
Uint64 mean_time_passed= tot_time_passed /
(Uint64)number_events;
ndbout << "Number of events= " << number_events;
ndbout << " Mean time passed= " << mean_time_passed << endl;
number_events <<= 1;
tot_time_passed= 0;
time_events= 0;
}
}
#endif
// next tuple
buildPtr.p->m_tupleNo++;
break;
} while (0);
signal->theData[0]= ZBUILD_INDEX;
signal->theData[1]= buildPtr.i;
sendSignal(reference(), GSN_CONTINUEB, signal, 2, 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);
}
TFSentinel() {
for (Uint32 i = 0; i < NDB_ARRAY_SIZE(data); i++)
data[i] = 0;
}
void
Restore::restore_next(Signal* signal, FilePtr file_ptr)
{
Uint32 *data, len= 0;
Uint32 status = file_ptr.p->m_status;
Uint32 page_count = file_ptr.p->m_pages.getSize();
do
{
Uint32 left= file_ptr.p->m_bytes_left;
if (left < 8)
{
jam();
/**
* Not enough bytes to read header
*/
break;
}
Ptr<GlobalPage> page_ptr(0,0), next_page_ptr(0,0);
m_global_page_pool.getPtr(page_ptr, file_ptr.p->m_current_page_ptr_i);
List::Iterator it;
Uint32 pos= file_ptr.p->m_current_page_pos;
if(status & File::READING_RECORDS)
{
jam();
/**
* We are reading records
*/
len= ntohl(* (page_ptr.p->data + pos)) + 1;
ndbrequire(len < GLOBAL_PAGE_SIZE_WORDS);
}
else
{
jam();
/**
* Section length is in 2 word
*/
if(pos + 1 == GLOBAL_PAGE_SIZE_WORDS)
{
jam();
/**
* But that's stored on next page...
* and since we have atleast 8 bytes left in buffer
* we can be sure that that's in buffer
*/
LocalDataBuffer<15> pages(m_databuffer_pool, file_ptr.p->m_pages);
Uint32 next_page = file_ptr.p->m_current_page_index + 1;
pages.position(it, next_page % page_count);
m_global_page_pool.getPtr(next_page_ptr, * it.data);
len= ntohl(* next_page_ptr.p->data);
}
else
{
jam();
len= ntohl(* (page_ptr.p->data + pos + 1));
}
}
if (file_ptr.p->m_status & File::FIRST_READ)
{
jam();
len= 3;
file_ptr.p->m_status &= ~(Uint32)File::FIRST_READ;
}
if (4 * len > left)
{
jam();
/**
* Not enought bytes to read "record"
*/
if (unlikely((status & File:: FILE_THREAD_RUNNING) == 0))
{
crash_during_restore(file_ptr, __LINE__, 0);
}
len= 0;
break;
}
/**
* Entire record is in buffer
*/
if(pos + len >= GLOBAL_PAGE_SIZE_WORDS)
{
jam();
/**
* But it's split over pages
*/
if(next_page_ptr.p == 0)
{
LocalDataBuffer<15> pages(m_databuffer_pool, file_ptr.p->m_pages);
Uint32 next_page = file_ptr.p->m_current_page_index + 1;
pages.position(it, next_page % page_count);
m_global_page_pool.getPtr(next_page_ptr, * it.data);
}
file_ptr.p->m_current_page_ptr_i = next_page_ptr.i;
file_ptr.p->m_current_page_pos = (pos + len) - GLOBAL_PAGE_SIZE_WORDS;
file_ptr.p->m_current_page_index =
(file_ptr.p->m_current_page_index + 1) % page_count;
if (len <= GLOBAL_PAGE_SIZE_WORDS)
{
jam();
Uint32 first = (GLOBAL_PAGE_SIZE_WORDS - pos);
// wl4391_todo removing valgrind overlap warning for now
memmove(page_ptr.p, page_ptr.p->data+pos, 4 * first);
memcpy(page_ptr.p->data+first, next_page_ptr.p, 4 * (len - first));
data= page_ptr.p->data;
}
else
{
jam();
/**
* A table definition can be larger than one page...
* when that happens copy it out to side buffer
*
* First copy part belonging to page_ptr
* Then copy full middle pages (moving forward in page-list)
* Last copy last part
*/
Uint32 save = len;
assert(len <= NDB_ARRAY_SIZE(m_table_buf));
Uint32 * dst = m_table_buf;
/**
* First
*/
Uint32 first = (GLOBAL_PAGE_SIZE_WORDS - pos);
memcpy(dst, page_ptr.p->data+pos, 4 * first);
len -= first;
dst += first;
/**
* Middle
*/
while (len > GLOBAL_PAGE_SIZE_WORDS)
{
jam();
memcpy(dst, next_page_ptr.p, 4 * GLOBAL_PAGE_SIZE_WORDS);
len -= GLOBAL_PAGE_SIZE_WORDS;
dst += GLOBAL_PAGE_SIZE_WORDS;
{
LocalDataBuffer<15> pages(m_databuffer_pool, file_ptr.p->m_pages);
Uint32 next_page = (file_ptr.p->m_current_page_index + 1) % page_count;
pages.position(it, next_page % page_count);
m_global_page_pool.getPtr(next_page_ptr, * it.data);
file_ptr.p->m_current_page_ptr_i = next_page_ptr.i;
file_ptr.p->m_current_page_index = next_page;
}
}
/**
* last
*/
memcpy(dst, next_page_ptr.p, 4 * len);
file_ptr.p->m_current_page_pos = len;
/**
* Set pointer and len
*/
len = save;
data = m_table_buf;
}
}
else
{
file_ptr.p->m_current_page_pos = pos + len;
data= page_ptr.p->data+pos;
}
file_ptr.p->m_bytes_left -= 4*len;
if(status & File::READING_RECORDS)
{
if(len == 1)
{
file_ptr.p->m_status = status & ~(Uint32)File::READING_RECORDS;
}
else
{
parse_record(signal, file_ptr, data, len);
}
}
else
{
switch(ntohl(* data)){
case BackupFormat::FILE_HEADER:
parse_file_header(signal, file_ptr, data-3, len+3);
break;
case BackupFormat::FRAGMENT_HEADER:
file_ptr.p->m_status = status | File::READING_RECORDS;
parse_fragment_header(signal, file_ptr, data, len);
break;
case BackupFormat::FRAGMENT_FOOTER:
parse_fragment_footer(signal, file_ptr, data, len);
break;
case BackupFormat::TABLE_LIST:
parse_table_list(signal, file_ptr, data, len);
break;
case BackupFormat::TABLE_DESCRIPTION:
parse_table_description(signal, file_ptr, data, len);
break;
case BackupFormat::GCP_ENTRY:
parse_gcp_entry(signal, file_ptr, data, len);
break;
case BackupFormat::EMPTY_ENTRY:
// skip
break;
case 0x4e444242: // 'NDBB'
if (check_file_version(signal, ntohl(* (data+2))) == 0)
{
break;
}
default:
parse_error(signal, file_ptr, __LINE__, ntohl(* data));
}
}
} while(0);
if(file_ptr.p->m_bytes_left == 0 && status & File::FILE_EOF)
{
file_ptr.p->m_status &= ~(Uint32)File::RESTORE_THREAD_RUNNING;
/**
* File is finished...
*/
close_file(signal, file_ptr);
return;
}
/**
* We send an immediate signal to continue the restore, at times this
* could lead to burning some extra CPU since we might still wait for
* input from the disk reading. This code is however only executed
* as part of restarts, so it should be ok to spend some extra CPU
* to ensure that restarts are quick.
*/
signal->theData[0] = RestoreContinueB::RESTORE_NEXT;
signal->theData[1] = file_ptr.i;
sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB);
}
void
Thrman::execDBINFO_SCANREQ(Signal* signal)
{
jamEntry();
DbinfoScanReq req= *(DbinfoScanReq*)signal->theData;
const Ndbinfo::ScanCursor* cursor =
CAST_CONSTPTR(Ndbinfo::ScanCursor, DbinfoScan::getCursorPtr(&req));
Ndbinfo::Ratelimit rl;
switch(req.tableId) {
case Ndbinfo::THREADBLOCKS_TABLEID: {
Uint32 arr[NO_OF_BLOCKS];
Uint32 len = mt_get_blocklist(this, arr, NDB_ARRAY_SIZE(arr));
Uint32 pos = cursor->data[0];
for (; ; )
{
Ndbinfo::Row row(signal, req);
row.write_uint32(getOwnNodeId());
row.write_uint32(getThreadId()); // thr_no
row.write_uint32(blockToMain(arr[pos])); // block_number
row.write_uint32(blockToInstance(arr[pos])); // block_instance
ndbinfo_send_row(signal, req, row, rl);
pos++;
if (pos == len)
{
jam();
break;
}
else if (rl.need_break(req))
{
jam();
ndbinfo_send_scan_break(signal, req, rl, pos);
return;
}
}
break;
}
case Ndbinfo::THREADSTAT_TABLEID:{
ndb_thr_stat stat;
mt_get_thr_stat(this, &stat);
Ndbinfo::Row row(signal, req);
row.write_uint32(getOwnNodeId());
row.write_uint32(getThreadId()); // thr_no
row.write_string(stat.name);
row.write_uint64(stat.loop_cnt);
row.write_uint64(stat.exec_cnt);
row.write_uint64(stat.wait_cnt);
row.write_uint64(stat.local_sent_prioa);
row.write_uint64(stat.local_sent_priob);
row.write_uint64(stat.remote_sent_prioa);
row.write_uint64(stat.remote_sent_priob);
row.write_uint64(stat.os_tid);
row.write_uint64(NdbTick_CurrentMillisecond());
struct ndb_rusage os_rusage;
Ndb_GetRUsage(&os_rusage);
row.write_uint64(os_rusage.ru_utime);
row.write_uint64(os_rusage.ru_stime);
row.write_uint64(os_rusage.ru_minflt);
row.write_uint64(os_rusage.ru_majflt);
row.write_uint64(os_rusage.ru_nvcsw);
row.write_uint64(os_rusage.ru_nivcsw);
ndbinfo_send_row(signal, req, row, rl);
break;
}
default:
break;
}
ndbinfo_send_scan_conf(signal, req, rl);
}
int
TCP_Transporter::doSend() {
struct iovec iov[64];
Uint32 cnt = fetch_send_iovec_data(iov, NDB_ARRAY_SIZE(iov));
if (cnt == 0)
{
return 0;
}
Uint32 sum = 0;
for(Uint32 i = 0; i<cnt; i++)
{
assert(iov[i].iov_len);
sum += iov[i].iov_len;
}
Uint32 pos = 0;
Uint32 sum_sent = 0;
Uint32 send_cnt = 0;
Uint32 remain = sum;
if (cnt == NDB_ARRAY_SIZE(iov))
{
// If pulling all iov's make sure that we never return everyting
// flushed
sum++;
}
while (send_cnt < 5)
{
send_cnt++;
Uint32 iovcnt = cnt > m_os_max_iovec ? m_os_max_iovec : cnt;
int nBytesSent = (int)my_socket_writev(theSocket, iov+pos, iovcnt);
assert(nBytesSent <= (int)remain);
if (Uint32(nBytesSent) == remain)
{
sum_sent += nBytesSent;
goto ok;
}
else if (nBytesSent > 0)
{
sum_sent += nBytesSent;
remain -= nBytesSent;
/**
* Forward in iovec
*/
while (Uint32(nBytesSent) >= iov[pos].iov_len)
{
assert(iov[pos].iov_len > 0);
nBytesSent -= iov[pos].iov_len;
pos++;
cnt--;
}
if (nBytesSent)
{
assert(iov[pos].iov_len > Uint32(nBytesSent));
iov[pos].iov_len -= nBytesSent;
iov[pos].iov_base = ((char*)(iov[pos].iov_base))+nBytesSent;
}
continue;
}
else
{
int err = my_socket_errno();
if (!(DISCONNECT_ERRNO(err, nBytesSent)))
{
if (sum_sent)
{
goto ok;
}
else
{
return remain;
}
}
#if defined DEBUG_TRANSPORTER
g_eventLogger->error("Send Failure(disconnect==%d) to node = %d "
"nBytesSent = %d "
"errno = %d strerror = %s",
DISCONNECT_ERRNO(err, nBytesSent),
remoteNodeId, nBytesSent, my_socket_errno(),
(char*)ndbstrerror(err));
#endif
do_disconnect(err);
return 0;
}
}
ok:
assert(sum >= sum_sent);
iovec_data_sent(sum_sent);
sendCount += send_cnt;
sendSize += sum_sent;
if(sendCount >= reportFreq)
{
get_callback_obj()->reportSendLen(remoteNodeId, sendCount, sendSize);
sendCount = 0;
sendSize = 0;
}
return sum - sum_sent; // 0 if every thing flushed else >0
}
