Merge jbruehe@bk-internal.mysql.com:/home/bk/mysql-4.1

into mysql.com:/M41/mysql-4.1

innobase/dict/dict0dict.c

@@ -197,7 +197,17 @@ FILE*	dict_foreign_err_file		= NULL;
 mutex_t	dict_foreign_err_mutex; 	/* mutex protecting the foreign
 					and unique error buffers */
 	
-	
+/**********************************************************************
+Makes all characters in a NUL-terminated UTF-8 string lower case. */
+
+void
+dict_casedn_str(
+/*============*/
+	char*	a)	/* in/out: string to put in lower case */
+{
+	innobase_casedn_str(a);
+}
+
 /************************************************************************
 Checks if the database name in two table names is the same. */
 

innobase/fil/fil0fil.c

@@ -25,6 +25,7 @@ Created 10/25/1995 Heikki Tuuri
 #include "srv0start.h"
 #include "mtr0mtr.h"
 #include "mtr0log.h"
+#include "dict0dict.h"
 
 	 
 /*
@@ -2732,7 +2733,15 @@ fil_load_single_table_tablespace(
 	sprintf(filepath, "%s/%s/%s", fil_path_to_mysql_datadir, dbname,
 								filename);
 	srv_normalize_path_for_win(filepath);
+#ifdef __WIN__
+	/* If lower_case_table_names is 0 or 2, then MySQL allows database
+	directory names with upper case letters. On Windows, all table and
+	database names in InnoDB are internally always in lower case. Put the
+	file path to lower case, so that we are consistent with InnoDB's
+	internal data dictionary. */
 
