Merge perch.ndb.mysql.com:/home/jonas/src/50-work

into  perch.ndb.mysql.com:/home/jonas/src/51-telco-gca


storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp:
  Auto merged
storage/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp:
  Auto merged
storage/ndb/test/run-test/daily-basic-tests.txt:
  Auto merged
storage/ndb/src/kernel/blocks/ERROR_codes.txt:
  merge
storage/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp:
  merge
storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp:
  merge
storage/ndb/test/ndbapi/testNodeRestart.cpp:
  merge

storage/ndb/src/kernel/blocks/ERROR_codes.txt

 Next QMGR 1
-Next NDBCNTR 1000
+Next NDBCNTR 1001
 Next NDBFS 2000
 Next DBACC 3002
-Next DBTUP 4024
+Next DBTUP 4029
 Next DBLQH 5045
 Next DBDICT 6007
 Next DBDIH 7181
@@ -512,3 +512,12 @@ Dbtup:
 
 4022 - addTuxEntries - fail before add of first entry
 4023 - addTuxEntries - fail add of last entry (the entry for last index)
+
+4025: Fail all inserts with out of memory
+4026: Fail one insert with oom
+4027: Fail inserts randomly with oom
+4028: Fail one random insert with oom
+
+NDBCNTR:
+
+1000: Crash insertion on SystemError::CopyFragRef

storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp

@@ -10537,6 +10537,15 @@ void Dblqh::copyCompletedLab(Signal* signal)
     closeCopyLab(signal);
     return;
   }//if
+
+  if (scanptr.p->scanState == ScanRecord::WAIT_LQHKEY_COPY &&
+      scanptr.p->scanErrorCounter)
+  {
+    jam();
+    closeCopyLab(signal);
+    return;
+  }
+  
   if (scanptr.p->scanState == ScanRecord::WAIT_LQHKEY_COPY) {
     jam();
 /*---------------------------------------------------------------------------*/
@@ -10625,13 +10634,16 @@ void Dblqh::continueCopyAfterBlockedLab(Signal* signal)
 void Dblqh::copyLqhKeyRefLab(Signal* signal) 
 {
   ndbrequire(tcConnectptr.p->transid[1] == signal->theData[4]);
-  tcConnectptr.p->copyCountWords -= signal->theData[3];
+  Uint32 copyWords = signal->theData[3];
   scanptr.i = tcConnectptr.p->tcScanRec;
   c_scanRecordPool.getPtr(scanptr);
   scanptr.p->scanErrorCounter++;
   tcConnectptr.p->errorCode = terrorCode;
-  closeCopyLab(signal);
-  return;
+  
+  LqhKeyConf* conf = (LqhKeyConf*)signal->getDataPtrSend();
+  conf->transId1 = copyWords;
+  conf->transId2 = tcConnectptr.p->transid[1];
+  copyCompletedLab(signal);
 }//Dblqh::copyLqhKeyRefLab()
 
 void Dblqh::closeCopyLab(Signal* signal) 
@@ -10642,6 +10654,7 @@ void Dblqh::closeCopyLab(Signal* signal)
 // Wait until all of those have arrived until we start the
 // close process.
 /*---------------------------------------------------------------------------*/
+    scanptr.p->scanState = ScanRecord::WAIT_LQHKEY_COPY;
     jam();
     return;
   }//if

storage/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp

