Commit 8de29d3a authored by unknown's avatar unknown
Browse files

Merge mysql.com:/space_old/pekka/ndb/version/my41-bug20847 

into  mysql.com:/space_old/pekka/ndb/version/my50-bug20847


BitKeeper/etc/config:
  auto
ndb/src/kernel/blocks/ERROR_codes.txt:
  manual
ndb/src/kernel/blocks/dbtup/Dbtup.hpp:
  SCCS merged
ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp:
  SCCS merged
ndb/test/ndbapi/testDict.cpp:
  SCCS merged
ndb/test/run-test/daily-basic-tests.txt:
  SCCS merged
sql/opt_range.cc:
  SCCS merged
parents 05348e41 2c48aaa1

ndb/src/kernel/blocks/ERROR_codes.txt

+3 −1
Original line number Diff line number Diff line
@@ -2,7 +2,7 @@ Next QMGR 1 
Next NDBCNTR 1000

Next NDBFS 2000

Next DBACC 3002

Next DBTUP 4013

Next DBTUP 4014

Next DBLQH 5043

Next DBDICT 6007

Next DBDIH 7177
@@ -437,6 +437,8 @@ Drop Table/Index: 
8036: Fail next index drop in TC

6006: Crash participant in create index



4013: verify TUP tab descr before and after next DROP TABLE



System Restart:

---------------

ndb/src/kernel/blocks/dbtup/Dbtup.hpp

+6 −3
Original line number Diff line number Diff line
@@ -2185,15 +2185,18 @@ private: 
// Public methods

  Uint32 getTabDescrOffsets(const Tablerec* regTabPtr, Uint32* offset);

  Uint32 allocTabDescr(const Tablerec* regTabPtr, Uint32* offset);

  void freeTabDescr(Uint32 retRef, Uint32 retNo);

  void freeTabDescr(Uint32 retRef, Uint32 retNo, bool normal = true);

  Uint32 getTabDescrWord(Uint32 index);

  void setTabDescrWord(Uint32 index, Uint32 word);



// Private methods

  Uint32 sizeOfReadFunction();

  void   removeTdArea(Uint32 tabDesRef, Uint32 list);

  void   insertTdArea(Uint32 sizeOfChunk, Uint32 tabDesRef, Uint32 list);

  Uint32 itdaMergeTabDescr(Uint32 retRef, Uint32 retNo);

  void   insertTdArea(Uint32 tabDesRef, Uint32 list);

  void   itdaMergeTabDescr(Uint32& retRef, Uint32& retNo, bool normal);

#ifdef VM_TRACE

  void verifytabdes();

#endif



//------------------------------------------------------------------------------------------------------

// Page Memory Manager

ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp

+7 −0
Original line number Diff line number Diff line
@@ -601,6 +601,9 @@ void 
Dbtup::execDROP_TAB_REQ(Signal* signal)

{

  ljamEntry();

  if (ERROR_INSERTED(4013)) {

    verifytabdes();

  }

  DropTabReq* req = (DropTabReq*)signal->getDataPtr();

  

  TablerecPtr tabPtr;
@@ -719,5 +722,9 @@ void Dbtup::execFSREMOVECONF(Signal* signal) 
  

  releaseTabDescr(tabPtr.p);

  initTab(tabPtr.p);

  if (ERROR_INSERTED(4013)) {

    CLEAR_ERROR_INSERT_VALUE;

    verifytabdes();

  }

}//Dbtup::execFSREMOVECONF()

ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp

+138 −31
Original line number Diff line number Diff line
@@ -24,13 +24,15 @@ 
#define ljam() { jamLine(22000 + __LINE__); }

#define ljamEntry() { jamEntryLine(22000 + __LINE__); }



/* **************************************************************** */

/* *********** TABLE DESCRIPTOR MEMORY MANAGER ******************** */

/* **************************************************************** */

/* This module is used to allocate and deallocate table descriptor  */

/* memory attached to fragments (could be allocated per table       */

/* instead. Performs its task by a buddy algorithm.                 */

/* **************************************************************** */

/*

 * TABLE DESCRIPTOR MEMORY MANAGER

 *

 * Each table has a descriptor which is a contiguous array of words.

 * The descriptor is allocated from a global array using a buddy

 * algorithm.  Free lists exist for each power of 2 words.  Freeing

 * a piece first merges with free right and left neighbours and then

 * divides itself up into free list chunks.

 */



Uint32

Dbtup::getTabDescrOffsets(const Tablerec* regTabPtr, Uint32* offset)
@@ -59,7 +61,7 @@ Uint32 Dbtup::allocTabDescr(const Tablerec* regTabPtr, Uint32* offset) 
  Uint32 reference = RNIL;

  Uint32 allocSize = getTabDescrOffsets(regTabPtr, offset);

