bk commit into 5.1 tree (jonas:1.2609) BUG#37072

[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-05-29 17:58:58+02:00, jonas@stripped +14 -0
  ndb - bug#37072
    table creation failing in tup/acc *may* lead to crash of resource leak

  storage/ndb/include/kernel/signaldata/DumpStateOrd.hpp@stripped, 2008-05-29 17:58:53+02:00,
jonas@stripped +4 -1
    introduce "framework" for resource leak detection wrt to schema
    1) snapshot resource allocation
    2) check that current values == snapshot
    
    can be used for failed create table, or that create+drop does not leak

  storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp@stripped, 2008-05-29 17:58:53+02:00,
jonas@stripped +4 -0
    introduce "framework" for resource leak detection wrt to schema
    1) snapshot resource allocation
    2) check that current values == snapshot
    
    can be used for failed create table, or that create+drop does not leak

  storage/ndb/src/kernel/blocks/dbacc/DbaccInit.cpp@stripped, 2008-05-29 17:58:53+02:00,
jonas@stripped +3 -0
    introduce "framework" for resource leak detection wrt to schema
    1) snapshot resource allocation
    2) check that current values == snapshot
    
    can be used for failed create table, or that create+drop does not leak

  storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp@stripped, 2008-05-29 17:58:53+02:00,
jonas@stripped +14 -0
    introduce "framework" for resource leak detection wrt to schema
    1) snapshot resource allocation
    2) check that current values == snapshot
    
    can be used for failed create table, or that create+drop does not leak

  storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp@stripped, 2008-05-29 17:58:53+02:00,
jonas@stripped +23 -1
    introduce "framework" for resource leak detection wrt to schema
    1) snapshot resource allocation
    2) check that current values == snapshot
    
    can be used for failed create table, or that create+drop does not leak

  storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp@stripped, 2008-05-29 17:58:53+02:00,
jonas@stripped +5 -0
    introduce "framework" for resource leak detection wrt to schema
    1) snapshot resource allocation
    2) check that current values == snapshot
    
    can be used for failed create table, or that create+drop does not leak

  storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp@stripped, 2008-05-29 17:58:53+02:00,
jonas@stripped +6 -0
    introduce "framework" for resource leak detection wrt to schema
    1) snapshot resource allocation
    2) check that current values == snapshot
    
    can be used for failed create table, or that create+drop does not leak

  storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp@stripped, 2008-05-29 17:58:53+02:00,
jonas@stripped +16 -0
    introduce "framework" for resource leak detection wrt to schema
    1) snapshot resource allocation
    2) check that current values == snapshot
    
    can be used for failed create table, or that create+drop does not leak

  storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp@stripped, 2008-05-29 17:58:53+02:00,
jonas@stripped +5 -0
    introduce "framework" for resource leak detection wrt to schema
    1) snapshot resource allocation
    2) check that current values == snapshot
    
    can be used for failed create table, or that create+drop does not leak

  storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp@stripped, 2008-05-29 17:58:53+02:00,
jonas@stripped +43 -14
    fix 1 crashing bug (on failed create table) and 2 memleaks detected by new RSS macros

  storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp@stripped, 2008-05-29 17:58:53+02:00,
jonas@stripped +3 -0
    introduce "framework" for resource leak detection wrt to schema
    1) snapshot resource allocation
    2) check that current values == snapshot
    
    can be used for failed create table, or that create+drop does not leak

  storage/ndb/src/kernel/vm/SimulatedBlock.hpp@stripped, 2008-05-29 17:58:53+02:00,
jonas@stripped +33 -0
    introduce "framework" for resource leak detection wrt to schema
    1) snapshot resource allocation
    2) check that current values == snapshot
    
    can be used for failed create table, or that create+drop does not leak

  storage/ndb/test/ndbapi/testDict.cpp@stripped, 2008-05-29 17:58:53+02:00,
jonas@stripped +48 -3
    fix test prg

  storage/ndb/test/run-test/daily-basic-tests.txt@stripped, 2008-05-29 17:58:53+02:00,
