void
SafeCounterManager::printNODE_FAILREP(){
ActiveCounterPtr ptr;
NodeBitmask nodes;
nodes.clear();
// nodes.bitORC(nodes);
for(m_activeCounters.first(ptr); !ptr.isNull(); m_activeCounters.next(ptr)){
ActiveCounter::SignalDesc desc = ptr.p->m_signalDesc;
ndbout_c("theData[desc.m_senderDataOffset=%u] = %u",
desc.m_senderDataOffset, ptr.p->m_senderData);
ndbout_c("theData[desc.m_errorCodeOffset=%u] = %u",
desc.m_errorCodeOffset, desc.m_nodeFailErrorCode);
Uint32 len = MAX(MAX(desc.m_senderDataOffset, desc.m_errorCodeOffset),
desc.m_senderRefOffset);
NodeBitmask overlapping = ptr.p->m_nodes;
Uint32 i = 0;
while((i = overlapping.find(i)) != NodeBitmask::NotFound){
ndbout_c(" theData[desc.m_senderRefOffset=%u] = %x",
desc.m_senderRefOffset, numberToRef(desc.m_block, i));
ndbout_c(" sendSignal(%x,%u,signal,%u,JBB",
m_block.reference(), desc.m_gsn, len+1);
i++;
}
}
}
inline
NodeReceiverGroup&
NodeReceiverGroup::operator=(BlockReference blockRef){
m_nodes.clear();
m_block = refToBlock(blockRef);
m_nodes.set(refToNode(blockRef));
return * this;
}
static Uint32 getNodeId(NodeBitmask & mask, unsigned arr[], unsigned i)
{
Uint32 nodeId = 0;
if (arr != 0)
{
nodeId = arr[i];
}
else
{
nodeId = mask.find_first();
}
require(mask.get(nodeId));
mask.clear(nodeId);
return nodeId;
}
static Properties create(unsigned mgmds = 1,
unsigned ndbds = 1,
unsigned mysqlds = 1,
unsigned mgmd_nodeids[] = 0,
unsigned ndbd_nodeids[] = 0,
unsigned mysqld_nodeids[] = 0)
{
Uint32 base_port = get_ndbt_base_port() + /* mysqld */ 1;
Properties config;
require(mgmds >= 1 && ndbds >= 1 && mysqlds >= 1);
NodeBitmask mask;
mask.set();
mask.clear(Uint32(0));
for (unsigned i = 0; i < mgmds; i++)
{
Uint32 nodeId = getNodeId(mask, mgmd_nodeids, i);
Properties node_settings;
node_settings.put("NodeId", nodeId);
node_settings.put("HostName", "localhost");
node_settings.put("PortNumber", base_port + i);
config.put("ndb_mgmd", nodeId, &node_settings);
}
for (unsigned i = 0; i < ndbds; i++)
{
Uint32 nodeId = getNodeId(mask, ndbd_nodeids, i);
Properties node_settings;
node_settings.put("NodeId", nodeId);
if (ndbds == 1)
node_settings.put("NoOfReplicas", 1);
config.put("ndbd", nodeId, &node_settings);
}
for (unsigned i = 0; i < mysqlds; i++)
{
Uint32 nodeId = getNodeId(mask, mysqld_nodeids, i);
Properties node_settings;
node_settings.put("NodeId", nodeId);
config.put("mysqld", nodeId, &node_settings);
}
return config;
}
inline
NodeReceiverGroup::NodeReceiverGroup(Uint32 blockRef){
m_nodes.clear();
m_block = refToBlock(blockRef);
m_nodes.set(refToNode(blockRef));
}
inline
NodeReceiverGroup::NodeReceiverGroup() : m_block(0){
m_nodes.clear();
}
void
Trpman::execDUMP_STATE_ORD(Signal* signal)
{
DumpStateOrd * const & dumpState = (DumpStateOrd *)&signal->theData[0];
Uint32 arg = dumpState->args[0]; (void)arg;
#ifdef ERROR_INSERT
if (arg == 9000 || arg == 9002)
{
SET_ERROR_INSERT_VALUE(arg);
for (Uint32 i = 1; i<signal->getLength(); i++)
c_error_9000_nodes_mask.set(signal->theData[i]);
}
if (arg == 9001)
{
CLEAR_ERROR_INSERT_VALUE;
if (signal->getLength() == 1 || signal->theData[1])
{
signal->header.theLength = 2;
for (Uint32 i = 1; i<MAX_NODES; i++)
{
if (c_error_9000_nodes_mask.get(i) &&
handles_this_node(i))
{
signal->theData[0] = 0;
signal->theData[1] = i;
execOPEN_COMORD(signal);
}
}
}
c_error_9000_nodes_mask.clear();
}
if (arg == 9004 && signal->getLength() == 2)
{
SET_ERROR_INSERT_VALUE(9004);
c_error_9000_nodes_mask.clear();
c_error_9000_nodes_mask.set(signal->theData[1]);
}
if (arg == 9005 && signal->getLength() == 2 && ERROR_INSERTED(9004))
{
Uint32 db = signal->theData[1];
Uint32 i = c_error_9000_nodes_mask.find(1);
if (handles_this_node(i))
{
signal->theData[0] = i;
sendSignal(calcQmgrBlockRef(db),GSN_API_FAILREQ, signal, 1, JBA);
ndbout_c("stopping %u using %u", i, db);
}
CLEAR_ERROR_INSERT_VALUE;
}
#endif
#ifdef ERROR_INSERT
/* <Target NodeId> dump 9992 <NodeId list>
* On Target NodeId, block receiving signals from NodeId list
*
* <Target NodeId> dump 9993 <NodeId list>
* On Target NodeId, resume receiving signals from NodeId list
*
* <Target NodeId> dump 9991
* On Target NodeId, resume receiving signals from any blocked node
*
*
* See also code in QMGR for blocking receive from nodes based
* on HB roles.
*
*/
if((arg == 9993) || /* Unblock recv from nodeid */
(arg == 9992)) /* Block recv from nodeid */
{
bool block = (arg == 9992);
TransporterReceiveHandle * recvdata = mt_get_trp_receive_handle(instance());
assert(recvdata != 0);
for (Uint32 n = 1; n < signal->getLength(); n++)
{
Uint32 nodeId = signal->theData[n];
if (!handles_this_node(nodeId))
continue;
if ((nodeId > 0) &&
(nodeId < MAX_NODES))
{
if (block)
{
ndbout_c("TRPMAN : Blocking receive from node %u", nodeId);
globalTransporterRegistry.blockReceive(*recvdata, nodeId);
}
else
{
ndbout_c("TRPMAN : Unblocking receive from node %u", nodeId);
globalTransporterRegistry.unblockReceive(*recvdata, nodeId);
}
}
else
{
ndbout_c("TRPMAN : Ignoring dump %u for node %u",
arg, nodeId);
}
}
}
if (arg == 9990) /* Block recv from all ndbd matching pattern */
{
Uint32 pattern = 0;
if (signal->getLength() > 1)
{
pattern = signal->theData[1];
ndbout_c("TRPMAN : Blocking receive from all ndbds matching pattern -%s-",
((pattern == 1)? "Other side":"Unknown"));
}
TransporterReceiveHandle * recvdata = mt_get_trp_receive_handle(instance());
assert(recvdata != 0);
for (Uint32 node = 1; node < MAX_NDB_NODES; node++)
{
if (!handles_this_node(node))
continue;
if (globalTransporterRegistry.is_connected(node))
{
if (getNodeInfo(node).m_type == NodeInfo::DB)
{
if (!globalTransporterRegistry.isBlocked(node))
{
switch (pattern)
{
case 1:
{
/* Match if given node is on 'other side' of
* 2-replica cluster
*/
if ((getOwnNodeId() & 1) != (node & 1))
{
/* Node is on the 'other side', match */
break;
}
/* Node is on 'my side', don't match */
continue;
}
default:
break;
}
ndbout_c("TRPMAN : Blocking receive from node %u", node);
globalTransporterRegistry.blockReceive(*recvdata, node);
}
}
}
}
}
if (arg == 9991) /* Unblock recv from all blocked */
{
TransporterReceiveHandle * recvdata = mt_get_trp_receive_handle(instance());
assert(recvdata != 0);
for (Uint32 node = 1; node < MAX_NODES; node++)
{
if (!handles_this_node(node))
continue;
if (globalTransporterRegistry.isBlocked(node))
{
ndbout_c("CMVMI : Unblocking receive from node %u", node);
globalTransporterRegistry.unblockReceive(*recvdata, node);
}
}
}
#endif
}