@@ -1259,6 +1259,28 @@ int Dbtup::handleInsertReq(Signal* signal,
   {  
     shrink_tuple(req_struct, sizes+2, regTabPtr, true);
   }
+
+  if (ERROR_INSERTED(4025))
+  {
+    goto mem_error;
+  }
+
+  if (ERROR_INSERTED(4026))
+  {
+    CLEAR_ERROR_INSERT_VALUE;
+    goto mem_error;
+  }
+
+  if (ERROR_INSERTED(4027) && (rand() % 100) > 25)
+  {
+    goto mem_error;
+  }
+ 
+  if (ERROR_INSERTED(4028) && (rand() % 100) > 25)
+  {
+    CLEAR_ERROR_INSERT_VALUE;
+    goto mem_error;
+  }
   
   /**
    * Alloc memory

storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp

@@ -113,6 +113,7 @@ Dbtup::Dbtup(Block_context& ctx, Pgman* pgman)
   cnoOfAllocatedPages = 0;
   
   initData();
+  CLEAR_ERROR_INSERT_VALUE;
 }//Dbtup::Dbtup()
 
 Dbtup::~Dbtup() 
@@ -263,7 +264,6 @@ void Dbtup::execSTTOR(Signal* signal)
   switch (startPhase) {
   case ZSTARTPHASE1:
     ljam();
-    CLEAR_ERROR_INSERT_VALUE;
     ndbrequire((c_lqh= (Dblqh*)globalData.getBlock(DBLQH)) != 0);
     ndbrequire((c_tsman= (Tsman*)globalData.getBlock(TSMAN)) != 0);
     ndbrequire((c_lgman= (Lgman*)globalData.getBlock(LGMAN)) != 0);

storage/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp

@@ -197,6 +197,7 @@ void Ndbcntr::execSYSTEM_ERROR(Signal* signal)
     break;
 
   case SystemError::CopyFragRefError:
+    CRASH_INSERTION(1000);
     BaseString::snprintf(buf, sizeof(buf), 
 			 "Killed by node %d as "
 			 "copyfrag failed, error: %u",

storage/ndb/test/ndbapi/testNodeRestart.cpp

@@ -1320,6 +1320,58 @@ runBug26450(NDBT_Context* ctx, NDBT_Step* step)
   return NDBT_OK;
 }
 
+int
+runBug27003(NDBT_Context* ctx, NDBT_Step* step)
+{
+  int result = NDBT_OK;
+  int loops = ctx->getNumLoops();
+  int records = ctx->getNumRecords();
+  NdbRestarter res;
+  
+  static const int errnos[] = { 4025, 4026, 4027, 4028, 0 };
+
+  int node = res.getRandomNotMasterNodeId(rand());
+  ndbout_c("node: %d", node);
+  if (res.restartOneDbNode(node, false, true, true))
+    return NDBT_FAILED;
+
+  Uint32 pos = 0;
+  for (Uint32 i = 0; i<loops; i++)
+  {
+    while (errnos[pos] != 0)
+    {
+      ndbout_c("Tesing err: %d", errnos[pos]);
+      
+      if (res.waitNodesNoStart(&node, 1))
+	return NDBT_FAILED;
+
+      if (res.insertErrorInNode(node, 1000))
+	return NDBT_FAILED;
+      
+      if (res.insertErrorInNode(node, errnos[pos]))
+	return NDBT_FAILED;
+      
+      int val2[] = { DumpStateOrd::CmvmiSetRestartOnErrorInsert, 1 };
+      if (res.dumpStateOneNode(node, val2, 2))
+	return NDBT_FAILED;
+      
+      res.startNodes(&node, 1);
+      res.waitNodesStartPhase(&node, 1, 2);
+      pos++;
+    }
+    pos = 0;
+  }
+
+  if (res.waitNodesNoStart(&node, 1))
+    return NDBT_FAILED;
+  
+  res.startNodes(&node, 1);
+  if (res.waitClusterStarted())
+    return NDBT_FAILED;
+  
+  return NDBT_OK;
+}
+
 NDBT_TESTSUITE(testNodeRestart);
 TESTCASE("NoLoad", 
 	 "Test that one node at a time can be stopped and then restarted "\
@@ -1665,6 +1717,9 @@ TESTCASE("Bug26450", ""){
   INITIALIZER(runLoadTable);
   INITIALIZER(runBug26450);
 }
+TESTCASE("Bug27003", ""){
+  INITIALIZER(runBug27003);
+}
 NDBT_TESTSUITE_END(testNodeRestart);
 
 int main(int argc, const char** argv){

storage/ndb/test/run-test/daily-basic-tests.txt

@@ -461,6 +461,10 @@ max-time: 500
 cmd: testScan
 args: -n Bug24447 T1
 
+max-time: 1000
+cmd: testNodeRestart
+args: -n Bug27003 T1
+
 max-time: 500
 cmd: testScan
 args: -n ScanVariants