jonas@stripped +6 -0
    add test prg to autotest

diff -Nrup a/storage/ndb/include/kernel/signaldata/DumpStateOrd.hpp
b/storage/ndb/include/kernel/signaldata/DumpStateOrd.hpp
--- a/storage/ndb/include/kernel/signaldata/DumpStateOrd.hpp	2007-05-21 11:03:16 +02:00
+++ b/storage/ndb/include/kernel/signaldata/DumpStateOrd.hpp	2008-05-29 17:58:53 +02:00
@@ -156,7 +156,10 @@ public:
     
     DumpTsman = 9800, 
     DumpLgman = 10000,
-    DumpPgman = 11000
+    DumpPgman = 11000,
+
+    SchemaResourceSnapshot = 4000, // Save resource consumption
+    SchemaResourceCheckLeak = 4001 // check same as snapshot
   };
 public:
   
diff -Nrup a/storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp
b/storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp
--- a/storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp	2007-03-16 11:14:05 +01:00
+++ b/storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp	2008-05-29 17:58:53 +02:00
@@ -881,6 +881,10 @@ private:
   FragmentrecPtr fragrecptr;
   Uint32 cfirstfreefrag;
   Uint32 cfragmentsize;
+  RSS_OP_COUNTER(cnoOfFreeFragrec);
+  RSS_OP_SNAPSHOT(cnoOfFreeFragrec);
+
+
 /* --------------------------------------------------------------------------------- */
 /* FS_CONNECTREC                                                                     */
 /* --------------------------------------------------------------------------------- */
diff -Nrup a/storage/ndb/src/kernel/blocks/dbacc/DbaccInit.cpp
b/storage/ndb/src/kernel/blocks/dbacc/DbaccInit.cpp
--- a/storage/ndb/src/kernel/blocks/dbacc/DbaccInit.cpp	2007-02-14 06:35:28 +01:00
+++ b/storage/ndb/src/kernel/blocks/dbacc/DbaccInit.cpp	2008-05-29 17:58:53 +02:00
@@ -43,6 +43,9 @@ void Dbacc::initData() 
 
   cnoOfAllocatedPages = cpagesize = 0;
   // Records with constant sizes
+
+  RSS_OP_COUNTER_INIT(cnoOfFreeFragrec);
+
 }//Dbacc::initData()
 
 void Dbacc::initRecords() 
diff -Nrup a/storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp
b/storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp
--- a/storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp	2008-05-26 10:30:44 +02:00
+++ b/storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp	2008-05-29 17:58:53 +02:00
@@ -858,6 +858,7 @@ void Dbacc::releaseFragRecord(Signal* si
   regFragPtr.p->nextfreefrag = cfirstfreefrag;
   cfirstfreefrag = regFragPtr.i;
   initFragGeneral(regFragPtr);
+  RSS_OP_FREE(cnoOfFreeFragrec);
 }//Dbacc::releaseFragRecord()
 
 /* -------------------------------------------------------------------------- */
@@ -8074,6 +8075,7 @@ void Dbacc::seizeDirrange(Signal* signal
 /* --------------------------------------------------------------------------------- */
 void Dbacc::seizeFragrec(Signal* signal) 
 {
+  RSS_OP_ALLOC(cnoOfFreeFragrec);
   fragrecptr.i = cfirstfreefrag;
   ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec);
   cfirstfreefrag = fragrecptr.p->nextfreefrag;
@@ -8520,6 +8522,18 @@ Dbacc::execDUMP_STATE_ORD(Signal* signal
     return;
   }//if
 #endif
+
+  if (signal->theData[0] == DumpStateOrd::SchemaResourceSnapshot)
+  {
+    RSS_OP_SNAPSHOT_SAVE(cnoOfFreeFragrec);
+    return;
+  }
+
+  if (signal->theData[0] == DumpStateOrd::SchemaResourceCheckLeak)
+  {
+    RSS_OP_SNAPSHOT_CHECK(cnoOfFreeFragrec);
+    return;
+  }
 }//Dbacc::execDUMP_STATE_ORD()
 
 void
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-05-16 15:08:32 +02:00
+++ b/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp	2008-05-29 17:58:53 +02:00
@@ -87,6 +87,8 @@
 #include <signaldata/CreateObj.hpp>
 #include <SLList.hpp>
 
