bk commit into 5.1 tree (jonas:1.2843)

[jonas]

Below is the list of changes that have just been committed into a local
5.1 repository of jonas.  When jonas does a push these changes
will be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet@stripped, 2008-02-06 21:00:10+01:00, jonas@stripped +14 -0
  ndb - wl3600 [ 3 / 11 ]
  
  Cleanup Drop-table
  
  This patch
  1) removes IT_REPEAT from dropTable::*
  2) removes WAIT_DROP_TAB 
     (which after some analysis proved not to be needed anymore)
  
  The patch is tested using
  testDict -n SchemaTrans
  testDict -l 25 -n DropTable* (using max LCP speed)
  
  ---
   storage/ndb/include/kernel/GlobalSignalNumbers.h           |    6 
   storage/ndb/include/kernel/signaldata/PrepDropTab.hpp      |   70 ------
   storage/ndb/include/kernel/signaldata/TcContinueB.hpp      |    1 
   storage/ndb/src/common/debugger/signaldata/SignalNames.cpp |    4 
   storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp            |  151 ++++++-------
   storage/ndb/src/kernel/blocks/dbdih/Dbdih.hpp              |    3 
   storage/ndb/src/kernel/blocks/dbdih/DbdihInit.cpp          |    2 
   storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp          |  104 --------
   storage/ndb/src/kernel/blocks/dblqh/Dblqh.hpp              |    3 
   storage/ndb/src/kernel/blocks/dblqh/DblqhInit.cpp          |    1 
   storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp          |  100 --------
   storage/ndb/src/kernel/blocks/dbtc/Dbtc.hpp                |   11 
   storage/ndb/src/kernel/blocks/dbtc/DbtcInit.cpp            |    2 
   storage/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp            |  142 ------------
   14 files changed, 101 insertions(+), 499 deletions(-)

  storage/ndb/include/kernel/GlobalSignalNumbers.h@stripped, 2008-02-06 21:00:08+01:00,
jonas@stripped +3 -3
    Cleanup Drop-table
    
    This patch
    1) removes IT_REPEAT from dropTable::*
    2) removes WAIT_DROP_TAB 
       (which after some analysis proved not to be needed anymore)
    
    The patch is tested using
    testDict -n SchemaTrans
    testDict -l 25 -n DropTable* (using max LCP speed)

  storage/ndb/include/kernel/signaldata/PrepDropTab.hpp@stripped, 2008-02-06 21:00:08+01:00,
jonas@stripped +0 -70
    Cleanup Drop-table
    
    This patch
    1) removes IT_REPEAT from dropTable::*
    2) removes WAIT_DROP_TAB 
       (which after some analysis proved not to be needed anymore)
    
    The patch is tested using
    testDict -n SchemaTrans
    testDict -l 25 -n DropTable* (using max LCP speed)

  storage/ndb/include/kernel/signaldata/TcContinueB.hpp@stripped, 2008-02-06 21:00:08+01:00,
jonas@stripped +0 -1
    Cleanup Drop-table
    
    This patch
    1) removes IT_REPEAT from dropTable::*
    2) removes WAIT_DROP_TAB 
       (which after some analysis proved not to be needed anymore)
    
    The patch is tested using
    testDict -n SchemaTrans
    testDict -l 25 -n DropTable* (using max LCP speed)

  storage/ndb/src/common/debugger/signaldata/SignalNames.cpp@stripped, 2008-02-06
21:00:08+01:00, jonas@stripped +0 -4
    Cleanup Drop-table
    
    This patch
    1) removes IT_REPEAT from dropTable::*
    2) removes WAIT_DROP_TAB 
       (which after some analysis proved not to be needed anymore)
    
    The patch is tested using
    testDict -n SchemaTrans
    testDict -l 25 -n DropTable* (using max LCP speed)

  storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp@stripped, 2008-02-06 21:00:08+01:00,
jonas@stripped +76 -75
    Cleanup Drop-table
    
    This patch
    1) removes IT_REPEAT from dropTable::*
    2) removes WAIT_DROP_TAB 
       (which after some analysis proved not to be needed anymore)
    
    The patch is tested using
    testDict -n SchemaTrans
    testDict -l 25 -n DropTable* (using max LCP speed)

  storage/ndb/src/kernel/blocks/dbdih/Dbdih.hpp@stripped, 2008-02-06 21:00:08+01:00,
jonas@stripped +0 -3
    Cleanup Drop-table
    
    This patch
    1) removes IT_REPEAT from dropTable::*
    2) removes WAIT_DROP_TAB 
       (which after some analysis proved not to be needed anymore)
    
    The patch is tested using
    testDict -n SchemaTrans
    testDict -l 25 -n DropTable* (using max LCP speed)

  storage/ndb/src/kernel/blocks/dbdih/DbdihInit.cpp@stripped, 2008-02-06 21:00:08+01:00,
jonas@stripped +0 -2
    Cleanup Drop-table
    
    This patch
    1) removes IT_REPEAT from dropTable::*
    2) removes WAIT_DROP_TAB 
       (which after some analysis proved not to be needed anymore)
    
    The patch is tested using
    testDict -n SchemaTrans
    testDict -l 25 -n DropTable* (using max LCP speed)

  storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp@stripped, 2008-02-06 21:00:08+01:00,
jonas@stripped +2 -102
    Cleanup Drop-table
    
    This patch
    1) removes IT_REPEAT from dropTable::*
    2) removes WAIT_DROP_TAB 
       (which after some analysis proved not to be needed anymore)
    
    The patch is tested using
    testDict -n SchemaTrans
    testDict -l 25 -n DropTable* (using max LCP speed)

  storage/ndb/src/kernel/blocks/dblqh/Dblqh.hpp@stripped, 2008-02-06 21:00:08+01:00,
jonas@stripped +0 -3
    Cleanup Drop-table
    
    This patch
    1) removes IT_REPEAT from dropTable::*
    2) removes WAIT_DROP_TAB 
       (which after some analysis proved not to be needed anymore)
    
    The patch is tested using
    testDict -n SchemaTrans
    testDict -l 25 -n DropTable* (using max LCP speed)

  storage/ndb/src/kernel/blocks/dblqh/DblqhInit.cpp@stripped, 2008-02-06 21:00:08+01:00,
jonas@stripped +0 -1
    Cleanup Drop-table
    
    This patch
    1) removes IT_REPEAT from dropTable::*
    2) removes WAIT_DROP_TAB 
       (which after some analysis proved not to be needed anymore)
    
    The patch is tested using
    testDict -n SchemaTrans
    testDict -l 25 -n DropTable* (using max LCP speed)

  storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp@stripped, 2008-02-06 21:00:08+01:00,