/* ---------------------------------------------------------------- */

/*       ALWAYS ALLOCATE A MULTIPLE OF 16 BYTES                     */

/*       ALWAYS ALLOCATE A MULTIPLE OF 16 WORDS                     */

/* ---------------------------------------------------------------- */

  allocSize = (((allocSize - 1) >> 4) + 1) << 4;

  Uint32 list = nextHigherTwoLog(allocSize - 1);	/* CALCULATE WHICH LIST IT BELONGS TO     */
@@ -72,9 +74,9 @@ Uint32 Dbtup::allocTabDescr(const Tablerec* regTabPtr, Uint32* offset) 
      Uint32 retNo = (1 << i) - allocSize;	        /* CALCULATE THE DIFFERENCE               */

      if (retNo >= ZTD_FREE_SIZE) {

        ljam();

        Uint32 retRef = reference + allocSize;          /* SET THE RETURN POINTER                 */

        retNo = itdaMergeTabDescr(retRef, retNo);       /* MERGE WITH POSSIBLE RIGHT NEIGHBOURS   */

        freeTabDescr(retRef, retNo);	                /* RETURN UNUSED TD SPACE TO THE TD AREA  */

        // return unused words, of course without attempting left merge

        Uint32 retRef = reference + allocSize;

        freeTabDescr(retRef, retNo, false);

      } else {

        ljam();

        allocSize = 1 << i;
@@ -100,17 +102,19 @@ Uint32 Dbtup::allocTabDescr(const Tablerec* regTabPtr, Uint32* offset) 
  }//if

}//Dbtup::allocTabDescr()



void Dbtup::freeTabDescr(Uint32 retRef, Uint32 retNo) 

void Dbtup::freeTabDescr(Uint32 retRef, Uint32 retNo, bool normal)

{

  itdaMergeTabDescr(retRef, retNo, normal);       /* MERGE WITH POSSIBLE NEIGHBOURS   */

  while (retNo >= ZTD_FREE_SIZE) {

    ljam();

    Uint32 list = nextHigherTwoLog(retNo);

    list--;	/* RETURN TO NEXT LOWER LIST    */

    Uint32 sizeOfChunk = 1 << list;

    insertTdArea(sizeOfChunk, retRef, list);

    insertTdArea(retRef, list);

    retRef += sizeOfChunk;

    retNo -= sizeOfChunk;

  }//while

  ndbassert(retNo == 0);

}//Dbtup::freeTabDescr()



Uint32
@@ -127,7 +131,7 @@ Dbtup::setTabDescrWord(Uint32 index, Uint32 word) 
  tableDescriptor[index].tabDescr = word;

}//Dbtup::setTabDescrWord()



void Dbtup::insertTdArea(Uint32 sizeOfChunk, Uint32 tabDesRef, Uint32 list) 

void Dbtup::insertTdArea(Uint32 tabDesRef, Uint32 list) 

{

  ndbrequire(list < 16);

  setTabDescrWord(tabDesRef + ZTD_FL_HEADER, ZTD_TYPE_FREE);
@@ -144,19 +148,14 @@ void Dbtup::insertTdArea(Uint32 sizeOfChunk, Uint32 tabDesRef, Uint32 list) 
  setTabDescrWord((tabDesRef + (1 << list)) - ZTD_TR_SIZE, 1 << list);

}//Dbtup::insertTdArea()



/* ---------------------------------------------------------------- */

/* ----------------------- MERGE_TAB_DESCR ------------------------ */

/* ---------------------------------------------------------------- */

/* INPUT:  TAB_DESCR_PTR   POINTING AT THE CURRENT CHUNK            */

/*                                                                  */

/* SHORTNAME:   MTD                                                 */

/* -----------------------------------------------------------------*/

Uint32 Dbtup::itdaMergeTabDescr(Uint32 retRef, Uint32 retNo) 

/*

 * Merge to-be-removed chunk (which need not be initialized with header

 * and trailer) with left and right buddies.  The start point retRef

 * moves to left and the size retNo increases to match the new chunk.

 */

void Dbtup::itdaMergeTabDescr(Uint32& retRef, Uint32& retNo, bool normal)