+#include <signaldata/DumpStateOrd.hpp>
+
 #include <EventLogger.hpp>
 extern EventLogger * g_eventLogger;
 
@@ -309,8 +311,28 @@ Dbdict::execDUMP_STATE_ORD(Signal* signa
               c_counterMgr.getNoOfFree());
     c_counterMgr.printNODE_FAILREP();
   }
-    
+
+  if (signal->theData[0] == DumpStateOrd::SchemaResourceSnapshot)
+  {
+    RSS_AP_SNAPSHOT_SAVE(c_rope_pool);
+    RSS_AP_SNAPSHOT_SAVE(c_attributeRecordPool);
+    RSS_AP_SNAPSHOT_SAVE(c_tableRecordPool);
+    RSS_AP_SNAPSHOT_SAVE(c_triggerRecordPool);
+    RSS_AP_SNAPSHOT_SAVE(c_obj_pool);
+  }
+
+  if (signal->theData[0] == DumpStateOrd::SchemaResourceCheckLeak)
+  {
+    RSS_AP_SNAPSHOT_CHECK(c_rope_pool);
+    RSS_AP_SNAPSHOT_CHECK(c_attributeRecordPool);
+    RSS_AP_SNAPSHOT_CHECK(c_tableRecordPool);
+    RSS_AP_SNAPSHOT_CHECK(c_triggerRecordPool);
+    RSS_AP_SNAPSHOT_CHECK(c_obj_pool);
+  }
+
   return;
+
+
 }//Dbdict::execDUMP_STATE_ORD()
 
 /* ---------------------------------------------------------------- */
diff -Nrup a/storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp
b/storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp
--- a/storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp	2008-05-16 15:08:32 +02:00
+++ b/storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp	2008-05-29 17:58:53 +02:00
@@ -198,6 +198,7 @@ public:
   typedef Ptr<AttributeRecord> AttributeRecordPtr;
   ArrayPool<AttributeRecord> c_attributeRecordPool;
   DLHashTable<AttributeRecord> c_attributeRecordHash;