jonas@stripped +9 -91
    Cleanup Drop-table
    
    This patch
    1) removes IT_REPEAT from dropTable::*
    2) removes WAIT_DROP_TAB 
       (which after some analysis proved not to be needed anymore)
    
    The patch is tested using
    testDict -n SchemaTrans
    testDict -l 25 -n DropTable* (using max LCP speed)

  storage/ndb/src/kernel/blocks/dbtc/Dbtc.hpp@stripped, 2008-02-06 21:00:08+01:00,
jonas@stripped +1 -10
    Cleanup Drop-table
    
    This patch
    1) removes IT_REPEAT from dropTable::*
    2) removes WAIT_DROP_TAB 
       (which after some analysis proved not to be needed anymore)
    
    The patch is tested using
    testDict -n SchemaTrans
    testDict -l 25 -n DropTable* (using max LCP speed)

  storage/ndb/src/kernel/blocks/dbtc/DbtcInit.cpp@stripped, 2008-02-06 21:00:08+01:00,
jonas@stripped +0 -2
    Cleanup Drop-table
    
    This patch
    1) removes IT_REPEAT from dropTable::*
    2) removes WAIT_DROP_TAB 
       (which after some analysis proved not to be needed anymore)
    
    The patch is tested using
    testDict -n SchemaTrans
    testDict -l 25 -n DropTable* (using max LCP speed)

  storage/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp@stripped, 2008-02-06 21:00:08+01:00,
jonas@stripped +10 -132
    Cleanup Drop-table
    
    This patch
    1) removes IT_REPEAT from dropTable::*
    2) removes WAIT_DROP_TAB 
       (which after some analysis proved not to be needed anymore)
    
    The patch is tested using
    testDict -n SchemaTrans
    testDict -l 25 -n DropTable* (using max LCP speed)

diff -Nrup a/storage/ndb/include/kernel/GlobalSignalNumbers.h
b/storage/ndb/include/kernel/GlobalSignalNumbers.h
--- a/storage/ndb/include/kernel/GlobalSignalNumbers.h	2008-01-08 15:44:21 +01:00
+++ b/storage/ndb/include/kernel/GlobalSignalNumbers.h	2008-02-06 21:00:08 +01:00
@@ -287,9 +287,9 @@ extern const GlobalSignalNumber NO_OF_SI
 #define GSN_DROP_TAB_REF                203
 #define GSN_DROP_TAB_CONF               204
 
-#define GSN_WAIT_DROP_TAB_REQ           208
-#define GSN_WAIT_DROP_TAB_REF           209
-#define GSN_WAIT_DROP_TAB_CONF          216
+#define GSN_208
+#define GSN_209
+#define GSN_216
 
 /*****************************************/
 
diff -Nrup a/storage/ndb/include/kernel/signaldata/PrepDropTab.hpp
b/storage/ndb/include/kernel/signaldata/PrepDropTab.hpp
--- a/storage/ndb/include/kernel/signaldata/PrepDropTab.hpp	2006-12-23 20:20:06 +01:00
+++ b/storage/ndb/include/kernel/signaldata/PrepDropTab.hpp	2008-02-06 21:00:08 +01:00
@@ -98,74 +98,4 @@ private:
   Uint32 errorCode;
 };
 
-class WaitDropTabReq {
-  /**
-   * Sender
-   */
-  friend class Dbtc;
-  friend class Dbdih;
-
-  /**
-   * Receiver(s)
-   */
-  friend class Dblqh;
-
-  friend bool printWAIT_DROP_TAB_REQ(FILE *, const Uint32 *, Uint32, Uint16);
-public:
-  STATIC_CONST( SignalLength = 2 );
-  
-  Uint32 tableId;
-  Uint32 senderRef;
-};
-
-class WaitDropTabRef {
-  /**
-   * Sender
-   */
-  friend class Dblqh;
-
-  /**
-   * Receiver(s)
-   */
-  friend class Dbtc;
-  friend class Dbdih;
-
-  friend bool printWAIT_DROP_TAB_REF(FILE *, const Uint32 *, Uint32, Uint16);
-public:
-  STATIC_CONST( SignalLength = 4 );
-  
-  enum ErrorCode {
-    NoSuchTable = 1,
-    IllegalTableState = 2,
-    DropInProgress = 3,
-    NF_FakeErrorREF = 4
-  };
-  
-  Uint32 tableId;
-  Uint32 senderRef;
-  Uint32 errorCode;
-  Uint32 tableStatus;
-};
-
-
-class WaitDropTabConf {
-  /**
-   * Sender
-   */
-  friend class Dblqh;
-
-  /**
-   * Receiver(s)
-   */
-  friend class Dbtc;
-  friend class Dbdih;
-
-  friend bool printWAIT_DROP_TAB_CONF(FILE *, const Uint32 *, Uint32, Uint16);
-public:
-  STATIC_CONST( SignalLength = 2 );
-
-  Uint32 tableId;
-  Uint32 senderRef;
-};
-
 #endif
diff -Nrup a/storage/ndb/include/kernel/signaldata/TcContinueB.hpp
b/storage/ndb/include/kernel/signaldata/TcContinueB.hpp
--- a/storage/ndb/include/kernel/signaldata/TcContinueB.hpp	2006-12-23 20:20:06 +01:00
+++ b/storage/ndb/include/kernel/signaldata/TcContinueB.hpp	2008-02-06 21:00:08 +01:00
@@ -40,7 +40,6 @@ private:
     ZHANDLE_FAILED_API_NODE_REMOVE_MARKERS = 13,
     ZWAIT_ABORT_ALL                        = 14,
     ZCHECK_SCAN_ACTIVE_FAILED_LQH          = 15,
-    CHECK_WAIT_DROP_TAB_FAILED_LQH         = 16,
     TRIGGER_PENDING                        = 17,
     
     DelayTCKEYCONF = 18,