{

   /* THE SIZE OF THE PART TO MERGE MUST BE OF THE SAME SIZE AS THE INSERTED PART */

   /* THIS IS TRUE EITHER IF ONE PART HAS THE SAME SIZE OR THE SUM OF BOTH PARTS  */

   /* TOGETHER HAS THE SAME SIZE AS THE PART TO BE INSERTED                       */

   /* FIND THE SIZES OF THE PARTS TO THE RIGHT OF THE PART TO BE REINSERTED */

  // merge right

  while ((retRef + retNo) < cnoOfTabDescrRec) {

    ljam();

    Uint32 tabDesRef = retRef + retNo;
@@ -170,11 +169,28 @@ Uint32 Dbtup::itdaMergeTabDescr(Uint32 retRef, Uint32 retNo) 
      removeTdArea(tabDesRef, list);

    } else {

      ljam();

      return retNo;

    }//if

  }//while

  ndbrequire((retRef + retNo) == cnoOfTabDescrRec);

  return retNo;

      break;

    }

  }

  // merge left

  const bool mergeLeft = normal;

  while (mergeLeft && retRef > 0) {

    ljam();

    Uint32 trailerWord = getTabDescrWord(retRef - ZTD_TR_TYPE);

    if (trailerWord == ZTD_TYPE_FREE) {

      ljam();

      Uint32 sizeOfMergedPart = getTabDescrWord(retRef - ZTD_TR_SIZE);

      ndbrequire(retRef >= sizeOfMergedPart);

      retRef -= sizeOfMergedPart;

      retNo += sizeOfMergedPart;

      Uint32 list = nextHigherTwoLog(sizeOfMergedPart - 1);

      removeTdArea(retRef, list);

    } else {

      ljam();

      break;

    }

  }

  ndbrequire((retRef + retNo) <= cnoOfTabDescrRec);

}//Dbtup::itdaMergeTabDescr()



/* ---------------------------------------------------------------- */
@@ -210,3 +226,94 @@ void Dbtup::removeTdArea(Uint32 tabDesRef, Uint32 list) 
    setTabDescrWord(tabDescrPrevPtr + ZTD_FL_NEXT, tabDescrNextPtr);

  }//if

}//Dbtup::removeTdArea()



#ifdef VM_TRACE

void

Dbtup::verifytabdes()

{

  struct WordType {

    short fl;   // free list 0-15

    short ti;   // table id

    WordType() : fl(-1), ti(-1) {}

  };

  WordType* wt = new WordType [cnoOfTabDescrRec];

  uint free_frags = 0;

  // free lists

  {

    for (uint i = 0; i < 16; i++) {

      Uint32 desc2 = RNIL;

      Uint32 desc = cfreeTdList[i];

      while (desc != RNIL) {

        const Uint32 size = (1 << i);

        ndbrequire(size >= ZTD_FREE_SIZE);

        ndbrequire(desc + size <= cnoOfTabDescrRec);

        { Uint32 index = desc + ZTD_FL_HEADER;

          ndbrequire(tableDescriptor[index].tabDescr == ZTD_TYPE_FREE);

        }

        { Uint32 index = desc + ZTD_FL_SIZE;

          ndbrequire(tableDescriptor[index].tabDescr == size);

        }

        { Uint32 index = desc + size - ZTD_TR_TYPE;

          ndbrequire(tableDescriptor[index].tabDescr == ZTD_TYPE_FREE);

        }

        { Uint32 index = desc + size - ZTD_TR_SIZE;

          ndbrequire(tableDescriptor[index].tabDescr == size);

        }

        { Uint32 index = desc + ZTD_FL_PREV;

          ndbrequire(tableDescriptor[index].tabDescr == desc2);

        }

        for (uint j = 0; j < size; j++) {

          ndbrequire(wt[desc + j].fl == -1);

          wt[desc + j].fl = i;

        }

        desc2 = desc;

        desc = tableDescriptor[desc + ZTD_FL_NEXT].tabDescr;

        free_frags++;

      }

    }

  }

  // tables

  {

    for (uint i = 0; i < cnoOfTablerec; i++) {

      TablerecPtr ptr;

      ptr.i = i;

      ptrAss(ptr, tablerec);

      if (ptr.p->tableStatus == DEFINED) {

        Uint32 offset[10];

        const Uint32 alloc = getTabDescrOffsets(ptr.p, offset);

        const Uint32 desc = ptr.p->readKeyArray - offset[3];

        Uint32 size = alloc;

        if (size % ZTD_FREE_SIZE != 0)

          size += ZTD_FREE_SIZE - size % ZTD_FREE_SIZE;

        ndbrequire(desc + size <= cnoOfTabDescrRec);

        { Uint32 index = desc + ZTD_FL_HEADER;

          ndbrequire(tableDescriptor[index].tabDescr == ZTD_TYPE_NORMAL);

        }

        { Uint32 index = desc + ZTD_FL_SIZE;

          ndbrequire(tableDescriptor[index].tabDescr == size);

        }

        { Uint32 index = desc + size - ZTD_TR_TYPE;

          ndbrequire(tableDescriptor[index].tabDescr == ZTD_TYPE_NORMAL);

        }

        { Uint32 index = desc + size - ZTD_TR_SIZE;

          ndbrequire(tableDescriptor[index].tabDescr == size);

        }

        for (uint j = 0; j < size; j++) {

          ndbrequire(wt[desc + j].ti == -1);

          wt[desc + j].ti = i;

        }

      }

    }

  }

  // all words

  {

    for (uint i = 0; i < cnoOfTabDescrRec; i++) {

      bool is_fl = wt[i].fl != -1;

      bool is_ti = wt[i].ti != -1;

      ndbrequire(is_fl != is_ti);

    }

  }

  delete [] wt;

  ndbout << "verifytabdes: frags=" << free_frags << endl;

}