+	dict_casedn_str(filepath);
+#endif
 	file = os_file_create_simple_no_error_handling(filepath, OS_FILE_OPEN,
 						OS_FILE_READ_ONLY, &success);
 	if (!success) {

innobase/include/dict0dict.h

@@ -26,6 +26,13 @@ Created 1/8/1996 Heikki Tuuri
 #include "ut0byte.h"
 #include "trx0types.h"
 
+/**********************************************************************
+Makes all characters in a NUL-terminated UTF-8 string lower case. */
+
+void
+dict_casedn_str(
+/*============*/
+	char*	a);	/* in/out: string to put in lower case */
 /************************************************************************
 Get the database name length in a table name. */
 

mysql-test/r/func_math.result

@@ -1,3 +1,4 @@
+drop table if exists t1;
 select floor(5.5),floor(-5.5);
 floor(5.5)	floor(-5.5)
 5	-6
@@ -126,3 +127,13 @@ Warnings:
 Note	1003	select degrees(pi()) AS `degrees(pi())`,radians(360) AS `radians(360)`
 select rand(rand);
 ERROR 42S22: Unknown column 'rand' in 'field list'
+create table t1 select round(1, 6);
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `round(1, 6)` double(7,6) NOT NULL default '0.000000'
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+select * from t1;
+round(1, 6)
+1.000000
+drop table t1;

mysql-test/t/func_math.test

@@ -2,6 +2,10 @@
 # Test of math functions
 #
 
+--disable_warnings                                                              
+drop table if exists t1;                                                        
+--enable_warnings                                                               
+
 select floor(5.5),floor(-5.5);
 explain extended select floor(5.5),floor(-5.5);
 select ceiling(5.5),ceiling(-5.5);
@@ -58,3 +62,12 @@ explain extended select degrees(pi()),radians(360);
 
 --error 1054
 select rand(rand);
+
+#
+# Bug #9837: problem with round()
+#
+
+create table t1 select round(1, 6);
+show create table t1;
+select * from t1;
+drop table t1;

ndb/include/kernel/signaldata/BackupImpl.hpp

@@ -75,7 +75,7 @@ class DefineBackupRef {
 
   friend bool printDEFINE_BACKUP_REF(FILE *, const Uint32 *, Uint32, Uint16);
 public:
-  STATIC_CONST( SignalLength = 3 );
+  STATIC_CONST( SignalLength = 4 );
   
   enum ErrorCode {
     Undefined = 1340,
@@ -92,6 +92,7 @@ private:
   Uint32 backupId;
   Uint32 backupPtr;
   Uint32 errorCode;
+  Uint32 nodeId;
 };
 
 class DefineBackupConf {
@@ -158,7 +159,7 @@ class StartBackupRef {
 
   friend bool printSTART_BACKUP_REF(FILE *, const Uint32 *, Uint32, Uint16);
 public:
-  STATIC_CONST( SignalLength = 4 );
+  STATIC_CONST( SignalLength = 5 );
 
   enum ErrorCode {
     FailedToAllocateTriggerRecord = 1
@@ -168,6 +169,7 @@ private:
   Uint32 backupPtr;
   Uint32 signalNo;
   Uint32 errorCode;
+  Uint32 nodeId;
 };
 
 class StartBackupConf {
@@ -232,9 +234,8 @@ public:
 private:
   Uint32 backupId;
   Uint32 backupPtr;
-  Uint32 tableId;
-  Uint32 fragmentNo;
   Uint32 errorCode;
+  Uint32 nodeId;
 };
 
 class BackupFragmentConf {
@@ -296,12 +297,13 @@ class StopBackupRef {
 
   friend bool printSTOP_BACKUP_REF(FILE *, const Uint32 *, Uint32, Uint16);
 public:
-  STATIC_CONST( SignalLength = 3 );
+  STATIC_CONST( SignalLength = 4 );
 
 private:
   Uint32 backupId;
   Uint32 backupPtr;
   Uint32 errorCode;
+  Uint32 nodeId;
 };
 
 class StopBackupConf {

ndb/include/kernel/signaldata/BackupSignalData.hpp

@@ -240,6 +240,9 @@ public:
     FileOrScanError = 1325, //                       slave -> coordinator
     BackupFailureDueToNodeFail = 1326, //             slave -> slave
     OkToClean = 1327                  //             master -> slave
+    
+    ,AbortScan = 1328
+    ,IncompatibleVersions = 1329
   };
 private:
   Uint32 requestType;

ndb/src/common/debugger/signaldata/BackupImpl.cpp

@@ -90,10 +90,8 @@ printBACKUP_FRAGMENT_REQ(FILE * out, const Uint32 * data, Uint32 l, Uint16 bno){
 bool 
 printBACKUP_FRAGMENT_REF(FILE * out, const Uint32 * data, Uint32 l, Uint16 bno){
   BackupFragmentRef* sig = (BackupFragmentRef*)data;
-  fprintf(out, " backupPtr: %d backupId: %d\n",
+  fprintf(out, " backupPtr: %d backupId: %d nodeId: %d errorCode: %d\n",
-	  sig->backupPtr, sig->backupId);
+	  sig->backupPtr, sig->backupId, sig->nodeId, sig->errorCode);
-  fprintf(out, " tableId: %d fragmentNo: %d errorCode: %d\n",
-	  sig->tableId, sig->fragmentNo, sig->errorCode);
   return true;
 }
 

ndb/src/kernel/blocks/backup/Backup.hpp

@@ -232,6 +232,7 @@ public:
      */
     bool newScan();
     bool scanConf(Uint32 noOfOps, Uint32 opLen);
+    bool closeScan();
     
     /**
      * Per record
@@ -330,7 +331,7 @@ public:
     
     Uint8 fileOpened;
     Uint8 fileRunning;
-    Uint8 fileDone;
+    Uint8 fileClosing;
     Uint8 scanRunning;
   }; 
   typedef Ptr<BackupFile> BackupFilePtr;
@@ -403,13 +404,11 @@ public:
 		 ArrayPool<TriggerRecord> & trp) 
       : slaveState(b, validSlaveTransitions, validSlaveTransitionsCount,1)
       , tables(tp), triggers(trp), files(bp), pages(pp)
-      , masterData(b, validMasterTransitions, validMasterTransitionsCount)
+      , masterData(b), backup(b)
-	, backup(b)
+      {
-    {
+      }
-      closingFiles    = false;
-      okToCleanMaster = true;
-    }
     
+    Uint32 m_gsn;
     CompoundState slaveState; 
     
     Uint32 clientRef;
@@ -420,9 +419,6 @@ public:
     Uint32 errorCode;
     NdbNodeBitmask nodes;
     
-    bool okToCleanMaster;
-    bool closingFiles;
-
     Uint64 noOfBytes;
     Uint64 noOfRecords;
     Uint64 noOfLogBytes;
@@ -444,15 +440,13 @@ public:
     SimpleProperties props;// Used for (un)packing backup request
     
     struct MasterData {
-      MasterData(Backup & b, const State valid[], Uint32 count) 
+      MasterData(Backup & b) 
-	: state(b, valid, count, 0) 
+	{
-      {
+	}
-      }
       MutexHandle2<BACKUP_DEFINE_MUTEX> m_defineBackupMutex;
       MutexHandle2<DICT_COMMIT_TABLE_MUTEX> m_dictCommitTableMutex;
 
       Uint32 gsn;
-      CompoundState state;
       SignalCounter sendCounter;
       Uint32 errorCode;
       struct {
@@ -557,7 +551,8 @@ public:
   void stopBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32 nodeId);
   
   void defineBackupRef(Signal*, BackupRecordPtr, Uint32 errCode = 0);
-  
+  void backupFragmentRef(Signal * signal, BackupFilePtr filePtr);
+
   void nextFragment(Signal*, BackupRecordPtr);
   
   void sendCreateTrig(Signal*, BackupRecordPtr ptr, TablePtr tabPtr);
@@ -578,14 +573,14 @@ public:
   void sendAbortBackupOrd(Signal* signal, BackupRecordPtr ptr, Uint32 errCode);
   void sendAbortBackupOrdSlave(Signal* signal, BackupRecordPtr ptr, 
 			       Uint32 errCode);
-  void masterAbort(Signal*, BackupRecordPtr ptr, bool controlledAbort);
+  void masterAbort(Signal*, BackupRecordPtr ptr);
   void masterSendAbortBackup(Signal*, BackupRecordPtr ptr);
   void slaveAbort(Signal*, BackupRecordPtr ptr);
   
   void abortFile(Signal* signal, BackupRecordPtr ptr, BackupFilePtr filePtr);
   void abortFileHook(Signal* signal, BackupFilePtr filePtr, bool scanDone);
   
-  bool verifyNodesAlive(const NdbNodeBitmask& aNodeBitMask);
+  bool verifyNodesAlive(BackupRecordPtr, const NdbNodeBitmask& aNodeBitMask);
   bool checkAbort(BackupRecordPtr ptr);
   void checkNodeFail(Signal* signal,
 		     BackupRecordPtr ptr,
@@ -603,9 +598,8 @@ public:
   void sendBackupRef(BlockReference ref, Signal *signal,
 		     Uint32 senderData, Uint32 errorCode);
   void dumpUsedResources();
-  void cleanupMasterResources(BackupRecordPtr ptr);
+  void cleanup(Signal*, BackupRecordPtr ptr);
-  void cleanupSlaveResources(BackupRecordPtr ptr);
+  void abort_scan(Signal*, BackupRecordPtr ptr);
-  void cleanupFinalResources(BackupRecordPtr ptr);
   void removeBackup(Signal*, BackupRecordPtr ptr);
 
   void sendSTTORRY(Signal*);

ndb/src/kernel/blocks/backup/Backup.txt

@@ -341,3 +341,28 @@ start backup
        (ERROR_INSERTED(10022))) {
   if (ERROR_INSERTED(10029)) {
     if(trigPtr.p->operation->noOfBytes > 123 && ERROR_INSERTED(10030)) {
+
+----- XXX ---
+
+DEFINE_BACKUP_REF ->
+  ABORT_BACKUP_ORD(no reply) when all DEFINE_BACKUP replies has arrived
+
+START_BACKUP_REF
+  ABORT_BACKUP_ORD(no reply) when all START_BACKUP_ replies has arrived
+
+BACKUP_FRAGMENT_REF
+  ABORT_BACKUP_ORD(reply) directly to all nodes running BACKUP_FRAGMENT
+
+  When all nodes has replied BACKUP_FRAGMENT
+    ABORT_BACKUP_ORD(no reply)
+
+STOP_BACKUP_REF
+  ABORT_BACKUP_ORD(no reply) when all STOP_BACKUP_ replies has arrived
+
+NF_COMPLETE_REP
+  slave dies
+    master sends OUTSTANDING_REF to self
+    slave does nothing
+
+  master dies
+    slave elects self as master and sets only itself as participant

ndb/src/kernel/blocks/backup/BackupInit.cpp

@@ -175,7 +175,7 @@ Backup::Backup(const Configuration & conf) :
   addRecSignal(GSN_START_BACKUP_CONF, &Backup::execSTART_BACKUP_CONF);
   
   addRecSignal(GSN_BACKUP_FRAGMENT_REQ, &Backup::execBACKUP_FRAGMENT_REQ);
-  //addRecSignal(GSN_BACKUP_FRAGMENT_REF, &Backup::execBACKUP_FRAGMENT_REF);
+  addRecSignal(GSN_BACKUP_FRAGMENT_REF, &Backup::execBACKUP_FRAGMENT_REF);
   addRecSignal(GSN_BACKUP_FRAGMENT_CONF, &Backup::execBACKUP_FRAGMENT_CONF);
   
   addRecSignal(GSN_STOP_BACKUP_REQ, &Backup::execSTOP_BACKUP_REQ);

ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp

@@ -126,6 +126,7 @@ Cmvmi::Cmvmi(const Configuration & conf) :
   }
 
   setNodeInfo(getOwnNodeId()).m_connected = true;
+  setNodeInfo(getOwnNodeId()).m_version = ndbGetOwnVersion();
 }
 
 Cmvmi::~Cmvmi()

ndb/src/kernel/blocks/dbacc/Dbacc.hpp

@@ -1022,7 +1022,7 @@ private:
   Uint32 placeReadInLockQueue(Signal* signal);
   void placeSerialQueueRead(Signal* signal);
   void checkOnlyReadEntry(Signal* signal);
-  void getNoParallelTransaction(Signal* signal);
+  Uint32 getNoParallelTransaction(const Operationrec*);
   void moveLastParallelQueue(Signal* signal);
   void moveLastParallelQueueWrite(Signal* signal);
   Uint32 placeWriteInLockQueue(Signal* signal);
@@ -1100,6 +1100,8 @@ private:
   Uint32 executeNextOperation(Signal* signal);
   void releaselock(Signal* signal);
   void takeOutFragWaitQue(Signal* signal);
+  void check_lock_upgrade(Signal* signal, OperationrecPtr lock_owner,
+			  OperationrecPtr release_op);
   void allocOverflowPage(Signal* signal);
   bool getrootfragmentrec(Signal* signal, RootfragmentrecPtr&, Uint32 fragId);
   void insertLockOwnersList(Signal* signal, const OperationrecPtr&);
@@ -1263,7 +1265,6 @@ private:
   OperationrecPtr mlpqOperPtr;
   OperationrecPtr queOperPtr;
   OperationrecPtr readWriteOpPtr;
-  OperationrecPtr tgnptMainOpPtr;
   Uint32 cfreeopRec;
   Uint32 coprecsize;
 /* --------------------------------------------------------------------------------- */
@@ -1514,7 +1515,6 @@ private:
   Uint32 turlIndex;
   Uint32 tlfrTmp1;
   Uint32 tlfrTmp2;
-  Uint32 tgnptNrTransaction;
   Uint32 tudqeIndex;
   Uint32 tscanTrid1;
   Uint32 tscanTrid2;

ndb/src/kernel/blocks/dbacc/DbaccMain.cpp

@@ -1936,9 +1936,7 @@ void Dbacc::insertelementLab(Signal* signal)
 /* --------------------------------------------------------------------------------- */
 Uint32 Dbacc::placeReadInLockQueue(Signal* signal) 
 {
-  tgnptMainOpPtr = queOperPtr;
+  if (getNoParallelTransaction(queOperPtr.p) == 1) {
-  getNoParallelTransaction(signal);
-  if (tgnptNrTransaction == 1) {
     if ((queOperPtr.p->transId1 == operationRecPtr.p->transId1) && 
         (queOperPtr.p->transId2 == operationRecPtr.p->transId2)) {
       /* --------------------------------------------------------------------------------- */
@@ -2021,9 +2019,7 @@ void Dbacc::placeSerialQueueRead(Signal* signal)
     checkOnlyReadEntry(signal);
     return;
   }//if
-  tgnptMainOpPtr = readWriteOpPtr;
+  if (getNoParallelTransaction(readWriteOpPtr.p) == 1) {
-  getNoParallelTransaction(signal);
-  if (tgnptNrTransaction == 1) {
     jam();
     /* --------------------------------------------------------------------------------- */
     /* THERE WAS ONLY ONE TRANSACTION INVOLVED IN THE PARALLEL QUEUE. IF THIS IS OUR     */
@@ -2104,24 +2100,23 @@ void Dbacc::checkOnlyReadEntry(Signal* signal)
 /* --------------------------------------------------------------------------------- */
 /* GET_NO_PARALLEL_TRANSACTION                                                       */
 /* --------------------------------------------------------------------------------- */
-void Dbacc::getNoParallelTransaction(Signal* signal) 
+Uint32
+Dbacc::getNoParallelTransaction(const Operationrec * op) 
 {
-  OperationrecPtr tnptOpPtr;
+  OperationrecPtr tmp;
-
+  
-  tgnptNrTransaction = 1;
+  tmp.i= op->nextParallelQue;
-  tnptOpPtr.i = tgnptMainOpPtr.p->nextParallelQue;
+  Uint32 transId[2] = { op->transId1, op->transId2 };
-  while ((tnptOpPtr.i != RNIL) &&
+  while (tmp.i != RNIL) 
-         (tgnptNrTransaction == 1)) {
+  {
     jam();
-    ptrCheckGuard(tnptOpPtr, coprecsize, operationrec);
+    ptrCheckGuard(tmp, coprecsize, operationrec);
-    if ((tnptOpPtr.p->transId1 == tgnptMainOpPtr.p->transId1) &&
+    if (tmp.p->transId1 == transId[0] && tmp.p->transId2 == transId[1])
-        (tnptOpPtr.p->transId2 == tgnptMainOpPtr.p->transId2)) {
+      tmp.i = tmp.p->nextParallelQue;
-      tnptOpPtr.i = tnptOpPtr.p->nextParallelQue;
+    else
-    } else {
+      return 2;
-      jam();
+  }
-      tgnptNrTransaction++;
+  return 1;
-    }//if
-  }//while
 }//Dbacc::getNoParallelTransaction()
 
 void Dbacc::moveLastParallelQueue(Signal* signal) 
@@ -2162,9 +2157,7 @@ void Dbacc::moveLastParallelQueueWrite(Signal* signal)
 /* --------------------------------------------------------------------------------- */
 Uint32 Dbacc::placeWriteInLockQueue(Signal* signal) 
 {
-  tgnptMainOpPtr = queOperPtr;
+  if (!((getNoParallelTransaction(queOperPtr.p) == 1) &&
-  getNoParallelTransaction(signal);
-  if (!((tgnptNrTransaction == 1) &&
 	(queOperPtr.p->transId1 == operationRecPtr.p->transId1) &&
 	(queOperPtr.p->transId2 == operationRecPtr.p->transId2))) {
     jam();
@@ -2215,9 +2208,7 @@ void Dbacc::placeSerialQueueWrite(Signal* signal)
   }//if
   readWriteOpPtr.i = readWriteOpPtr.p->nextSerialQue;
   ptrCheckGuard(readWriteOpPtr, coprecsize, operationrec);
-  tgnptMainOpPtr = readWriteOpPtr;
+  if (getNoParallelTransaction(readWriteOpPtr.p) == 1) {
-  getNoParallelTransaction(signal);
-  if (tgnptNrTransaction == 1) {
     /* --------------------------------------------------------------------------------- */
     /* THERE WAS ONLY ONE TRANSACTION INVOLVED IN THE PARALLEL QUEUE. IF THIS IS OUR     */
     /* TRANSACTION WE CAN STILL GET HOLD OF THE LOCK.                                    */
@@ -5802,9 +5793,153 @@ void Dbacc::commitOperation(Signal* signal)
       ptrCheckGuard(tolqTmpPtr, coprecsize, operationrec);
       tolqTmpPtr.p->prevParallelQue = operationRecPtr.p->prevParallelQue;
     }//if
-  }//if
+
+    /**
+     * Check possible lock upgrade
+     * 1) Find lock owner
+     * 2) Count transactions in parallel que
+     * 3) If count == 1 and TRANSID(next serial) == TRANSID(lock owner)
+     *      upgrade next serial
+     */
+    if(operationRecPtr.p->lockMode)
+    {
+      jam();
+      /**
+       * Committing a non shared operation can't lead to lock upgrade
+       */
+      return;
+    }
+    
+    OperationrecPtr lock_owner;
+    lock_owner.i = operationRecPtr.p->prevParallelQue;
+    ptrCheckGuard(lock_owner, coprecsize, operationrec);
+    Uint32 transid[2] = { lock_owner.p->transId1, 
+			  lock_owner.p->transId2 };
+    
+    
+    while(lock_owner.p->prevParallelQue != RNIL)
+    {
+      lock_owner.i = lock_owner.p->prevParallelQue;
+      ptrCheckGuard(lock_owner, coprecsize, operationrec);
+      
+      if(lock_owner.p->transId1 != transid[0] || 
+	 lock_owner.p->transId2 != transid[1])
+      {
+	jam();
+	/**
+	 * If more than 1 trans in lock queue -> no lock upgrade
+	 */
+	return;
+      }
+    }
+    
+    check_lock_upgrade(signal, lock_owner, operationRecPtr);
+  }
 }//Dbacc::commitOperation()
 
+void
+Dbacc::check_lock_upgrade(Signal* signal, 
+			  OperationrecPtr lock_owner,
+			  OperationrecPtr release_op)
+{
+  if((lock_owner.p->transId1 == release_op.p->transId1 &&
+      lock_owner.p->transId2 == release_op.p->transId2) ||
+     release_op.p->lockMode ||
+     lock_owner.p->nextSerialQue == RNIL)
+  {
+    jam();
+    /**
+     * No lock upgrade if same trans or lock owner has no serial queue
+     *                 or releasing non shared op
+     */
+    return;
+  }
+
+  OperationrecPtr next;
+  next.i = lock_owner.p->nextSerialQue;
+  ptrCheckGuard(next, coprecsize, operationrec);
+  
+  if(lock_owner.p->transId1 != next.p->transId1 ||
+     lock_owner.p->transId2 != next.p->transId2)
+  {
+    jam();
+    /**
+     * No lock upgrad if !same trans in serial queue
+     */
+    return;
+  }
+  
+  if (getNoParallelTransaction(lock_owner.p) > 1)
+  {
+    jam();
+    /**
+     * No lock upgrade if more than 1 transaction in parallell queue
+     */
+    return;
+  }
+
+  if (getNoParallelTransaction(next.p) > 1)
+  {
+    jam();
+    /**
+     * No lock upgrade if more than 1 transaction in next's parallell queue
+     */
+    return;
+  }
+  
+  OperationrecPtr tmp;
+  tmp.i = lock_owner.p->nextSerialQue = next.p->nextSerialQue;
+  if(tmp.i != RNIL)
+  {
+    ptrCheckGuard(tmp, coprecsize, operationrec);
+    ndbassert(tmp.p->prevSerialQue == next.i);
+    tmp.p->prevSerialQue = lock_owner.i;
+  }
+  next.p->nextSerialQue = next.p->prevSerialQue = RNIL;
+  
+  // Find end of parallell que
+  tmp = lock_owner;
+  Uint32 lockMode = next.p->lockMode > lock_owner.p->lockMode ?
+    next.p->lockMode : lock_owner.p->lockMode;
+  while(tmp.p->nextParallelQue != RNIL)
+  {
+    jam();
+    tmp.i = tmp.p->nextParallelQue;
+    tmp.p->lockMode = lockMode;
+    ptrCheckGuard(tmp, coprecsize, operationrec);
+  }
+  tmp.p->lockMode = lockMode;
+  
+  next.p->prevParallelQue = tmp.i;
+  tmp.p->nextParallelQue = next.i;
+  
+  OperationrecPtr save = operationRecPtr;
+
+  Uint32 localdata[2];
+  localdata[0] = lock_owner.p->localdata[0];
+  localdata[1] = lock_owner.p->localdata[1];
+  do {
+    next.p->localdata[0] = localdata[0];
+    next.p->localdata[1] = localdata[1];
+    next.p->lockMode = lockMode;
+    
+    operationRecPtr = next;
+    executeNextOperation(signal);
+    if (next.p->nextParallelQue != RNIL) 
+    {
+      jam();
+      next.i = next.p->nextParallelQue;
+      ptrCheckGuard(next, coprecsize, operationrec);
+    } else {
+      jam();
+      break;
+    }//if
+  } while (1);
+  
+  operationRecPtr = save;
+  
+}
+
 /* ------------------------------------------------------------------------- */
 /* RELEASELOCK                                                               */
 /*          RESETS LOCK OF AN ELEMENT.                                       */
@@ -5841,6 +5976,8 @@ void Dbacc::releaselock(Signal* signal)
       ptrCheckGuard(trlTmpOperPtr, coprecsize, operationrec);
       trlTmpOperPtr.p->prevSerialQue = trlOperPtr.i;
     }//if
+
+    check_lock_upgrade(signal, copyInOperPtr, operationRecPtr);
     /* --------------------------------------------------------------------------------- */
     /*       SINCE THERE ARE STILL ITEMS IN THE PARALLEL QUEUE WE NEED NOT WORRY ABOUT   */
     /*       STARTING QUEUED OPERATIONS. THUS WE CAN END HERE.                           */
@@ -8348,7 +8485,7 @@ void Dbacc::checkSendLcpConfLab(Signal* signal)
     break;
   }//switch
   lcpConnectptr.p->noOfLcpConf++;
-  ndbrequire(lcpConnectptr.p->noOfLcpConf <= 2);
+  ndbrequire(lcpConnectptr.p->noOfLcpConf <= 4);
   fragrecptr.p->fragState = ACTIVEFRAG;
   rlpPageptr.i = fragrecptr.p->zeroPagePtr;
   ptrCheckGuard(rlpPageptr, cpagesize, page8);
@@ -8366,7 +8503,7 @@ void Dbacc::checkSendLcpConfLab(Signal* signal)
   }//for
   signal->theData[0] = fragrecptr.p->lcpLqhPtr;
   sendSignal(lcpConnectptr.p->lcpUserblockref, GSN_ACC_LCPCONF, signal, 1, JBB);
-  if (lcpConnectptr.p->noOfLcpConf == 2) {
+  if (lcpConnectptr.p->noOfLcpConf == 4) {
     jam();
     releaseLcpConnectRec(signal);
     rootfragrecptr.i = fragrecptr.p->myroot;
@@ -8397,6 +8534,13 @@ void Dbacc::execACC_CONTOPREQ(Signal* signal)
   /* LOCAL FRAG ID                   */
   tresult = 0;
   ptrCheckGuard(lcpConnectptr, clcpConnectsize, lcpConnectrec);
+  if(ERROR_INSERTED(3002) && lcpConnectptr.p->noOfLcpConf < 2)
+  {
+    sendSignalWithDelay(cownBlockref, GSN_ACC_CONTOPREQ, signal, 300, 
+			signal->getLength());
+    return;
+  }
+  
   ndbrequire(lcpConnectptr.p->lcpstate == LCP_ACTIVE);
   rootfragrecptr.i = lcpConnectptr.p->rootrecptr;
   ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec);
@@ -8430,6 +8574,15 @@ void Dbacc::execACC_CONTOPREQ(Signal* signal)
   }//while
   signal->theData[0] = fragrecptr.p->lcpLqhPtr;
   sendSignal(lcpConnectptr.p->lcpUserblockref, GSN_ACC_CONTOPCONF, signal, 1, JBA);
+
+  lcpConnectptr.p->noOfLcpConf++;
+  if (lcpConnectptr.p->noOfLcpConf == 4) {
+    jam();
+    releaseLcpConnectRec(signal);
+    rootfragrecptr.i = fragrecptr.p->myroot;
+    ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec);
+    rootfragrecptr.p->rootState = ACTIVEROOT;
+  }//if
   return;	/* ALL QUEUED OPERATION ARE RESTARTED IF NEEDED. */
 }//Dbacc::execACC_CONTOPREQ()
 

ndb/src/kernel/blocks/dbdict/Dbdict.cpp

@@ -9811,11 +9811,20 @@ Dbdict::execBUILDINDXREQ(Signal* signal)
       requestType == BuildIndxReq::RT_ALTER_INDEX ||
       requestType == BuildIndxReq::RT_SYSTEMRESTART) {
     jam();
+
+    const bool isLocal = req->getRequestFlag() & RequestFlag::RF_LOCAL;
+    NdbNodeBitmask receiverNodes = c_aliveNodes;
+    if (isLocal) {
+      receiverNodes.clear();
+      receiverNodes.set(getOwnNodeId());
+    }
+    
     if (signal->getLength() == BuildIndxReq::SignalLength) {
       jam();
-      if (getOwnNodeId() != c_masterNodeId) {
+      
+      if (!isLocal && getOwnNodeId() != c_masterNodeId) {
         jam();
-
+	
 	releaseSections(signal);
 	OpBuildIndex opBad;
 	opPtr.p = &opBad;
@@ -9828,9 +9837,9 @@ Dbdict::execBUILDINDXREQ(Signal* signal)
       }
       // forward initial request plus operation key to all
       req->setOpKey(++c_opRecordSequence);
-      NodeReceiverGroup rg(DBDICT, c_aliveNodes);
+      NodeReceiverGroup rg(DBDICT, receiverNodes);
       sendSignal(rg, GSN_BUILDINDXREQ,
-          signal, BuildIndxReq::SignalLength + 1, JBB);
+		 signal, BuildIndxReq::SignalLength + 1, JBB);
       return;
     }
     // seize operation record
@@ -9853,7 +9862,7 @@ Dbdict::execBUILDINDXREQ(Signal* signal)
     }
     c_opBuildIndex.add(opPtr);
     // master expects to hear from all
-    opPtr.p->m_signalCounter = c_aliveNodes;
+    opPtr.p->m_signalCounter = receiverNodes;
     buildIndex_sendReply(signal, opPtr, false);
     return;
   }
@@ -10208,10 +10217,20 @@ Dbdict::buildIndex_sendSlaveReq(Signal* signal, OpBuildIndexPtr opPtr)
   req->setConnectionPtr(opPtr.p->key);
   req->setRequestType(opPtr.p->m_requestType);
   req->addRequestFlag(opPtr.p->m_requestFlag);
-  opPtr.p->m_signalCounter = c_aliveNodes;
+  if(opPtr.p->m_requestFlag & RequestFlag::RF_LOCAL)
-  NodeReceiverGroup rg(DBDICT, c_aliveNodes);
+  {
-  sendSignal(rg, GSN_BUILDINDXREQ,
+    opPtr.p->m_signalCounter.clearWaitingFor();
-      signal, BuildIndxReq::SignalLength, JBB);
+    opPtr.p->m_signalCounter.setWaitingFor(getOwnNodeId());
+    sendSignal(reference(), GSN_BUILDINDXREQ,
+	       signal, BuildIndxReq::SignalLength, JBB);
+  }
+  else
+  {
+    opPtr.p->m_signalCounter = c_aliveNodes;
+    NodeReceiverGroup rg(DBDICT, c_aliveNodes);
+    sendSignal(rg, GSN_BUILDINDXREQ,
+	       signal, BuildIndxReq::SignalLength, JBB);
+  }
 }
 
 void

ndb/src/kernel/blocks/dblqh/Dblqh.hpp

@@ -968,7 +968,6 @@ public:
     
     enum LcpState {
       LCP_IDLE = 0,
-      LCP_STARTED = 1,
       LCP_COMPLETED = 2,
       LCP_WAIT_FRAGID = 3,
       LCP_WAIT_TUP_PREPLCP = 4,
@@ -2266,7 +2265,7 @@ private:
   void sendCopyActiveConf(Signal* signal,Uint32 tableId);
   void checkLcpCompleted(Signal* signal);
   void checkLcpHoldop(Signal* signal);
-  void checkLcpStarted(Signal* signal);
+  bool checkLcpStarted(Signal* signal);
   void checkLcpTupprep(Signal* signal);
   void getNextFragForLcp(Signal* signal);
   void initLcpLocAcc(Signal* signal, Uint32 fragId);

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

@@ -10351,8 +10351,8 @@ void Dblqh::execTUP_LCPSTARTED(Signal* signal)
 
 void Dblqh::lcpStartedLab(Signal* signal) 
 {
-  checkLcpStarted(signal);
+  if (checkLcpStarted(signal))
-  if (lcpPtr.p->lcpState == LcpRecord::LCP_STARTED) {
+  {
     jam();
     /* ----------------------------------------------------------------------
      *  THE LOCAL CHECKPOINT HAS BEEN STARTED. IT IS NOW TIME TO 
@@ -10432,26 +10432,7 @@ void Dblqh::execLQH_RESTART_OP(Signal* signal)
   lcpPtr.i = signal->theData[1];
   ptrCheckGuard(lcpPtr, clcpFileSize, lcpRecord);
   ndbrequire(fragptr.p->fragStatus == Fragrecord::BLOCKED);
-  if (lcpPtr.p->lcpState == LcpRecord::LCP_STARTED) {
+  restartOperationsLab(signal);
-    jam();
-    /***********************************************************************/
-    /*  THIS SIGNAL CAN ONLY BE RECEIVED WHEN FRAGMENT IS BLOCKED AND 
-     *  THE LOCAL CHECKPOINT HAS BEEN STARTED. THE BLOCKING WILL BE 
-     *  REMOVED AS SOON AS ALL OPERATIONS HAVE BEEN STARTED.
-     ***********************************************************************/
-    restartOperationsLab(signal);
-  } else if (lcpPtr.p->lcpState == LcpRecord::LCP_BLOCKED_COMP) {
-    jam();
-    /*******************************************************************>
-     *   THE CHECKPOINT IS COMPLETED BUT HAS NOT YET STARTED UP 
-     *   ALL OPERATIONS AGAIN. 
-     *   WE PERFORM THIS START-UP BEFORE CONTINUING WITH THE NEXT 
-     *   FRAGMENT OF THE LOCAL CHECKPOINT TO AVOID ANY STRANGE ERRORS.  
-     *******************************************************************> */
-    restartOperationsLab(signal);
-  } else {
-    ndbrequire(false);
-  }
 }//Dblqh::execLQH_RESTART_OP()
 
 void Dblqh::restartOperationsLab(Signal* signal) 
@@ -11000,7 +10981,8 @@ void Dblqh::checkLcpHoldop(Signal* signal)
  *
  *       SUBROUTINE SHORT NAME = CLS
  * ========================================================================== */
-void Dblqh::checkLcpStarted(Signal* signal) 
+bool
+Dblqh::checkLcpStarted(Signal* signal) 
 {
   LcpLocRecordPtr clsLcpLocptr;
 
@@ -11010,7 +10992,7 @@ void Dblqh::checkLcpStarted(Signal* signal)
   do {
     ptrCheckGuard(clsLcpLocptr, clcpLocrecFileSize, lcpLocRecord);
     if (clsLcpLocptr.p->lcpLocstate == LcpLocRecord::ACC_WAIT_STARTED){
-      return;
+      return false;
     }//if
     clsLcpLocptr.i = clsLcpLocptr.p->nextLcpLoc;
     i++;
@@ -11021,12 +11003,13 @@ void Dblqh::checkLcpStarted(Signal* signal)
   do {
     ptrCheckGuard(clsLcpLocptr, clcpLocrecFileSize, lcpLocRecord);
     if (clsLcpLocptr.p->lcpLocstate == LcpLocRecord::TUP_WAIT_STARTED){
-      return;
+      return false;
     }//if
     clsLcpLocptr.i = clsLcpLocptr.p->nextLcpLoc;
     i++;
   } while (clsLcpLocptr.i != RNIL);
-  lcpPtr.p->lcpState = LcpRecord::LCP_STARTED;
+  
+  return true;
 }//Dblqh::checkLcpStarted()
 
 /* ========================================================================== 
@@ -11187,20 +11170,12 @@ void Dblqh::sendAccContOp(Signal* signal)
   do {
     ptrCheckGuard(sacLcpLocptr, clcpLocrecFileSize, lcpLocRecord);
     sacLcpLocptr.p->accContCounter = 0;
-    if(sacLcpLocptr.p->lcpLocstate == LcpLocRecord::ACC_STARTED){
+    /* ------------------------------------------------------------------- */
-      /* ------------------------------------------------------------------- */
+    /*SEND START OPERATIONS TO ACC AGAIN                                   */
-      /*SEND START OPERATIONS TO ACC AGAIN                                   */
+    /* ------------------------------------------------------------------- */
-      /* ------------------------------------------------------------------- */
+    signal->theData[0] = lcpPtr.p->lcpAccptr;
-      signal->theData[0] = lcpPtr.p->lcpAccptr;
+    signal->theData[1] = sacLcpLocptr.p->locFragid;
-      signal->theData[1] = sacLcpLocptr.p->locFragid;
+    sendSignal(fragptr.p->accBlockref, GSN_ACC_CONTOPREQ, signal, 2, JBA);
-      sendSignal(fragptr.p->accBlockref, GSN_ACC_CONTOPREQ, signal, 2, JBA);
-      count++;
-    } else if(sacLcpLocptr.p->lcpLocstate == LcpLocRecord::ACC_COMPLETED){
-      signal->theData[0] = sacLcpLocptr.i;
-      sendSignal(reference(), GSN_ACC_CONTOPCONF, signal, 1, JBB);
-    } else {
-      ndbrequire(false);
-    }
     sacLcpLocptr.i = sacLcpLocptr.p->nextLcpLoc;
   } while (sacLcpLocptr.i != RNIL);
   
@@ -11236,9 +11211,18 @@ void Dblqh::sendStartLcp(Signal* signal)
     signal->theData[0] = stlLcpLocptr.i;
     signal->theData[1] = cownref;
     signal->theData[2] = stlLcpLocptr.p->tupRef;
-    sendSignal(fragptr.p->tupBlockref, GSN_TUP_LCPREQ, signal, 3, JBA);
+    if(ERROR_INSERTED(5077))
+      sendSignalWithDelay(fragptr.p->tupBlockref, GSN_TUP_LCPREQ, 
+			  signal, 5000, 3);
+    else
+      sendSignal(fragptr.p->tupBlockref, GSN_TUP_LCPREQ, signal, 3, JBA);
     stlLcpLocptr.i = stlLcpLocptr.p->nextLcpLoc;
   } while (stlLcpLocptr.i != RNIL);
+
+  if(ERROR_INSERTED(5077))
+  {
+    ndbout_c("Delayed TUP_LCPREQ with 5 sec");
+  }
 }//Dblqh::sendStartLcp()
 
 /* ------------------------------------------------------------------------- */

ndb/src/kernel/blocks/ndbfs/OpenFiles.hpp

@@ -82,8 +82,14 @@ inline bool OpenFiles::insert(AsyncFile* file, Uint16 id){
       continue;
 
     if(strcmp(m_files[i].m_file->theFileName.c_str(), 
-	      file->theFileName.c_str()) == 0){
+	      file->theFileName.c_str()) == 0)
-      ERROR_SET(fatal, AFS_ERROR_ALLREADY_OPEN,"","OpenFiles::insert()");    
+    {
+      BaseString names;
+      names.assfmt("open: >%s< existing: >%s<",
+		   file->theFileName.c_str(),
+		   m_files[i].m_file->theFileName.c_str());
+      ERROR_SET(fatal, AFS_ERROR_ALLREADY_OPEN, names.c_str(),
+		"OpenFiles::insert()");    
     }
   }
   

ndb/src/mgmapi/mgmapi.cpp

@@ -1565,9 +1565,9 @@ ndb_mgm_start_backup(NdbMgmHandle handle, int wait_completed,
   { // start backup can take some time, set timeout high
     Uint64 old_timeout= handle->read_timeout;
     if (wait_completed == 2)
-      handle->read_timeout= 30*60*1000; // 30 minutes
+      handle->read_timeout= 48*60*60*1000; // 48 hours
     else if (wait_completed == 1)
-      handle->read_timeout= 5*60*1000; // 5 minutes
+      handle->read_timeout= 10*60*1000; // 10 minutes
     reply = ndb_mgm_call(handle, start_backup_reply, "start backup", &args);
     handle->read_timeout= old_timeout;
   }

ndb/src/mgmsrv/MgmtSrvr.cpp

@@ -791,7 +791,7 @@ MgmtSrvr::restartNode(int processId, bool nostart,
     result = sendSignal(processId, NO_WAIT, signal, true);
   }
   
-  if (result == -1) {
+  if (result == -1 && theWaitState != WAIT_NODEFAILURE) {
     m_stopRec.inUse = false;
     return SEND_OR_RECEIVE_FAILED;
   }
@@ -1920,6 +1920,7 @@ MgmtSrvr::handleReceivedSignal(NdbApiSignal* signal)
 #ifdef VM_TRACE
       ndbout_c("I'm not master resending to %d", aNodeId);
 #endif
+      theWaitNode= aNodeId;
       NdbApiSignal aSignal(_ownReference);
       BackupReq* req = CAST_PTR(BackupReq, aSignal.getDataPtrSend());
       aSignal.set(TestOrd::TraceAPI, BACKUP, GSN_BACKUP_REQ, 
@@ -1947,6 +1948,7 @@ MgmtSrvr::handleReceivedSignal(NdbApiSignal* signal)
     event.Event = BackupEvent::BackupAborted;
     event.Aborted.Reason = rep->reason;
     event.Aborted.BackupId = rep->backupId;
+    event.Aborted.ErrorCode = rep->reason;
     backupCallback(event);
   }
   break;
@@ -2076,6 +2078,13 @@ MgmtSrvr::handleStatus(NodeId nodeId, bool alive, bool nfComplete)
       handleStopReply(nodeId, 0);
       DBUG_VOID_RETURN;
     }
+
+    if(theWaitNode == nodeId && 
+       theWaitState != NO_WAIT && theWaitState != WAIT_STOP)
+    {
+      theWaitState = WAIT_NODEFAILURE;
+      NdbCondition_Signal(theMgmtWaitForResponseCondPtr);
+    }
   }
   
   eventReport(_ownNodeId, theData);
@@ -2427,7 +2436,7 @@ MgmtSrvr::startBackup(Uint32& backupId, int waitCompleted)
   int result;
   if (waitCompleted == 2) {
     result = sendRecSignal(nodeId, WAIT_BACKUP_COMPLETED,
-			   signal, true, 30*60*1000 /*30 secs*/);
+			   signal, true, 48*60*60*1000 /* 48 hours */);
   }
   else if (waitCompleted == 1) {
     result = sendRecSignal(nodeId, WAIT_BACKUP_STARTED,
@@ -2456,22 +2465,6 @@ MgmtSrvr::startBackup(Uint32& backupId, int waitCompleted)
       return -1;
       break;
     }
-  } else {
-    switch(m_lastBackupEvent.Event){
-    case BackupEvent::BackupCompleted:
-      backupId = m_lastBackupEvent.Completed.BackupId;
-      break;
-    case BackupEvent::BackupStarted:
-      backupId = m_lastBackupEvent.Started.BackupId;
-      break;
-    case BackupEvent::BackupFailedToStart:
-      return m_lastBackupEvent.FailedToStart.ErrorCode;
-    case BackupEvent::BackupAborted:
-      return m_lastBackupEvent.Aborted.ErrorCode;
-    default:
-      return -1;
-      break;
-    }
   }
   
   return 0;

ndb/src/mgmsrv/MgmtSrvr.hpp

@@ -611,7 +611,8 @@ private:
     WAIT_STOP,
     WAIT_BACKUP_STARTED,
     WAIT_BACKUP_COMPLETED,
-    WAIT_VERSION
+    WAIT_VERSION,
+    WAIT_NODEFAILURE
   };
 
   /**
@@ -695,6 +696,7 @@ private:
   NdbApiSignal* theSignalIdleList;
   // List of unused signals
   
+  Uint32 theWaitNode;
   WaitSignalType theWaitState;
   // State denoting a set of signals we accept to recieve.
 

ndb/src/mgmsrv/MgmtSrvrGeneralSignalHandling.cpp

@@ -108,6 +108,7 @@ MgmtSrvr::sendRecSignal(Uint16 aNodeId,
     return -1;
   }
   theWaitState = aWaitState;
+  theWaitNode = aNodeId;
   return receiveOptimisedResponse(waitTime);
 }
 
@@ -119,11 +120,12 @@ MgmtSrvr::receiveOptimisedResponse(int waitTime)
   theFacade->checkForceSend(_blockNumber);
   NDB_TICKS maxTime = NdbTick_CurrentMillisecond() + waitTime;
   
-  while (theWaitState != NO_WAIT && waitTime > 0) {
+  while (theWaitState != NO_WAIT && theWaitState != WAIT_NODEFAILURE
+	 && waitTime > 0) {
     NdbCondition_WaitTimeout(theMgmtWaitForResponseCondPtr, 
 			     theFacade->theMutexPtr,
 			     waitTime);
-    if(theWaitState == NO_WAIT)
+    if(theWaitState == NO_WAIT || theWaitState == WAIT_NODEFAILURE)
       break;
     waitTime = (maxTime - NdbTick_CurrentMillisecond());
   }//while

ndb/src/ndbapi/Ndbif.cpp

@@ -453,7 +453,7 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
       tFirstDataPtr = int2void(tFirstData);
       if(tFirstDataPtr != 0){
 	tOp = void2rec_op(tFirstDataPtr);
-	if (tOp->checkMagicNumber() == 0) {
+	if (tOp->checkMagicNumber(false) == 0) {
 	  tCon = tOp->theNdbCon;
 	  if (tCon != NULL) {
 	    if ((tCon->theSendStatus == NdbConnection::sendTC_OP) ||
@@ -466,11 +466,11 @@ Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
 	    }//if
 	  }//if
 	}//if
-      } else {
-#ifdef VM_TRACE
-	ndbout_c("Recevied TCKEY_FAILREF wo/ operation");
-#endif
       }
+#ifdef VM_TRACE
+      ndbout_c("Recevied TCKEY_FAILREF wo/ operation");
+#endif
+      return;
       break;
     }
   case GSN_TCKEYREF:

ndb/src/ndbapi/ndberror.c

@@ -140,10 +140,10 @@ ErrorBundle ErrorCodes[] = {
   { 4008, UR, "Receive from NDB failed" },
   { 4009, UR, "Cluster Failure" },
   { 4012, UR, 
-   "Time-out, most likely caused by simple read or cluster failure" }, 
+    "Request ndbd time-out, maybe due to high load or communication problems"}, 
   { 4024, UR, 
-   "Time-out, most likely caused by simple read or cluster failure" }, 
+    "Time-out, most likely caused by simple read or cluster failure" }, 
-
+  
   /**
    * TemporaryResourceError
    */