diff -Nrup a/storage/ndb/src/common/debugger/signaldata/SignalNames.cpp
b/storage/ndb/src/common/debugger/signaldata/SignalNames.cpp
--- a/storage/ndb/src/common/debugger/signaldata/SignalNames.cpp	2008-01-08 15:30:27
+01:00
+++ b/storage/ndb/src/common/debugger/signaldata/SignalNames.cpp	2008-02-06 21:00:08
+01:00
@@ -427,10 +427,6 @@ const GsnName SignalNames [] = {
   ,{ GSN_PREP_DROP_TAB_REF,      "PREP_DROP_TAB_REF" }
   ,{ GSN_PREP_DROP_TAB_CONF,     "PREP_DROP_TAB_CONF" }
 
-  ,{ GSN_WAIT_DROP_TAB_REQ,      "WAIT_DROP_TAB_REQ" }
-  ,{ GSN_WAIT_DROP_TAB_REF,      "WAIT_DROP_TAB_REF" }
-  ,{ GSN_WAIT_DROP_TAB_CONF,     "WAIT_DROP_TAB_CONF" }
-  
   ,{ GSN_CREATE_TRIG_REQ,        "CREATE_TRIG_REQ" }
   ,{ GSN_CREATE_TRIG_CONF,       "CREATE_TRIG_CONF" }
   ,{ GSN_CREATE_TRIG_REF,        "CREATE_TRIG_REF" }
diff -Nrup a/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
b/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
--- a/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp	2008-02-06 20:54:57 +01:00
+++ b/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp	2008-02-06 21:00:08 +01:00
@@ -6504,30 +6504,16 @@ Dbdict::dropTable_prepare(Signal* signal
 
   D("dropTable_prepare" << V(itRepeat) << *op_ptr.p);
 
-  if (itRepeat == 0) {
-    jam();
-    dropTabPtr.p->m_block = 0;
-
-    // master checks table state and all sync via next repeat
+  dropTabPtr.p->m_block = 0;
 
-    if (trans_ptr.p->m_isMaster) {
-      jam();
-      Mutex mutex(signal, c_mutexMgr, dropTabPtr.p->m_define_backup_mutex);
-      Callback c = {
-        safe_cast(&Dbdict::dropTable_backup_mutex_locked),
-        op_ptr.p->op_key
-      };
-      bool ok = mutex.lock(c);
-      ndbrequire(ok);
-      return;
-    }
-
-    Uint32 itFlags = SchemaTransImplConf::IT_REPEAT;
-    sendTransConf(signal, trans_ptr, itFlags);
-    return;
-  }
-
-  prepDropTab_nextStep(signal, op_ptr);
+  Mutex mutex(signal, c_mutexMgr, dropTabPtr.p->m_define_backup_mutex);
+  Callback c = {
+    safe_cast(&Dbdict::dropTable_backup_mutex_locked),
+    op_ptr.p->op_key
+  };
+  bool ok = mutex.lock(c);
+  ndbrequire(ok);
+  return;
 }
 
 void
@@ -6553,16 +6539,16 @@ Dbdict::dropTable_backup_mutex_locked(Si
   Mutex mutex(signal, c_mutexMgr, dropTabPtr.p->m_define_backup_mutex);
   mutex.unlock(); // ignore response
 
-  if (tablePtr.p->tabState == TableRecord::BACKUP_ONGOING) {
+  if (tablePtr.p->tabState == TableRecord::BACKUP_ONGOING)
+  {
     jam();
     setError(op_ptr, DropTableRef::BackupInProgress, __LINE__);
     sendTransRef(signal, op_ptr);
-  } else {
-    jam();
-    tablePtr.p->tabState = TableRecord::PREPARE_DROPPING;
-    Uint32 itFlags = SchemaTransImplConf::IT_REPEAT;
-    sendTransConf(signal, trans_ptr, itFlags);
+    return;
   }
+
+  tablePtr.p->tabState = TableRecord::PREPARE_DROPPING;
+  prepDropTab_nextStep(signal, op_ptr);
 }
 
 void
@@ -6727,7 +6713,8 @@ Dbdict::execPREP_DROP_TAB_REF(Signal* si
   Uint32 errorCode = ref->errorCode;
   ndbrequire(errorCode != 0);
 
-  if (errorCode == PrepDropTabRef::NoSuchTable && block == DBLQH) {
+  if (errorCode == PrepDropTabRef::NoSuchTable && block == DBLQH)
+  {
     jam();
     /**
      * Ignore errors:
@@ -6746,14 +6733,13 @@ Dbdict::prepDropTab_fromLocal(Signal* si
   findSchemaOp(op_ptr, dropTabPtr, op_key);
   ndbrequire(!op_ptr.isNull());
 
-  if (errorCode != 0) {
+  if (errorCode != 0)
+  {
     jam();
     setError(op_ptr, errorCode, __LINE__);
   }
 
-  // one local block done, coordinator will order next
-  Uint32 itFlags = SchemaTransImplConf::IT_REPEAT;
-  sendTransConf(signal, op_ptr, itFlags);
+  prepDropTab_nextStep(signal, op_ptr);
 }
 
 void
@@ -6778,39 +6764,33 @@ Dbdict::dropTable_commit(Signal* signal,
 
   D("dropTable_commit" << V(itRepeat) << *op_ptr.p);
 
-  if (itRepeat == 0) {
-    jam();
-
-    // on first round do like old execDROP_TAB_REQ
-
-    TableRecordPtr tablePtr;
-    c_tableRecordPool.getPtr(tablePtr, dropTabPtr.p->m_request.tableId);
-    tablePtr.p->tabState = TableRecord::DROPPING;
+  TableRecordPtr tablePtr;
+  c_tableRecordPool.getPtr(tablePtr, dropTabPtr.p->m_request.tableId);
+  tablePtr.p->tabState = TableRecord::DROPPING;
 
-    dropTabPtr.p->m_block = 0;
-    dropTabPtr.p->m_callback.m_callbackData =
-      op_ptr.p->op_key;
-    dropTabPtr.p->m_callback.m_callbackFunction =
-      safe_cast(&Dbdict::dropTab_complete);
-
-    if (tablePtr.p->m_tablespace_id != RNIL)
-    {
-      FilegroupPtr ptr;
-      ndbrequire(c_filegroup_hash.find(ptr, tablePtr.p->m_tablespace_id));
-      decrease_ref_count(ptr.p->m_obj_ptr_i);
-    }
+  dropTabPtr.p->m_block = 0;
+  dropTabPtr.p->m_callback.m_callbackData =
+    op_ptr.p->op_key;
+  dropTabPtr.p->m_callback.m_callbackFunction =
+    safe_cast(&Dbdict::dropTab_complete);
+
+  if (tablePtr.p->m_tablespace_id != RNIL)
+  {
+    FilegroupPtr ptr;
+    ndbrequire(c_filegroup_hash.find(ptr, tablePtr.p->m_tablespace_id));
+    decrease_ref_count(ptr.p->m_obj_ptr_i);
+  }
 
 #if defined VM_TRACE || defined ERROR_INSERT
-    // from a newer execDROP_TAB_REQ version
-    {
-      char buf[1024];
-      Rope name(c_rope_pool, tablePtr.p->tableName);
-      name.copy(buf);
-      ndbout_c("Dbdict: drop name=%s,id=%u,obj_id=%u", buf, tablePtr.i, 
-               tablePtr.p->m_obj_ptr_i);
-    }
-#endif
+  // from a newer execDROP_TAB_REQ version
+  {
+    char buf[1024];
+    Rope name(c_rope_pool, tablePtr.p->tableName);
+    name.copy(buf);
+    ndbout_c("Dbdict: drop name=%s,id=%u,obj_id=%u", buf, tablePtr.i,
+             tablePtr.p->m_obj_ptr_i);
   }
+#endif
 
   dropTab_nextStep(signal, op_ptr);
 }
@@ -6924,17 +6904,7 @@ Dbdict::dropTab_fromLocal(Signal* signal
 
   D("dropTab_fromLocal" << *op_ptr.p);
 
-  Uint32 requestType = impl_req->requestType;
-  if (requestType == DropTabReq::CreateTabDrop ||
-      requestType == DropTabReq::RestartDropTab) {
-    jam();
-    dropTab_nextStep(signal, op_ptr);
-    return;
-  }
-
-  // one local block done, coordinator will order next
-  Uint32 itFlags = SchemaTransImplConf::IT_REPEAT;
-  sendTransConf(signal, op_ptr, itFlags);
+  dropTab_nextStep(signal, op_ptr);
 }
 
 void
@@ -20026,6 +19996,8 @@ void
 Dbdict::trans_commit(Signal* signal, SchemaTransPtr trans_ptr)
 {
   jam();
+  ndbout_c("trans_commit");
+
   Mutex mutex(signal, c_mutexMgr, trans_ptr.p->m_commit_mutex);
   Callback c = { safe_cast(&Dbdict::trans_commit_mutex_locked), trans_ptr.i };
 
@@ -20040,6 +20012,8 @@ Dbdict::trans_commit_mutex_locked(Signal
                                   Uint32 ret)
 {
   jamEntry();
+  ndbout_c("trans_commit_mutex_locked");
+
   SchemaTransPtr trans_ptr;
   c_schemaTransPool.getPtr(trans_ptr, transPtrI);
 
@@ -20051,10 +20025,23 @@ Dbdict::trans_commit_mutex_locked(Signal
 void
 Dbdict::trans_commit_done(Signal* signal, SchemaTransPtr trans_ptr)
 {
+  ndbout_c("trans_commit_done");
   Mutex mutex(signal, c_mutexMgr, trans_ptr.p->m_commit_mutex);
   Callback c = { safe_cast(&Dbdict::trans_commit_mutex_unlocked), trans_ptr.i };
 
-  mutex.unlock(c);
+  if (mutex.isNull())
+  {
+    /**
+     * Argh...this is a temporary fix until trans-phases are "clear"
+     */
+    jam();
+    trans_commit_mutex_unlocked(signal, trans_ptr.i, 0);
+  }
+  else
+  {
+    jam();
+    mutex.unlock(c);
+  }
 }
 
 void
@@ -20063,8 +20050,22 @@ Dbdict::trans_commit_mutex_unlocked(Sign
                                     Uint32 ret)
 {
   jamEntry();
+  ndbout_c("trans_commit_mutex_unlocked");
   SchemaTransPtr trans_ptr;
   c_schemaTransPool.getPtr(trans_ptr, transPtrI);
+
+  if (trans_ptr.p->m_commit_mutex.isNull())
+  {
+    jam();
+    /**
+     * Argh...this is a temporary fix until trans-phases are "clear"
+     */
+  }
+  else
+  {
+    jam();
+    trans_ptr.p->m_commit_mutex.release(c_mutexMgr);
+  }
 
   sendTransClientReply(signal, trans_ptr);
   // unlock
diff -Nrup a/storage/ndb/src/kernel/blocks/dbdih/Dbdih.hpp
b/storage/ndb/src/kernel/blocks/dbdih/Dbdih.hpp
--- a/storage/ndb/src/kernel/blocks/dbdih/Dbdih.hpp	2007-12-25 17:14:44 +01:00
+++ b/storage/ndb/src/kernel/blocks/dbdih/Dbdih.hpp	2008-02-06 21:00:08 +01:00
@@ -755,8 +755,6 @@ private:
   void execWAIT_GCP_CONF(Signal* signal);
 
   void execPREP_DROP_TAB_REQ(Signal* signal);
-  void execWAIT_DROP_TAB_REF(Signal* signal);
-  void execWAIT_DROP_TAB_CONF(Signal* signal);
   void execDROP_TAB_REQ(Signal* signal);
 
   void execALTER_TAB_REQ(Signal* signal);
@@ -765,7 +763,6 @@ private:
   
   void waitDropTabWritingToFile(Signal *, TabRecordPtr tabPtr);
   void checkPrepDropTabComplete(Signal *, TabRecordPtr tabPtr);
-  void checkWaitDropTabFailedLqh(Signal *, Uint32 nodeId, Uint32 tableId);
 
   void execDICT_LOCK_CONF(Signal* signal);
   void execDICT_LOCK_REF(Signal* signal);
diff -Nrup a/storage/ndb/src/kernel/blocks/dbdih/DbdihInit.cpp
b/storage/ndb/src/kernel/blocks/dbdih/DbdihInit.cpp
--- a/storage/ndb/src/kernel/blocks/dbdih/DbdihInit.cpp	2007-11-30 12:00:29 +01:00
+++ b/storage/ndb/src/kernel/blocks/dbdih/DbdihInit.cpp	2008-02-06 21:00:08 +01:00
@@ -258,8 +258,6 @@ Dbdih::Dbdih(Block_context& ctx):
   addRecSignal(GSN_WAIT_GCP_CONF, &Dbdih::execWAIT_GCP_CONF);
 
   addRecSignal(GSN_PREP_DROP_TAB_REQ, &Dbdih::execPREP_DROP_TAB_REQ);
-  addRecSignal(GSN_WAIT_DROP_TAB_REF, &Dbdih::execWAIT_DROP_TAB_REF);
-  addRecSignal(GSN_WAIT_DROP_TAB_CONF, &Dbdih::execWAIT_DROP_TAB_CONF);
   addRecSignal(GSN_DROP_TAB_REQ, &Dbdih::execDROP_TAB_REQ);
 
   addRecSignal(GSN_ALTER_TAB_REQ, &Dbdih::execALTER_TAB_REQ);
diff -Nrup a/storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp
b/storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp
--- a/storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp	2008-01-08 15:30:27 +01:00
+++ b/storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp	2008-02-06 21:00:08 +01:00
@@ -615,13 +615,6 @@ void Dbdih::execCONTINUEB(Signal* signal
     waitDropTabWritingToFile(signal, tabPtr);
     return;
   }
-  case DihContinueB::CHECK_WAIT_DROP_TAB_FAILED_LQH:{
-    jam();
-    Uint32 nodeId = signal->theData[1];
-    Uint32 tableId = signal->theData[2];
-    checkWaitDropTabFailedLqh(signal, nodeId, tableId);
-    return;
-  }
   case DihContinueB::ZTO_START_FRAGMENTS:
   {
     TakeOverRecordPtr takeOverPtr;
@@ -4498,7 +4491,6 @@ void Dbdih::execNODE_FAILREP(Signal* sig
     /*--------------------------------------------------*/
     checkStopMe(signal, failedNodePtr);
     failedNodeLcpHandling(signal, failedNodePtr);
-    checkWaitDropTabFailedLqh(signal, failedNodePtr.i, 0); // 0 = start w/ tab 0
     startRemoveFailedNode(signal, failedNodePtr);
 
     /**
@@ -15194,28 +15186,6 @@ Dbdih::execPREP_DROP_TAB_REQ(Signal* sig
     ndbrequire(ok);
   }  
   
-  { /**
-     * Send WaitDropTabReq to all LQH
-     */
-    WaitDropTabReq * req = (WaitDropTabReq*)signal->getDataPtrSend();
-    req->tableId = tabPtr.i;
-    req->senderRef = reference();
-    
-    NodeRecordPtr nodePtr;
-    nodePtr.i = cfirstAliveNode;
-    tabPtr.p->m_prepDropTab.waitDropTabCount.clearWaitingFor();
-    while(nodePtr.i != RNIL){
-      jam();
-      ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRecord);
-      
-      tabPtr.p->m_prepDropTab.waitDropTabCount.setWaitingFor(nodePtr.i);
-      sendSignal(calcLqhBlockRef(nodePtr.i), GSN_WAIT_DROP_TAB_REQ,
-		 signal, WaitDropTabReq::SignalLength, JBB);
-      
-      nodePtr.i = nodePtr.p->nextNode;
-    }
-  }
-  
   waitDropTabWritingToFile(signal, tabPtr);
 }
 
@@ -15248,7 +15218,8 @@ Dbdih::checkPrepDropTabComplete(Signal* 
   }
   
   const Uint32 ref = tabPtr.p->m_prepDropTab.senderRef;
-  if(ref != 0){
+  if(ref != 0)
+  {
     PrepDropTabConf* conf = (PrepDropTabConf*)signal->getDataPtrSend();
     conf->tableId = tabPtr.i;
     conf->senderRef = reference();
@@ -15258,77 +15229,6 @@ Dbdih::checkPrepDropTabComplete(Signal* 
     tabPtr.p->m_prepDropTab.senderRef = 0;
   }
 }
-			
-void
-Dbdih::execWAIT_DROP_TAB_REF(Signal* signal){
-  jamEntry();
-  WaitDropTabRef * ref = (WaitDropTabRef*)signal->getDataPtr();
-  
-  TabRecordPtr tabPtr;
-  tabPtr.i = ref->tableId;
-  ptrCheckGuard(tabPtr, ctabFileSize, tabRecord);
-  
-  ndbrequire(tabPtr.p->tabStatus == TabRecord::TS_DROPPING);
-  Uint32 nodeId = refToNode(ref->senderRef);
- 
-  ndbrequire(ref->errorCode == WaitDropTabRef::NoSuchTable ||
-	     ref->errorCode == WaitDropTabRef::NF_FakeErrorREF);
-
-  tabPtr.p->m_prepDropTab.waitDropTabCount.clearWaitingFor(nodeId);
-  checkPrepDropTabComplete(signal, tabPtr);
-}
-
-void
-Dbdih::execWAIT_DROP_TAB_CONF(Signal* signal){
-  jamEntry();
-  WaitDropTabConf * conf = (WaitDropTabConf*)signal->getDataPtr();
-  
-  TabRecordPtr tabPtr;
-  tabPtr.i = conf->tableId;
-  ptrCheckGuard(tabPtr, ctabFileSize, tabRecord);
-  
-  ndbrequire(tabPtr.p->tabStatus == TabRecord::TS_DROPPING);
-  Uint32 nodeId = refToNode(conf->senderRef);
-  tabPtr.p->m_prepDropTab.waitDropTabCount.clearWaitingFor(nodeId);
-  checkPrepDropTabComplete(signal, tabPtr);
-}
-
-void
-Dbdih::checkWaitDropTabFailedLqh(Signal* signal, Uint32 nodeId, Uint32 tableId){
-  
-  TabRecordPtr tabPtr;
-  tabPtr.i = tableId;
-
-  WaitDropTabConf * conf = (WaitDropTabConf*)signal->getDataPtr();
-  conf->tableId = tableId;
-
-  const Uint32 RT_BREAK = 16;
-  for(Uint32 i = 0; i<RT_BREAK && tabPtr.i < ctabFileSize; i++,
tabPtr.i++){
-    ptrAss(tabPtr, tabRecord);
-    if(tabPtr.p->tabStatus == TabRecord::TS_DROPPING){
-      if(tabPtr.p->m_prepDropTab.waitDropTabCount.isWaitingFor(nodeId)){
-	conf->senderRef = calcLqhBlockRef(nodeId);
-	execWAIT_DROP_TAB_CONF(signal);
-	tabPtr.i++;
-	break;
-      }
-    }
-  }
-  
-  if(tabPtr.i == ctabFileSize){
-    /**
-     * Finished
-     */
-    jam();
-    return;
-  }
-  
-  signal->theData[0] = DihContinueB::CHECK_WAIT_DROP_TAB_FAILED_LQH;
-  signal->theData[1] = nodeId;
-  signal->theData[2] = tabPtr.i;
-  sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB);
-}
-
 
 void
 Dbdih::execNDB_TAMPER(Signal* signal)
diff -Nrup a/storage/ndb/src/kernel/blocks/dblqh/Dblqh.hpp
b/storage/ndb/src/kernel/blocks/dblqh/Dblqh.hpp
--- a/storage/ndb/src/kernel/blocks/dblqh/Dblqh.hpp	2007-12-25 17:26:06 +01:00
+++ b/storage/ndb/src/kernel/blocks/dblqh/Dblqh.hpp	2008-02-06 21:00:08 +01:00
@@ -1848,8 +1848,6 @@ public:
     Uint8 m_disk_table;
 
     Uint32 usageCount;
-    NdbNodeBitmask waitingTC;
-    NdbNodeBitmask waitingDIH;
   }; // Size 100 bytes
   typedef Ptr<Tablerec> TablerecPtr;
 
@@ -2174,7 +2172,6 @@ private:
   void execDROP_TRIG_IMPL_REQ(Signal* signal);
 
   void execPREP_DROP_TAB_REQ(Signal* signal);
-  void execWAIT_DROP_TAB_REQ(Signal* signal);
   void execDROP_TAB_REQ(Signal* signal);
 
   void execLQH_ALLOCREQ(Signal* signal);
diff -Nrup a/storage/ndb/src/kernel/blocks/dblqh/DblqhInit.cpp
b/storage/ndb/src/kernel/blocks/dblqh/DblqhInit.cpp
--- a/storage/ndb/src/kernel/blocks/dblqh/DblqhInit.cpp	2008-01-08 15:30:27 +01:00
+++ b/storage/ndb/src/kernel/blocks/dblqh/DblqhInit.cpp	2008-02-06 21:00:08 +01:00
@@ -280,7 +280,6 @@ Dblqh::Dblqh(Block_context& ctx):
 
   //addRecSignal(GSN_DROP_TAB_REQ, &Dblqh::execDROP_TAB_REQ);
   addRecSignal(GSN_PREP_DROP_TAB_REQ, &Dblqh::execPREP_DROP_TAB_REQ);
-  addRecSignal(GSN_WAIT_DROP_TAB_REQ, &Dblqh::execWAIT_DROP_TAB_REQ);
   addRecSignal(GSN_DROP_TAB_REQ, &Dblqh::execDROP_TAB_REQ);
 
   addRecSignal(GSN_LQH_ALLOCREQ, &Dblqh::execLQH_ALLOCREQ);
diff -Nrup a/storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
b/storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
--- a/storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp	2008-01-08 15:30:27 +01:00
+++ b/storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp	2008-02-06 21:00:08 +01:00
@@ -1879,7 +1879,8 @@ Dblqh::execPREP_DROP_TAB_REQ(Signal* sig
   
   Uint32 errCode = 0;
   errCode = checkDropTabState(tabPtr.p->tableStatus, GSN_PREP_DROP_TAB_REQ);
-  if(errCode != 0){
+  if(errCode != 0)
+  {
     jam();
 
     PrepDropTabRef* ref = (PrepDropTabRef*)signal->getDataPtrSend();
@@ -1893,15 +1894,6 @@ Dblqh::execPREP_DROP_TAB_REQ(Signal* sig
   }
   
   tabPtr.p->tableStatus = Tablerec::PREP_DROP_TABLE_ONGOING;
-  tabPtr.p->waitingTC.clear();
-  tabPtr.p->waitingDIH.clear();
-  
-  PrepDropTabConf * conf = (PrepDropTabConf*)signal->getDataPtrSend();
-  conf->tableId = tabPtr.i;
-  conf->senderRef = reference();
-  conf->senderData = senderData;
-  sendSignal(senderRef, GSN_PREP_DROP_TAB_CONF, signal,
-	     PrepDropTabConf::SignalLength, JBB);
   
   signal->theData[0] = ZPREP_DROP_TABLE;
   signal->theData[1] = tabPtr.i;
@@ -1916,6 +1908,9 @@ Dblqh::checkDropTab(Signal* signal){
   TablerecPtr tabPtr;
   tabPtr.i = signal->theData[1];
   ptrCheckGuard(tabPtr, ctabrecFileSize, tablerec);
+
+  Uint32 senderRef = signal->theData[2];
+  Uint32 senderData = signal->theData[3];
   
   ndbrequire(tabPtr.p->tableStatus == Tablerec::PREP_DROP_TABLE_ONGOING);
   
@@ -1951,89 +1946,12 @@ Dblqh::checkDropTab(Signal* signal){
   
   tabPtr.p->tableStatus = Tablerec::PREP_DROP_TABLE_DONE;
 
-  WaitDropTabConf * conf = (WaitDropTabConf*)signal->getDataPtrSend();
+  PrepDropTabConf * conf = (PrepDropTabConf*)signal->getDataPtrSend();
   conf->tableId = tabPtr.i;
   conf->senderRef = reference();
-  for(Uint32 i = 1; i<MAX_NDB_NODES; i++){
-    if(tabPtr.p->waitingTC.get(i)){
-      tabPtr.p->waitingTC.clear(i);
-      sendSignal(calcTcBlockRef(i), GSN_WAIT_DROP_TAB_CONF, signal,
-		 WaitDropTabConf::SignalLength, JBB);
-    }
-    if(tabPtr.p->waitingDIH.get(i)){
-      tabPtr.p->waitingDIH.clear(i);
-      sendSignal(calcDihBlockRef(i), GSN_WAIT_DROP_TAB_CONF, signal,
-		 WaitDropTabConf::SignalLength, JBB);
-    }
-  }
-}
-
-void
-Dblqh::execWAIT_DROP_TAB_REQ(Signal* signal){
-  jamEntry();
-  WaitDropTabReq * req = (WaitDropTabReq*)signal->getDataPtr();
-  
-  TablerecPtr tabPtr;
-  tabPtr.i = req->tableId;
-  ptrCheckGuard(tabPtr, ctabrecFileSize, tablerec);
-  
-  Uint32 senderRef = req->senderRef;
-  Uint32 nodeId = refToNode(senderRef);
-  Uint32 blockNo = refToBlock(senderRef);
-
-  if(tabPtr.p->tableStatus == Tablerec::PREP_DROP_TABLE_ONGOING){
-    jam();
-    switch(blockNo){
-    case DBTC:
-      tabPtr.p->waitingTC.set(nodeId);
-      break;
-    case DBDIH:
-      tabPtr.p->waitingDIH.set(nodeId);
-      break;
-    default:
-      ndbrequire(false);
-    }
-    return;
-  }
-
-  if(tabPtr.p->tableStatus == Tablerec::PREP_DROP_TABLE_DONE){
-    jam();
-    WaitDropTabConf * conf = (WaitDropTabConf*)signal->getDataPtrSend();
-    conf->tableId = tabPtr.i;
-    conf->senderRef = reference();
-    sendSignal(senderRef, GSN_WAIT_DROP_TAB_CONF, signal,
-	       WaitDropTabConf::SignalLength, JBB);
-    return;
-  }
-
-  WaitDropTabRef * ref = (WaitDropTabRef*)signal->getDataPtrSend();
-  ref->tableId = tabPtr.i;
-  ref->senderRef = reference();
-
-  bool ok = false;
-  switch(tabPtr.p->tableStatus){
-  case Tablerec::TABLE_DEFINED:
-    ok = true;
-    ref->errorCode = WaitDropTabRef::IllegalTableState;
-    break;
-  case Tablerec::NOT_DEFINED:
-    ok = true;
-    ref->errorCode = WaitDropTabRef::NoSuchTable;
-    break;
-  case Tablerec::ADD_TABLE_ONGOING:
-    ok = true;
-    ref->errorCode = WaitDropTabRef::IllegalTableState;
-    break;
-  case Tablerec::PREP_DROP_TABLE_ONGOING:
-  case Tablerec::PREP_DROP_TABLE_DONE:
-    // Should have been take care of above
-    ndbrequire(false);
-  }
-  ndbrequire(ok);
-  ref->tableStatus = tabPtr.p->tableStatus;
-  sendSignal(senderRef, GSN_WAIT_DROP_TAB_REF, signal,
-	     WaitDropTabRef::SignalLength, JBB);
-  return;
+  conf->senderData = senderData;
+  sendSignal(senderRef, GSN_PREP_DROP_TAB_CONF, signal,
+	     PrepDropTabConf::SignalLength, JBB);
 }
 
 void
diff -Nrup a/storage/ndb/src/kernel/blocks/dbtc/Dbtc.hpp
b/storage/ndb/src/kernel/blocks/dbtc/Dbtc.hpp
--- a/storage/ndb/src/kernel/blocks/dbtc/Dbtc.hpp	2007-12-25 17:33:55 +01:00
+++ b/storage/ndb/src/kernel/blocks/dbtc/Dbtc.hpp	2008-02-06 21:00:08 +01:00
@@ -947,8 +947,7 @@ public:
       NF_TAKEOVER          = 0x1,
       NF_CHECK_SCAN        = 0x2,
       NF_CHECK_TRANSACTION = 0x4,
-      NF_CHECK_DROP_TAB    = 0x8,
-      NF_NODE_FAIL_BITS    = 0xF // All bits...
+      NF_NODE_FAIL_BITS    = 0x7 // All bits...
     };
     Uint32 m_nf_bits;
     NdbNodeBitmask m_lqh_trans_conf;
@@ -1001,12 +1000,6 @@ public:
     }
 
     Uint32 getErrorCode(Uint32 schemaVersion) const;
-
-    struct DropTable {
-      Uint32 senderRef;
-      Uint32 senderData;
-      SignalCounter waitDropTabCount;
-    } dropTable;
   };
   typedef Ptr<TableRecord> TableRecordPtr;
 
@@ -1375,8 +1368,6 @@ private:
   void execCREATE_TAB_REQ(Signal* signal);
   void execPREP_DROP_TAB_REQ(Signal* signal);
   void execDROP_TAB_REQ(Signal* signal);
-  void execWAIT_DROP_TAB_REF(Signal* signal);
-  void execWAIT_DROP_TAB_CONF(Signal* signal);
   void checkWaitDropTabFailedLqh(Signal*, Uint32 nodeId, Uint32 tableId);
   void execALTER_TAB_REQ(Signal* signal);
   void set_timeout_value(Uint32 timeOut);
diff -Nrup a/storage/ndb/src/kernel/blocks/dbtc/DbtcInit.cpp
b/storage/ndb/src/kernel/blocks/dbtc/DbtcInit.cpp
--- a/storage/ndb/src/kernel/blocks/dbtc/DbtcInit.cpp	2008-01-08 15:30:28 +01:00
+++ b/storage/ndb/src/kernel/blocks/dbtc/DbtcInit.cpp	2008-02-06 21:00:08 +01:00
@@ -274,8 +274,6 @@ Dbtc::Dbtc(Block_context& ctx):
   //addRecSignal(GSN_CREATE_TAB_REQ, &Dbtc::execCREATE_TAB_REQ);
   addRecSignal(GSN_DROP_TAB_REQ, &Dbtc::execDROP_TAB_REQ);
   addRecSignal(GSN_PREP_DROP_TAB_REQ, &Dbtc::execPREP_DROP_TAB_REQ);
-  addRecSignal(GSN_WAIT_DROP_TAB_REF, &Dbtc::execWAIT_DROP_TAB_REF);
-  addRecSignal(GSN_WAIT_DROP_TAB_CONF, &Dbtc::execWAIT_DROP_TAB_CONF);
   
   addRecSignal(GSN_ALTER_TAB_REQ, &Dbtc::execALTER_TAB_REQ);
   addRecSignal(GSN_ROUTE_ORD, &Dbtc::execROUTE_ORD);
diff -Nrup a/storage/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
b/storage/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
--- a/storage/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp	2008-01-08 15:30:28 +01:00
+++ b/storage/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp	2008-02-06 21:00:08 +01:00
@@ -281,10 +281,6 @@ void Dbtc::execCONTINUEB(Signal* signal)
     jam();
     nodeFailCheckTransactions(signal, Tdata0, Tdata1);
     return;
-  case TcContinueB::CHECK_WAIT_DROP_TAB_FAILED_LQH:
-    jam();
-    checkWaitDropTabFailedLqh(signal, Tdata0, Tdata1);
-    return;
   case TcContinueB::TRIGGER_PENDING:
     jam();
     ApiConnectRecordPtr transPtr;
@@ -415,7 +411,8 @@ Dbtc::execPREP_DROP_TAB_REQ(Signal* sign
   Uint32 senderRef = req->senderRef;
   Uint32 senderData = req->senderData;
   
-  if(!tabPtr.p->get_enabled()){
+  if(!tabPtr.p->get_enabled())
+  {
     jam();
     PrepDropTabRef* ref = (PrepDropTabRef*)signal->getDataPtrSend();
     ref->senderRef = reference();
@@ -427,7 +424,8 @@ Dbtc::execPREP_DROP_TAB_REQ(Signal* sign
     return;
   }
 
-  if(tabPtr.p->get_dropping()){
+  if(tabPtr.p->get_dropping())
+  {
     jam();
     PrepDropTabRef* ref = (PrepDropTabRef*)signal->getDataPtrSend();
     ref->senderRef = reference();
@@ -440,132 +438,13 @@ Dbtc::execPREP_DROP_TAB_REQ(Signal* sign
   }
   
   tabPtr.p->set_dropping(true);
-  tabPtr.p->dropTable.senderRef = senderRef;
-  tabPtr.p->dropTable.senderData = senderData;
-
-  {
-    WaitDropTabReq * req = (WaitDropTabReq*)signal->getDataPtrSend();
-    req->tableId = tabPtr.i;
-    req->senderRef = reference();
-    
-    HostRecordPtr hostPtr;
-    tabPtr.p->dropTable.waitDropTabCount.clearWaitingFor();
-    for (hostPtr.i = 1; hostPtr.i < MAX_NDB_NODES; hostPtr.i++) {
-      jam();
-      ptrAss(hostPtr, hostRecord);
-      if (hostPtr.p->hostStatus == HS_ALIVE) {
-	jam();
-	tabPtr.p->dropTable.waitDropTabCount.setWaitingFor(hostPtr.i);
-	sendSignal(calcLqhBlockRef(hostPtr.i), GSN_WAIT_DROP_TAB_REQ,
-		   signal, WaitDropTabReq::SignalLength, JBB);
-      }//for
-    }//if
-    
-    ndbrequire(tabPtr.p->dropTable.waitDropTabCount.done() != true);
-  }
-}
-
-void
-Dbtc::execWAIT_DROP_TAB_CONF(Signal* signal)
-{
-  jamEntry();
-  WaitDropTabConf * conf = (WaitDropTabConf*)signal->getDataPtr();
 
-  TableRecordPtr tabPtr;
-  tabPtr.i = conf->tableId;
-  ptrCheckGuard(tabPtr, ctabrecFilesize, tableRecord);
-  
-  ndbrequire(tabPtr.p->get_dropping() == true);
-  Uint32 nodeId = refToNode(conf->senderRef);
-  tabPtr.p->dropTable.waitDropTabCount.clearWaitingFor(nodeId);
-  
-  if(!tabPtr.p->dropTable.waitDropTabCount.done()){
-    jam();
-    return;
-  }
-  
-  {
-    PrepDropTabConf* conf = (PrepDropTabConf*)signal->getDataPtrSend();
-    conf->tableId = tabPtr.i;
-    conf->senderRef = reference();
-    conf->senderData = tabPtr.p->dropTable.senderData;
-    sendSignal(tabPtr.p->dropTable.senderRef, GSN_PREP_DROP_TAB_CONF, signal,
-	       PrepDropTabConf::SignalLength, JBB);
-    tabPtr.p->dropTable.senderRef = 0;
-  }
-}
-
-void
-Dbtc::execWAIT_DROP_TAB_REF(Signal* signal)
-{
-  jamEntry();
-  WaitDropTabRef * ref = (WaitDropTabRef*)signal->getDataPtr();
-
-  TableRecordPtr tabPtr;
-  tabPtr.i = ref->tableId;
-  ptrCheckGuard(tabPtr, ctabrecFilesize, tableRecord);
-  
-  ndbrequire(tabPtr.p->get_dropping() == true);
-  Uint32 nodeId = refToNode(ref->senderRef);
-  tabPtr.p->dropTable.waitDropTabCount.clearWaitingFor(nodeId);
-  
-  ndbrequire(ref->errorCode == WaitDropTabRef::NoSuchTable ||
-	     ref->errorCode == WaitDropTabRef::NF_FakeErrorREF);
-  
-  if(!tabPtr.p->dropTable.waitDropTabCount.done()){
-    jam();
-    return;
-  }
-  
-  {
-    PrepDropTabConf* conf = (PrepDropTabConf*)signal->getDataPtrSend();
-    conf->tableId = tabPtr.i;
-    conf->senderRef = reference();
-    conf->senderData = tabPtr.p->dropTable.senderData;
-    sendSignal(tabPtr.p->dropTable.senderRef, GSN_PREP_DROP_TAB_CONF, signal,
-	       PrepDropTabConf::SignalLength, JBB);
-    tabPtr.p->dropTable.senderRef = 0;
-  }
-}  
-
-void
-Dbtc::checkWaitDropTabFailedLqh(Signal* signal, Uint32 nodeId, Uint32 tableId)
-{
-  
-  TableRecordPtr tabPtr;
-  tabPtr.i = tableId;
-
-  WaitDropTabConf * conf = (WaitDropTabConf*)signal->getDataPtr();
-  conf->tableId = tableId;
-
-  const Uint32 RT_BREAK = 16;
-  for(Uint32 i = 0; i<RT_BREAK && tabPtr.i < ctabrecFilesize; i++,
tabPtr.i++){
-    jam();
-    ptrAss(tabPtr, tableRecord);
-    if(tabPtr.p->get_enabled() && tabPtr.p->get_dropping()){
-      if(tabPtr.p->dropTable.waitDropTabCount.isWaitingFor(nodeId)){
-        jam();
-	conf->senderRef = calcLqhBlockRef(nodeId);
-	execWAIT_DROP_TAB_CONF(signal);
-	tabPtr.i++;
-	break;
-      }
-    }
-  }
-  
-  if(tabPtr.i == ctabrecFilesize){
-    /**
-     * Finished
-     */
-    jam();
-    checkNodeFailComplete(signal, nodeId, HostRecord::NF_CHECK_DROP_TAB);
-    return;
-  }
-  
-  signal->theData[0] = TcContinueB::CHECK_WAIT_DROP_TAB_FAILED_LQH;
-  signal->theData[1] = nodeId;
-  signal->theData[2] = tabPtr.i;
-  sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB);
+  PrepDropTabConf* conf = (PrepDropTabConf*)signal->getDataPtrSend();
+  conf->tableId = tabPtr.i;
+  conf->senderRef = reference();
+  conf->senderData = senderData;
+  sendSignal(senderRef, GSN_PREP_DROP_TAB_CONF, signal,
+             PrepDropTabConf::SignalLength, JBB);
 }
 
 void
@@ -7290,7 +7169,6 @@ void Dbtc::execNODE_FAILREP(Signal* sign
     }
 
     checkScanActiveInFailedLqh(signal, 0, hostptr.i);
-    checkWaitDropTabFailedLqh(signal, hostptr.i, 0); // nodeid, tableid
     nodeFailCheckTransactions(signal, 0, hostptr.i);
   }
 }//Dbtc::execNODE_FAILREP()