#endif

ndb/test/ndbapi/testDict.cpp

+101 −0
Original line number Diff line number Diff line
@@ -233,6 +233,101 @@ int runCreateAndDrop(NDBT_Context* ctx, NDBT_Step* step){ 
  return NDBT_OK;

}



int runCreateAndDropAtRandom(NDBT_Context* ctx, NDBT_Step* step)

{

  myRandom48Init(NdbTick_CurrentMillisecond());

  Ndb* pNdb = GETNDB(step);

  NdbDictionary::Dictionary* pDic = pNdb->getDictionary();

  int loops = ctx->getNumLoops();

  int numTables = NDBT_Tables::getNumTables();

  bool* tabList = new bool [ numTables ];

  int tabCount;



  {

    for (int num = 0; num < numTables; num++) {

      (void)pDic->dropTable(NDBT_Tables::getTable(num)->getName());

      tabList[num] = false;

    }

    tabCount = 0;

  }



  NdbRestarter restarter;

  int result = NDBT_OK;

  int bias = 1; // 0-less 1-more

  int i = 0;

  

  while (i < loops) {

    g_info << "loop " << i << " tabs " << tabCount << "/" << numTables << endl;

    int num = myRandom48(numTables);

    const NdbDictionary::Table* pTab = NDBT_Tables::getTable(num);

    char tabName[200];

    strcpy(tabName, pTab->getName());



    if (tabList[num] == false) {

      if (bias == 0 && myRandom48(100) < 80)

        continue;

      g_info << tabName << ": create" << endl;

      if (pDic->createTable(*pTab) != 0) {

        const NdbError err = pDic->getNdbError();

        g_err << tabName << ": create failed: " << err << endl;

        result = NDBT_FAILED;

        break;

      }

      const NdbDictionary::Table* pTab2 = pDic->getTable(tabName);

      if (pTab2 == NULL) {

        const NdbError err = pDic->getNdbError();

        g_err << tabName << ": verify create: " << err << endl;

        result = NDBT_FAILED;

        break;

      }

      tabList[num] = true;

      assert(tabCount < numTables);

      tabCount++;

      if (tabCount == numTables)

        bias = 0;

    }

    else {

      if (bias == 1 && myRandom48(100) < 80)

        continue;

      g_info << tabName << ": drop" << endl;

      if (restarter.insertErrorInAllNodes(4013) != 0) {

        g_err << "error insert failed" << endl;

        result = NDBT_FAILED;

        break;

      }

      if (pDic->dropTable(tabName) != 0) {

        const NdbError err = pDic->getNdbError();

        g_err << tabName << ": drop failed: " << err << endl;

        result = NDBT_FAILED;

        break;

      }

      const NdbDictionary::Table* pTab2 = pDic->getTable(tabName);

      if (pTab2 != NULL) {

        g_err << tabName << ": verify drop: table exists" << endl;

        result = NDBT_FAILED;

        break;

      }

      if (pDic->getNdbError().code != 709 &&

          pDic->getNdbError().code != 723) {

        const NdbError err = pDic->getNdbError();

        g_err << tabName << ": verify drop: " << err << endl;

        result = NDBT_FAILED;

        break;

      }

      tabList[num] = false;

      assert(tabCount > 0);

      tabCount--;

      if (tabCount == 0)

        bias = 1;

    }

    i++;

  }



  delete [] tabList;

  return result;

}





int runCreateAndDropWithData(NDBT_Context* ctx, NDBT_Step* step){

  Ndb* pNdb = GETNDB(step);

  int loops = ctx->getNumLoops();
@@ -1849,6 +1944,12 @@ TESTCASE("CreateAndDrop", 
	 "Try to create and drop the table loop number of times\n"){

  INITIALIZER(runCreateAndDrop);

}

TESTCASE("CreateAndDropAtRandom",

	 "Try to create and drop table at random loop number of times\n"

         "Uses all available tables\n"

         "Uses error insert 4013 to make TUP verify table descriptor"){

  INITIALIZER(runCreateAndDropAtRandom);

}

TESTCASE("CreateAndDropWithData", 

	 "Try to create and drop the table when it's filled with data\n"

	 "do this loop number of times\n"){