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
Trpman::execDBINFO_SCANREQ(Signal *signal)
{
DbinfoScanReq req= *(DbinfoScanReq*)signal->theData;
const Ndbinfo::ScanCursor* cursor =
CAST_CONSTPTR(Ndbinfo::ScanCursor, DbinfoScan::getCursorPtr(&req));
Ndbinfo::Ratelimit rl;
jamEntry();
switch(req.tableId){
case Ndbinfo::TRANSPORTERS_TABLEID:
{
jam();
Uint32 rnode = cursor->data[0];
if (rnode == 0)
rnode++; // Skip node 0
while (rnode < MAX_NODES)
{
if (!handles_this_node(rnode))
{
rnode++;
continue;
}
switch(getNodeInfo(rnode).m_type)
{
default:
{
jam();
Ndbinfo::Row row(signal, req);
row.write_uint32(getOwnNodeId()); // Node id
row.write_uint32(rnode); // Remote node id
row.write_uint32(globalTransporterRegistry.getPerformState(rnode)); // State
if (globalTransporterRegistry.get_transporter(rnode) != NULL)
{
jam();
/* Connect address */
if (globalTransporterRegistry.get_connect_address(rnode).s_addr != 0)
{
jam();
row.write_string(inet_ntoa(globalTransporterRegistry.get_connect_address(rnode)));
}
else
{
jam();
row.write_string("-");
}
/* Bytes sent/received */
row.write_uint64(globalTransporterRegistry.get_bytes_sent(rnode));
row.write_uint64(globalTransporterRegistry.get_bytes_received(rnode));
/* Connect count, overload and Slowdown states */
row.write_uint32(globalTransporterRegistry.get_connect_count(rnode));
row.write_uint32(globalTransporterRegistry.get_status_overloaded().get(rnode));
row.write_uint32(globalTransporterRegistry.get_overload_count(rnode));
row.write_uint32(globalTransporterRegistry.get_status_slowdown().get(rnode));
row.write_uint32(globalTransporterRegistry.get_slowdown_count(rnode));
}
else
{
/* Null transporter */
jam();
row.write_string("-"); /* Remote address */
row.write_uint64(0); /* Bytes sent */
row.write_uint64(0); /* Bytes received */
row.write_uint32(0); /* Connect count */
row.write_uint32(0); /* Overloaded */
row.write_uint32(0); /* Overload_count */
row.write_uint32(0); /* Slowdown */
row.write_uint32(0); /* Slowdown_count */
}
ndbinfo_send_row(signal, req, row, rl);
break;
}
case NodeInfo::INVALID:
jam();
break;
}
rnode++;
if (rl.need_break(req))
{
jam();
ndbinfo_send_scan_break(signal, req, rl, rnode);
return;
}
}
break;
}
default:
break;
}
ndbinfo_send_scan_conf(signal, req, rl);
}
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);
}