void
SafeCounterManager::execNODE_FAILREP(Signal* signal){
Uint32 * theData = signal->getDataPtrSend();
ActiveCounterPtr ptr;
NodeBitmask nodes;
nodes.assign(NodeBitmask::Size,
((const NodeFailRep*)signal->getDataPtr())->theNodes);
for(m_activeCounters.first(ptr); !ptr.isNull(); m_activeCounters.next(ptr)){
if(nodes.overlaps(ptr.p->m_nodes)){
ActiveCounter::SignalDesc desc = ptr.p->m_signalDesc;
theData[desc.m_senderDataOffset] = ptr.p->m_senderData;
theData[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;
overlapping.bitAND(nodes);
Uint32 i = 0;
while((i = overlapping.find(i)) != NodeBitmask::NotFound){
theData[desc.m_senderRefOffset] = numberToRef(desc.m_block, i);
m_block.sendSignal(m_block.reference(), desc.m_gsn, signal, len+1,JBB);
i++;
}
}
}
}
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++;
}
}
}
NodeId
SignalSender::find_node(const NodeBitmask& mask, T & t)
{
unsigned n= 0;
do {
n= mask.find(n+1);
if (n == NodeBitmask::NotFound)
return 0;
assert(n < MAX_NODES);
} while (!t.found_ok(*this, getNodeInfo(n)));
return n;
}
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
}