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;
}
NodeBitmask
SignalSender::broadcastSignal(NodeBitmask mask,
SimpleSignal& sig,
Uint16 recBlock, Uint16 gsn,
Uint32 len)
{
sig.set(*this, TestOrd::TraceAPI, recBlock, gsn, len);
NodeBitmask result;
for(Uint32 i = 0; i < MAX_NODES; i++)
{
if(mask.get(i) && sendSignal(i, &sig) == SEND_OK)
result.set(i);
}
return result;
}
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
void
trp_client::unlock()
{
assert(m_send_nodes_mask.isclear()); // Nothing unsent when unlocking...
assert(m_poll.m_locked == true);
m_poll.m_locked = false;
NdbMutex_Unlock(m_mutex);
}
void
DblqhProxy::sendEXEC_SR_2(Signal* signal, Uint32 ssId)
{
Ss_EXEC_SR_2& ss = ssFind<Ss_EXEC_SR_2>(ssId);
if (!lastReply(ss)) {
jam();
return;
}
NodeBitmask nodes;
nodes.assign(NdbNodeBitmask::Size, ss.m_sig.sr_nodes);
NodeReceiverGroup rg(DBLQH, nodes);
signal->theData[0] = ss.m_sig.nodeId;
sendSignal(rg, ss.m_gsn, signal, 1, JBB);
ssRelease<Ss_EXEC_SR_2>(ssId);
}
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++;
}
}
}
}
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;
}
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
ClusterMgr::execNODE_FAILREP(const NdbApiSignal* sig,
const LinearSectionPtr ptr[])
{
const NodeFailRep * rep = CAST_CONSTPTR(NodeFailRep, sig->getDataPtr());
NodeBitmask mask;
if (sig->getLength() == NodeFailRep::SignalLengthLong)
{
mask.assign(NodeBitmask::Size, rep->theAllNodes);
}
else
{
mask.assign(NdbNodeBitmask::Size, rep->theNodes);
}
NdbApiSignal signal(sig->theSendersBlockRef);
signal.theVerId_signalNumber = GSN_NODE_FAILREP;
signal.theReceiversBlockNumber = API_CLUSTERMGR;
signal.theTrace = 0;
signal.theLength = NodeFailRep::SignalLengthLong;
NodeFailRep * copy = CAST_PTR(NodeFailRep, signal.getDataPtrSend());
copy->failNo = 0;
copy->masterNodeId = 0;
copy->noOfNodes = 0;
NodeBitmask::clear(copy->theAllNodes);
for (Uint32 i = mask.find_first(); i != NodeBitmask::NotFound;
i = mask.find_next(i + 1))
{
Node & cm_node = theNodes[i];
trp_node & theNode = cm_node;
bool node_failrep = theNode.m_node_fail_rep;
bool connected = theNode.is_connected();
set_node_dead(theNode);
if (node_failrep == false)
{
theNode.m_node_fail_rep = true;
NodeBitmask::set(copy->theAllNodes, i);
copy->noOfNodes++;
}
if (connected)
{
theFacade.doDisconnect(i);
}
}
recalcMinDbVersion();
if (copy->noOfNodes)
{
theFacade.for_each(this, &signal, 0); // report GSN_NODE_FAILREP
}
if (noOfAliveNodes == 0)
{
NdbApiSignal signal(numberToRef(API_CLUSTERMGR, getOwnNodeId()));
signal.theVerId_signalNumber = GSN_NF_COMPLETEREP;
signal.theReceiversBlockNumber = 0;
signal.theTrace = 0;
signal.theLength = NFCompleteRep::SignalLength;
NFCompleteRep * rep = CAST_PTR(NFCompleteRep, signal.getDataPtrSend());
rep->blockNo =0;
rep->nodeId = getOwnNodeId();
rep->unused = 0;
rep->from = __LINE__;
for (Uint32 i = 1; i < MAX_NODES; i++)
{
trp_node& theNode = theNodes[i];
if (theNode.defined && theNode.nfCompleteRep == false)
{
rep->failedNodeId = i;
execNF_COMPLETEREP(&signal, 0);
}
}
}
}
void Cmvmi::execOPEN_COMREQ(Signal* signal)
{
// Connect to the specifed NDB node, only QMGR allowed communication
// so far with the node
const BlockReference userRef = signal->theData[0];
Uint32 tStartingNode = signal->theData[1];
Uint32 tData2 = signal->theData[2];
jamEntry();
const Uint32 len = signal->getLength();
if(len == 2)
{
#ifdef ERROR_INSERT
if (! ((ERROR_INSERTED(9000) || ERROR_INSERTED(9002))
&& c_error_9000_nodes_mask.get(tStartingNode)))
#endif
{
if (globalData.theStartLevel != NodeState::SL_STARTED &&
(getNodeInfo(tStartingNode).m_type != NodeInfo::DB &&
getNodeInfo(tStartingNode).m_type != NodeInfo::MGM))
{
jam();
goto done;
}
globalTransporterRegistry.do_connect(tStartingNode);
globalTransporterRegistry.setIOState(tStartingNode, HaltIO);
//-----------------------------------------------------
// Report that the connection to the node is opened
//-----------------------------------------------------
signal->theData[0] = NDB_LE_CommunicationOpened;
signal->theData[1] = tStartingNode;
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
//-----------------------------------------------------
}
} else {
for(unsigned int i = 1; i < MAX_NODES; i++ )
{
jam();
if (i != getOwnNodeId() && getNodeInfo(i).m_type == tData2)
{
jam();
#ifdef ERROR_INSERT
if ((ERROR_INSERTED(9000) || ERROR_INSERTED(9002))
&& c_error_9000_nodes_mask.get(i))
continue;
#endif
globalTransporterRegistry.do_connect(i);
globalTransporterRegistry.setIOState(i, HaltIO);
signal->theData[0] = NDB_LE_CommunicationOpened;
signal->theData[1] = i;
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
}
}
}
done:
if (userRef != 0) {
jam();
signal->theData[0] = tStartingNode;
signal->theData[1] = tData2;
sendSignal(userRef, GSN_OPEN_COMCONF, signal, len - 1,JBA);
}
}
void
Trpman::execOPEN_COMORD(Signal* signal)
{
// Connect to the specifed NDB node, only QMGR allowed communication
// so far with the node
const BlockReference userRef = signal->theData[0];
Uint32 tStartingNode = signal->theData[1];
Uint32 tData2 = signal->theData[2];
jamEntry();
const Uint32 len = signal->getLength();
if (len == 2)
{
#ifdef ERROR_INSERT
if (! ((ERROR_INSERTED(9000) || ERROR_INSERTED(9002))
&& c_error_9000_nodes_mask.get(tStartingNode)))
#endif
{
if (!handles_this_node(tStartingNode))
{
jam();
goto done;
}
globalTransporterRegistry.do_connect(tStartingNode);
globalTransporterRegistry.setIOState(tStartingNode, HaltIO);
//-----------------------------------------------------
// Report that the connection to the node is opened
//-----------------------------------------------------
signal->theData[0] = NDB_LE_CommunicationOpened;
signal->theData[1] = tStartingNode;
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
//-----------------------------------------------------
}
}
else
{
for(unsigned int i = 1; i < MAX_NODES; i++ )
{
jam();
if (i != getOwnNodeId() && getNodeInfo(i).m_type == tData2 &&
handles_this_node(i))
{
jam();
#ifdef ERROR_INSERT
if ((ERROR_INSERTED(9000) || ERROR_INSERTED(9002))
&& c_error_9000_nodes_mask.get(i))
continue;
#endif
globalTransporterRegistry.do_connect(i);
globalTransporterRegistry.setIOState(i, HaltIO);
signal->theData[0] = NDB_LE_CommunicationOpened;
signal->theData[1] = i;
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
}
}
}
done:
/**
* NO REPLY for now
*/
(void)userRef;
}
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
}