+  RSS_AP_SNAPSHOT(c_attributeRecordPool);
 
   /**
    * Shared table / index record.  Most of this is permanent data stored
@@ -384,6 +385,7 @@ public:
 
   typedef Ptr<TableRecord> TableRecordPtr;
   ArrayPool<TableRecord> c_tableRecordPool;
+  RSS_AP_SNAPSHOT(c_tableRecordPool);
 
   /**  Node Group and Tablespace id+version + range or list data.
     *  This is only stored temporarily in DBDICT during an ongoing
@@ -463,6 +465,7 @@ public:
   Uint32 c_maxNoOfTriggers;
   typedef Ptr<TriggerRecord> TriggerRecordPtr;
   ArrayPool<TriggerRecord> c_triggerRecordPool;
+  RSS_AP_SNAPSHOT(c_triggerRecordPool);
 
   /**
    * Information for each FS connection.
@@ -612,6 +615,7 @@ public:
   Filegroup_hash c_filegroup_hash;
   
   RopePool c_rope_pool;
+  RSS_AP_SNAPSHOT(c_rope_pool);
 
   struct DictObject {
     DictObject() {}
@@ -643,6 +647,7 @@ public:
   
   DLHashTable<DictObject> c_obj_hash; // Name
   ArrayPool<DictObject> c_obj_pool;
+  RSS_AP_SNAPSHOT(c_obj_pool);
   
   DictObject * get_object(const char * name){
     return get_object(name, strlen(name) + 1);
diff -Nrup a/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
b/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
--- a/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp	2008-04-03 14:46:00 +02:00
+++ b/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp	2008-05-29 17:58:53 +02:00
@@ -2967,10 +2967,14 @@ private:
   Fragoperrec *fragoperrec;
   Uint32 cfirstfreeFragopr;
   Uint32 cnoOfFragoprec;
+  RSS_OP_COUNTER(cnoOfFreeFragoprec);
+  RSS_OP_SNAPSHOT(cnoOfFreeFragoprec);
 
   Fragrecord *fragrecord;
   Uint32 cfirstfreefrag;
   Uint32 cnoOfFragrec;
+  RSS_OP_COUNTER(cnoOfFreeFragrec);
+  RSS_OP_SNAPSHOT(cnoOfFreeFragrec);
 
   AlterTabOperation *alterTabOperRec;
   Uint32 cfirstfreeAlterTabOp;
@@ -2993,6 +2997,8 @@ private:
 
   TableDescriptor *tableDescriptor;
   Uint32 cnoOfTabDescrRec;
+  RSS_OP_COUNTER(cnoOfFreeTabDescrRec);
+  RSS_OP_SNAPSHOT(cnoOfFreeTabDescrRec);
   
   Uint32 cdata[32];
   Uint32 cdataPages[16];
diff -Nrup a/storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp
b/storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp	2007-06-12 09:39:21 +02:00
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp	2008-05-29 17:58:53 +02:00
@@ -259,6 +259,22 @@ Dbtup::execDUMP_STATE_ORD(Signal* signal
              max_loop);
   }
 #endif
+
+  if (signal->theData[0] == DumpStateOrd::SchemaResourceSnapshot)
+  {
+    RSS_OP_SNAPSHOT_SAVE(cnoOfFreeFragoprec);
+    RSS_OP_SNAPSHOT_SAVE(cnoOfFreeFragrec);
+    RSS_OP_SNAPSHOT_SAVE(cnoOfFreeTabDescrRec);
+    return;
+  }
+
+  if (signal->theData[0] == DumpStateOrd::SchemaResourceCheckLeak)
+  {
+    RSS_OP_SNAPSHOT_CHECK(cnoOfFreeFragoprec);
+    RSS_OP_SNAPSHOT_CHECK(cnoOfFreeFragrec);
+    RSS_OP_SNAPSHOT_CHECK(cnoOfFreeTabDescrRec);
+    return;
+  }
 }//Dbtup::execDUMP_STATE_ORD()
 
 /* ---------------------------------------------------------------- */
diff -Nrup a/storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp
b/storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp	2007-06-14 19:08:12 +02:00
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp	2008-05-29 17:58:53 +02:00
@@ -117,6 +117,10 @@ Dbtup::Dbtup(Block_context& ctx, Pgman* 
   
   initData();
   CLEAR_ERROR_INSERT_VALUE;
+
+  RSS_OP_COUNTER_INIT(cnoOfFreeFragoprec);
+  RSS_OP_COUNTER_INIT(cnoOfFreeFragrec);
+  RSS_OP_COUNTER_INIT(cnoOfFreeTabDescrRec);
 }//Dbtup::Dbtup()
 
 Dbtup::~Dbtup() 
