List:Commits« Previous MessageNext Message »
From:jonas oreland Date:December 3 2010 5:54am
Subject:bzr push into mysql-5.1-telco-7.0 branch (jonas:4043 to 4044)
View as plain text  
 4044 jonas oreland	2010-12-03
      ndb - move checks from TransporterFacade::sendSignal to NdbImpl::sendSignal

    modified:
      storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp
      storage/ndb/src/ndbapi/NdbImpl.hpp
      storage/ndb/src/ndbapi/Ndbif.cpp
      storage/ndb/src/ndbapi/TransporterFacade.cpp
      storage/ndb/src/ndbapi/TransporterFacade.hpp
      storage/ndb/src/ndbapi/trp_client.hpp
 4043 jonas oreland	2010-12-02 [merge]
      ndb - merge 63 to 70

    modified:
      storage/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp
=== modified file 'storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp'
--- a/storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp	2010-11-28 11:34:01 +0000
+++ b/storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp	2010-12-03 05:53:47 +0000
@@ -2240,8 +2240,8 @@ NdbDictInterface::dictSignal(NdbApiSigna
       DBUG_RETURN(-1);
     }
     int res = (ptr ? 
-	       getTransporter()->sendFragmentedSignal(sig, node, ptr, secs):
-	       getTransporter()->sendSignal(sig, node));
+	       m_impl->sendFragmentedSignal(sig, node, ptr, secs):
+	       m_impl->sendSignal(sig, node));
     if(res != 0){
       DBUG_PRINT("info", ("dictSignal failed to send signal"));
       m_error.code = 4007;
@@ -5599,7 +5599,7 @@ NdbDictInterface::listObjects(NdbApiSign
       m_error.code= 4009;
       return -1;
     }
-    NodeInfo info = getTransporter()->theClusterMgr->getNodeInfo(aNodeId).m_info;
+    NodeInfo info = m_impl->getNodeInfo(aNodeId).m_info;
     if (ndbd_LIST_TABLES_CONF_long_signal(info.m_version))
     {
       /*
@@ -5617,7 +5617,7 @@ NdbDictInterface::listObjects(NdbApiSign
       return -1;
     }
 
-    if (getTransporter()->sendSignal(signal, aNodeId) != 0) {
+    if (m_impl->sendSignal(signal, aNodeId) != 0) {
       continue;
     }
     m_error.code= 0;
@@ -5639,7 +5639,7 @@ NdbDictInterface::execLIST_TABLES_CONF(c
                                        const LinearSectionPtr ptr[3])
 {
   Uint16 nodeId = refToNode(signal->theSendersBlockRef);
-  NodeInfo info = getTransporter()->theClusterMgr->getNodeInfo(nodeId).m_info;
+  NodeInfo info = m_impl->getNodeInfo(nodeId).m_info;
   if (!ndbd_LIST_TABLES_CONF_long_signal(info.m_version))
   {
     /*
@@ -5760,7 +5760,7 @@ NdbDictInterface::forceGCPWait(int type)
         m_error.code= 4009;
         return -1;
       }
-      if (getTransporter()->sendSignal(&tSignal, aNodeId) != 0)
+      if (m_impl->sendSignal(&tSignal, aNodeId) != 0)
       {
         continue;
       }
@@ -5788,20 +5788,20 @@ NdbDictInterface::forceGCPWait(int type)
     const Uint32 RETRIES = 100;
     for (Uint32 i = 0; i < RETRIES; i++)
     {
-      getTransporter()->lock_mutex();
+      m_impl->lock();
       Uint16 aNodeId = getTransporter()->get_an_alive_node();
       if (aNodeId == 0) {
         m_error.code= 4009;
-        getTransporter()->unlock_mutex();
+        m_impl->unlock();
         return -1;
       }
-      if (getTransporter()->sendSignal(&tSignal, aNodeId) != 0) {
-        getTransporter()->unlock_mutex();
+      if (m_impl->sendSignal(&tSignal, aNodeId) != 0) {
+        m_impl->unlock();
         continue;
       }
 
-      getTransporter()->forceSend(refToBlock(m_reference));
-      getTransporter()->unlock_mutex();
+      m_impl->forceSend();
+      m_impl->unlock();
     }
     return m_error.code == 0 ? 0 : -1;
   }

=== modified file 'storage/ndb/src/ndbapi/NdbImpl.hpp'
--- a/storage/ndb/src/ndbapi/NdbImpl.hpp	2010-11-09 20:40:03 +0000
+++ b/storage/ndb/src/ndbapi/NdbImpl.hpp	2010-12-03 05:53:47 +0000
@@ -164,6 +164,16 @@ public:
   Uint32 getNodeNdbVersion(NodeId nodeId) const;
   Uint32 getMinDbNodeVersion() const;
   bool check_send_size(Uint32 node_id, Uint32 send_size) const { return true;}
+
+  int sendSignal(NdbApiSignal*, Uint32 nodeId);
+  int sendSignal(NdbApiSignal*, Uint32 nodeId,
+                 const LinearSectionPtr ptr[3], Uint32 secs);
+  int sendSignal(NdbApiSignal*, Uint32 nodeId,
+                 const GenericSectionPtr ptr[3], Uint32 secs);
+  int sendFragmentedSignal(NdbApiSignal*, Uint32 nodeId,
+                           const LinearSectionPtr ptr[3], Uint32 secs);
+  int sendFragmentedSignal(NdbApiSignal*, Uint32 nodeId,
+                           const GenericSectionPtr ptr[3], Uint32 secs);
 };
 
 #ifdef VM_TRACE
@@ -443,4 +453,63 @@ NdbImpl::getNodeNdbVersion(NodeId n) con
   return getNodeInfo(n).m_info.m_version;
 }
 
+inline
+int
+NdbImpl::sendSignal(NdbApiSignal * signal, Uint32 nodeId)
+{
+  if (getIsNodeSendable(nodeId))
+  {
+    return raw_sendSignal(signal, nodeId);
+  }
+  return -1;
+}
+
+inline
+int
+NdbImpl::sendSignal(NdbApiSignal * signal, Uint32 nodeId,
+                    const LinearSectionPtr ptr[3], Uint32 secs)
+{
+  if (getIsNodeSendable(nodeId))
+  {
+    return raw_sendSignal(signal, nodeId, ptr, secs);
+  }
+  return -1;
+}
+
+inline
+int
+NdbImpl::sendSignal(NdbApiSignal * signal, Uint32 nodeId,
+                    const GenericSectionPtr ptr[3], Uint32 secs)
+{
+  if (getIsNodeSendable(nodeId))
+  {
+    return raw_sendSignal(signal, nodeId, ptr, secs);
+  }
+  return -1;
+}
+
+inline
+int
+NdbImpl::sendFragmentedSignal(NdbApiSignal * signal, Uint32 nodeId,
+                              const LinearSectionPtr ptr[3], Uint32 secs)
+{
+  if (getIsNodeSendable(nodeId))
+  {
+    return raw_sendFragmentedSignal(signal, nodeId, ptr, secs);
+  }
+  return -1;
+}
+
+inline
+int
+NdbImpl::sendFragmentedSignal(NdbApiSignal * signal, Uint32 nodeId,
+                              const GenericSectionPtr ptr[3], Uint32 secs)
+{
+  if (getIsNodeSendable(nodeId))
+  {
+    return raw_sendFragmentedSignal(signal, nodeId, ptr, secs);
+  }
+  return -1;
+}
+
 #endif

=== modified file 'storage/ndb/src/ndbapi/Ndbif.cpp'
--- a/storage/ndb/src/ndbapi/Ndbif.cpp	2010-11-09 20:40:03 +0000
+++ b/storage/ndb/src/ndbapi/Ndbif.cpp	2010-12-03 05:53:47 +0000
@@ -1418,7 +1418,7 @@ NdbImpl::send_event_report(bool has_lock
   int ret = 0;
   if (!has_lock)
   {
-    tp->lock_mutex();
+    lock();
   }
   Uint32 tNode;
   Ndb_cluster_connection_node_iter node_iter;
@@ -1427,7 +1427,7 @@ NdbImpl::send_event_report(bool has_lock
   {
     if(get_node_alive(tNode))
     {
-      sendSignal(&aSignal, tNode);
+      tp->sendSignal(&aSignal, tNode);
       goto done;
     }
   }
@@ -1436,7 +1436,7 @@ NdbImpl::send_event_report(bool has_lock
 done:
   if (!has_lock)
   {
-    tp->unlock_mutex();
+    unlock();
   }
   return ret;
 }

=== modified file 'storage/ndb/src/ndbapi/TransporterFacade.cpp'
--- a/storage/ndb/src/ndbapi/TransporterFacade.cpp	2010-11-09 20:40:03 +0000
+++ b/storage/ndb/src/ndbapi/TransporterFacade.cpp	2010-12-03 05:53:47 +0000
@@ -857,47 +857,47 @@ TransporterFacade::checkForceSend(Uint32
  * SEND SIGNAL METHODS
  *****************************************************************************/
 int
-TransporterFacade::sendSignal(NdbApiSignal * aSignal, NodeId aNode){
+TransporterFacade::sendSignal(NdbApiSignal * aSignal, NodeId aNode)
+{
   Uint32* tDataPtr = aSignal->getDataPtrSend();
   Uint32 Tlen = aSignal->theLength;
   Uint32 TBno = aSignal->theReceiversBlockNumber;
-  if(getIsNodeSendable(aNode) == true){
 #ifdef API_TRACE
-    if(setSignalLog() && TRACE_GSN(aSignal->theVerId_signalNumber)){
-      Uint32 tmp = aSignal->theSendersBlockRef;
-      aSignal->theSendersBlockRef = numberToRef(tmp, theOwnId);
-      LinearSectionPtr ptr[3];
-      signalLogger.sendSignal(* aSignal,
-			      1,
-			      tDataPtr,
-			      aNode, ptr, 0);
-      signalLogger.flushSignalLog();
-      aSignal->theSendersBlockRef = tmp;
-    }
+  if(setSignalLog() && TRACE_GSN(aSignal->theVerId_signalNumber)){
+    Uint32 tmp = aSignal->theSendersBlockRef;
+    aSignal->theSendersBlockRef = numberToRef(tmp, theOwnId);
+    LinearSectionPtr ptr[3];
+    signalLogger.sendSignal(* aSignal,
+                            1,
+                            tDataPtr,
+                            aNode, ptr, 0);
+    signalLogger.flushSignalLog();
+    aSignal->theSendersBlockRef = tmp;
+  }
 #endif
-    if ((Tlen != 0) && (Tlen <= 25) && (TBno != 0)) {
-      SendStatus ss = theTransporterRegistry->prepareSend(aSignal, 
-							  1, // JBB
-							  tDataPtr, 
-							  aNode, 
-							  (LinearSectionPtr*)0);
-      //if (ss != SEND_OK) ndbout << ss << endl;
-      return (ss == SEND_OK ? 0 : -1);
-    } else {
-      ndbout << "ERR: SigLen = " << Tlen << " BlockRec = " << TBno;
-      ndbout << " SignalNo = " << aSignal->theVerId_signalNumber << endl;
-      assert(0);
-    }//if
+  if ((Tlen != 0) && (Tlen <= 25) && (TBno != 0)) {
+    SendStatus ss = theTransporterRegistry->prepareSend(aSignal,
+                                                        1, // JBB
+                                                        tDataPtr,
+                                                        aNode,
+                                                        (LinearSectionPtr*)0);
+    //if (ss != SEND_OK) ndbout << ss << endl;
+    return (ss == SEND_OK ? 0 : -1);
   }
-  //const ClusterMgr::Node & node = theClusterMgr->getNodeInfo(aNode);
-  //const Uint32 startLevel = node.m_state.startLevel;
+  else
+  {
+    ndbout << "ERR: SigLen = " << Tlen << " BlockRec = " << TBno;
+    ndbout << " SignalNo = " << aSignal->theVerId_signalNumber << endl;
+    assert(0);
+  }//if
   return -1; // Node Dead
 }
 
 int
 TransporterFacade::sendSignalUnCond(NdbApiSignal * aSignal, 
                                     NodeId aNode,
-                                    Uint32 prio){
+                                    Uint32 prio)
+{
   Uint32* tDataPtr = aSignal->getDataPtrSend();
   assert(prio <= 1);
 #ifdef API_TRACE
@@ -1151,7 +1151,7 @@ public:
 int
 TransporterFacade::sendFragmentedSignal(NdbApiSignal* aSignal,
                                         NodeId aNode,
-					const GenericSectionPtr ptr[3],
+                                        const GenericSectionPtr ptr[3],
                                         Uint32 secs)
 {
   unsigned i;
@@ -1163,10 +1163,6 @@ TransporterFacade::sendFragmentedSignal(
   if (totalSectionLength <= CHUNK_SZ)
     return sendSignal(aSignal, aNode, ptr, secs);
   
-  /* We will fragment */
-  if(getIsNodeSendable(aNode) != true)
-    return -1;
-
   // TODO : Consider tracing fragment signals?
 #ifdef API_TRACE
   if(setSignalLog() && TRACE_GSN(aSignal->theVerId_signalNumber)){
@@ -1333,8 +1329,8 @@ TransporterFacade::sendFragmentedSignal(
 }
 
 int
-TransporterFacade::sendFragmentedSignal(NdbApiSignal* aSignal, NodeId aNode, 
-					const LinearSectionPtr ptr[3],
+TransporterFacade::sendFragmentedSignal(NdbApiSignal* aSignal, NodeId aNode,
+                                        const LinearSectionPtr ptr[3],
                                         Uint32 secs)
 {
   /* Use the GenericSection variant of sendFragmentedSignal */
@@ -1363,70 +1359,64 @@ TransporterFacade::sendFragmentedSignal(
   
 
 int
-TransporterFacade::sendSignal(NdbApiSignal* aSignal, NodeId aNode, 
-			      const LinearSectionPtr ptr[3], Uint32 secs){
+TransporterFacade::sendSignal(NdbApiSignal* aSignal, NodeId aNode,
+                              const LinearSectionPtr ptr[3], Uint32 secs)
+{
   aSignal->m_noOfSections = secs;
-  if(getIsNodeSendable(aNode) == true){
 #ifdef API_TRACE
-    if(setSignalLog() && TRACE_GSN(aSignal->theVerId_signalNumber)){
-      Uint32 tmp = aSignal->theSendersBlockRef;
-      aSignal->theSendersBlockRef = numberToRef(tmp, theOwnId);
-      signalLogger.sendSignal(* aSignal,
-			      1,
-			      aSignal->getDataPtrSend(),
-			      aNode,
-                              ptr, secs);
-      signalLogger.flushSignalLog();
-      aSignal->theSendersBlockRef = tmp;
-    }
-#endif
-    SendStatus ss = theTransporterRegistry->prepareSend
-      (aSignal, 
-       1, // JBB
-       aSignal->getDataPtrSend(),
-       aNode, 
-       ptr);
-    assert(ss != SEND_MESSAGE_TOO_BIG);
-    aSignal->m_noOfSections = 0;
-    return (ss == SEND_OK ? 0 : -1);
+  if(setSignalLog() && TRACE_GSN(aSignal->theVerId_signalNumber)){
+    Uint32 tmp = aSignal->theSendersBlockRef;
+    aSignal->theSendersBlockRef = numberToRef(tmp, theOwnId);
+    signalLogger.sendSignal(* aSignal,
+                            1,
+                            aSignal->getDataPtrSend(),
+                            aNode,
+                            ptr, secs);
+    signalLogger.flushSignalLog();
+    aSignal->theSendersBlockRef = tmp;
   }
+#endif
+  SendStatus ss = theTransporterRegistry->prepareSend
+    (aSignal,
+     1, // JBB
+     aSignal->getDataPtrSend(),
+     aNode,
+     ptr);
+  assert(ss != SEND_MESSAGE_TOO_BIG);
   aSignal->m_noOfSections = 0;
-  return -1;
+  return (ss == SEND_OK ? 0 : -1);
 }
 
 int
 TransporterFacade::sendSignal(NdbApiSignal* aSignal, NodeId aNode,
-                              const GenericSectionPtr ptr[3], Uint32 secs){
+                              const GenericSectionPtr ptr[3], Uint32 secs)
+{
   aSignal->m_noOfSections = secs;
-  if(getIsNodeSendable(aNode) == true){
 #ifdef API_TRACE
-    if(setSignalLog() && TRACE_GSN(aSignal->theVerId_signalNumber)){
-      Uint32 tmp = aSignal->theSendersBlockRef;
-      aSignal->theSendersBlockRef = numberToRef(tmp, theOwnId);
-      signalLogger.sendSignal(* aSignal,
-			      1,
-			      aSignal->getDataPtrSend(),
-			      aNode,
-                              ptr, secs);
-      signalLogger.flushSignalLog();
-      aSignal->theSendersBlockRef = tmp;
-    }
-    /* Reset section iterators */
-    for(Uint32 s=0; s < secs; s++)
-      ptr[s].sectionIter->reset();
-#endif
-    SendStatus ss = theTransporterRegistry->prepareSend
-      (aSignal, 
-       1, // JBB
-       aSignal->getDataPtrSend(),
-       aNode, 
-       ptr);
-    assert(ss != SEND_MESSAGE_TOO_BIG);
-    aSignal->m_noOfSections = 0;
-    return (ss == SEND_OK ? 0 : -1);
+  if(setSignalLog() && TRACE_GSN(aSignal->theVerId_signalNumber)){
+    Uint32 tmp = aSignal->theSendersBlockRef;
+    aSignal->theSendersBlockRef = numberToRef(tmp, theOwnId);
+    signalLogger.sendSignal(* aSignal,
+                            1,
+                            aSignal->getDataPtrSend(),
+                            aNode,
+                            ptr, secs);
+    signalLogger.flushSignalLog();
+    aSignal->theSendersBlockRef = tmp;
   }
+  /* Reset section iterators */
+  for(Uint32 s=0; s < secs; s++)
+    ptr[s].sectionIter->reset();
+#endif
+  SendStatus ss = theTransporterRegistry->prepareSend
+    (aSignal,
+     1, // JBB
+     aSignal->getDataPtrSend(),
+     aNode,
+     ptr);
+  assert(ss != SEND_MESSAGE_TOO_BIG);
   aSignal->m_noOfSections = 0;
-  return -1;
+  return (ss == SEND_OK ? 0 : -1);
 }
 
 /******************************************************************************
@@ -1719,7 +1709,8 @@ template class Vector<trp_client*>;
 #include "SignalSender.hpp"
 
 SendStatus
-SignalSender::sendSignal(Uint16 nodeId, const SimpleSignal * s){
+SignalSender::sendSignal(Uint16 nodeId, const SimpleSignal * s)
+{
 #ifdef API_TRACE
   if(setSignalLog() && TRACE_GSN(s->header.theVerId_signalNumber)){
     SignalHeader tmp = s->header;

=== modified file 'storage/ndb/src/ndbapi/TransporterFacade.hpp'
--- a/storage/ndb/src/ndbapi/TransporterFacade.hpp	2010-11-09 20:40:03 +0000
+++ b/storage/ndb/src/ndbapi/TransporterFacade.hpp	2010-12-03 05:53:47 +0000
@@ -83,12 +83,12 @@ public:
   // Only sends to nodes which are alive
 private:
   int sendSignal(NdbApiSignal * signal, NodeId nodeId);
-  int sendSignal(NdbApiSignal*, NodeId, 
-		 const LinearSectionPtr ptr[3], Uint32 secs);
+  int sendSignal(NdbApiSignal*, NodeId,
+                 const LinearSectionPtr ptr[3], Uint32 secs);
   int sendSignal(NdbApiSignal*, NodeId,
                  const GenericSectionPtr ptr[3], Uint32 secs);
-  int sendFragmentedSignal(NdbApiSignal*, NodeId, 
-			   const LinearSectionPtr ptr[3], Uint32 secs);
+  int sendFragmentedSignal(NdbApiSignal*, NodeId,
+                           const LinearSectionPtr ptr[3], Uint32 secs);
   int sendFragmentedSignal(NdbApiSignal*, NodeId,
                            const GenericSectionPtr ptr[3], Uint32 secs);
 public:
@@ -206,11 +206,10 @@ private:
   friend class ArbitMgr;
   friend class MgmtSrvr;
   friend class SignalSender;
-  friend class Ndb;
   friend class Ndb_cluster_connection;
   friend class Ndb_cluster_connection_impl;
+  friend class NdbImpl;
   friend class NdbTransaction;
-  friend class NdbDictInterface;
 
   int sendSignalUnCond(NdbApiSignal *, NodeId nodeId, Uint32 prio = 0);
 
@@ -327,21 +326,6 @@ TransporterFacade::hb_received(NodeId n)
 }
 
 inline
-bool
-TransporterFacade::getIsNodeSendable(NodeId n) const {
-  const trp_node & node = theClusterMgr->getNodeInfo(n);
-  const Uint32 startLevel = node.m_state.startLevel;
-  const NodeInfo::NodeType node_type = node.m_info.getType();
-  assert(node_type == NodeInfo::DB ||
-         node_type == NodeInfo::MGM);
-
-  return node.compatible && (startLevel == NodeState::SL_STARTED ||
-                             startLevel == NodeState::SL_STOPPING_1 ||
-                             node.m_state.getSingleUserMode() ||
-                             node_type == NodeInfo::MGM);
-}
-
-inline
 Uint32
 TransporterFacade::getMinDbNodeVersion() const
 {

=== modified file 'storage/ndb/src/ndbapi/trp_client.hpp'
--- a/storage/ndb/src/ndbapi/trp_client.hpp	2010-11-09 20:40:03 +0000
+++ b/storage/ndb/src/ndbapi/trp_client.hpp	2010-12-03 05:53:47 +0000
@@ -47,13 +47,15 @@ public:
 
   void forceSend(int val = 1);
 
-  int sendSignal(NdbApiSignal * signal, Uint32 nodeId);
-  int sendSignal(NdbApiSignal*, Uint32, const LinearSectionPtr p[3], Uint32 s);
-  int sendSignal(NdbApiSignal*, Uint32, const GenericSectionPtr p[3], Uint32 s);
-  int sendFragmentedSignal(NdbApiSignal*, Uint32,
-			   const LinearSectionPtr ptr[3], Uint32 secs);
-  int sendFragmentedSignal(NdbApiSignal*, Uint32,
-                           const GenericSectionPtr ptr[3], Uint32 secs);
+  int raw_sendSignal(NdbApiSignal*, Uint32 nodeId);
+  int raw_sendSignal(NdbApiSignal*, Uint32 nodeId,
+                     const LinearSectionPtr ptr[3], Uint32 secs);
+  int raw_sendSignal(NdbApiSignal*, Uint32 nodeId,
+                     const GenericSectionPtr ptr[3], Uint32 secs);
+  int raw_sendFragmentedSignal(NdbApiSignal*, Uint32 nodeId,
+                               const LinearSectionPtr ptr[3], Uint32 secs);
+  int raw_sendFragmentedSignal(NdbApiSignal*, Uint32 nodeId,
+                               const GenericSectionPtr ptr[3], Uint32 secs);
 
   const trp_node & getNodeInfo(Uint32 i) const;
 
@@ -126,40 +128,46 @@ trp_client::unlock()
 
 inline
 int
-trp_client::sendSignal(NdbApiSignal * signal, Uint32 nodeId)
+trp_client::raw_sendSignal(NdbApiSignal * signal, Uint32 nodeId)
 {
+  assert(m_poll.m_locked);
   return m_facade->sendSignal(signal, nodeId);
 }
 
 inline
 int
-trp_client::sendSignal(NdbApiSignal * signal, Uint32 nodeId,
-                       const LinearSectionPtr ptr[3], Uint32 secs)
+trp_client::raw_sendSignal(NdbApiSignal * signal, Uint32 nodeId,
+                           const LinearSectionPtr ptr[3], Uint32 secs)
 {
+  assert(m_poll.m_locked);
   return m_facade->sendSignal(signal, nodeId, ptr, secs);
 }
 
 inline
 int
-trp_client::sendSignal(NdbApiSignal * signal, Uint32 nodeId,
-                       const GenericSectionPtr ptr[3], Uint32 secs)
+trp_client::raw_sendSignal(NdbApiSignal * signal, Uint32 nodeId,
+                           const GenericSectionPtr ptr[3], Uint32 secs)
 {
+  assert(m_poll.m_locked);
   return m_facade->sendSignal(signal, nodeId, ptr, secs);
 }
 
 inline
 int
-trp_client::sendFragmentedSignal(NdbApiSignal * signal, Uint32 nodeId,
-                                 const LinearSectionPtr ptr[3], Uint32 secs)
+trp_client::raw_sendFragmentedSignal(NdbApiSignal * signal, Uint32 nodeId,
+                                     const LinearSectionPtr ptr[3], Uint32 secs)
 {
+  assert(m_poll.m_locked);
   return m_facade->sendFragmentedSignal(signal, nodeId, ptr, secs);
 }
 
 inline
 int
-trp_client::sendFragmentedSignal(NdbApiSignal * signal, Uint32 nodeId,
-                                 const GenericSectionPtr ptr[3], Uint32 secs)
+trp_client::raw_sendFragmentedSignal(NdbApiSignal * signal, Uint32 nodeId,
+                                     const GenericSectionPtr ptr[3],
+                                     Uint32 secs)
 {
+  assert(m_poll.m_locked);
   return m_facade->sendFragmentedSignal(signal, nodeId, ptr, secs);
 }
 

No bundle (reason: useless for push emails).
Thread
bzr push into mysql-5.1-telco-7.0 branch (jonas:4043 to 4044) jonas oreland3 Dec