@@ -348,7 +348,7 @@ ErrorBundle ErrorCodes[] = {
   { 1325, IE, "File or scan error" },
   { 1326, IE, "Backup abortet due to node failure" },
   { 1327, IE, "1327" },
-
+  
   { 1340, IE, "Backup undefined error" },
   { 1342, AE, "Backup failed to allocate buffers (check configuration)" },
   { 1343, AE, "Backup failed to setup fs buffers (check configuration)" },
@@ -358,7 +358,8 @@ ErrorBundle ErrorCodes[] = {
   { 1347, AE, "Backup failed to allocate table memory (check configuration)" },
   { 1348, AE, "Backup failed to allocate file record (check configuration)" },
   { 1349, AE, "Backup failed to allocate attribute record (check configuration)" },
-
+  { 1329, AE, "Backup during software upgrade not supported" },
+  
   /**
    * Still uncategorized
    */

ndb/test/ndbapi/testBackup.cpp

@@ -74,20 +74,20 @@ int runAbort(NDBT_Context* ctx, NDBT_Step* step){
 
   if (testMaster) {
     if (testSlave) {
-      if (backup.NFMasterAsSlave(restarter) == -1){
+      if (backup.NFMasterAsSlave(restarter) != NDBT_OK){
 	return NDBT_FAILED;
       }
     } else {
-      if (backup.NFMaster(restarter) == -1){
+      if (backup.NFMaster(restarter) != NDBT_OK){
 	return NDBT_FAILED;
       }
     }
   } else {
-    if (backup.NFSlave(restarter) == -1){
+    if (backup.NFSlave(restarter) != NDBT_OK){
       return NDBT_FAILED;
     }
   }
-
+  
   return NDBT_OK;
 }
 
@@ -108,16 +108,16 @@ int runFail(NDBT_Context* ctx, NDBT_Step* step){
 
   if (testMaster) {
     if (testSlave) {
-      if (backup.FailMasterAsSlave(restarter) == -1){
+      if (backup.FailMasterAsSlave(restarter) != NDBT_OK){
 	return NDBT_FAILED;
       }
     } else {
-      if (backup.FailMaster(restarter) == -1){
+      if (backup.FailMaster(restarter) != NDBT_OK){
 	return NDBT_FAILED;
       }
     }
   } else {
-    if (backup.FailSlave(restarter) == -1){
+    if (backup.FailSlave(restarter) != NDBT_OK){
       return NDBT_FAILED;
     }
   }

ndb/test/ndbapi/testIndex.cpp

@@ -1329,7 +1329,7 @@ TESTCASE("NFNR2_O",
   INITIALIZER(runLoadTable);
   STEP(runRestarts);
   STEP(runTransactions2);
-  STEP(runTransactions2);
+  //STEP(runTransactions2);
   FINALIZER(runVerifyIndex);
   FINALIZER(createRandomIndex_Drop);
   FINALIZER(createPkIndex_Drop);

ndb/test/ndbapi/testOperations.cpp

@@ -547,21 +547,64 @@ runLockUpgrade1(NDBT_Context* ctx, NDBT_Step* step){
   do
   {
     CHECK(hugoOps.startTransaction(pNdb) == 0);  
-    CHECK(hugoOps.pkReadRecord(pNdb, 0, 1, NdbOperation::LM_Read) == 0);
+    if(ctx->getProperty("LOCK_UPGRADE", 1) == 1)
-    CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
+    {
+      CHECK(hugoOps.pkReadRecord(pNdb, 0, 1, NdbOperation::LM_Read) == 0);
+      CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
     
-    ctx->setProperty("READ_DONE", 1);
+      ctx->setProperty("READ_DONE", 1);
-    ctx->broadcast();
+      ctx->broadcast();
-    ndbout_c("wait 2");
+      ndbout_c("wait 2");
-    ctx->getPropertyWait("READ_DONE", 2);
+      ctx->getPropertyWait("READ_DONE", 2);
-    ndbout_c("wait 2 - done");
+      ndbout_c("wait 2 - done");
+    }
+    else
+    {
+      ctx->setProperty("READ_DONE", 1);
+      ctx->broadcast();
+      ctx->getPropertyWait("READ_DONE", 2);
+      ndbout_c("wait 2 - done");
+      CHECK(hugoOps.pkReadRecord(pNdb, 0, 1, NdbOperation::LM_Read) == 0);
+      CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
+    }
+    if(ctx->getProperty("LU_OP", o_INS) == o_INS)
+    {
+      CHECK(hugoOps.pkDeleteRecord(pNdb, 0, 1) == 0);
+      CHECK(hugoOps.pkInsertRecord(pNdb, 0, 1, 2) == 0);
+    }
+    else if(ctx->getProperty("LU_OP", o_UPD) == o_UPD)
+    {
+      CHECK(hugoOps.pkUpdateRecord(pNdb, 0, 1, 2) == 0);
+    } 
+    else
+    {
+      CHECK(hugoOps.pkDeleteRecord(pNdb, 0, 1) == 0);
+    }
     ctx->setProperty("READ_DONE", 3);
     ctx->broadcast();
     ndbout_c("before update");
-    CHECK(hugoOps.pkUpdateRecord(pNdb, 0, 1, 2) == 0);
     ndbout_c("wait update");
-    CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
+    CHECK(hugoOps.execute_Commit(pNdb) == 0);
-    CHECK(hugoOps.closeTransaction(pNdb));
+    CHECK(hugoOps.closeTransaction(pNdb) == 0);
+
+    CHECK(hugoOps.startTransaction(pNdb) == 0);
+    CHECK(hugoOps.pkReadRecord(pNdb, 0, 1) == 0);
+    int res= hugoOps.execute_Commit(pNdb);
+    if(ctx->getProperty("LU_OP", o_INS) == o_INS)
+    {
+      CHECK(res == 0);
+      CHECK(hugoOps.verifyUpdatesValue(2) == 0);
+    }
+    else if(ctx->getProperty("LU_OP", o_UPD) == o_UPD)
+    {
+      CHECK(res == 0);
+      CHECK(hugoOps.verifyUpdatesValue(2) == 0);
+    } 
+    else
+    {
+      CHECK(res == 626);
+    }
+    
   } while(0);
   
   return result;
@@ -592,10 +635,17 @@ runLockUpgrade2(NDBT_Context* ctx, NDBT_Step* step){
     ndbout_c("wait 3 - done");
     
     NdbSleep_MilliSleep(200);
-    CHECK(hugoOps.execute_Commit(pNdb) == 0);  
+    if(ctx->getProperty("LU_COMMIT", (Uint32)0) == 0)
+    {
+      CHECK(hugoOps.execute_Commit(pNdb) == 0);
+    }
+    else
+    {
+      CHECK(hugoOps.execute_Rollback(pNdb) == 0);
+    }
   } while(0);
 
-  return NDBT_FAILED;
+  return result;
 }
 
 int
@@ -607,11 +657,17 @@ main(int argc, const char** argv){
 
   NDBT_TestSuite ts("testOperations");
 
+  for(Uint32 i = 0; i < 12; i++)
   {
     BaseString name("bug_9749");
+    name.appfmt("_%d", i);
     NDBT_TestCaseImpl1 *pt = new NDBT_TestCaseImpl1(&ts, 
 						    name.c_str(), "");    
     
+    pt->setProperty("LOCK_UPGRADE", 1 + (i & 1));
+    pt->setProperty("LU_OP", 1 + ((i >> 1) % 3));
+    pt->setProperty("LU_COMMIT", i / 6);
+
     pt->addInitializer(new NDBT_Initializer(pt,
 					    "runClearTable", 
 					    runClearTable));

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

@@ -2,6 +2,54 @@ max-time: 3600
 cmd: atrt-mysql-test-run
 args: --force
 
+max-time: 600
+cmd: atrt-testBackup
+args: -n NFMaster T1
+
+max-time: 600
+cmd: testBasic
+args: -n PkRead T1
+
+max-time: 600
+cmd: atrt-testBackup
+args: -n NFMasterAsSlave T1
+
+max-time: 600
+cmd: testBasic
+args: -n PkRead T1
+
+max-time: 600
+cmd: atrt-testBackup
+args: -n NFSlave T1 
+
+max-time: 600
+cmd: testBasic
+args: -n PkRead T1
+
+max-time: 600
+cmd: atrt-testBackup
+args: -n FailMaster T1
+
+max-time: 600
+cmd: testBasic
+args: -n PkRead T1
+
+max-time: 600
+cmd: atrt-testBackup
+args: -n FailMasterAsSlave T1
+
+max-time: 600
+cmd: testBasic
+args: -n PkRead T1
+
+max-time: 600
+cmd: atrt-testBackup
+args: -n FailSlave T1
+
+max-time: 600
+cmd: testBasic
+args: -n PkRead T1
+
 max-time: 600
 cmd: atrt-testBackup
 args: -n BackupOne T1 T6 T3 I3

ndb/test/src/NdbBackup.cpp

@@ -244,7 +244,11 @@ NdbBackup::NFSlave(NdbRestarter& _restarter){
 
 int 
 NdbBackup::NF(NdbRestarter& _restarter, int *NFDuringBackup_codes, const int sz, bool onMaster){
+  int nNodes = _restarter.getNumDbNodes();
   {
+    if(nNodes == 1)
+      return NDBT_OK;
+    
     int nodeId = _restarter.getMasterNodeId();
 
     CHECK(_restarter.restartOneDbNode(nodeId, false, true, true) == 0,
@@ -255,15 +259,11 @@ NdbBackup::NF(NdbRestarter& _restarter, int *NFDuringBackup_codes, const int sz,
     
     CHECK(_restarter.startNodes(&nodeId, 1) == 0,
 	  "failed to start node");
-
-    NdbSleep_SecSleep(10);
   }
-
+  
   CHECK(_restarter.waitClusterStarted() == 0,
 	"waitClusterStarted failed");
-
+  
-  int nNodes = _restarter.getNumDbNodes();
-
   myRandom48Init(NdbTick_CurrentMillisecond());
 
   for(int i = 0; i<sz; i++){
@@ -296,6 +296,7 @@ NdbBackup::NF(NdbRestarter& _restarter, int *NFDuringBackup_codes, const int sz,
 	  "failed to set error insert");
    
     g_info << "error inserted"  << endl;
+    NdbSleep_SecSleep(1);
 
     g_info << "starting backup"  << endl;
     int r = start(backupId);
@@ -304,6 +305,7 @@ NdbBackup::NF(NdbRestarter& _restarter, int *NFDuringBackup_codes, const int sz,
     if (r == 0) {
       g_err << "Backup should have failed on error_insertion " << error << endl
 	    << "Master = " << masterNodeId << "Node = " << nodeId << endl;
+      return NDBT_FAILED;
     }
 
     CHECK(_restarter.waitNodesNoStart(&nodeId, 1) == 0,
@@ -316,8 +318,6 @@ NdbBackup::NF(NdbRestarter& _restarter, int *NFDuringBackup_codes, const int sz,
       return NDBT_FAILED;
     }
 
-    NdbSleep_SecSleep(1);
-
     g_info << "starting new backup"  << endl;
     CHECK(start(backupId) == 0,
 	  "failed to start backup");
@@ -331,8 +331,14 @@ NdbBackup::NF(NdbRestarter& _restarter, int *NFDuringBackup_codes, const int sz,
 	  "waitClusterStarted failed");
     g_info << "node started"  << endl;
 
+    int val2[] = { 24, 2424 };
+    CHECK(_restarter.dumpStateAllNodes(val2, 2) == 0,
+	  "failed to check backup resources RestartOnErrorInsert");
+    
     CHECK(_restarter.insertErrorInNode(nodeId, 10099) == 0,
 	  "failed to set error insert");
+
+    NdbSleep_SecSleep(1);
   }
 
   return NDBT_OK;
@@ -340,15 +346,8 @@ NdbBackup::NF(NdbRestarter& _restarter, int *NFDuringBackup_codes, const int sz,
 
 int
 FailS_codes[] = {
-  10023,
-  10024,
-  10025,
-  10026,
   10027,
-  10028,
+  10033
-  10029,
-  10030,
-  10031
 };
 
 int
@@ -359,9 +358,8 @@ FailM_codes[] = {
   10026,
   10027,
   10028,
-  10029,
+  10031,
-  10030,
+  10033
-  10031
 };
 
 int 
@@ -426,13 +424,21 @@ NdbBackup::Fail(NdbRestarter& _restarter, int *Fail_codes, const int sz, bool on
     if (r == 0) {
       g_err << "Backup should have failed on error_insertion " << error << endl
 	    << "Master = " << masterNodeId << "Node = " << nodeId << endl;
+      return NDBT_FAILED;
     }
-
+    
     CHECK(_restarter.waitClusterStarted() == 0,
 	  "waitClusterStarted failed");
 
     CHECK(_restarter.insertErrorInNode(nodeId, 10099) == 0,
 	  "failed to set error insert");
+
+    NdbSleep_SecSleep(5);
+    
+    int val2[] = { 24, 2424 };
+    CHECK(_restarter.dumpStateAllNodes(val2, 2) == 0,
+	  "failed to check backup resources RestartOnErrorInsert");
+    
   }
 
   return NDBT_OK;

sql/item_func.cc

@@ -1072,6 +1072,8 @@ void Item_func_round::fix_length_and_dec()
       decimals=0;
     else
       decimals=min(tmp,NOT_FIXED_DEC);
+    if ((tmp= decimals - args[0]->decimals) > 0)
+      max_length+= tmp;
   }
 }