@@ -762,6 +766,7 @@ void Dbtup::releaseFragrec(FragrecordPtr
 {
   regFragPtr.p->nextfreefrag = cfirstfreefrag;
   cfirstfreefrag = regFragPtr.i;
+  RSS_OP_FREE(cnoOfFreeFragrec);
 }//Dbtup::releaseFragrec()
 
 
diff -Nrup a/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
b/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp	2008-03-19 13:56:57 +01:00
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp	2008-05-29 17:58:53 +02:00
@@ -266,6 +266,7 @@ void Dbtup::seizeFragrecord(FragrecordPt
   ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
   cfirstfreefrag= regFragPtr.p->nextfreefrag;
   regFragPtr.p->nextfreefrag= RNIL;
+  RSS_OP_ALLOC(cnoOfFreeFragrec);
 }
 
 void Dbtup::seizeFragoperrec(FragoperrecPtr& fragOperPtr) 
@@ -275,6 +276,7 @@ void Dbtup::seizeFragoperrec(Fragoperrec
   cfirstfreeFragopr = fragOperPtr.p->nextFragoprec;
   fragOperPtr.p->nextFragoprec = RNIL;
   fragOperPtr.p->inUse = true;
+  RSS_OP_ALLOC(cnoOfFreeFragoprec);
 }//Dbtup::seizeFragoperrec()
 
 void Dbtup::seizeAlterTabOperation(AlterTabOperationPtr& alterTabOpPtr)
@@ -314,6 +316,17 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* 
   fragOperPtr.p->attributeCount--;
   const bool lastAttr = (fragOperPtr.p->attributeCount == 0);
 
+  if (ERROR_INSERTED(4009) && regTabPtr.p->fragid[0] == fragId &&
attrId == 0||
+      ERROR_INSERTED(4010) && regTabPtr.p->fragid[0] == fragId &&
lastAttr ||
+      ERROR_INSERTED(4011) && regTabPtr.p->fragid[1] == fragId &&
attrId == 0||
+      ERROR_INSERTED(4012) && regTabPtr.p->fragid[1] == fragId &&
lastAttr) {
+    jam();
+    terrorCode = 1;
+    addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
+    CLEAR_ERROR_INSERT_VALUE;
+    return;
+  }
+
   if (regTabPtr.p->tableStatus != DEFINING)
   {
     ndbrequire(regTabPtr.p->tableStatus == DEFINED);
@@ -455,17 +468,6 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* 
                    fragOperPtr.p->charsetIndex, attrDes2);
   setTabDescrWord(firstTabDesIndex + 1, attrDes2);
 
-  if (ERROR_INSERTED(4009) && regTabPtr.p->fragid[0] == fragId &&
attrId == 0||
-      ERROR_INSERTED(4010) && regTabPtr.p->fragid[0] == fragId &&
lastAttr ||
-      ERROR_INSERTED(4011) && regTabPtr.p->fragid[1] == fragId &&
attrId == 0||
-      ERROR_INSERTED(4012) && regTabPtr.p->fragid[1] == fragId &&
lastAttr) {
-    jam();
-    terrorCode = 1;
-    addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
-    CLEAR_ERROR_INSERT_VALUE;
-    return;
-  }
-
 /* **************************************************************** */
 /* **************          TUP_ADD_ATTCONF       ****************** */
 /* **************************************************************** */
@@ -1359,7 +1361,6 @@ void Dbtup::addattrrefuseLab(Signal* sig
   deleteFragTab(regTabPtr, fragId);
   releaseFragrec(regFragPtr);
   releaseTabDescr(regTabPtr);
-  initTab(regTabPtr);
 
   signal->theData[0]= fragOperPtr.p->lqhPtrFrag;
   signal->theData[1]= terrorCode;
@@ -1372,10 +1373,24 @@ void Dbtup::fragrefuse4Lab(Signal* signa
                            FragoperrecPtr fragOperPtr,
                            FragrecordPtr regFragPtr,
                            Tablerec* const regTabPtr,
-                           Uint32 fragId) 
+                           Uint32 fragId)
 {
+  bool found = false;
+  for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) 
+  {
+    jam();
+    if (regTabPtr->fragid[i] == fragId) 
+    {
+      jam();
+      ndbrequire(regTabPtr->fragrec[i] == regFragPtr.i);
+      regTabPtr->fragid[i] = RNIL;
+      regTabPtr->fragrec[i] = RNIL;
+      found = true;
+      break;
+    }
+  }
+  ndbrequire(found);
   fragrefuse3Lab(signal, fragOperPtr, regFragPtr, regTabPtr, fragId);
-  initTab(regTabPtr);
 }
 
 void Dbtup::fragrefuse3Lab(Signal* signal,
@@ -1413,6 +1428,7 @@ void Dbtup::releaseFragoperrec(Fragoperr
   fragOperPtr.p->inUse = false;
   fragOperPtr.p->nextFragoprec = cfirstfreeFragopr;
   cfirstfreeFragopr = fragOperPtr.i;
+  RSS_OP_FREE(cnoOfFreeFragoprec);
 }//Dbtup::releaseFragoperrec()
 
 void Dbtup::releaseAlterTabOpRec(AlterTabOperationPtr regAlterTabOpPtr)
@@ -1466,6 +1482,19 @@ Dbtup::execDROP_TAB_REQ(Signal* signal)
   
   tabPtr.p->m_dropTable.tabUserRef = req->senderRef;
   tabPtr.p->m_dropTable.tabUserPtr = req->senderData;
+
+  if (tabPtr.p->tableStatus == NOT_DEFINED) 
+  {
+    jam();
+    DropTabConf * const dropConf= (DropTabConf *)signal->getDataPtrSend();
+    dropConf->senderRef= reference();
+    dropConf->senderData= tabPtr.p->m_dropTable.tabUserPtr;
+    dropConf->tableId= tabPtr.i;
+    sendSignal(tabPtr.p->m_dropTable.tabUserRef, GSN_DROP_TAB_CONF,
+               signal, DropTabConf::SignalLength, JBB);
+    return;
+  }
+
   tabPtr.p->tableStatus = DROPPING;
 
   signal->theData[0]= ZREL_FRAG;
diff -Nrup a/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp
b/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp	2008-02-03 12:31:07 +01:00
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp	2008-05-29 17:58:53 +02:00
@@ -144,6 +144,7 @@ Dbtup::setTabDescrWord(Uint32 index, Uin
 void Dbtup::insertTdArea(Uint32 tabDesRef, Uint32 list) 
 {
   ndbrequire(list < 16);
+  RSS_OP_FREE_X(cnoOfFreeTabDescrRec, 1 << list);
   setTabDescrWord(tabDesRef + ZTD_FL_HEADER, ZTD_TYPE_FREE);
   setTabDescrWord(tabDesRef + ZTD_FL_NEXT, cfreeTdList[list]);
   if (cfreeTdList[list] != RNIL) {
@@ -217,6 +218,8 @@ void Dbtup::itdaMergeTabDescr(Uint32& re
 void Dbtup::removeTdArea(Uint32 tabDesRef, Uint32 list) 
 {
   ndbrequire(list < 16);
+  RSS_OP_ALLOC_X(cnoOfFreeTabDescrRec, 1 << list);
+
   Uint32 tabDescrNextPtr = getTabDescrWord(tabDesRef + ZTD_FL_NEXT);
   Uint32 tabDescrPrevPtr = getTabDescrWord(tabDesRef + ZTD_FL_PREV);
 
diff -Nrup a/storage/ndb/src/kernel/vm/SimulatedBlock.hpp
b/storage/ndb/src/kernel/vm/SimulatedBlock.hpp
--- a/storage/ndb/src/kernel/vm/SimulatedBlock.hpp	2008-02-20 10:04:24 +01:00
+++ b/storage/ndb/src/kernel/vm/SimulatedBlock.hpp	2008-05-29 17:58:53 +02:00
@@ -822,5 +822,38 @@ BLOCK::addRecSignal(GlobalSignalNumber g
 
 #include "Mutex.hpp"
 
+#ifdef ERROR_INSERT
+#define RSS_AP_SNAPSHOT(x) Uint32 rss_##x
+#define RSS_AP_SNAPSHOT_SAVE(x) rss_##x = x.getNoOfFree()
+#define RSS_AP_SNAPSHOT_CHECK(x) ndbrequire(rss_##x == x.getNoOfFree())
+
+#define RSS_OP_COUNTER(x) Uint32 x
+#define RSS_OP_COUNTER_INIT(x) x = 0
+#define RSS_OP_ALLOC(x) x ++
+#define RSS_OP_FREE(x) x --
+#define RSS_OP_ALLOC_X(x,n) x += n
+#define RSS_OP_FREE_X(x,n) x -= n
+
+#define RSS_OP_SNAPSHOT(x) Uint32 rss_##x
+#define RSS_OP_SNAPSHOT_SAVE(x) rss_##x = x
+#define RSS_OP_SNAPSHOT_CHECK(x) ndbrequire(rss_##x == x)
+#else
+#define RSS_AP_SNAPSHOT(x)
+#define RSS_AP_SNAPSHOT_SAVE(x)
+#define RSS_AP_SNAPSHOT_CHECK(x)
+
+#define RSS_OP_COUNTER(x)
+#define RSS_OP_COUNTER_INIT(x)
+#define RSS_OP_ALLOC(x)
+#define RSS_OP_FREE(x)
+#define RSS_OP_ALLOC_X(x,n)
+#define RSS_OP_FREE_X(x,n)
+
+#define RSS_OP_SNAPSHOT(x)
+#define RSS_OP_SNAPSHOT_SAVE(x)
+#define RSS_OP_SNAPSHOT_CHECK(x)
+
+#endif
+
 #endif
 
diff -Nrup a/storage/ndb/test/ndbapi/testDict.cpp b/storage/ndb/test/ndbapi/testDict.cpp
--- a/storage/ndb/test/ndbapi/testDict.cpp	2008-01-24 16:39:37 +01:00
+++ b/storage/ndb/test/ndbapi/testDict.cpp	2008-05-29 17:58:53 +02:00
@@ -24,6 +24,8 @@
 #include <random.h>
 #include <NdbAutoPtr.hpp>
 #include <NdbMixRestarter.hpp>
+#include <NdbSqlUtil.hpp>
+#include <NdbEnv.h>
 
 char f_tablename[256];
  
@@ -1967,6 +1969,8 @@ runCreateDiskTable(NDBT_Context* ctx, ND
   return NDBT_OK;
 }
 
+#include <NDBT_Tables.hpp>
+
 int runFailAddFragment(NDBT_Context* ctx, NDBT_Step* step){
   static int acclst[] = { 3001 };
   static int tuplst[] = { 4007, 4008, 4009, 4010, 4011, 4012 };
@@ -1982,31 +1986,64 @@ int runFailAddFragment(NDBT_Context* ctx
   NdbDictionary::Table tab(*ctx->getTab());
   tab.setFragmentType(NdbDictionary::Object::FragAllLarge);
 
+  int errNo = 0;
+  char buf[100];
+  if (NdbEnv_GetEnv("ERRNO", buf, sizeof(buf)))
+  {
+    errNo = atoi(buf);
+    ndbout_c("Using errno: %u", errNo);
+  }
+  
   // ordered index on first few columns
   NdbDictionary::Index idx("X");
   idx.setTable(tab.getName());
   idx.setType(NdbDictionary::Index::OrderedIndex);
   idx.setLogging(false);
-  for (int i_hate_broken_compilers = 0;
-       i_hate_broken_compilers < 3 &&
+  for (int cnt = 0, i_hate_broken_compilers = 0;
+       cnt < 3 &&
        i_hate_broken_compilers < tab.getNoOfColumns();
        i_hate_broken_compilers++) {
-    idx.addColumn(*tab.getColumn(i_hate_broken_compilers));
+    if (NdbSqlUtil::check_column_for_ordered_index
+        (tab.getColumn(i_hate_broken_compilers)->getType(), 0) == 0 &&
+        tab.getColumn(i_hate_broken_compilers)->getStorageType() != 
+        NdbDictionary::Column::StorageTypeDisk)
+    {
+      idx.addColumn(*tab.getColumn(i_hate_broken_compilers));
+      cnt++;
+    }
+  }
+
+  for (Uint32 i = 0; i<tab.getNoOfColumns(); i++)
+  {
+    if (tab.getColumn(i)->getStorageType() == 
+        NdbDictionary::Column::StorageTypeDisk)
+    {
+      NDBT_Tables::create_default_tablespace(pNdb);
+      break;
+    }
   }
 
   const int loops = ctx->getNumLoops();
   int result = NDBT_OK;
   (void)pDic->dropTable(tab.getName());
 
+  int dump1 = DumpStateOrd::SchemaResourceSnapshot;
+  int dump2 = DumpStateOrd::SchemaResourceCheckLeak;
+
   for (int l = 0; l < loops; l++) {
     for (unsigned i0 = 0; i0 < acccnt; i0++) {
       unsigned j = (l == 0 ? i0 : myRandom48(acccnt));
       int errval = acclst[j];
+      if (errNo != 0 && errNo != errval)
+        continue;
       g_info << "insert error node=" << nodeId << " value=" <<
errval << endl;
       CHECK2(restarter.insertErrorInNode(nodeId, errval) == 0,
              "failed to set error insert");
+      CHECK(restarter.dumpStateAllNodes(&dump1, 1) == 0);
+
       CHECK2(pDic->createTable(tab) != 0,
              "failed to fail after error insert " << errval);
+      CHECK(restarter.dumpStateAllNodes(&dump2, 1) == 0);
       CHECK2(pDic->createTable(tab) == 0,
              pDic->getNdbError());
       CHECK2(pDic->dropTable(tab.getName()) == 0,
@@ -2015,11 +2052,15 @@ int runFailAddFragment(NDBT_Context* ctx
     for (unsigned i1 = 0; i1 < tupcnt; i1++) {
       unsigned j = (l == 0 ? i1 : myRandom48(tupcnt));
       int errval = tuplst[j];
+      if (errNo != 0 && errNo != errval)
+        continue;
       g_info << "insert error node=" << nodeId << " value=" <<
errval << endl;
       CHECK2(restarter.insertErrorInNode(nodeId, errval) == 0,
              "failed to set error insert");
+      CHECK(restarter.dumpStateAllNodes(&dump1, 1) == 0);
       CHECK2(pDic->createTable(tab) != 0,
              "failed to fail after error insert " << errval);
+      CHECK(restarter.dumpStateAllNodes(&dump2, 1) == 0);
       CHECK2(pDic->createTable(tab) == 0,
              pDic->getNdbError());
       CHECK2(pDic->dropTable(tab.getName()) == 0,
@@ -2028,13 +2069,17 @@ int runFailAddFragment(NDBT_Context* ctx
     for (unsigned i2 = 0; i2 < tuxcnt; i2++) {
       unsigned j = (l == 0 ? i2 : myRandom48(tuxcnt));
       int errval = tuxlst[j];
+      if (errNo != 0 && errNo != errval)
+        continue;
       g_info << "insert error node=" << nodeId << " value=" <<
errval << endl;
       CHECK2(restarter.insertErrorInNode(nodeId, errval) == 0,
              "failed to set error insert");
       CHECK2(pDic->createTable(tab) == 0,
              pDic->getNdbError());
+      CHECK(restarter.dumpStateAllNodes(&dump1, 1) == 0);
       CHECK2(pDic->createIndex(idx) != 0,
              "failed to fail after error insert " << errval);
+      CHECK(restarter.dumpStateAllNodes(&dump2, 1) == 0);
       CHECK2(pDic->createIndex(idx) == 0,
              pDic->getNdbError());
       CHECK2(pDic->dropTable(tab.getName()) == 0,
diff -Nrup a/storage/ndb/test/run-test/daily-basic-tests.txt
b/storage/ndb/test/run-test/daily-basic-tests.txt
--- a/storage/ndb/test/run-test/daily-basic-tests.txt	2008-05-21 18:39:40 +02:00
+++ b/storage/ndb/test/run-test/daily-basic-tests.txt	2008-05-29 17:58:53 +02:00
@@ -1129,3 +1129,9 @@ cmd: test_event
 args: -n Bug34853 T1
 
 # EOF 2008-04-25
+# 2008-05-29
+max-time: 1200
+cmd: testDict
+args: -l 1 -n FailAddFragment
+
+# EOF 2008-05-29