Merge dev3-240.dev.cn.tlan:/home/justin.he/mysql/mysql-5.1/mysql-5.1-new-ndb.test

into  dev3-240.dev.cn.tlan:/home/justin.he/mysql/mysql-5.1/mysql-5.1-new-ndb-bj.test


sql/ha_ndbcluster.cc:
  Auto merged
storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp:
  Auto merged
storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp:
  Auto merged
storage/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp:
  Auto merged
storage/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp:
  Auto merged
storage/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp:
  Auto merged
storage/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp:
  Auto merged
storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp:
  Auto merged
storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp:
  Auto merged
storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp:
  Auto merged
storage/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp:
  Auto merged
storage/ndb/src/kernel/blocks/dbtup/DbtupScan.cpp:
  Auto merged
storage/ndb/src/kernel/blocks/dbtup/DbtupVarAlloc.cpp:
  Auto merged
storage/ndb/src/kernel/vm/Pool.hpp:
  Auto merged
storage/ndb/src/mgmclient/CommandInterpreter.cpp:
  Auto merged
storage/ndb/src/mgmsrv/ConfigInfo.cpp:
  Auto merged
storage/ndb/tools/restore/consumer_restore.cpp:
  Auto merged

32 files changed, 1652 insertions, 562 deletions

diff --git a/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp b/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
index fa982063e36..dc6581afd05 100644
--- a/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
+++ b/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
@@ -1089,7 +1089,6 @@ Dbdict::updateSchemaState(Signal* signal, Uint32 tableId,
 			  SchemaFile::TableEntry* te, Callback* callback,
                           bool savetodisk){
   jam();
-  ndbrequire(tableId < c_tableRecordPool.getSize());
   XSchemaFile * xsf = &c_schemaFile[c_schemaRecord.schemaPage != 0];
   SchemaFile::TableEntry * tableEntry = getTableEntry(xsf, tableId);
   
diff --git a/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp b/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
index fecc4649fe9..7aef13204f2 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
@@ -32,6 +32,82 @@
 #include <../pgman.hpp>
 #include <../tsman.hpp>
 
+// jams
+#undef jam
+#undef jamEntry
+#ifdef DBTUP_BUFFER_CPP
+#define jam()	 	jamLine(10000 + __LINE__)
+#define jamEntry() 	jamEntryLine(10000 + __LINE__)
+#endif
+#ifdef DBTUP_ROUTINES_CPP
+#define jam()           jamLine(15000 + __LINE__)
+#define jamEntry()      jamEntryLine(15000 + __LINE__)
+#endif
+#ifdef DBTUP_COMMIT_CPP
+#define jam()           jamLine(20000 + __LINE__)
+#define jamEntry()      jamEntryLine(20000 + __LINE__)
+#endif
+#ifdef DBTUP_FIXALLOC_CPP
+#define jam()           jamLine(25000 + __LINE__)
+#define jamEntry()      jamEntryLine(25000 + __LINE__)
+#endif
+#ifdef DBTUP_TRIGGER_CPP
+#define jam()           jamLine(30000 + __LINE__)
+#define jamEntry()      jamEntryLine(30000 + __LINE__)
+#endif
+#ifdef DBTUP_ABORT_CPP
+#define jam()           jamLine(35000 + __LINE__)
+#define jamEntry()      jamEntryLine(35000 + __LINE__)
+#endif
+#ifdef DBTUP_PAGE_MAP_CPP
+#define jam()           jamLine(40000 + __LINE__)
+#define jamEntry()      jamEntryLine(40000 + __LINE__)
+#endif
+#ifdef DBTUP_PAG_MAN_CPP
+#define jam()           jamLine(45000 + __LINE__)
+#define jamEntry()      jamEntryLine(45000 + __LINE__)
+#endif
+#ifdef DBTUP_STORE_PROC_DEF_CPP
+#define jam()           jamLine(50000 + __LINE__)
+#define jamEntry()      jamEntryLine(50000 + __LINE__)
+#endif
+#ifdef DBTUP_META_CPP
+#define jam()           jamLine(55000 + __LINE__)
+#define jamEntry()      jamEntryLine(55000 + __LINE__)
+#endif
+#ifdef DBTUP_TAB_DES_MAN_CPP
+#define jam()           jamLine(60000 + __LINE__)
+#define jamEntry()      jamEntryLine(60000 + __LINE__)
+#endif
+#ifdef DBTUP_GEN_CPP
+#define jam()           jamLine(65000 + __LINE__)
+#define jamEntry()      jamEntryLine(65000 + __LINE__)
+#endif
+#ifdef DBTUP_INDEX_CPP
+#define jam()           jamLine(70000 + __LINE__)
+#define jamEntry()      jamEntryLine(70000 + __LINE__)
+#endif
+#ifdef DBTUP_DEBUG_CPP
+#define jam()           jamLine(75000 + __LINE__)
+#define jamEntry()      jamEntryLine(75000 + __LINE__)
+#endif
+#ifdef DBTUP_VAR_ALLOC_CPP
+#define jam()           jamLine(80000 + __LINE__)
+#define jamEntry()      jamEntryLine(80000 + __LINE__)
+#endif
+#ifdef DBTUP_SCAN_CPP
+#define jam()           jamLine(85000 + __LINE__)
+#define jamEntry()      jamEntryLine(85000 + __LINE__)
+#endif
+#ifdef DBTUP_DISK_ALLOC_CPP
+#define jam()           jamLine(90000 + __LINE__)
+#define jamEntry()      jamEntryLine(90000 + __LINE__)
+#endif
+#ifndef jam
+#define jam()           jamLine(__LINE__)
+#define jamEntry()      jamEntryLine(__LINE__)
+#endif
+
 #ifdef VM_TRACE
 inline const char* dbgmask(const Bitmask<MAXNROFATTRIBUTESINWORDS>& bm) {
   static int i=0; static char buf[5][200];
@@ -70,22 +146,23 @@ inline const Uint32* ALIGN_WORD(const void* ptr)
 // only reports the line number in the file it currently is located in.
 // 
 // DbtupExecQuery.cpp         0
-// DbtupBuffer.cpp         2000
-// DbtupRoutines.cpp       3000
-// DbtupCommit.cpp         5000
-// DbtupFixAlloc.cpp       6000
-// DbtupTrigger.cpp        7000
-// DbtupAbort.cpp          9000
-// DbtupPageMap.cpp       14000
-// DbtupPagMan.cpp        16000
-// DbtupStoredProcDef.cpp 18000
-// DbtupMeta.cpp          20000
-// DbtupTabDesMan.cpp     22000
-// DbtupGen.cpp           24000
-// DbtupIndex.cpp         28000
-// DbtupDebug.cpp         30000
-// DbtupVarAlloc.cpp      32000
-// DbtupScan.cpp          33000
+// DbtupBuffer.cpp         10000
+// DbtupRoutines.cpp       15000
+// DbtupCommit.cpp         20000
+// DbtupFixAlloc.cpp       25000
+// DbtupTrigger.cpp        30000
+// DbtupAbort.cpp          35000
+// DbtupPageMap.cpp        40000
+// DbtupPagMan.cpp         45000
+// DbtupStoredProcDef.cpp  50000
+// DbtupMeta.cpp           55000
+// DbtupTabDesMan.cpp      60000
+// DbtupGen.cpp            65000
+// DbtupIndex.cpp          70000
+// DbtupDebug.cpp          75000
+// DbtupVarAlloc.cpp       80000
+// DbtupScan.cpp           85000
+// DbtupDiskAlloc.cpp      90000
 //------------------------------------------------------------------
 
 /*
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp
index 2414e8a10bf..b3ecbc4f435 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp
@@ -14,21 +14,19 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_ABORT_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
 #include <pc.hpp>
 
-#define ljam() { jamLine(9000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(9000 + __LINE__); }
-
 void Dbtup::freeAllAttrBuffers(Operationrec*  const regOperPtr)
 {
   if (regOperPtr->storedProcedureId == RNIL) {
-    ljam();
+    jam();
     freeAttrinbufrec(regOperPtr->firstAttrinbufrec);
   } else {
-    ljam();
+    jam();
     StoredProcPtr storedPtr;
     c_storedProcPool.getPtr(storedPtr, (Uint32)regOperPtr->storedProcedureId);
     ndbrequire(storedPtr.p->storedCode == ZSCAN_PROCEDURE);
@@ -46,7 +44,7 @@ void Dbtup::freeAttrinbufrec(Uint32 anAttrBuf)
   Uint32 RnoFree = cnoFreeAttrbufrec;
   localAttrBufPtr.i = anAttrBuf;
   while (localAttrBufPtr.i != RNIL) {
-    ljam();
+    jam();
     ptrCheckGuard(localAttrBufPtr, cnoOfAttrbufrec, attrbufrec);
     Ttemp = localAttrBufPtr.p->attrbuf[ZBUF_NEXT];
     localAttrBufPtr.p->attrbuf[ZBUF_NEXT] = cfirstfreeAttrbufrec;
@@ -62,7 +60,7 @@ void Dbtup::freeAttrinbufrec(Uint32 anAttrBuf)
  */
 void Dbtup::execTUP_ABORTREQ(Signal* signal) 
 {
-  ljamEntry();
+  jamEntry();
   do_tup_abortreq(signal, 0);
 }
 
@@ -80,7 +78,7 @@ void Dbtup::do_tup_abortreq(Signal* signal, Uint32 flags)
              (trans_state == TRANS_ERROR_WAIT_TUPKEYREQ) ||
              (trans_state == TRANS_IDLE));
   if (regOperPtr.p->op_struct.op_type == ZREAD) {
-    ljam();
+    jam();
     freeAllAttrBuffers(regOperPtr.p);
     initOpConnection(regOperPtr.p);
     return;
@@ -94,7 +92,7 @@ void Dbtup::do_tup_abortreq(Signal* signal, Uint32 flags)
 
   if (get_tuple_state(regOperPtr.p) == TUPLE_PREPARED)
   {
-    ljam();
+    jam();
     if (!regTabPtr.p->tuxCustomTriggers.isEmpty() &&
         (flags & ZSKIP_TUX_TRIGGERS) == 0)
       executeTuxAbortTriggers(signal,
@@ -105,12 +103,12 @@ void Dbtup::do_tup_abortreq(Signal* signal, Uint32 flags)
     OperationrecPtr loopOpPtr;
     loopOpPtr.i = regOperPtr.p->nextActiveOp;
     while (loopOpPtr.i != RNIL) {
-      ljam();
+      jam();
       c_operation_pool.getPtr(loopOpPtr);
       if (get_tuple_state(loopOpPtr.p) != TUPLE_ALREADY_ABORTED &&
 	  !regTabPtr.p->tuxCustomTriggers.isEmpty() &&
           (flags & ZSKIP_TUX_TRIGGERS) == 0) {
-        ljam();
+        jam();
         executeTuxAbortTriggers(signal,
                                 loopOpPtr.p,
                                 regFragPtr.p,
@@ -211,116 +209,116 @@ int Dbtup::TUPKEY_abort(Signal* signal, int error_type)
   case 1:
 //tmupdate_alloc_error:
     terrorCode= ZMEM_NOMEM_ERROR;
-    ljam();
+    jam();
     break;
 
   case 15:
-    ljam();
+    jam();
     terrorCode = ZREGISTER_INIT_ERROR;
     break;
 
   case 16:
-    ljam();
+    jam();
     terrorCode = ZTRY_TO_UPDATE_ERROR;
     break;
 
   case 17:
-    ljam();
+    jam();
     terrorCode = ZNO_ILLEGAL_NULL_ATTR;
     break;
 
   case 19:
-    ljam();
+    jam();
     terrorCode = ZTRY_TO_UPDATE_ERROR;
     break;
 
   case 20:
-    ljam();
+    jam();
     terrorCode = ZREGISTER_INIT_ERROR;
     break;
 
   case 22:
-    ljam();
+    jam();
     terrorCode = ZTOTAL_LEN_ERROR;
     break;
 
   case 23:
-    ljam();
+    jam();
     terrorCode = ZREGISTER_INIT_ERROR;
     break;
 
   case 24:
-    ljam();
+    jam();
     terrorCode = ZREGISTER_INIT_ERROR;
     break;
 
   case 26:
-    ljam();
+    jam();
     terrorCode = ZREGISTER_INIT_ERROR;
     break;
 
   case 27:
-    ljam();
+    jam();
     terrorCode = ZREGISTER_INIT_ERROR;
     break;
 
   case 28:
-    ljam();
+    jam();
     terrorCode = ZREGISTER_INIT_ERROR;
     break;
 
   case 29:
-    ljam();
+    jam();
     break;
 
   case 30:
-    ljam();
+    jam();
     terrorCode = ZCALL_ERROR;
     break;
 
   case 31:
-    ljam();
+    jam();
     terrorCode = ZSTACK_OVERFLOW_ERROR;
     break;
 
   case 32:
-    ljam();
+    jam();
     terrorCode = ZSTACK_UNDERFLOW_ERROR;
     break;
 
   case 33:
-    ljam();
+    jam();
     terrorCode = ZNO_INSTRUCTION_ERROR;
     break;
 
   case 34:
-    ljam();
+    jam();
     terrorCode = ZOUTSIDE_OF_PROGRAM_ERROR;
     break;
 
   case 35:
-    ljam();
+    jam();
     terrorCode = ZTOO_MANY_INSTRUCTIONS_ERROR;
     break;
 
   case 38:
-    ljam();
+    jam();
     terrorCode = ZTEMPORARY_RESOURCE_FAILURE;
     break;
 
   case 39:
     if (get_trans_state(operPtr.p) == TRANS_TOO_MUCH_AI) {
-      ljam();
+      jam();
       terrorCode = ZTOO_MUCH_ATTRINFO_ERROR;
     } else if (get_trans_state(operPtr.p) == TRANS_ERROR_WAIT_TUPKEYREQ) {
-      ljam();
+      jam();
       terrorCode = ZSEIZE_ATTRINBUFREC_ERROR;
     } else {
       ndbrequire(false);
     }//if
     break;
   case 40:
-    ljam();
+    jam();
     terrorCode = ZUNSUPPORTED_BRANCH;
     break;
   default:
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp
index 60c0c22ae6c..adac4d3d460 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp
@@ -14,28 +14,26 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_BUFFER_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
 #include <pc.hpp>
 #include <signaldata/TransIdAI.hpp>
 
-#define ljam() { jamLine(2000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(2000 + __LINE__); }
-
 void Dbtup::execSEND_PACKED(Signal* signal)
 {
   Uint16 hostId;
   Uint32 i;
   Uint32 TpackedListIndex= cpackedListIndex;
-  ljamEntry();
+  jamEntry();
   for (i= 0; i < TpackedListIndex; i++) {
-    ljam();
+    jam();
     hostId= cpackedList[i];
     ndbrequire((hostId - 1) < (MAX_NODES - 1)); // Also check not zero
     Uint32 TpacketTA= hostBuffer[hostId].noOfPacketsTA;
     if (TpacketTA != 0) {
-      ljam();
+      jam();
       BlockReference TBref= numberToRef(API_PACKED, hostId);
       Uint32 TpacketLen= hostBuffer[hostId].packetLenTA;
       MEMCOPY_NO_WORDS(&signal->theData[0],
@@ -73,7 +71,7 @@ void Dbtup::bufferTRANSID_AI(Signal* signal, BlockReference aRef,
 // There is still space in the buffer. We will copy it into the
 // buffer.
 // ----------------------------------------------------------------
-    ljam();
+    jam();
     updatePackedList(signal, hostId);
   } else if (false && TnoOfPackets == 1) {
 // ----------------------------------------------------------------
@@ -118,7 +116,7 @@ void Dbtup::updatePackedList(Signal* signal, Uint16 hostId)
 {
   if (hostBuffer[hostId].inPackedList == false) {
     Uint32 TpackedListIndex= cpackedListIndex;
-    ljam();
+    jam();
     hostBuffer[hostId].inPackedList= true;
     cpackedList[TpackedListIndex]= hostId;
     cpackedListIndex= TpackedListIndex + 1;
@@ -149,7 +147,7 @@ void Dbtup::sendReadAttrinfo(Signal* signal,
 
   if (ERROR_INSERTED(4006) && (nodeId != getOwnNodeId())){
     // Use error insert to turn routing on
-    ljam();
+    jam();
     connectedToNode= false;    
   }
 
@@ -167,18 +165,18 @@ void Dbtup::sendReadAttrinfo(Signal* signal,
      * Own node -> execute direct
      */
     if(nodeId != getOwnNodeId()){
-      ljam();
+      jam();
     
       /**
        * Send long sig
        */
       if (ToutBufIndex >= 22 && is_api && !old_dest) {
-	ljam();
+	jam();
 	/**
 	 * Flush buffer so that order is maintained
 	 */
 	if (TpacketTA != 0) {
-	  ljam();
+	  jam();
 	  BlockReference TBref = numberToRef(API_PACKED, nodeId);
 	  MEMCOPY_NO_WORDS(&signal->theData[0],
 			   &hostBuffer[nodeId].packetBufferTA[0],
@@ -202,7 +200,7 @@ void Dbtup::sendReadAttrinfo(Signal* signal,
        */
 #ifndef NDB_NO_DROPPED_SIGNAL
       if (ToutBufIndex < 22 && is_api){
-	ljam();
+	jam();
 	bufferTRANSID_AI(signal, recBlockref, 3+ToutBufIndex);
 	return;
       }
@@ -214,7 +212,7 @@ void Dbtup::sendReadAttrinfo(Signal* signal,
       Uint32 * src= signal->theData+25;
       if (ToutBufIndex >= 22){
 	do {
-	  ljam();
+	  jam();
 	  MEMCOPY_NO_WORDS(&signal->theData[3], src, 22);
 	  sendSignal(recBlockref, GSN_TRANSID_AI, signal, 25, JBB);
 	  ToutBufIndex -= 22;
@@ -223,14 +221,14 @@ void Dbtup::sendReadAttrinfo(Signal* signal,
       }
       
       if (ToutBufIndex > 0){
-	ljam();
+	jam();
 	MEMCOPY_NO_WORDS(&signal->theData[3], src, ToutBufIndex);
 	sendSignal(recBlockref, GSN_TRANSID_AI, signal, 3+ToutBufIndex, JBB);
       }
       return;
     }
     EXECUTE_DIRECT(block, GSN_TRANSID_AI, signal, 3 + ToutBufIndex);
-    ljamEntry();
+    jamEntry();
     return;
   }
 
@@ -242,7 +240,7 @@ void Dbtup::sendReadAttrinfo(Signal* signal,
   Uint32 routeBlockref= req_struct->TC_ref;
   
   if (true){ // TODO is_api && !old_dest){
-    ljam();
+    jam();
     transIdAI->attrData[0]= recBlockref;
     LinearSectionPtr ptr[3];
     ptr[0].p= &signal->theData[25];
@@ -260,7 +258,7 @@ void Dbtup::sendReadAttrinfo(Signal* signal,
   Uint32 sent= 0;
   Uint32 maxLen= TransIdAI::DataLength - 1;
   while (sent < tot) {
-    ljam();      
+    jam();      
     Uint32 dataLen= (tot - sent > maxLen) ? maxLen : tot - sent;
     Uint32 sigLen= dataLen + TransIdAI::HeaderLength + 1; 
     MEMCOPY_NO_WORDS(&transIdAI->attrData,
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp
index 91d2ca97744..880c956185f 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp
@@ -14,6 +14,7 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_COMMIT_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
@@ -21,16 +22,13 @@
 #include <signaldata/TupCommit.hpp>
 #include "../dblqh/Dblqh.hpp"
 
-#define ljam() { jamLine(5000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(5000 + __LINE__); }
-
 void Dbtup::execTUP_DEALLOCREQ(Signal* signal)
 {
   TablerecPtr regTabPtr;
   FragrecordPtr regFragPtr;
   Uint32 frag_page_id, frag_id;
 
-  ljamEntry();
+  jamEntry();
 
   frag_id= signal->theData[0];
   regTabPtr.i= signal->theData[1];
@@ -62,7 +60,7 @@ void Dbtup::execTUP_DEALLOCREQ(Signal* signal)
     
     if (regTabPtr.p->m_attributes[MM].m_no_of_varsize)
     {
-      ljam();
+      jam();
       free_var_rec(regFragPtr.p, regTabPtr.p, &tmp, pagePtr);
     } else {
       free_fix_rec(regFragPtr.p, regTabPtr.p, &tmp, (Fix_page*)pagePtr.p);
@@ -78,7 +76,7 @@ void Dbtup::execTUP_WRITELOG_REQ(Signal* signal)
   Uint32 gci= signal->theData[1];
   c_operation_pool.getPtr(loopOpPtr);
   while (loopOpPtr.p->prevActiveOp != RNIL) {
-    ljam();
+    jam();
     loopOpPtr.i= loopOpPtr.p->prevActiveOp;
     c_operation_pool.getPtr(loopOpPtr);
   }
@@ -87,11 +85,11 @@ void Dbtup::execTUP_WRITELOG_REQ(Signal* signal)
     signal->theData[0]= loopOpPtr.p->userpointer;
     signal->theData[1]= gci;
     if (loopOpPtr.p->nextActiveOp == RNIL) {
-      ljam();
+      jam();
       EXECUTE_DIRECT(DBLQH, GSN_LQH_WRITELOG_REQ, signal, 2);
       return;
     }
-    ljam();
+    jam();
     EXECUTE_DIRECT(DBLQH, GSN_LQH_WRITELOG_REQ, signal, 2);
     jamEntry();
     loopOpPtr.i= loopOpPtr.p->nextActiveOp;
@@ -114,16 +112,16 @@ void Dbtup::removeActiveOpList(Operationrec*  const regOperPtr,
   if (regOperPtr->op_struct.in_active_list) {
     regOperPtr->op_struct.in_active_list= false;
     if (regOperPtr->nextActiveOp != RNIL) {
-      ljam();
+      jam();
       raoOperPtr.i= regOperPtr->nextActiveOp;
       c_operation_pool.getPtr(raoOperPtr);
       raoOperPtr.p->prevActiveOp= regOperPtr->prevActiveOp;
     } else {
-      ljam();
+      jam();
       tuple_ptr->m_operation_ptr_i = regOperPtr->prevActiveOp;
     }
     if (regOperPtr->prevActiveOp != RNIL) {
-      ljam();
+      jam();
       raoOperPtr.i= regOperPtr->prevActiveOp;
       c_operation_pool.getPtr(raoOperPtr);
       raoOperPtr.p->nextActiveOp= regOperPtr->nextActiveOp;
@@ -343,7 +341,7 @@ Dbtup::disk_page_commit_callback(Signal* signal,
   Uint32 gci;
   OperationrecPtr regOperPtr;
 
-  ljamEntry();
+  jamEntry();
   
   c_operation_pool.getPtr(regOperPtr, opPtrI);
   c_lqh->get_op_info(regOperPtr.p->userpointer, &hash_value, &gci);
@@ -379,7 +377,7 @@ Dbtup::disk_page_log_buffer_callback(Signal* signal,
   Uint32 gci;
   OperationrecPtr regOperPtr;
 
-  ljamEntry();
+  jamEntry();
   
   c_operation_pool.getPtr(regOperPtr, opPtrI);
   c_lqh->get_op_info(regOperPtr.p->userpointer, &hash_value, &gci);
@@ -447,7 +445,7 @@ void Dbtup::execTUP_COMMITREQ(Signal* signal)
   TupCommitReq * const tupCommitReq= (TupCommitReq *)signal->getDataPtr();
 
   regOperPtr.i= tupCommitReq->opPtr;
-  ljamEntry();
+  jamEntry();
 
   c_operation_pool.getPtr(regOperPtr);
   if(!regOperPtr.p->is_first_operation())
@@ -603,7 +601,7 @@ skip_disk:
      *   why can't we instead remove "own version" (when approriate ofcourse)
      */
     if (!regTabPtr.p->tuxCustomTriggers.isEmpty()) {
-      ljam();
+      jam();
       OperationrecPtr loopPtr= regOperPtr;
       while(loopPtr.i != RNIL)
       {
@@ -656,18 +654,18 @@ Dbtup::set_change_mask_info(KeyReqStruct * const req_struct,
 {
   ChangeMaskState state = get_change_mask_state(regOperPtr);
   if (state == USE_SAVED_CHANGE_MASK) {
-    ljam();
+    jam();
     req_struct->changeMask.setWord(0, regOperPtr->saved_change_mask[0]);
     req_struct->changeMask.setWord(1, regOperPtr->saved_change_mask[1]);
   } else if (state == RECALCULATE_CHANGE_MASK) {
-    ljam();
+    jam();
     // Recompute change mask, for now set all bits
     req_struct->changeMask.set();
   } else if (state == SET_ALL_MASK) {
-    ljam();
+    jam();
     req_struct->changeMask.set();
   } else {
-    ljam();
+    jam();
     ndbrequire(state == DELETE_CHANGES);
     req_struct->changeMask.set();
   }
@@ -687,17 +685,17 @@ Dbtup::calculateChangeMask(Page* const pagePtr,
     ndbrequire(loopOpPtr.p->op_struct.op_type == ZUPDATE);
     ChangeMaskState change_mask= get_change_mask_state(loopOpPtr.p);
     if (change_mask == USE_SAVED_CHANGE_MASK) {
-      ljam();
+      jam();
       saved_word1|= loopOpPtr.p->saved_change_mask[0];
       saved_word2|= loopOpPtr.p->saved_change_mask[1];
     } else if (change_mask == RECALCULATE_CHANGE_MASK) {
-      ljam();
+      jam();
       //Recompute change mask, for now set all bits
       req_struct->changeMask.set();
       return;
     } else {
       ndbrequire(change_mask == SET_ALL_MASK);
-      ljam();
+      jam();
       req_struct->changeMask.set();
       return;
     }
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp
index ccb0bdcb537..708b4e0e8d7 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp
@@ -15,6 +15,7 @@
 
 
 #define DBTUP_C
+#define DBTUP_DEBUG_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
@@ -24,9 +25,6 @@
 #include <signaldata/EventReport.hpp>
 #include <Vector.hpp>
 
-#define ljam() { jamLine(30000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(30000 + __LINE__); }
-
 /* **************************************************************** */
 /* ---------------------------------------------------------------- */
 /* ------------------------ DEBUG MODULE -------------------------- */
@@ -35,7 +33,7 @@
 void Dbtup::execDEBUG_SIG(Signal* signal) 
 {
   PagePtr regPagePtr;
-  ljamEntry();
+  jamEntry();
   regPagePtr.i = signal->theData[0];
   c_page_pool.getPtr(regPagePtr);
 }//Dbtup::execDEBUG_SIG()
@@ -248,18 +246,18 @@ void Dbtup::execMEMCHECKREQ(Signal* signal)
   PagePtr regPagePtr;
   Uint32* data = &signal->theData[0];
 
-  ljamEntry();
+  jamEntry();
   BlockReference blockref = signal->theData[0];
   Uint32 i;
   for (i = 0; i < 25; i++) {
-    ljam();
+    jam();
     data[i] = 0;
   }//for
   for (i = 0; i < 16; i++) {
     regPagePtr.i = cfreepageList[i];
-    ljam();
+    jam();
     while (regPagePtr.i != RNIL) {
-      ljam();
+      jam();
       ptrCheckGuard(regPagePtr, cnoOfPage, cpage);
       regPagePtr.i = regPagePtr.p->next_page;
       data[0]++;
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp
index f865904b413..1c3986afbbd 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp
@@ -14,6 +14,7 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_DISK_ALLOC_CPP
 #include "Dbtup.hpp"
 
 static bool f_undo_done = true;
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp
index 50500b96134..31903ea8c33 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp
@@ -14,14 +14,12 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_FIXALLOC_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
 #include <pc.hpp>
 
-#define ljam() { jamLine(6000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(6000 + __LINE__); }
-
 //
 // Fixed Allocator
 // This module is used to allocate and free fixed size tuples from the
@@ -79,7 +77,7 @@ Dbtup::alloc_fix_rec(Fragrecord* const regFragPtr,
 /* ---------------------------------------------------------------- */
     pagePtr.i = getEmptyPage(regFragPtr);
     if (pagePtr.i != RNIL) {
-      ljam();
+      jam();
 /* ---------------------------------------------------------------- */
 // We found empty pages on the fragment. Allocate an empty page and
 // convert it into a tuple header page and put it in thFreeFirst-list.
@@ -95,14 +93,14 @@ Dbtup::alloc_fix_rec(Fragrecord* const regFragPtr,
       LocalDLList<Page> free_pages(c_page_pool, regFragPtr->thFreeFirst);    
       free_pages.add(pagePtr);
     } else {
-      ljam();
+      jam();
 /* ---------------------------------------------------------------- */
 /*       THERE ARE NO EMPTY PAGES. MEMORY CAN NOT BE ALLOCATED.     */
 /* ---------------------------------------------------------------- */
       return 0;
     }
   } else {
-    ljam();
+    jam();
 /* ---------------------------------------------------------------- */
 /*       THIS SHOULD BE THE COMMON PATH THROUGH THE CODE, FREE      */
 /*       COPY PAGE EXISTED.                                         */
@@ -193,7 +191,7 @@ void Dbtup::free_fix_rec(Fragrecord* regFragPtr,
   
   if(free == 1)
   {
-    ljam();
+    jam();
     PagePtr pagePtr = { (Page*)regPagePtr, key->m_page_no };
     LocalDLList<Page> free_pages(c_page_pool, regFragPtr->thFreeFirst);    
     ndbrequire(regPagePtr->page_state == ZTH_MM_FULL);
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp
index 67fc5a4ceb0..db3399d795a 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp
@@ -15,6 +15,7 @@
 
 
 #define DBTUP_C
+#define DBTUP_GEN_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
@@ -34,9 +35,6 @@
 
 #define DEBUG(x) { ndbout << "TUP::" << x << endl; }
 
-#define ljam() { jamLine(24000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(24000 + __LINE__); }
-
 void Dbtup::initData() 
 {
   cnoOfAttrbufrec = ZNO_OF_ATTRBUFREC;
@@ -151,21 +149,21 @@ BLOCK_FUNCTIONS(Dbtup)
 
 void Dbtup::execCONTINUEB(Signal* signal) 
 {
-  ljamEntry();
+  jamEntry();
   Uint32 actionType = signal->theData[0];
   Uint32 dataPtr = signal->theData[1];
   switch (actionType) {
   case ZINITIALISE_RECORDS:
-    ljam();
+    jam();
     initialiseRecordsLab(signal, dataPtr, 
 			 signal->theData[2], signal->theData[3]);
     break;
   case ZREL_FRAG:
-    ljam();
+    jam();
     releaseFragment(signal, dataPtr, signal->theData[2]);
     break;
   case ZREPORT_MEMORY_USAGE:{
-    ljam();
+    jam();
     static int c_currentMemUsed = 0;
     Uint32 cnt = signal->theData[1];
     Uint32 tmp = c_page_pool.getSize();
@@ -200,11 +198,11 @@ void Dbtup::execCONTINUEB(Signal* signal)
     return;
   }
   case ZBUILD_INDEX:
-    ljam();
+    jam();
     buildIndex(signal, dataPtr);
     break;
   case ZTUP_SCAN:
-    ljam();
+    jam();
     {
       ScanOpPtr scanPtr;
       c_scanOpPool.getPtr(scanPtr, dataPtr);
@@ -213,7 +211,7 @@ void Dbtup::execCONTINUEB(Signal* signal)
     return;
   case ZFREE_EXTENT:
   {
-    ljam();
+    jam();
     
     TablerecPtr tabPtr;
     tabPtr.i= dataPtr;
@@ -226,7 +224,7 @@ void Dbtup::execCONTINUEB(Signal* signal)
   }
   case ZUNMAP_PAGES:
   {
-    ljam();
+    jam();
     
     TablerecPtr tabPtr;
     tabPtr.i= dataPtr;
@@ -239,7 +237,7 @@ void Dbtup::execCONTINUEB(Signal* signal)
   }
   case ZFREE_VAR_PAGES:
   {
-    ljam();
+    jam();
     drop_fragment_free_var_pages(signal);
     return;
   }
@@ -256,12 +254,12 @@ void Dbtup::execCONTINUEB(Signal* signal)
 /* **************************************************************** */
 void Dbtup::execSTTOR(Signal* signal) 
 {
-  ljamEntry();
+  jamEntry();
   Uint32 startPhase = signal->theData[1];
   Uint32 sigKey = signal->theData[6];
   switch (startPhase) {
   case ZSTARTPHASE1:
-    ljam();
+    jam();
     CLEAR_ERROR_INSERT_VALUE;
     ndbrequire((c_lqh= (Dblqh*)globalData.getBlock(DBLQH)) != 0);
     ndbrequire((c_tsman= (Tsman*)globalData.getBlock(TSMAN)) != 0);
@@ -269,7 +267,7 @@ void Dbtup::execSTTOR(Signal* signal)
     cownref = calcTupBlockRef(0);
     break;
   default:
-    ljam();
+    jam();
     break;
   }//switch
   signal->theData[0] = sigKey;
@@ -292,7 +290,7 @@ void Dbtup::execREAD_CONFIG_REQ(Signal* signal)
   Uint32 senderData = req->senderData;
   ndbrequire(req->noOfParameters == 0);
   
-  ljamEntry();
+  jamEntry();
 
   const ndb_mgm_configuration_iterator * p = 
     m_ctx.m_config.getOwnConfigIterator();
@@ -412,58 +410,58 @@ void Dbtup::initialiseRecordsLab(Signal* signal, Uint32 switchData,
 {
   switch (switchData) {
   case 0:
-    ljam();
+    jam();
     initializeHostBuffer();
     break;
   case 1:
-    ljam();
+    jam();
     initializeOperationrec();
     break;
   case 2:
-    ljam();
+    jam();
     initializePage();
     break;
   case 3:
-    ljam();
+    jam();
     break;
   case 4:
-    ljam();
+    jam();
     initializeTablerec();
     break;
   case 5:
-    ljam();
+    jam();
     break;
   case 6:
-    ljam();
+    jam();
     initializeFragrecord();
     break;
   case 7:
-    ljam();
+    jam();
     initializeFragoperrec();
     break;
   case 8:
-    ljam();
+    jam();
     initializePageRange();
     break;
   case 9:
-    ljam();
+    jam();
     initializeTabDescr();
     break;
   case 10:
-    ljam();
+    jam();
     break;
   case 11:
-    ljam();
+    jam();
     break;
   case 12:
-    ljam();
+    jam();
     initializeAttrbufrec();
     break;
   case 13:
-    ljam();
+    jam();
     break;
   case 14:
-    ljam();
+    jam();
 
     {
       ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend();
@@ -487,28 +485,28 @@ void Dbtup::initialiseRecordsLab(Signal* signal, Uint32 switchData,
 
 void Dbtup::execNDB_STTOR(Signal* signal) 
 {
-  ljamEntry();
+  jamEntry();
   cndbcntrRef = signal->theData[0];
   Uint32 ownNodeId = signal->theData[1];
   Uint32 startPhase = signal->theData[2];
   switch (startPhase) {
   case ZSTARTPHASE1:
-    ljam();
+    jam();
     cownNodeId = ownNodeId;
     cownref = calcTupBlockRef(ownNodeId);
     break;
   case ZSTARTPHASE2:
-    ljam();
+    jam();
     break;
   case ZSTARTPHASE3:
-    ljam();
+    jam();
     startphase3Lab(signal, ~0, ~0);
     break;
   case ZSTARTPHASE4:
-    ljam();
+    jam();
     break;
   case ZSTARTPHASE6:
-    ljam();
+    jam();
 /*****************************************/
 /*       NOW SET THE DISK WRITE SPEED TO */
 /*       PAGES PER TICK AFTER SYSTEM     */
@@ -519,7 +517,7 @@ void Dbtup::execNDB_STTOR(Signal* signal)
     sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 1000, 1);    
     break;
   default:
-    ljam();
+    jam();
     break;
   }//switch
   signal->theData[0] = cownref;
@@ -596,7 +594,7 @@ void Dbtup::initializeTablerec()
 {
   TablerecPtr regTabPtr;
   for (regTabPtr.i = 0; regTabPtr.i < cnoOfTablerec; regTabPtr.i++) {
-    ljam();
+    jam();
     refresh_watch_dog();
     ptrAss(regTabPtr, tablerec);
     initTab(regTabPtr.p);
@@ -667,12 +665,12 @@ void Dbtup::initializeTabDescr()
 void Dbtup::execTUPSEIZEREQ(Signal* signal)
 {
   OperationrecPtr regOperPtr;
-  ljamEntry();
+  jamEntry();
   Uint32 userPtr = signal->theData[0];
   BlockReference userRef = signal->theData[1];
   if (!c_operation_pool.seize(regOperPtr))
   {
-    ljam();
+    jam();
     signal->theData[0] = userPtr;
     signal->theData[1] = ZGET_OPREC_ERROR;
     sendSignal(userRef, GSN_TUPSEIZEREF, signal, 2, JBB);
@@ -706,7 +704,7 @@ void Dbtup::execTUPSEIZEREQ(Signal* signal)
 void Dbtup::execTUPRELEASEREQ(Signal* signal) 
 {
   OperationrecPtr regOperPtr;
-  ljamEntry();
+  jamEntry();
   regOperPtr.i = signal->theData[0];
   c_operation_pool.getPtr(regOperPtr);
   set_trans_state(regOperPtr.p, TRANS_DISCONNECTED);
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp
index 3f42f0151e6..e4a26f8ccd0 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp
@@ -14,6 +14,7 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_INDEX_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
@@ -23,9 +24,6 @@
 #include <AttributeHeader.hpp>
 #include <signaldata/TuxMaint.hpp>
 
-#define ljam() { jamLine(28000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(28000 + __LINE__); }
-
 // methods used by ordered index
 
 void
@@ -34,7 +32,7 @@ Dbtup::tuxGetTupAddr(Uint32 fragPtrI,
                      Uint32 pageIndex,
                      Uint32& tupAddr)
 {
-  ljamEntry();
+  jamEntry();
   PagePtr pagePtr;
   c_page_pool.getPtr(pagePtr, pageId);
   Uint32 fragPageId= pagePtr.p->frag_page_id;
@@ -48,7 +46,7 @@ Dbtup::tuxAllocNode(Signal* signal,
                     Uint32& pageOffset,
                     Uint32*& node)
 {
-  ljamEntry();
+  jamEntry();
   FragrecordPtr fragPtr;
   fragPtr.i= fragPtrI;
   ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
@@ -61,7 +59,7 @@ Dbtup::tuxAllocNode(Signal* signal,
   Uint32* ptr, frag_page_id;
   if ((ptr= alloc_fix_rec(fragPtr.p, tablePtr.p, &key, &frag_page_id)) == 0)
   {
-    ljam();
+    jam();
     terrorCode = ZMEM_NOMEM_ERROR; // caller sets error
     return terrorCode;
   }
@@ -82,7 +80,7 @@ Dbtup::tuxFreeNode(Signal* signal,
                    Uint32 pageOffset,
                    Uint32* node)
 {
-  ljamEntry();
+  jamEntry();
   FragrecordPtr fragPtr;
   fragPtr.i= fragPtrI;
   ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
@@ -105,7 +103,7 @@ Dbtup::tuxGetNode(Uint32 fragPtrI,
                   Uint32 pageOffset,
                   Uint32*& node)
 {
-  ljamEntry();
+  jamEntry();
   FragrecordPtr fragPtr;
   fragPtr.i= fragPtrI;
   ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
@@ -130,7 +128,7 @@ Dbtup::tuxReadAttrs(Uint32 fragPtrI,
                     Uint32 numAttrs,
                     Uint32* dataOut)
 {
-  ljamEntry();
+  jamEntry();
   // use own variables instead of globals
   FragrecordPtr fragPtr;
   fragPtr.i= fragPtrI;
@@ -150,21 +148,21 @@ Dbtup::tuxReadAttrs(Uint32 fragPtrI,
   Tuple_header *tuple_ptr= req_struct.m_tuple_ptr;
   if (tuple_ptr->get_tuple_version() != tupVersion)
   {
-    ljam();
+    jam();
     OperationrecPtr opPtr;
     opPtr.i= tuple_ptr->m_operation_ptr_i;
     Uint32 loopGuard= 0;
     while (opPtr.i != RNIL) {
       c_operation_pool.getPtr(opPtr);
       if (opPtr.p->tupVersion == tupVersion) {
-	ljam();
+	jam();
 	if (!opPtr.p->m_copy_tuple_location.isNull()) {
 	  req_struct.m_tuple_ptr= (Tuple_header*)
 	    c_undo_buffer.get_ptr(&opPtr.p->m_copy_tuple_location);
         }
 	break;
       }
-      ljam();
+      jam();
       opPtr.i= opPtr.p->prevActiveOp;
       ndbrequire(++loopGuard < (1 << ZTUP_VERSION_BITS));
     }
@@ -202,7 +200,7 @@ Dbtup::tuxReadAttrs(Uint32 fragPtrI,
 int
 Dbtup::tuxReadPk(Uint32 fragPtrI, Uint32 pageId, Uint32 pageIndex, Uint32* dataOut, bool xfrmFlag)
 {
-  ljamEntry();
+  jamEntry();
   // use own variables instead of globals
   FragrecordPtr fragPtr;
   fragPtr.i= fragPtrI;
@@ -305,7 +303,7 @@ Dbtup::tuxReadPk(Uint32 fragPtrI, Uint32 pageId, Uint32 pageIndex, Uint32* dataO
 int
 Dbtup::accReadPk(Uint32 tableId, Uint32 fragId, Uint32 fragPageId, Uint32 pageIndex, Uint32* dataOut, bool xfrmFlag)
 {
-  ljamEntry();
+  jamEntry();
   // get table
   TablerecPtr tablePtr;
   tablePtr.i = tableId;
@@ -329,7 +327,7 @@ Dbtup::tuxQueryTh(Uint32 fragPtrI,
                   Uint32 transId2,
                   Uint32 savePointId)
 {
-  ljamEntry();
+  jamEntry();
   FragrecordPtr fragPtr;
   fragPtr.i= fragPtrI;
   ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
@@ -358,9 +356,9 @@ Dbtup::tuxQueryTh(Uint32 fragPtrI,
      * for this transaction and savepoint id.  If its tuple version
      * equals the requested then we have a visible tuple otherwise not.
      */
-    ljam();
+    jam();
     if (req_struct.m_tuple_ptr->get_tuple_version() == tupVersion) {
-      ljam();
+      jam();
       return true;
     }
   }
@@ -378,7 +376,7 @@ Dbtup::tuxQueryTh(Uint32 fragPtrI,
 void
 Dbtup::execBUILDINDXREQ(Signal* signal)
 {
-  ljamEntry();
+  jamEntry();
 #ifdef TIME_MEASUREMENT
   time_events= 0;
   tot_time_passed= 0;
@@ -387,7 +385,7 @@ Dbtup::execBUILDINDXREQ(Signal* signal)
   // get new operation
   BuildIndexPtr buildPtr;
   if (! c_buildIndexList.seize(buildPtr)) {
-    ljam();
+    jam();
     BuildIndexRec buildRec;
     memcpy(buildRec.m_request, signal->theData, sizeof(buildRec.m_request));
     buildRec.m_errorCode= BuildIndxRef::Busy;
@@ -402,7 +400,7 @@ Dbtup::execBUILDINDXREQ(Signal* signal)
   do {
     const BuildIndxReq* buildReq= (const BuildIndxReq*)buildPtr.p->m_request;
     if (buildReq->getTableId() >= cnoOfTablerec) {
-      ljam();
+      jam();
       buildPtr.p->m_errorCode= BuildIndxRef::InvalidPrimaryTable;
       break;
     }
@@ -410,7 +408,7 @@ Dbtup::execBUILDINDXREQ(Signal* signal)
     tablePtr.i= buildReq->getTableId();
     ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
     if (tablePtr.p->tableStatus != DEFINED) {
-      ljam();
+      jam();
       buildPtr.p->m_errorCode= BuildIndxRef::InvalidPrimaryTable;
       break;
     }
@@ -418,7 +416,7 @@ Dbtup::execBUILDINDXREQ(Signal* signal)
     buildPtr.p->m_build_vs =
       tablePtr.p->m_attributes[MM].m_no_of_varsize > 0;
     if (DictTabInfo::isOrderedIndex(buildReq->getIndexType())) {
-      ljam();
+      jam();
       const DLList<TupTriggerData>& triggerList = 
 	tablePtr.p->tuxCustomTriggers;
 
@@ -426,13 +424,13 @@ Dbtup::execBUILDINDXREQ(Signal* signal)
       triggerList.first(triggerPtr);
       while (triggerPtr.i != RNIL) {
 	if (triggerPtr.p->indexId == buildReq->getIndexId()) {
-	  ljam();
+	  jam();
 	  break;
 	}
 	triggerList.next(triggerPtr);
       }
       if (triggerPtr.i == RNIL) {
-	ljam();
+	jam();
 	// trigger was not created
 	buildPtr.p->m_errorCode = BuildIndxRef::InternalError;
 	break;
@@ -440,12 +438,12 @@ Dbtup::execBUILDINDXREQ(Signal* signal)
       buildPtr.p->m_indexId = buildReq->getIndexId();
       buildPtr.p->m_buildRef = DBTUX;
     } else if(buildReq->getIndexId() == RNIL) {
-      ljam();
+      jam();
       // REBUILD of acc
       buildPtr.p->m_indexId = RNIL;
       buildPtr.p->m_buildRef = DBACC;
     } else {
-      ljam();
+      jam();
       buildPtr.p->m_errorCode = BuildIndxRef::InvalidIndexType;
       break;
     }
@@ -490,7 +488,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
     // get fragment
     FragrecordPtr fragPtr;
     if (buildPtr.p->m_fragNo == MAX_FRAG_PER_NODE) {
-      ljam();
+      jam();
       // build ready
       buildIndexReply(signal, buildPtr.p);
       c_buildIndexList.release(buildPtr);
@@ -499,7 +497,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
     ndbrequire(buildPtr.p->m_fragNo < MAX_FRAG_PER_NODE);
     fragPtr.i= tablePtr.p->fragrec[buildPtr.p->m_fragNo];
     if (fragPtr.i == RNIL) {
-      ljam();
+      jam();
       buildPtr.p->m_fragNo++;
       buildPtr.p->m_pageId= 0;
       buildPtr.p->m_tupleNo= firstTupleNo;
@@ -509,7 +507,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
     // get page
     PagePtr pagePtr;
     if (buildPtr.p->m_pageId >= fragPtr.p->noOfPages) {
-      ljam();
+      jam();
       buildPtr.p->m_fragNo++;
       buildPtr.p->m_pageId= 0;
       buildPtr.p->m_tupleNo= firstTupleNo;
@@ -520,7 +518,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
     Uint32 pageState= pagePtr.p->page_state;
     // skip empty page
     if (pageState == ZEMPTY_MM) {
-      ljam();
+      jam();
       buildPtr.p->m_pageId++;
       buildPtr.p->m_tupleNo= firstTupleNo;
       break;
@@ -530,7 +528,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
     const Tuple_header* tuple_ptr = 0;
     pageIndex = buildPtr.p->m_tupleNo * tupheadsize;
     if (pageIndex + tupheadsize > Fix_page::DATA_WORDS) {
-      ljam();
+      jam();
       buildPtr.p->m_pageId++;
       buildPtr.p->m_tupleNo= firstTupleNo;
       break;
@@ -538,7 +536,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
     tuple_ptr = (Tuple_header*)&pagePtr.p->m_data[pageIndex];
     // skip over free tuple
     if (tuple_ptr->m_header_bits & Tuple_header::FREE) {
-      ljam();
+      jam();
       buildPtr.p->m_tupleNo++;
       break;
     }
@@ -581,7 +579,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
       tuple as a copy tuple. The original tuple is stable and is thus
       preferrable to store in TUX.
       */
-      ljam();
+      jam();
 
       /**
        * Since copy tuples now can't be found on real pages.
@@ -610,11 +608,11 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
       } while(req->errorCode == 0 && pageOperPtr.i != RNIL);
     } 
     
-    ljamEntry();
+    jamEntry();
     if (req->errorCode != 0) {
       switch (req->errorCode) {
       case TuxMaintReq::NoMemError:
-        ljam();
+        jam();
         buildPtr.p->m_errorCode= BuildIndxRef::AllocationFailure;
         break;
       default:
@@ -666,7 +664,7 @@ Dbtup::buildIndexReply(Signal* signal, const BuildIndexRec* buildPtrP)
   rep->setIndexId(buildReq->getIndexId());
   // conf
   if (buildPtrP->m_errorCode == BuildIndxRef::NoError) {
-    ljam();
+    jam();
     sendSignal(rep->getUserRef(), GSN_BUILDINDXCONF,
         signal, BuildIndxConf::SignalLength, JBB);
     return;
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
index e51638b8a20..cb3ec632362 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
@@ -15,6 +15,7 @@
 
 
 #define DBTUP_C
+#define DBTUP_META_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
@@ -29,16 +30,13 @@
 #include "AttributeOffset.hpp"
 #include <my_sys.h>
 
-#define ljam() { jamLine(20000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(20000 + __LINE__); }
-
 void Dbtup::execTUPFRAGREQ(Signal* signal)
 {
-  ljamEntry();
+  jamEntry();
 
   TupFragReq* tupFragReq = (TupFragReq*)signal->getDataPtr();
   if (tupFragReq->userPtr == (Uint32)-1) {
-    ljam();
+    jam();
     abortAddFragOp(signal);
     return;
   }
@@ -69,7 +67,7 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
 #ifndef VM_TRACE
   // config mismatch - do not crash if release compiled
   if (regTabPtr.i >= cnoOfTablerec) {
-    ljam();
+    jam();
     tupFragReq->userPtr = userptr;
     tupFragReq->userRef = 800;
     sendSignal(userblockref, GSN_TUPFRAGREF, signal, 2, JBB);
@@ -79,7 +77,7 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
 
   ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);
   if (cfirstfreeFragopr == RNIL) {
-    ljam();
+    jam();
     tupFragReq->userPtr = userptr;
     tupFragReq->userRef = ZNOFREE_FRAGOP_ERROR;
     sendSignal(userblockref, GSN_TUPFRAGREF, signal, 2, JBB);
@@ -108,29 +106,29 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
 
   getFragmentrec(regFragPtr, fragId, regTabPtr.p);
   if (regFragPtr.i != RNIL) {
-    ljam();
+    jam();
     terrorCode= ZEXIST_FRAG_ERROR;
     fragrefuse1Lab(signal, fragOperPtr);
     return;
   }
   if (cfirstfreefrag != RNIL) {
-    ljam();
+    jam();
     seizeFragrecord(regFragPtr);
   } else {
-    ljam();
+    jam();
     terrorCode= ZFULL_FRAGRECORD_ERROR;
     fragrefuse1Lab(signal, fragOperPtr);
     return;
   }
   initFragRange(regFragPtr.p);
   if (!addfragtotab(regTabPtr.p, fragId, regFragPtr.i)) {
-    ljam();
+    jam();
     terrorCode= ZNO_FREE_TAB_ENTRY_ERROR;
     fragrefuse2Lab(signal, fragOperPtr, regFragPtr);
     return;
   }
   if (cfirstfreerange == RNIL) {
-    ljam();
+    jam();
     terrorCode= ZNO_FREE_PAGE_RANGE_ERROR;
     fragrefuse3Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId);
     return;
@@ -146,7 +144,7 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
 
   if (ERROR_INSERTED(4007) && regTabPtr.p->fragid[0] == fragId ||
       ERROR_INSERTED(4008) && regTabPtr.p->fragid[1] == fragId) {
-    ljam();
+    jam();
     terrorCode = 1;
     fragrefuse4Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId);
     CLEAR_ERROR_INSERT_VALUE;
@@ -154,7 +152,7 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
   }
 
   if (regTabPtr.p->tableStatus == NOT_DEFINED) {
-    ljam();
+    jam();
 //-----------------------------------------------------------------------------
 // We are setting up references to the header of the tuple.
 // Active operation  This word contains a reference to the operation active
@@ -200,13 +198,13 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
     Uint32 offset[10];
     Uint32 tableDescriptorRef= allocTabDescr(regTabPtr.p, offset);
     if (tableDescriptorRef == RNIL) {
-      ljam();
+      jam();
       fragrefuse4Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId);
       return;
     }
     setUpDescriptorReferences(tableDescriptorRef, regTabPtr.p, offset);
   } else {
-    ljam();
+    jam();
     fragOperPtr.p->definingFragment= false;
   }
   signal->theData[0]= fragOperPtr.p->lqhPtrFrag;
@@ -222,9 +220,9 @@ bool Dbtup::addfragtotab(Tablerec* const regTabPtr,
                          Uint32 fragIndex) 
 {
   for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) {
-    ljam();
+    jam();
     if (regTabPtr->fragid[i] == RNIL) {
-      ljam();
+      jam();
       regTabPtr->fragid[i]= fragId;
       regTabPtr->fragrec[i]= fragIndex;
       return true;
@@ -238,9 +236,9 @@ void Dbtup::getFragmentrec(FragrecordPtr& regFragPtr,
                            Tablerec* const regTabPtr) 
 {
   for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) {
-    ljam();
+    jam();
     if (regTabPtr->fragid[i] == fragId) {
-      ljam();
+      jam();
       regFragPtr.i= regTabPtr->fragrec[i];
       ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
       return;
@@ -276,7 +274,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
   FragoperrecPtr fragOperPtr;
   TablerecPtr regTabPtr;
 
-  ljamEntry();
+  jamEntry();
   fragOperPtr.i= signal->theData[0];
   ptrCheckGuard(fragOperPtr, cnoOfFragoprec, fragoperrec);
   Uint32 attrId = signal->theData[2];
@@ -337,7 +335,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
   
   Uint32 attrDes2= 0;
   if (!AttributeDescriptor::getDynamic(attrDescriptor)) {
-    ljam();
+    jam();
     Uint32 pos= 0, null_pos;
     Uint32 bytes= AttributeDescriptor::getSizeInBytes(attrDescriptor);
     Uint32 words= (bytes + 3) / 4;
@@ -347,7 +345,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
 
     if (AttributeDescriptor::getNullable(attrDescriptor)) 
     {
-      ljam();
+      jam();
       fragOperPtr.p->m_null_bits[ind]++;
     } 
     else 
@@ -362,17 +360,17 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
     switch (AttributeDescriptor::getArrayType(attrDescriptor)) {
     case NDB_ARRAYTYPE_FIXED:
     {
-      ljam();
+      jam();
       regTabPtr.p->m_attributes[ind].m_no_of_fixsize++;
       if(attrLen != 0)
       {
-	ljam();
+	jam();
 	pos= fragOperPtr.p->m_fix_attributes_size[ind];
 	fragOperPtr.p->m_fix_attributes_size[ind] += words;
       }
       else
       {
-	ljam();
+	jam();
 	Uint32 bitCount = AttributeDescriptor::getArraySize(attrDescriptor);
 	fragOperPtr.p->m_null_bits[ind] += bitCount;
       }
@@ -380,7 +378,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
     }
     default:
     {
-      ljam();
+      jam();
       fragOperPtr.p->m_var_attributes_size[ind] += bytes;
       pos= regTabPtr.p->m_attributes[ind].m_no_of_varsize++;
       break;
@@ -397,13 +395,13 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
     ndbrequire(cs != NULL);
     Uint32 i = 0;
     while (i < fragOperPtr.p->charsetIndex) {
-      ljam();
+      jam();
       if (regTabPtr.p->charsetArray[i] == cs)
 	break;
       i++;
     }
     if (i == fragOperPtr.p->charsetIndex) {
-      ljam();
+      jam();
       fragOperPtr.p->charsetIndex++;
     }
     ndbrequire(i < regTabPtr.p->noOfCharsets);
@@ -416,7 +414,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
       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) {
-    ljam();
+    jam();
     terrorCode = 1;
     addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
     CLEAR_ERROR_INSERT_VALUE;
@@ -427,7 +425,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
 /* **************          TUP_ADD_ATTCONF       ****************** */
 /* **************************************************************** */
   if (! lastAttr) {
-    ljam();
+    jam();
     signal->theData[0] = fragOperPtr.p->lqhPtrFrag;
     signal->theData[1] = lastAttr;
     sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUP_ADD_ATTCONF, 
@@ -553,7 +551,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
     noAllocatedPages = allocFragPages(regFragPtr.p, noAllocatedPages);
 
     if (noAllocatedPages == 0) {
-      ljam();
+      jam();
       terrorCode = ZNO_PAGES_ALLOCATED_ERROR;
       addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
       return;
@@ -563,7 +561,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
   CreateFilegroupImplReq rep;
   if(regTabPtr.p->m_no_of_disk_attributes)
   {
-    ljam();
+    jam();
     Tablespace_client tsman(0, c_tsman, 0, 0, 
 			    regFragPtr.p->m_tablespace_id);
     ndbrequire(tsman.get_tablespace_info(&rep) == 0);
@@ -580,12 +578,12 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
   
   if (regTabPtr.p->m_no_of_disk_attributes)
   {
-    ljam();
+    jam();
     if(!(getNodeState().startLevel == NodeState::SL_STARTING && 
 	 getNodeState().starting.startPhase <= 4))
     {
       Callback cb;
-      ljam();
+      jam();
 
       cb.m_callbackData= fragOperPtr.i;
       cb.m_callbackFunction = 
@@ -599,7 +597,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
       int res= lgman.get_log_buffer(signal, sz, &cb);
       switch(res){
       case 0:
-        ljam();
+        jam();
 	signal->theData[0] = 1;
 	return;
       case -1:
@@ -718,11 +716,11 @@ void Dbtup::setUpKeyArray(Tablerec* const regTabPtr)
   Uint32* keyArray= &tableDescriptor[regTabPtr->readKeyArray].tabDescr;
   Uint32 countKeyAttr= 0;
   for (Uint32 i= 0; i < regTabPtr->m_no_of_attributes; i++) {
-    ljam();
+    jam();
     Uint32 refAttr= regTabPtr->tabDescriptor + (i * ZAD_SIZE);
     Uint32 attrDescriptor= getTabDescrWord(refAttr);
     if (AttributeDescriptor::getPrimaryKey(attrDescriptor)) {
-      ljam();
+      jam();
       AttributeHeader::init(&keyArray[countKeyAttr], i, 0);
       countKeyAttr++;
     }
@@ -742,7 +740,7 @@ void Dbtup::setUpKeyArray(Tablerec* const regTabPtr)
   {
     for (Uint32 i= 0; i < regTabPtr->m_no_of_attributes; i++) 
     {
-      ljam();
+      jam();
       Uint32 refAttr= regTabPtr->tabDescriptor + (i * ZAD_SIZE);
       Uint32 desc = getTabDescrWord(refAttr);
       Uint32 t = 0;
@@ -837,9 +835,9 @@ void Dbtup::releaseFragoperrec(FragoperrecPtr fragOperPtr)
 void Dbtup::deleteFragTab(Tablerec* const regTabPtr, Uint32 fragId) 
 {
   for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) {
-    ljam();
+    jam();
     if (regTabPtr->fragid[i] == fragId) {
-      ljam();
+      jam();
       regTabPtr->fragid[i]= RNIL;
       regTabPtr->fragrec[i]= RNIL;
       return;
@@ -865,7 +863,7 @@ void Dbtup::abortAddFragOp(Signal* signal)
 void
 Dbtup::execDROP_TAB_REQ(Signal* signal)
 {
-  ljamEntry();
+  jamEntry();
   if (ERROR_INSERTED(4013)) {
 #ifdef VM_TRACE
     verifytabdes();
@@ -891,7 +889,7 @@ void Dbtup::releaseTabDescr(Tablerec* const regTabPtr)
 {
   Uint32 descriptor= regTabPtr->readKeyArray;
   if (descriptor != RNIL) {
-    ljam();
+    jam();
     Uint32 offset[10];
     getTabDescrOffsets(regTabPtr, offset);
 
@@ -922,16 +920,16 @@ void Dbtup::releaseFragment(Signal* signal, Uint32 tableId,
   Uint32 fragId = RNIL;
   Uint32 i = 0;
   for (i = 0; i < MAX_FRAG_PER_NODE; i++) {
-    ljam();
+    jam();
     if (tabPtr.p->fragid[i] != RNIL) {
-      ljam();
+      jam();
       fragIndex= tabPtr.p->fragrec[i];
       fragId= tabPtr.p->fragid[i];
       break;
     }
   }
   if (fragIndex != RNIL) {
-    ljam();
+    jam();
     
     signal->theData[0] = ZUNMAP_PAGES;
     signal->theData[1] = tabPtr.i;
@@ -956,7 +954,7 @@ void Dbtup::releaseFragment(Signal* signal, Uint32 tableId,
     int res= lgman.get_log_buffer(signal, sz, &cb);
     switch(res){
     case 0:
-      ljam();
+      jam();
       return;
     case -1:
       ndbrequire("NOT YET IMPLEMENTED" == 0);
@@ -1087,7 +1085,7 @@ Dbtup::drop_fragment_free_extent(Signal *signal,
 	int res= lgman.get_log_buffer(signal, sz, &cb);
 	switch(res){
 	case 0:
-	  ljam();
+	  jam();
 	  return;
 	case -1:
 	  ndbrequire("NOT YET IMPLEMENTED" == 0);
@@ -1238,7 +1236,7 @@ Dbtup::drop_fragment_free_extent_log_buffer_callback(Signal* signal,
 void
 Dbtup::drop_fragment_free_var_pages(Signal* signal)
 {
-  ljam();
+  jam();
   Uint32 tableId = signal->theData[1];
   Uint32 fragPtrI = signal->theData[2];
   
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupPagMan.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupPagMan.cpp
index 73755494207..d10fabf42da 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupPagMan.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupPagMan.cpp
@@ -14,14 +14,12 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_PAG_MAN_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
 #include <pc.hpp>
 
-#define ljam() { jamLine(16000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(16000 + __LINE__); }
-
 /* ---------------------------------------------------------------- */
 // 4) Page Memory Manager (buddy algorithm)
 //
@@ -121,7 +119,7 @@ void Dbtup::initializePage()
   }//for
   PagePtr pagePtr;
   for (pagePtr.i = 0; pagePtr.i < c_page_pool.getSize(); pagePtr.i++) {
-    ljam();
+    jam();
     refresh_watch_dog();
     c_page_pool.getPtr(pagePtr);
     pagePtr.p->physical_page_id= RNIL;
@@ -153,16 +151,16 @@ void Dbtup::allocConsPages(Uint32 noOfPagesToAllocate,
                            Uint32& allocPageRef)
 {
   if (noOfPagesToAllocate == 0){ 
-    ljam();
+    jam();
     noOfPagesAllocated = 0;
     return;
   }//if
 
   Uint32 firstListToCheck = nextHigherTwoLog(noOfPagesToAllocate - 1);
   for (Uint32 i = firstListToCheck; i < 16; i++) {
-    ljam();
+    jam();
     if (cfreepageList[i] != RNIL) {
-      ljam();
+      jam();
 /* ---------------------------------------------------------------- */
 /*       PROPER AMOUNT OF PAGES WERE FOUND. NOW SPLIT THE FOUND     */
 /*       AREA AND RETURN THE PART NOT NEEDED.                       */
@@ -182,11 +180,11 @@ void Dbtup::allocConsPages(Uint32 noOfPagesToAllocate,
 /* ---------------------------------------------------------------- */
   if (firstListToCheck)
   {
-    ljam();
+    jam();
     for (Uint32 j = firstListToCheck - 1; (Uint32)~j; j--) {
-      ljam();
+      jam();
       if (cfreepageList[j] != RNIL) {
-	ljam();
+	jam();
 /* ---------------------------------------------------------------- */
 /*       SOME AREA WAS FOUND, ALLOCATE ALL OF IT.                   */
 /* ---------------------------------------------------------------- */
@@ -212,9 +210,9 @@ void Dbtup::allocConsPages(Uint32 noOfPagesToAllocate,
 void Dbtup::returnCommonArea(Uint32 retPageRef, Uint32 retNo) 
 {
   do {
-    ljam();
+    jam();
     if (retNo == 0) {
-      ljam();
+      jam();
       return;
     }//if
     Uint32 list = nextHigherTwoLog(retNo) - 1;
@@ -231,28 +229,28 @@ void Dbtup::findFreeLeftNeighbours(Uint32& allocPageRef,
   PagePtr pageFirstPtr, pageLastPtr;
   Uint32 remainAllocate = noOfPagesToAllocate - noPagesAllocated;
   while (allocPageRef > 0) {
-    ljam();
+    jam();
     pageLastPtr.i = allocPageRef - 1;
     c_page_pool.getPtr(pageLastPtr);
     if (pageLastPtr.p->page_state != ZFREE_COMMON) {
-      ljam();
+      jam();
       return;
     } else {
-      ljam();
+      jam();
       pageFirstPtr.i = pageLastPtr.p->first_cluster_page;
       ndbrequire(pageFirstPtr.i != RNIL);
       Uint32 list = nextHigherTwoLog(pageLastPtr.i - pageFirstPtr.i);
       removeCommonArea(pageFirstPtr.i, list);
       Uint32 listSize = 1 << list;
       if (listSize > remainAllocate) {
-        ljam();
+        jam();
         Uint32 retNo = listSize - remainAllocate;
         returnCommonArea(pageFirstPtr.i, retNo);
         allocPageRef = pageFirstPtr.i + retNo;
         noPagesAllocated = noOfPagesToAllocate;
         return;
       } else {
-        ljam();
+        jam();
         allocPageRef = pageFirstPtr.i;
         noPagesAllocated += listSize;
         remainAllocate -= listSize;
@@ -268,32 +266,32 @@ void Dbtup::findFreeRightNeighbours(Uint32& allocPageRef,
   PagePtr pageFirstPtr, pageLastPtr;
   Uint32 remainAllocate = noOfPagesToAllocate - noPagesAllocated;
   if (remainAllocate == 0) {
-    ljam();
+    jam();
     return;
   }//if
   while ((allocPageRef + noPagesAllocated) < c_page_pool.getSize()) {
-    ljam();
+    jam();
     pageFirstPtr.i = allocPageRef + noPagesAllocated;
     c_page_pool.getPtr(pageFirstPtr);
     if (pageFirstPtr.p->page_state != ZFREE_COMMON) {
-      ljam();
+      jam();
       return;
     } else {
-      ljam();
+      jam();
       pageLastPtr.i = pageFirstPtr.p->last_cluster_page;
       ndbrequire(pageLastPtr.i != RNIL);
       Uint32 list = nextHigherTwoLog(pageLastPtr.i - pageFirstPtr.i);
       removeCommonArea(pageFirstPtr.i, list);
       Uint32 listSize = 1 << list;
       if (listSize > remainAllocate) {
-        ljam();
+        jam();
         Uint32 retPageRef = pageFirstPtr.i + remainAllocate;
         Uint32 retNo = listSize - remainAllocate;
         returnCommonArea(retPageRef, retNo);
         noPagesAllocated += remainAllocate;
         return;
       } else {
-        ljam();
+        jam();
         noPagesAllocated += listSize;
         remainAllocate -= listSize;
       }//if
@@ -328,30 +326,30 @@ void Dbtup::removeCommonArea(Uint32 remPageRef, Uint32 list)
   c_page_pool.getPtr(remPagePtr, remPageRef);
   ndbrequire(list < 16);
   if (cfreepageList[list] == remPagePtr.i) {
-    ljam();
+    jam();
     cfreepageList[list] = remPagePtr.p->next_cluster_page;
     pageNextPtr.i = cfreepageList[list];
     if (pageNextPtr.i != RNIL) {
-      ljam();
+      jam();
       c_page_pool.getPtr(pageNextPtr);
       pageNextPtr.p->prev_cluster_page = RNIL;
     }//if
   } else {
     pageSearchPtr.i = cfreepageList[list];
     while (true) {
-      ljam();
+      jam();
       c_page_pool.getPtr(pageSearchPtr);
       pagePrevPtr = pageSearchPtr;
       pageSearchPtr.i = pageSearchPtr.p->next_cluster_page;
       if (pageSearchPtr.i == remPagePtr.i) {
-        ljam();
+        jam();
         break;
       }//if
     }//while
     pageNextPtr.i = remPagePtr.p->next_cluster_page;
     pagePrevPtr.p->next_cluster_page = pageNextPtr.i;
     if (pageNextPtr.i != RNIL) {
-      ljam();
+      jam();
       c_page_pool.getPtr(pageNextPtr);
       pageNextPtr.p->prev_cluster_page = pagePrevPtr.i;
     }//if
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp
index 26373708b66..cbbbc1fa56c 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp
@@ -15,14 +15,12 @@
 
 
 #define DBTUP_C
+#define DBTUP_PAGE_MAP_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
 #include <pc.hpp>
 
-#define ljam() { jamLine(14000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(14000 + __LINE__); }
-
 //
 // PageMap is a service used by Dbtup to map logical page id's to physical
 // page id's. The mapping is needs the fragment and the logical page id to
@@ -92,11 +90,11 @@ Uint32 Dbtup::getEmptyPage(Fragrecord* regFragPtr)
 {
   Uint32 pageId = regFragPtr->emptyPrimPage.firstItem;
   if (pageId == RNIL) {
-    ljam();
+    jam();
     allocMoreFragPages(regFragPtr);
     pageId = regFragPtr->emptyPrimPage.firstItem;
     if (pageId == RNIL) {
-      ljam();
+      jam();
       return RNIL;
     }//if
   }//if
@@ -122,11 +120,11 @@ Uint32 Dbtup::getRealpid(Fragrecord* regFragPtr, Uint32 logicalPageId)
     loopLimit = grpPageRangePtr.p->currentIndexPos;
     ndbrequire(loopLimit <= 3);
     for (Uint32 i = 0; i <= loopLimit; i++) {
-      ljam();
+      jam();
       if (grpPageRangePtr.p->startRange[i] <= logicalPageId) {
         if (grpPageRangePtr.p->endRange[i] >= logicalPageId) {
           if (grpPageRangePtr.p->type[i] == ZLEAF) {
-            ljam();
+            jam();
             Uint32 realPageId = (logicalPageId - grpPageRangePtr.p->startRange[i]) +
                                  grpPageRangePtr.p->basePageId[i];
             return realPageId;
@@ -167,12 +165,12 @@ bool Dbtup::insertPageRangeTab(Fragrecord*  const regFragPtr,
 {
   PageRangePtr currPageRangePtr;
   if (cfirstfreerange == RNIL) {
-    ljam();
+    jam();
     return false;
   }//if
   currPageRangePtr.i = regFragPtr->currentPageRange;
   if (currPageRangePtr.i == RNIL) {
-    ljam();
+    jam();
 /* ---------------------------------------------------------------- */
 /*       THE FIRST PAGE RANGE IS HANDLED WITH SPECIAL CODE          */
 /* ---------------------------------------------------------------- */
@@ -181,10 +179,10 @@ bool Dbtup::insertPageRangeTab(Fragrecord*  const regFragPtr,
     currPageRangePtr.p->currentIndexPos = 0;
     currPageRangePtr.p->parentPtr = RNIL;
   } else {
-    ljam();
+    jam();
     ptrCheckGuard(currPageRangePtr, cnoOfPageRangeRec, pageRange);
     if (currPageRangePtr.p->currentIndexPos < 3) {
-      ljam();
+      jam();
 /* ---------------------------------------------------------------- */
 /*       THE SIMPLE CASE WHEN IT IS ONLY NECESSARY TO FILL IN THE   */
 /*       NEXT EMPTY POSITION IN THE PAGE RANGE RECORD IS TREATED    */
@@ -192,7 +190,7 @@ bool Dbtup::insertPageRangeTab(Fragrecord*  const regFragPtr,
 /* ---------------------------------------------------------------- */
       currPageRangePtr.p->currentIndexPos++;
     } else {
-      ljam();
+      jam();
       ndbrequire(currPageRangePtr.p->currentIndexPos == 3);
       currPageRangePtr.i = leafPageRangeFull(regFragPtr, currPageRangePtr);
       if (currPageRangePtr.i == RNIL) {
@@ -223,15 +221,15 @@ bool Dbtup::insertPageRangeTab(Fragrecord*  const regFragPtr,
   PageRangePtr loopPageRangePtr;
   loopPageRangePtr = currPageRangePtr;
   while (true) {
-    ljam();
+    jam();
     loopPageRangePtr.i = loopPageRangePtr.p->parentPtr;
     if (loopPageRangePtr.i != RNIL) {
-      ljam();
+      jam();
       ptrCheckGuard(loopPageRangePtr, cnoOfPageRangeRec, pageRange);
       ndbrequire(loopPageRangePtr.p->currentIndexPos < 4);
       loopPageRangePtr.p->endRange[loopPageRangePtr.p->currentIndexPos] += noPages;
     } else {
-      ljam();
+      jam();
       break;
     }//if
   }//while
@@ -243,26 +241,26 @@ bool Dbtup::insertPageRangeTab(Fragrecord*  const regFragPtr,
 void Dbtup::releaseFragPages(Fragrecord* regFragPtr) 
 {
   if (regFragPtr->rootPageRange == RNIL) {
-    ljam();
+    jam();
     return;
   }//if
   PageRangePtr regPRPtr;
   regPRPtr.i = regFragPtr->rootPageRange;
   ptrCheckGuard(regPRPtr, cnoOfPageRangeRec, pageRange);
   while (true) {
-    ljam();
+    jam();
     const Uint32 indexPos = regPRPtr.p->currentIndexPos;
     ndbrequire(indexPos < 4);
 
     const Uint32 basePageId = regPRPtr.p->basePageId[indexPos];
     regPRPtr.p->basePageId[indexPos] = RNIL;
     if (basePageId == RNIL) {
-      ljam();
+      jam();
       /**
        * Finished with indexPos continue with next
        */
       if (indexPos > 0) {
-        ljam();
+        jam();
 	regPRPtr.p->currentIndexPos--;
 	continue;
       }//if
@@ -274,13 +272,13 @@ void Dbtup::releaseFragPages(Fragrecord* regFragPtr)
       releasePagerange(regPRPtr);
       
       if (parentPtr != RNIL) {
-	ljam();
+	jam();
 	regPRPtr.i = parentPtr;
 	ptrCheckGuard(regPRPtr, cnoOfPageRangeRec, pageRange);
 	continue;
       }//if
 
-      ljam();
+      jam();
       ndbrequire(regPRPtr.i == regFragPtr->rootPageRange);
       initFragRange(regFragPtr);
       for (Uint32 i = 0; i<MAX_FREE_LIST; i++)
@@ -364,7 +362,7 @@ Uint32 Dbtup::allocFragPages(Fragrecord* regFragPtr, Uint32 tafpNoAllocRequested
     Uint32 retPageRef = RNIL;
     allocConsPages(noPagesToAllocate, noOfPagesAllocated, retPageRef);
     if (noOfPagesAllocated == 0) {
-      ljam();
+      jam();
       return tafpPagesAllocated;
     }//if
 /* ---------------------------------------------------------------- */
@@ -373,7 +371,7 @@ Uint32 Dbtup::allocFragPages(Fragrecord* regFragPtr, Uint32 tafpNoAllocRequested
 /* ---------------------------------------------------------------- */
     Uint32 startRange = regFragPtr->nextStartRange;
     if (!insertPageRangeTab(regFragPtr, retPageRef, noOfPagesAllocated)) {
-      ljam();
+      jam();
       returnCommonArea(retPageRef, noOfPagesAllocated);
       return tafpPagesAllocated;
     }//if
@@ -388,7 +386,7 @@ Uint32 Dbtup::allocFragPages(Fragrecord* regFragPtr, Uint32 tafpNoAllocRequested
 /* ---------------------------------------------------------------- */
     Uint32 prev = RNIL;
     for (loopPagePtr.i = retPageRef; loopPagePtr.i < loopLimit; loopPagePtr.i++) {
-      ljam();
+      jam();
       c_page_pool.getPtr(loopPagePtr);
       loopPagePtr.p->page_state = ZEMPTY_MM;
       loopPagePtr.p->frag_page_id = startRange +
@@ -416,10 +414,10 @@ Uint32 Dbtup::allocFragPages(Fragrecord* regFragPtr, Uint32 tafpNoAllocRequested
 /*       WAS ENOUGH PAGES ALLOCATED OR ARE MORE NEEDED.             */
 /* ---------------------------------------------------------------- */
     if (tafpPagesAllocated < tafpNoAllocRequested) {
-      ljam();
+      jam();
     } else {
       ndbrequire(tafpPagesAllocated == tafpNoAllocRequested);
-      ljam();
+      jam();
       return tafpNoAllocRequested;
     }//if
   }//while
@@ -451,15 +449,15 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord*  const regFragPtr, PageRangePtr curr
   parentPageRangePtr = currPageRangePtr;
   Uint32 tiprNoLevels = 1;
   while (true) {
-    ljam();
+    jam();
     parentPageRangePtr.i = parentPageRangePtr.p->parentPtr;
     if (parentPageRangePtr.i == RNIL) {
-      ljam();
+      jam();
 /* ---------------------------------------------------------------- */
 /*       WE HAVE REACHED THE ROOT. A NEW ROOT MUST BE ALLOCATED.    */
 /* ---------------------------------------------------------------- */
       if (c_noOfFreePageRanges < tiprNoLevels) {
-        ljam();
+        jam();
         return RNIL;
       }//if
       PageRangePtr oldRootPRPtr;
@@ -482,10 +480,10 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord*  const regFragPtr, PageRangePtr curr
       foundPageRangePtr = newRootPRPtr;
       break;
     } else {
-      ljam();
+      jam();
       ptrCheckGuard(parentPageRangePtr, cnoOfPageRangeRec, pageRange);
       if (parentPageRangePtr.p->currentIndexPos < 3) {
-        ljam();
+        jam();
 /* ---------------------------------------------------------------- */
 /*       WE HAVE FOUND AN EMPTY ENTRY IN A PAGE RANGE RECORD.       */
 /*       ALLOCATE A NEW PAGE RANGE RECORD, FILL IN THE START RANGE, */
@@ -498,7 +496,7 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord*  const regFragPtr, PageRangePtr curr
         foundPageRangePtr = parentPageRangePtr;
         break;
       } else {
-        ljam();
+        jam();
         ndbrequire(parentPageRangePtr.p->currentIndexPos == 3);
 /* ---------------------------------------------------------------- */
 /*       THE PAGE RANGE RECORD WAS FULL. FIND THE PARENT RECORD     */
@@ -516,7 +514,7 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord*  const regFragPtr, PageRangePtr curr
   PageRangePtr prevPageRangePtr;
   prevPageRangePtr = foundPageRangePtr;
   if (c_noOfFreePageRanges < tiprNoLevels) {
-    ljam();
+    jam();
     return RNIL;
   }//if
 /* ---------------------------------------------------------------- */
@@ -527,7 +525,7 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord*  const regFragPtr, PageRangePtr curr
 /*       ARE ALSO PROPERLY UPDATED ON THE PATH TO THE LEAF LEVEL.   */
 /* ---------------------------------------------------------------- */
   while (true) {
-    ljam();
+    jam();
     seizePagerange(newPageRangePtr);
     tiprNoLevels--;
     ndbrequire(prevPageRangePtr.p->currentIndexPos < 4);
@@ -535,13 +533,13 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord*  const regFragPtr, PageRangePtr curr
     newPageRangePtr.p->parentPtr = prevPageRangePtr.i;
     newPageRangePtr.p->currentIndexPos = 0;
     if (tiprNoLevels > 0) {
-      ljam();
+      jam();
       newPageRangePtr.p->startRange[0] = regFragPtr->nextStartRange;
       newPageRangePtr.p->endRange[0] = regFragPtr->nextStartRange - 1;
       newPageRangePtr.p->type[0] = ZNON_LEAF;
       prevPageRangePtr = newPageRangePtr;
     } else {
-      ljam();
+      jam();
       break;
     }//if
   }//while
@@ -576,16 +574,16 @@ void Dbtup::errorHandler(Uint32 errorCode)
 {
   switch (errorCode) {
   case 0:
-    ljam();
+    jam();
     break;
   case 1:
-    ljam();
+    jam();
     break;
   case 2:
-    ljam();
+    jam();
     break;
   default:
-    ljam();
+    jam();
   }
   ndbrequire(false);
 }//Dbtup::errorHandler()
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp
index 28f66c5620a..6e932f8a058 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp
@@ -15,6 +15,7 @@
 
 
 #define DBTUP_C
+#define DBTUP_ROUTINES_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
@@ -23,9 +24,6 @@
 #include "AttributeOffset.hpp"
 #include <AttributeHeader.hpp>
 
-#define ljam() { jamLine(3000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(3000 + __LINE__); }
-
 void
 Dbtup::setUpQueryRoutines(Tablerec *regTabPtr)
 {
@@ -40,23 +38,23 @@ Dbtup::setUpQueryRoutines(Tablerec *regTabPtr)
       if (AttributeDescriptor::getArrayType(attrDescr) == NDB_ARRAYTYPE_FIXED){
         if (!AttributeDescriptor::getNullable(attrDescr)) {
           if (AttributeDescriptor::getSize(attrDescr) == 0){
-            ljam(); 
+            jam(); 
             regTabPtr->readFunctionArray[i] = &Dbtup::readBitsNotNULL;
             regTabPtr->updateFunctionArray[i] = &Dbtup::updateBitsNotNULL;
           } else if (AttributeDescriptor::getSizeInBytes(attrDescr) == 4) {
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i]=
 	      &Dbtup::readFixedSizeTHOneWordNotNULL;
             regTabPtr->updateFunctionArray[i]=
 	      &Dbtup::updateFixedSizeTHOneWordNotNULL;
           } else if (AttributeDescriptor::getSizeInBytes(attrDescr) == 8) {
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i]=
                     &Dbtup::readFixedSizeTHTwoWordNotNULL;
             regTabPtr->updateFunctionArray[i]=
                     &Dbtup::updateFixedSizeTHTwoWordNotNULL;
           } else {
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i]=
 	      &Dbtup::readFixedSizeTHManyWordNotNULL;
             regTabPtr->updateFunctionArray[i]=
@@ -64,27 +62,27 @@ Dbtup::setUpQueryRoutines(Tablerec *regTabPtr)
           }
           // replace functions for char attribute
           if (AttributeOffset::getCharsetFlag(attrOffset)) {
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHManyWordNotNULL;
             regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNotNULL;
           }
         } else {
 	  if (AttributeDescriptor::getSize(attrDescr) == 0){
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i] = &Dbtup::readBitsNULLable;
             regTabPtr->updateFunctionArray[i] = &Dbtup::updateBitsNULLable;
 	  } else if (AttributeDescriptor::getSizeInBytes(attrDescr) == 4){
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHOneWordNULLable;
             regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNULLable;
           } else if (AttributeDescriptor::getSizeInBytes(attrDescr) == 8) {
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i]=
                     &Dbtup::readFixedSizeTHTwoWordNULLable;
             regTabPtr->updateFunctionArray[i]=
                     &Dbtup::updateFixedSizeTHManyWordNULLable;
           } else {
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i]=
 	      &Dbtup::readFixedSizeTHManyWordNULLable;
             regTabPtr->updateFunctionArray[i]=
@@ -92,7 +90,7 @@ Dbtup::setUpQueryRoutines(Tablerec *regTabPtr)
           }
           // replace functions for char attribute
           if (AttributeOffset::getCharsetFlag(attrOffset)) {
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHManyWordNULLable;
             regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNULLable;
           }
@@ -144,7 +142,7 @@ Dbtup::setUpQueryRoutines(Tablerec *regTabPtr)
       }
       } else {
       if (AttributeDescriptor::getArrayType(attrDescr) == NDB_ARRAYTYPE_FIXED){
-        ljam();
+        jam();
         regTabPtr->readFunctionArray[i]= &Dbtup::readDynFixedSize;
         regTabPtr->updateFunctionArray[i]= &Dbtup::updateDynFixedSize;
       } else {
@@ -204,7 +202,7 @@ int Dbtup::readAttributes(KeyReqStruct *req_struct,
     inBufIndex++;
     attributeId= ahIn.getAttributeId();
     descr_index= attributeId << ZAD_LOG_SIZE;
-    ljam();
+    jam();
 
     AttributeHeader::init(&outBuffer[tmpAttrBufIndex], attributeId, 0);
     ahOut= (AttributeHeader*)&outBuffer[tmpAttrBufIndex];
@@ -223,7 +221,7 @@ int Dbtup::readAttributes(KeyReqStruct *req_struct,
         return -1;
       }
     } else if(attributeId & AttributeHeader::PSEUDO) {
-      ljam();
+      jam();
       Uint32 sz= read_pseudo(attributeId,
                              req_struct,
 			     outBuffer+tmpAttrBufIndex+1);
@@ -252,13 +250,13 @@ Dbtup::readFixedSizeTHOneWordNotNULL(Uint32* outBuffer,
 
   ndbrequire(readOffset < req_struct->check_offset[MM]);
   if (newIndexBuf <= maxRead) {
-    ljam();
+    jam();
     outBuffer[indexBuf]= wordRead;
     ahOut->setDataSize(1);
     req_struct->out_buf_index= newIndexBuf;
     return true;
   } else {
-    ljam();
+    jam();
     terrorCode= ZTRY_TO_READ_TOO_MUCH_ERROR;
     return false;
   }
@@ -280,14 +278,14 @@ Dbtup::readFixedSizeTHTwoWordNotNULL(Uint32* outBuffer,
 
   ndbrequire(readOffset + 1 < req_struct->check_offset[MM]);
   if (newIndexBuf <= maxRead) {
-    ljam();
+    jam();
     ahOut->setDataSize(2);
     outBuffer[indexBuf]= wordReadFirst;
     outBuffer[indexBuf + 1]= wordReadSecond;
     req_struct->out_buf_index= newIndexBuf;
     return true;
   } else {
-    ljam();
+    jam();
     terrorCode= ZTRY_TO_READ_TOO_MUCH_ERROR;
     return false;
   }
@@ -311,7 +309,7 @@ Dbtup::readFixedSizeTHManyWordNotNULL(Uint32* outBuffer,
   if (! charsetFlag || ! req_struct->xfrm_flag) {
     Uint32 newIndexBuf = indexBuf + attrNoOfWords;
     if (newIndexBuf <= maxRead) {
-      ljam();
+      jam();
       ahOut->setByteSize(AttributeDescriptor::getSizeInBytes(attrDescriptor));
       MEMCOPY_NO_WORDS(&outBuffer[indexBuf],
                        &tuple_header[readOffset],
@@ -319,11 +317,11 @@ Dbtup::readFixedSizeTHManyWordNotNULL(Uint32* outBuffer,
       req_struct->out_buf_index = newIndexBuf;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
     }//if
   } else {
-    ljam();
+    jam();
     Tablerec* regTabPtr = tabptr.p;
     Uint32 srcBytes = AttributeDescriptor::getSizeInBytes(attrDescriptor);
     uchar* dstPtr = (uchar*)&outBuffer[indexBuf];
@@ -340,7 +338,7 @@ Dbtup::readFixedSizeTHManyWordNotNULL(Uint32* outBuffer,
     Uint32 dstLen = xmul * (srcBytes - lb);
     Uint32 maxIndexBuf = indexBuf + (dstLen >> 2);
     if (maxIndexBuf <= maxRead && ok) {
-      ljam();
+      jam();
       int n = NdbSqlUtil::strnxfrm_bug7284(cs, dstPtr, dstLen, srcPtr + lb, len);
       ndbrequire(n != -1);
       int m = n;
@@ -353,7 +351,7 @@ Dbtup::readFixedSizeTHManyWordNotNULL(Uint32* outBuffer,
       req_struct->out_buf_index = newIndexBuf;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
     }
   } 
@@ -367,13 +365,13 @@ Dbtup::readFixedSizeTHOneWordNULLable(Uint32* outBuffer,
                                       Uint32  attrDes2)
 {
   if (!nullFlagCheck(req_struct, attrDes2)) {
-    ljam();
+    jam();
     return readFixedSizeTHOneWordNotNULL(outBuffer,
                                          req_struct,
                                          ahOut,
                                          attrDes2);
   } else {
-    ljam();
+    jam();
     ahOut->setNULL();
     return true;
   }
@@ -386,13 +384,13 @@ Dbtup::readFixedSizeTHTwoWordNULLable(Uint32* outBuffer,
                                       Uint32  attrDes2)
 {
   if (!nullFlagCheck(req_struct, attrDes2)) {
-    ljam();
+    jam();
     return readFixedSizeTHTwoWordNotNULL(outBuffer,
                                          req_struct,
                                          ahOut,
                                          attrDes2);
   } else {
-    ljam();
+    jam();
     ahOut->setNULL();
     return true;
   }
@@ -405,13 +403,13 @@ Dbtup::readFixedSizeTHManyWordNULLable(Uint32* outBuffer,
                                        Uint32  attrDes2)
 {
   if (!nullFlagCheck(req_struct, attrDes2)) {
-    ljam();
+    jam();
     return readFixedSizeTHManyWordNotNULL(outBuffer,
                                           req_struct,
                                           ahOut,
                                           attrDes2);
   } else {
-    ljam();
+    jam();
     ahOut->setNULL();
     return true;
   }
@@ -423,9 +421,9 @@ Dbtup::readFixedSizeTHZeroWordNULLable(Uint32* outBuffer,
                                        AttributeHeader* ahOut,
                                        Uint32  attrDes2)
 {
-  ljam();
+  jam();
   if (nullFlagCheck(req_struct, attrDes2)) {
-    ljam();
+    jam();
     ahOut->setNULL();
   }
   return true;
@@ -477,7 +475,7 @@ Dbtup::readVarSizeNotNULL(Uint32* out_buffer,
   if (! charsetFlag || ! req_struct->xfrm_flag)
   {
     if (new_index <= max_read) {
-      ljam();
+      jam();
       ah_out->setByteSize(vsize_in_bytes);
       out_buffer[index_buf + (vsize_in_bytes >> 2)] = 0;
       memcpy(out_buffer+index_buf,
@@ -489,7 +487,7 @@ Dbtup::readVarSizeNotNULL(Uint32* out_buffer,
   }
   else
   {
-    ljam();
+    jam();
     Tablerec* regTabPtr = tabptr.p;
     Uint32 maxBytes = AttributeDescriptor::getSizeInBytes(attr_descriptor);
     Uint32 srcBytes = vsize_in_bytes;
@@ -508,7 +506,7 @@ Dbtup::readVarSizeNotNULL(Uint32* out_buffer,
     Uint32 dstLen = xmul * (maxBytes - lb);
     Uint32 maxIndexBuf = index_buf + (dstLen >> 2);
     if (maxIndexBuf <= max_read && ok) {
-      ljam();
+      jam();
       int n = NdbSqlUtil::strnxfrm_bug7284(cs, dstPtr, dstLen, srcPtr + lb, len);
       ndbrequire(n != -1);
       int m = n;
@@ -522,7 +520,7 @@ Dbtup::readVarSizeNotNULL(Uint32* out_buffer,
       return true;
     }
   }
-  ljam();
+  jam();
   terrorCode= ZTRY_TO_READ_TOO_MUCH_ERROR;
   return false;
 }
@@ -534,13 +532,13 @@ Dbtup::readVarSizeNULLable(Uint32* outBuffer,
                            Uint32  attrDes2)
 {
   if (!nullFlagCheck(req_struct, attrDes2)) {
-    ljam();
+    jam();
     return readVarSizeNotNULL(outBuffer,
                               req_struct,
                               ahOut,
                               attrDes2);
   } else {
-    ljam();
+    jam();
     ahOut->setNULL();
     return true;
   }
@@ -552,7 +550,7 @@ Dbtup::readDynFixedSize(Uint32* outBuffer,
                         AttributeHeader* ahOut,
                         Uint32  attrDes2)
 {
-  ljam();
+  jam();
   terrorCode= ZVAR_SIZED_NOT_SUPPORTED;
   return false;
 }
@@ -563,7 +561,7 @@ Dbtup::readDynVarSize(Uint32* outBuffer,
                       AttributeHeader* ahOut,
                       Uint32  attrDes2)
 {
-  ljam();
+  jam();
   terrorCode= ZVAR_SIZED_NOT_SUPPORTED;
   return false;
 }//Dbtup::readDynBigVarSize()
@@ -586,7 +584,7 @@ Dbtup::readDiskFixedSizeNotNULL(Uint32* outBuffer,
   if (! charsetFlag || ! req_struct->xfrm_flag) {
     Uint32 newIndexBuf = indexBuf + attrNoOfWords;
     if (newIndexBuf <= maxRead) {
-      ljam();
+      jam();
       ahOut->setByteSize(AttributeDescriptor::getSizeInBytes(attrDescriptor));
       MEMCOPY_NO_WORDS(&outBuffer[indexBuf],
                        &tuple_header[readOffset],
@@ -594,11 +592,11 @@ Dbtup::readDiskFixedSizeNotNULL(Uint32* outBuffer,
       req_struct->out_buf_index = newIndexBuf;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
     }//if
   } else {
-    ljam();
+    jam();
     Tablerec* regTabPtr = tabptr.p;
     Uint32 srcBytes = AttributeDescriptor::getSizeInBytes(attrDescriptor);
     uchar* dstPtr = (uchar*)&outBuffer[indexBuf];
@@ -615,7 +613,7 @@ Dbtup::readDiskFixedSizeNotNULL(Uint32* outBuffer,
     Uint32 dstLen = xmul * (srcBytes - lb);
     Uint32 maxIndexBuf = indexBuf + (dstLen >> 2);
     if (maxIndexBuf <= maxRead && ok) {
-      ljam();
+      jam();
       int n = NdbSqlUtil::strnxfrm_bug7284(cs, dstPtr, dstLen, srcPtr + lb, len);
       ndbrequire(n != -1);
       int m = n;
@@ -628,7 +626,7 @@ Dbtup::readDiskFixedSizeNotNULL(Uint32* outBuffer,
       req_struct->out_buf_index = newIndexBuf;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
     }
   } 
@@ -642,13 +640,13 @@ Dbtup::readDiskFixedSizeNULLable(Uint32* outBuffer,
 				 Uint32  attrDes2)
 {
   if (!disk_nullFlagCheck(req_struct, attrDes2)) {
-    ljam();
+    jam();
     return readDiskFixedSizeNotNULL(outBuffer,
 				    req_struct,
 				    ahOut,
 				    attrDes2);
   } else {
-    ljam();
+    jam();
     ahOut->setNULL();
     return true;
   }
@@ -677,7 +675,7 @@ Dbtup::readDiskVarSizeNotNULL(Uint32* out_buffer,
 
   ndbrequire(vsize_in_words <= max_var_size);
   if (new_index <= max_read) {
-    ljam();
+    jam();
     ah_out->setByteSize(vsize_in_bytes);
     memcpy(out_buffer+index_buf,
 	   req_struct->m_var_data[DD].m_data_ptr+var_attr_pos,
@@ -685,7 +683,7 @@ Dbtup::readDiskVarSizeNotNULL(Uint32* out_buffer,
     req_struct->out_buf_index= new_index;
     return true;
   } else {
-    ljam();
+    jam();
     terrorCode= ZTRY_TO_READ_TOO_MUCH_ERROR;
     return false;
   }
@@ -698,13 +696,13 @@ Dbtup::readDiskVarSizeNULLable(Uint32* outBuffer,
 			       Uint32  attrDes2)
 {
   if (!disk_nullFlagCheck(req_struct, attrDes2)) {
-    ljam();
+    jam();
     return readDiskVarSizeNotNULL(outBuffer,
 				  req_struct,
 				  ahOut,
 				  attrDes2);
   } else {
-    ljam();
+    jam();
     ahOut->setNULL();
     return true;
   }
@@ -746,13 +744,13 @@ int Dbtup::updateAttributes(KeyReqStruct *req_struct,
         if (checkUpdateOfPrimaryKey(req_struct,
                                     &inBuffer[inBufIndex],
                                     regTabPtr)) {
-          ljam();
+          jam();
           terrorCode= ZTRY_UPDATE_PRIMARY_KEY;
           return -1;
         }
       }
       UpdateFunction f= regTabPtr->updateFunctionArray[attributeId];
-      ljam();
+      jam();
       req_struct->attr_descriptor= attrDescriptor;
       req_struct->changeMask.set(attributeId);
       if (attributeId >= 64) {
@@ -768,13 +766,13 @@ int Dbtup::updateAttributes(KeyReqStruct *req_struct,
         inBufIndex= req_struct->in_buf_index;
         continue;
       } else {
-        ljam();
+        jam();
         return -1;
       }
     } 
     else if(attributeId == AttributeHeader::DISK_REF)
     {
-      ljam();
+      jam();
       Uint32 sz= ahIn.getDataSize();
       ndbrequire(sz == 2);
       req_struct->m_tuple_ptr->m_header_bits |= Tuple_header::DISK_PART;
@@ -785,7 +783,7 @@ int Dbtup::updateAttributes(KeyReqStruct *req_struct,
     }
     else
     {
-      ljam();
+      jam();
       terrorCode= ZATTRIBUTE_ID_ERROR;
       return -1;
     }
@@ -839,13 +837,13 @@ Dbtup::checkUpdateOfPrimaryKey(KeyReqStruct* req_struct,
   
   ndbrequire(req_struct->out_buf_index == ahOut->getDataSize());
   if (ahIn.getDataSize() != ahOut->getDataSize()) {
-    ljam();
+    jam();
     return true;
   }
   if (memcmp(&keyReadBuffer[0],
              &updateBuffer[1],
              req_struct->out_buf_index << 2) != 0) {
-    ljam();
+    jam();
     return true;
   }
   return false;
@@ -868,17 +866,17 @@ Dbtup::updateFixedSizeTHOneWordNotNULL(Uint32* inBuffer,
   if (newIndex <= inBufLen) {
     Uint32 updateWord= inBuffer[indexBuf + 1];
     if (!nullIndicator) {
-      ljam();
+      jam();
       req_struct->in_buf_index= newIndex;
       tuple_header[updateOffset]= updateWord;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZNOT_NULL_ATTR;
       return false;
     }
   } else {
-    ljam();
+    jam();
     terrorCode= ZAI_INCONSISTENCY_ERROR;
     return false;
   }
@@ -903,18 +901,18 @@ Dbtup::updateFixedSizeTHTwoWordNotNULL(Uint32* inBuffer,
     Uint32 updateWord1= inBuffer[indexBuf + 1];
     Uint32 updateWord2= inBuffer[indexBuf + 2];
     if (!nullIndicator) {
-      ljam();
+      jam();
       req_struct->in_buf_index= newIndex;
       tuple_header[updateOffset]= updateWord1;
       tuple_header[updateOffset + 1]= updateWord2;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZNOT_NULL_ATTR;
       return false;
     }
   } else {
-    ljam();
+    jam();
     terrorCode= ZAI_INCONSISTENCY_ERROR;
     return false;
   }
@@ -940,9 +938,9 @@ Dbtup::updateFixedSizeTHManyWordNotNULL(Uint32* inBuffer,
 
   if (newIndex <= inBufLen) {
     if (!nullIndicator) {
-      ljam();
+      jam();
       if (charsetFlag) {
-        ljam();
+        jam();
         Tablerec* regTabPtr = tabptr.p;
 	Uint32 typeId = AttributeDescriptor::getType(attrDescriptor);
         Uint32 bytes = AttributeDescriptor::getSizeInBytes(attrDescriptor);
@@ -954,14 +952,14 @@ Dbtup::updateFixedSizeTHManyWordNotNULL(Uint32* inBuffer,
         const char* ssrc = (const char*)&inBuffer[indexBuf + 1];
         Uint32 lb, len;
         if (! NdbSqlUtil::get_var_length(typeId, ssrc, bytes, lb, len)) {
-          ljam();
+          jam();
           terrorCode = ZINVALID_CHAR_FORMAT;
           return false;
         }
 	// fast fix bug#7340
         if (typeId != NDB_TYPE_TEXT &&
 	    (*cs->cset->well_formed_len)(cs, ssrc + lb, ssrc + lb + len, ZNIL, &not_used) != len) {
-          ljam();
+          jam();
           terrorCode = ZINVALID_CHAR_FORMAT;
           return false;
         }
@@ -973,12 +971,12 @@ Dbtup::updateFixedSizeTHManyWordNotNULL(Uint32* inBuffer,
       
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZNOT_NULL_ATTR;
       return false;
     }
   } else {
-    ljam();
+    jam();
     terrorCode= ZAI_INCONSISTENCY_ERROR;
     return false;
   }
@@ -996,7 +994,7 @@ Dbtup::updateFixedSizeTHManyWordNULLable(Uint32* inBuffer,
   Uint32 *bits= req_struct->m_tuple_ptr->get_null_bits(regTabPtr);
   
   if (!nullIndicator) {
-    ljam();
+    jam();
     BitmaskImpl::clear(regTabPtr->m_offsets[MM].m_null_words, bits, pos);
     return updateFixedSizeTHManyWordNotNULL(inBuffer,
                                             req_struct,
@@ -1005,11 +1003,11 @@ Dbtup::updateFixedSizeTHManyWordNULLable(Uint32* inBuffer,
     Uint32 newIndex= req_struct->in_buf_index + 1;
     if (newIndex <= req_struct->in_buf_len) {
       BitmaskImpl::set(regTabPtr->m_offsets[MM].m_null_words, bits, pos);
-      ljam();
+      jam();
       req_struct->in_buf_index= newIndex;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZAI_INCONSISTENCY_ERROR;
       return false;
     }
@@ -1043,7 +1041,7 @@ Dbtup::updateVarSizeNotNULL(Uint32* in_buffer,
   
   if (new_index <= in_buf_len && vsize_in_words <= max_var_size) {
     if (!null_ind) {
-      ljam();
+      jam();
       var_attr_pos= vpos_array[var_index];
       var_data_start= req_struct->m_var_data[MM].m_data_ptr;
       vpos_array[var_index+idx]= var_attr_pos+size_in_bytes;
@@ -1054,12 +1052,12 @@ Dbtup::updateVarSizeNotNULL(Uint32* in_buffer,
 	     size_in_bytes);
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZNOT_NULL_ATTR;
       return false;
     }
   } else {
-    ljam();
+    jam();
     terrorCode= ZAI_INCONSISTENCY_ERROR;
     return false;
   }
@@ -1079,7 +1077,7 @@ Dbtup::updateVarSizeNULLable(Uint32* inBuffer,
   Uint32 idx= req_struct->m_var_data[MM].m_var_len_offset;
   
   if (!nullIndicator) {
-    ljam();
+    jam();
     BitmaskImpl::clear(regTabPtr->m_offsets[MM].m_null_words, bits, pos);
     return updateVarSizeNotNULL(inBuffer,
                                 req_struct,
@@ -1089,13 +1087,13 @@ Dbtup::updateVarSizeNULLable(Uint32* inBuffer,
     Uint32 var_index= AttributeOffset::getOffset(attrDes2);
     Uint32 var_pos= req_struct->var_pos_array[var_index];
     if (newIndex <= req_struct->in_buf_len) {
-      ljam();
+      jam();
       BitmaskImpl::set(regTabPtr->m_offsets[MM].m_null_words, bits, pos);
       req_struct->var_pos_array[var_index+idx]= var_pos;
       req_struct->in_buf_index= newIndex;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZAI_INCONSISTENCY_ERROR;
       return false;
     }
@@ -1107,7 +1105,7 @@ Dbtup::updateDynFixedSize(Uint32* inBuffer,
                           KeyReqStruct *req_struct,
                           Uint32  attrDes2)
 {
-  ljam();
+  jam();
   terrorCode= ZVAR_SIZED_NOT_SUPPORTED;
   return false;
 }
@@ -1117,7 +1115,7 @@ Dbtup::updateDynVarSize(Uint32* inBuffer,
                         KeyReqStruct *req_struct,
                         Uint32  attrDes2)
 {
-  ljam();
+  jam();
   terrorCode= ZVAR_SIZED_NOT_SUPPORTED;
   return false;
 }
@@ -1215,7 +1213,7 @@ Dbtup::readBitsNotNULL(Uint32* outBuffer,
   Uint32 maxRead = req_struct->max_read;
   Uint32 *bits= req_struct->m_tuple_ptr->get_null_bits(regTabPtr);
   if (newIndexBuf <= maxRead) {
-    ljam();
+    jam();
     ahOut->setDataSize((bitCount + 31) >> 5);
     req_struct->out_buf_index = newIndexBuf;
     
@@ -1224,7 +1222,7 @@ Dbtup::readBitsNotNULL(Uint32* outBuffer,
     
     return true;
   } else {
-    ljam();
+    jam();
     terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
     return false;
   }//if
@@ -1248,20 +1246,20 @@ Dbtup::readBitsNULLable(Uint32* outBuffer,
   
   if(BitmaskImpl::get(regTabPtr->m_offsets[MM].m_null_words, bits, pos))
   {
-    ljam();
+    jam();
     ahOut->setNULL();
     return true;
   }
 
   if (newIndexBuf <= maxRead) {
-    ljam();
+    jam();
     ahOut->setDataSize((bitCount + 31) >> 5);
     req_struct->out_buf_index = newIndexBuf;
     BitmaskImpl::getField(regTabPtr->m_offsets[MM].m_null_words, bits, pos+1, 
 			  bitCount, outBuffer+indexBuf);
     return true;
   } else {
-    ljam();
+    jam();
     terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
     return false;
   }//if
@@ -1290,12 +1288,12 @@ Dbtup::updateBitsNotNULL(Uint32* inBuffer,
       req_struct->in_buf_index = newIndex;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode = ZNOT_NULL_ATTR;
       return false;
     }//if
   } else {
-    ljam();
+    jam();
     terrorCode = ZAI_INCONSISTENCY_ERROR;
     return false;
   }//if
@@ -1328,13 +1326,13 @@ Dbtup::updateBitsNULLable(Uint32* inBuffer,
     Uint32 newIndex = indexBuf + 1;
     if (newIndex <= req_struct->in_buf_len)
     {
-      ljam();
+      jam();
       BitmaskImpl::set(regTabPtr->m_offsets[MM].m_null_words, bits, pos);
       
       req_struct->in_buf_index = newIndex;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode = ZAI_INCONSISTENCY_ERROR;
       return false;
     }//if
@@ -1361,9 +1359,9 @@ Dbtup::updateDiskFixedSizeNotNULL(Uint32* inBuffer,
 
   if (newIndex <= inBufLen) {
     if (!nullIndicator) {
-      ljam();
+      jam();
       if (charsetFlag) {
-        ljam();
+        jam();
         Tablerec* regTabPtr = tabptr.p;
 	Uint32 typeId = AttributeDescriptor::getType(attrDescriptor);
         Uint32 bytes = AttributeDescriptor::getSizeInBytes(attrDescriptor);
@@ -1375,14 +1373,14 @@ Dbtup::updateDiskFixedSizeNotNULL(Uint32* inBuffer,
         const char* ssrc = (const char*)&inBuffer[indexBuf + 1];
         Uint32 lb, len;
         if (! NdbSqlUtil::get_var_length(typeId, ssrc, bytes, lb, len)) {
-          ljam();
+          jam();
           terrorCode = ZINVALID_CHAR_FORMAT;
           return false;
         }
 	// fast fix bug#7340
         if (typeId != NDB_TYPE_TEXT &&
 	    (*cs->cset->well_formed_len)(cs, ssrc + lb, ssrc + lb + len, ZNIL, &not_used) != len) {
-          ljam();
+          jam();
           terrorCode = ZINVALID_CHAR_FORMAT;
           return false;
         }
@@ -1393,12 +1391,12 @@ Dbtup::updateDiskFixedSizeNotNULL(Uint32* inBuffer,
                        noOfWords);
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZNOT_NULL_ATTR;
       return false;
     }
   } else {
-    ljam();
+    jam();
     terrorCode= ZAI_INCONSISTENCY_ERROR;
     return false;
   }
@@ -1416,7 +1414,7 @@ Dbtup::updateDiskFixedSizeNULLable(Uint32* inBuffer,
   Uint32 *bits= req_struct->m_disk_ptr->get_null_bits(regTabPtr, DD);
   
   if (!nullIndicator) {
-    ljam();
+    jam();
     BitmaskImpl::clear(regTabPtr->m_offsets[DD].m_null_words, bits, pos);
     return updateDiskFixedSizeNotNULL(inBuffer,
 				      req_struct,
@@ -1425,11 +1423,11 @@ Dbtup::updateDiskFixedSizeNULLable(Uint32* inBuffer,
     Uint32 newIndex= req_struct->in_buf_index + 1;
     if (newIndex <= req_struct->in_buf_len) {
       BitmaskImpl::set(regTabPtr->m_offsets[DD].m_null_words, bits, pos);
-      ljam();
+      jam();
       req_struct->in_buf_index= newIndex;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZAI_INCONSISTENCY_ERROR;
       return false;
     }
@@ -1463,7 +1461,7 @@ Dbtup::updateDiskVarSizeNotNULL(Uint32* in_buffer,
   
   if (new_index <= in_buf_len && vsize_in_words <= max_var_size) {
     if (!null_ind) {
-      ljam();
+      jam();
       var_attr_pos= vpos_array[var_index];
       var_data_start= req_struct->m_var_data[DD].m_data_ptr;
       vpos_array[var_index+idx]= var_attr_pos+size_in_bytes;
@@ -1474,12 +1472,12 @@ Dbtup::updateDiskVarSizeNotNULL(Uint32* in_buffer,
 	     size_in_bytes);
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZNOT_NULL_ATTR;
       return false;
     }
   } else {
-    ljam();
+    jam();
     terrorCode= ZAI_INCONSISTENCY_ERROR;
     return false;
   }
@@ -1499,7 +1497,7 @@ Dbtup::updateDiskVarSizeNULLable(Uint32* inBuffer,
   Uint32 idx= req_struct->m_var_data[DD].m_var_len_offset;
   
   if (!nullIndicator) {
-    ljam();
+    jam();
     BitmaskImpl::clear(regTabPtr->m_offsets[DD].m_null_words, bits, pos);
     return updateDiskVarSizeNotNULL(inBuffer,
 				    req_struct,
@@ -1509,13 +1507,13 @@ Dbtup::updateDiskVarSizeNULLable(Uint32* inBuffer,
     Uint32 var_index= AttributeOffset::getOffset(attrDes2);
     Uint32 var_pos= req_struct->var_pos_array[var_index];
     if (newIndex <= req_struct->in_buf_len) {
-      ljam();
+      jam();
       BitmaskImpl::set(regTabPtr->m_offsets[DD].m_null_words, bits, pos);
       req_struct->var_pos_array[var_index+idx]= var_pos;
       req_struct->in_buf_index= newIndex;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZAI_INCONSISTENCY_ERROR;
       return false;
     }
@@ -1537,7 +1535,7 @@ Dbtup::readDiskBitsNotNULL(Uint32* outBuffer,
   Uint32 maxRead = req_struct->max_read;
   Uint32 *bits= req_struct->m_disk_ptr->get_null_bits(regTabPtr, DD);
   if (newIndexBuf <= maxRead) {
-    ljam();
+    jam();
     ahOut->setDataSize((bitCount + 31) >> 5);
     req_struct->out_buf_index = newIndexBuf;
     
@@ -1546,7 +1544,7 @@ Dbtup::readDiskBitsNotNULL(Uint32* outBuffer,
     
     return true;
   } else {
-    ljam();
+    jam();
     terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
     return false;
   }//if
@@ -1570,20 +1568,20 @@ Dbtup::readDiskBitsNULLable(Uint32* outBuffer,
   
   if(BitmaskImpl::get(regTabPtr->m_offsets[DD].m_null_words, bits, pos))
   {
-    ljam();
+    jam();
     ahOut->setNULL();
     return true;
   }
 
   if (newIndexBuf <= maxRead) {
-    ljam();
+    jam();
     ahOut->setDataSize((bitCount + 31) >> 5);
     req_struct->out_buf_index = newIndexBuf;
     BitmaskImpl::getField(regTabPtr->m_offsets[DD].m_null_words, bits, pos+1, 
 			  bitCount, outBuffer+indexBuf);
     return true;
   } else {
-    ljam();
+    jam();
     terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
     return false;
   }//if
@@ -1612,12 +1610,12 @@ Dbtup::updateDiskBitsNotNULL(Uint32* inBuffer,
       req_struct->in_buf_index = newIndex;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode = ZNOT_NULL_ATTR;
       return false;
     }//if
   } else {
-    ljam();
+    jam();
     terrorCode = ZAI_INCONSISTENCY_ERROR;
     return false;
   }//if
@@ -1650,13 +1648,13 @@ Dbtup::updateDiskBitsNULLable(Uint32* inBuffer,
     Uint32 newIndex = indexBuf + 1;
     if (newIndex <= req_struct->in_buf_len)
     {
-      ljam();
+      jam();
       BitmaskImpl::set(regTabPtr->m_offsets[DD].m_null_words, bits, pos);
       
       req_struct->in_buf_index = newIndex;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode = ZAI_INCONSISTENCY_ERROR;
       return false;
     }//if
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupScan.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupScan.cpp
index aad68c5ed17..9026a76d869 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupScan.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupScan.cpp
@@ -14,6 +14,7 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_SCAN_CPP
 #include "Dbtup.hpp"
 #include <signaldata/AccScan.hpp>
 #include <signaldata/NextScan.hpp>
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupStoredProcDef.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupStoredProcDef.cpp
index b2c42418418..c1ccf5952da 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupStoredProcDef.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupStoredProcDef.cpp
@@ -15,14 +15,12 @@
 
 
 #define DBTUP_C
+#define DBTUP_STORE_PROC_DEF_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
 #include <pc.hpp>
 
-#define ljam() { jamLine(18000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(18000 + __LINE__); }
-
 /* ---------------------------------------------------------------- */
 /* ---------------------------------------------------------------- */
 /* ------------ADD/DROP STORED PROCEDURE MODULE ------------------- */
@@ -32,7 +30,7 @@ void Dbtup::execSTORED_PROCREQ(Signal* signal)
 {
   OperationrecPtr regOperPtr;
   TablerecPtr regTabPtr;
-  ljamEntry();
+  jamEntry();
   regOperPtr.i = signal->theData[0];
   c_operation_pool.getPtr(regOperPtr);
   regTabPtr.i = signal->theData[1];
@@ -46,17 +44,17 @@ void Dbtup::execSTORED_PROCREQ(Signal* signal)
   ndbrequire(regTabPtr.p->tableStatus == DEFINED);
   switch (requestInfo) {
   case ZSCAN_PROCEDURE:
-    ljam();
+    jam();
     scanProcedure(signal,
                   regOperPtr.p,
                   signal->theData[4]);
     break;
   case ZCOPY_PROCEDURE:
-    ljam();
+    jam();
     copyProcedure(signal, regTabPtr, regOperPtr.p);
     break;
   case ZSTORED_PROCEDURE_DELETE:
-    ljam();
+    jam();
     deleteScanProcedure(signal, regOperPtr.p);
     break;
   default:
@@ -124,14 +122,14 @@ void Dbtup::copyProcedure(Signal* signal,
     AttributeHeader::init(&signal->theData[length + 1], Ti, 0);
     length++;
     if (length == 24) {
-      ljam();
+      jam();
       ndbrequire(storedProcedureAttrInfo(signal, regOperPtr, 
 					 signal->theData+1, length, true));
       length = 0;
     }//if
   }//for
   if (length != 0) {
-    ljam();
+    jam();
     ndbrequire(storedProcedureAttrInfo(signal, regOperPtr, 
 				       signal->theData+1, length, true));
   }//if
@@ -155,7 +153,7 @@ bool Dbtup::storedProcedureAttrInfo(Signal* signal,
   ndbrequire(regOperPtr->currentAttrinbufLen <= regOperPtr->attrinbufLen);
   if ((RnoFree > MIN_ATTRBUF) ||
       (copyProcedure)) {
-    ljam();
+    jam();
     regAttrPtr.i = cfirstfreeAttrbufrec;
     ptrCheckGuard(regAttrPtr, cnoOfAttrbufrec, attrbufrec);
     regAttrPtr.p->attrbuf[ZBUF_DATA_LEN] = 0;
@@ -163,18 +161,18 @@ bool Dbtup::storedProcedureAttrInfo(Signal* signal,
     cnoFreeAttrbufrec = RnoFree - 1;
     regAttrPtr.p->attrbuf[ZBUF_NEXT] = RNIL;
   } else {
-    ljam();
+    jam();
     storedSeizeAttrinbufrecErrorLab(signal, regOperPtr);
     return false;
   }//if
   if (regOperPtr->firstAttrinbufrec == RNIL) {
-    ljam();
+    jam();
     regOperPtr->firstAttrinbufrec = regAttrPtr.i;
   }//if
   regAttrPtr.p->attrbuf[ZBUF_NEXT] = RNIL;
   if (regOperPtr->lastAttrinbufrec != RNIL) {
     AttrbufrecPtr tempAttrinbufptr;
-    ljam();
+    jam();
     tempAttrinbufptr.i = regOperPtr->lastAttrinbufrec;  
     ptrCheckGuard(tempAttrinbufptr, cnoOfAttrbufrec, attrbufrec);
     tempAttrinbufptr.p->attrbuf[ZBUF_NEXT] = regAttrPtr.i;
@@ -187,7 +185,7 @@ bool Dbtup::storedProcedureAttrInfo(Signal* signal,
                    length);
 
   if (regOperPtr->currentAttrinbufLen < regOperPtr->attrinbufLen) {
-    ljam();
+    jam();
     return true;
   }//if
   if (ERROR_INSERTED(4005) && !copyProcedure) {
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp
index b85a2a8394d..6406bdefe1e 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp
@@ -15,14 +15,12 @@
 
 
 #define DBTUP_C
+#define DBTUP_TAB_DES_MAN_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
 #include <pc.hpp>
 
-#define ljam() { jamLine(22000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(22000 + __LINE__); }
-
 /*
  * TABLE DESCRIPTOR MEMORY MANAGER
  *
@@ -65,30 +63,30 @@ Uint32 Dbtup::allocTabDescr(const Tablerec* regTabPtr, Uint32* offset)
   allocSize = (((allocSize - 1) >> 4) + 1) << 4;
   Uint32 list = nextHigherTwoLog(allocSize - 1);	/* CALCULATE WHICH LIST IT BELONGS TO     */
   for (Uint32 i = list; i < 16; i++) {
-    ljam();
+    jam();
     if (cfreeTdList[i] != RNIL) {
-      ljam();
+      jam();
       reference = cfreeTdList[i];
       removeTdArea(reference, i);	                /* REMOVE THE AREA FROM THE FREELIST      */
       Uint32 retNo = (1 << i) - allocSize;	        /* CALCULATE THE DIFFERENCE               */
       if (retNo >= ZTD_FREE_SIZE) {
-        ljam();
+        jam();
         // return unused words, of course without attempting left merge
         Uint32 retRef = reference + allocSize;
         freeTabDescr(retRef, retNo, false);
       } else {
-        ljam();
+        jam();
         allocSize = 1 << i;
       }//if
       break;
     }//if
   }//for
   if (reference == RNIL) {
-    ljam();
+    jam();
     terrorCode = ZMEM_NOTABDESCR_ERROR;
     return RNIL;
   } else {
-    ljam();
+    jam();
     setTabDescrWord((reference + allocSize) - ZTD_TR_TYPE, ZTD_TYPE_NORMAL);
     setTabDescrWord(reference + ZTD_DATASIZE, allocSize);
 
@@ -105,7 +103,7 @@ void Dbtup::freeTabDescr(Uint32 retRef, Uint32 retNo, bool normal)
 {
   itdaMergeTabDescr(retRef, retNo, normal);       /* MERGE WITH POSSIBLE NEIGHBOURS   */
   while (retNo >= ZTD_FREE_SIZE) {
-    ljam();
+    jam();
     Uint32 list = nextHigherTwoLog(retNo);
     list--;	/* RETURN TO NEXT LOWER LIST    */
     Uint32 sizeOfChunk = 1 << list;
@@ -136,7 +134,7 @@ void Dbtup::insertTdArea(Uint32 tabDesRef, Uint32 list)
   setTabDescrWord(tabDesRef + ZTD_FL_HEADER, ZTD_TYPE_FREE);
   setTabDescrWord(tabDesRef + ZTD_FL_NEXT, cfreeTdList[list]);
   if (cfreeTdList[list] != RNIL) {
-    ljam();                                                /* PREVIOUSLY EMPTY SLOT     */
+    jam();                                                /* PREVIOUSLY EMPTY SLOT     */
     setTabDescrWord(cfreeTdList[list] + ZTD_FL_PREV, tabDesRef);
   }//if
   cfreeTdList[list] = tabDesRef;	/* RELINK THE LIST           */
@@ -156,28 +154,28 @@ void Dbtup::itdaMergeTabDescr(Uint32& retRef, Uint32& retNo, bool normal)
 {
   // merge right
   while ((retRef + retNo) < cnoOfTabDescrRec) {
-    ljam();
+    jam();
     Uint32 tabDesRef = retRef + retNo;
     Uint32 headerWord = getTabDescrWord(tabDesRef + ZTD_FL_HEADER);
     if (headerWord == ZTD_TYPE_FREE) {
-      ljam();
+      jam();
       Uint32 sizeOfMergedPart = getTabDescrWord(tabDesRef + ZTD_FL_SIZE);
 
       retNo += sizeOfMergedPart;
       Uint32 list = nextHigherTwoLog(sizeOfMergedPart - 1);
       removeTdArea(tabDesRef, list);
     } else {
-      ljam();
+      jam();
       break;
     }
   }
   // merge left
   const bool mergeLeft = normal;
   while (mergeLeft && retRef > 0) {
-    ljam();
+    jam();
     Uint32 trailerWord = getTabDescrWord(retRef - ZTD_TR_TYPE);
     if (trailerWord == ZTD_TYPE_FREE) {
-      ljam();
+      jam();
       Uint32 sizeOfMergedPart = getTabDescrWord(retRef - ZTD_TR_SIZE);
       ndbrequire(retRef >= sizeOfMergedPart);
       retRef -= sizeOfMergedPart;
@@ -185,7 +183,7 @@ void Dbtup::itdaMergeTabDescr(Uint32& retRef, Uint32& retNo, bool normal)
       Uint32 list = nextHigherTwoLog(sizeOfMergedPart - 1);
       removeTdArea(retRef, list);
     } else {
-      ljam();
+      jam();
       break;
     }
   }
@@ -213,15 +211,15 @@ void Dbtup::removeTdArea(Uint32 tabDesRef, Uint32 list)
   setTabDescrWord((tabDesRef + (1 << list)) - ZTD_TR_TYPE, ZTD_TYPE_NORMAL);
 
   if (tabDesRef == cfreeTdList[list]) {
-    ljam();
+    jam();
     cfreeTdList[list] = tabDescrNextPtr;	/* RELINK THE LIST           */
   }//if
   if (tabDescrNextPtr != RNIL) {
-    ljam();
+    jam();
     setTabDescrWord(tabDescrNextPtr + ZTD_FL_PREV, tabDescrPrevPtr);
   }//if
   if (tabDescrPrevPtr != RNIL) {
-    ljam();
+    jam();
     setTabDescrWord(tabDescrPrevPtr + ZTD_FL_NEXT, tabDescrNextPtr);
   }//if
 }//Dbtup::removeTdArea()
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp
index 9615047540b..0c6a1491543 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp
@@ -15,6 +15,7 @@
 
 
 #define DBTUP_C
+#define DBTUP_TRIGGER_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
@@ -26,9 +27,6 @@
 #include <signaldata/CreateTrig.hpp>
 #include <signaldata/TuxMaint.hpp>
 
-#define ljam() { jamLine(7000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(7000 + __LINE__); }
-
 /* **************************************************************** */
 /* ---------------------------------------------------------------- */
 /* ----------------------- TRIGGER HANDLING ----------------------- */
@@ -47,17 +45,17 @@ Dbtup::findTriggerList(Tablerec* table,
   case TriggerType::SUBSCRIPTION_BEFORE:
     switch (tevent) {
     case TriggerEvent::TE_INSERT:
-      ljam();
+      jam();
       if (ttime == TriggerActionTime::TA_DETACHED)
         tlist = &table->subscriptionInsertTriggers;
       break;
     case TriggerEvent::TE_UPDATE:
-      ljam();
+      jam();
       if (ttime == TriggerActionTime::TA_DETACHED)
         tlist = &table->subscriptionUpdateTriggers;
       break;
     case TriggerEvent::TE_DELETE:
-      ljam();
+      jam();
       if (ttime == TriggerActionTime::TA_DETACHED)
         tlist = &table->subscriptionDeleteTriggers;
       break;
@@ -68,17 +66,17 @@ Dbtup::findTriggerList(Tablerec* table,
   case TriggerType::SECONDARY_INDEX:
     switch (tevent) {
     case TriggerEvent::TE_INSERT:
-      ljam();
+      jam();
       if (ttime == TriggerActionTime::TA_AFTER)
         tlist = &table->afterInsertTriggers;
       break;
     case TriggerEvent::TE_UPDATE:
-      ljam();
+      jam();
       if (ttime == TriggerActionTime::TA_AFTER)
         tlist = &table->afterUpdateTriggers;
       break;
     case TriggerEvent::TE_DELETE:
-      ljam();
+      jam();
       if (ttime == TriggerActionTime::TA_AFTER)
         tlist = &table->afterDeleteTriggers;
       break;
@@ -89,7 +87,7 @@ Dbtup::findTriggerList(Tablerec* table,
   case TriggerType::ORDERED_INDEX:
     switch (tevent) {
     case TriggerEvent::TE_CUSTOM:
-      ljam();
+      jam();
       if (ttime == TriggerActionTime::TA_CUSTOM)
         tlist = &table->tuxCustomTriggers;
       break;
@@ -100,7 +98,7 @@ Dbtup::findTriggerList(Tablerec* table,
   case TriggerType::READ_ONLY_CONSTRAINT:
     switch (tevent) {
     case TriggerEvent::TE_UPDATE:
-      ljam();
+      jam();
       if (ttime == TriggerActionTime::TA_AFTER)
         tlist = &table->constraintUpdateTriggers;
       break;
@@ -118,7 +116,7 @@ Dbtup::findTriggerList(Tablerec* table,
 void
 Dbtup::execCREATE_TRIG_REQ(Signal* signal)
 {
-  ljamEntry();
+  jamEntry();
   BlockReference senderRef = signal->getSendersBlockRef();
   const CreateTrigReq reqCopy = *(const CreateTrigReq*)signal->getDataPtr();
   const CreateTrigReq* const req = &reqCopy;
@@ -131,13 +129,13 @@ Dbtup::execCREATE_TRIG_REQ(Signal* signal)
 
   if (tabPtr.p->tableStatus != DEFINED )
   {
-    ljam();
+    jam();
     error= CreateTrigRef::InvalidTable;
   }
   // Create trigger and associate it with the table
   else if (createTrigger(tabPtr.p, req))
   {
-    ljam();
+    jam();
     // Send conf
     CreateTrigConf* const conf = (CreateTrigConf*)signal->getDataPtrSend();
     conf->setUserRef(reference());
@@ -153,7 +151,7 @@ Dbtup::execCREATE_TRIG_REQ(Signal* signal)
   }
   else
   {
-    ljam();
+    jam();
     error= CreateTrigRef::TooManyTriggers;
   }
   ndbassert(error != CreateTrigRef::NoError);
@@ -174,7 +172,7 @@ Dbtup::execCREATE_TRIG_REQ(Signal* signal)
 void
 Dbtup::execDROP_TRIG_REQ(Signal* signal)
 {
-  ljamEntry();
+  jamEntry();
   BlockReference senderRef = signal->getSendersBlockRef();
   const DropTrigReq reqCopy = *(const DropTrigReq*)signal->getDataPtr();
   const DropTrigReq* const req = &reqCopy;
@@ -262,7 +260,7 @@ Dbtup::createTrigger(Tablerec* table, const CreateTrigReq* req)
   if ((tptr.p->triggerType == TriggerType::SUBSCRIPTION) &&
       ((tptr.p->triggerEvent == TriggerEvent::TE_UPDATE) ||
        (tptr.p->triggerEvent == TriggerEvent::TE_DELETE))) {
-    ljam();
+    jam();
     tptr.p->sendBeforeValues = false;
   }
   /*
@@ -270,7 +268,7 @@ Dbtup::createTrigger(Tablerec* table, const CreateTrigReq* req)
   if (((tptr.p->triggerType == TriggerType::SUBSCRIPTION) ||
       (tptr.p->triggerType == TriggerType::SUBSCRIPTION_BEFORE)) &&
       (tptr.p->triggerEvent == TriggerEvent::TE_UPDATE)) {
-    ljam();
+    jam();
     tptr.p->sendOnlyChangedAttributes = true;
   }
   */
@@ -282,16 +280,16 @@ Dbtup::createTrigger(Tablerec* table, const CreateTrigReq* req)
 
   tptr.p->attributeMask.clear();
   if (tptr.p->monitorAllAttributes) {
-    ljam();
+    jam();
     for(Uint32 i = 0; i < table->m_no_of_attributes; i++) {
       if (!primaryKey(table, i)) {
-        ljam();
+        jam();
         tptr.p->attributeMask.set(i);
       }
     }
   } else {
     // Set attribute mask
-    ljam();
+    jam();
     tptr.p->attributeMask = req->getAttributeMask();
   }
   return true;
@@ -336,7 +334,7 @@ Dbtup::dropTrigger(Tablerec* table, const DropTrigReq* req, BlockNumber sender)
 
   Ptr<TupTriggerData> ptr;
   for (tlist->first(ptr); !ptr.isNull(); tlist->next(ptr)) {
-    ljam();
+    jam();
     if (ptr.p->triggerId == triggerId) {
       if(ttype==TriggerType::SUBSCRIPTION && sender != ptr.p->m_receiverBlock)
       {
@@ -348,10 +346,10 @@ Dbtup::dropTrigger(Tablerec* table, const DropTrigReq* req, BlockNumber sender)
 	 *
 	 * Backup doesn't really care about the Ids though.
 	 */
-	ljam();
+	jam();
 	continue;
       }
-      ljam();
+      jam();
       tlist->release(ptr.i);
       return 0;
     }
@@ -379,7 +377,7 @@ Dbtup::checkImmediateTriggersAfterInsert(KeyReqStruct *req_struct,
 
   if ((regOperPtr->op_struct.primary_replica) &&
       (!(regTablePtr->afterInsertTriggers.isEmpty()))) {
-    ljam();
+    jam();
     fireImmediateTriggers(req_struct,
                           regTablePtr->afterInsertTriggers,
                           regOperPtr);
@@ -397,14 +395,14 @@ Dbtup::checkImmediateTriggersAfterUpdate(KeyReqStruct *req_struct,
 
   if ((regOperPtr->op_struct.primary_replica) &&
       (!(regTablePtr->afterUpdateTriggers.isEmpty()))) {
-    ljam();
+    jam();
     fireImmediateTriggers(req_struct,
                           regTablePtr->afterUpdateTriggers,
                           regOperPtr);
   }
   if ((regOperPtr->op_struct.primary_replica) &&
       (!(regTablePtr->constraintUpdateTriggers.isEmpty()))) {
-    ljam();
+    jam();
     fireImmediateTriggers(req_struct,
                           regTablePtr->constraintUpdateTriggers,
                           regOperPtr);
@@ -422,7 +420,7 @@ Dbtup::checkImmediateTriggersAfterDelete(KeyReqStruct *req_struct,
 
   if ((regOperPtr->op_struct.primary_replica) &&
       (!(regTablePtr->afterDeleteTriggers.isEmpty()))) {
-    ljam();
+    jam();
     executeTriggers(req_struct,
                     regTablePtr->afterDeleteTriggers,
                     regOperPtr);
@@ -443,7 +441,7 @@ void Dbtup::checkDeferredTriggers(Signal* signal,
                                   Operationrec* const regOperPtr,
                                   Tablerec* const regTablePtr)
 {
-  ljam();
+  jam();
   // NYI
 }//Dbtup::checkDeferredTriggers()
 #endif
@@ -479,7 +477,7 @@ void Dbtup::checkDetachedTriggers(KeyReqStruct *req_struct,
   if (save_ptr->m_header_bits & Tuple_header::ALLOC) {
     if (save_type == ZDELETE) {
       // insert + delete = nothing
-      ljam();
+      jam();
       return;
       goto end;
     }
@@ -495,10 +493,10 @@ void Dbtup::checkDetachedTriggers(KeyReqStruct *req_struct,
   
   switch(regOperPtr->op_struct.op_type) {
   case(ZINSERT):
-    ljam();
+    jam();
     if (regTablePtr->subscriptionInsertTriggers.isEmpty()) {
       // Table has no active triggers monitoring inserts at commit
-      ljam();
+      jam();
       goto end;
     }
 
@@ -508,10 +506,10 @@ void Dbtup::checkDetachedTriggers(KeyReqStruct *req_struct,
                          regOperPtr);
     break;
   case(ZDELETE):
-    ljam();
+    jam();
     if (regTablePtr->subscriptionDeleteTriggers.isEmpty()) {
       // Table has no active triggers monitoring deletes at commit
-      ljam();
+      jam();
       goto end;
     }
 
@@ -522,10 +520,10 @@ void Dbtup::checkDetachedTriggers(KeyReqStruct *req_struct,
 			 regOperPtr);
     break;
   case(ZUPDATE):
-    ljam();
+    jam();
     if (regTablePtr->subscriptionUpdateTriggers.isEmpty()) {
       // Table has no active triggers monitoring updates at commit
-      ljam();
+      jam();
       goto end;
     }
 
@@ -553,10 +551,10 @@ Dbtup::fireImmediateTriggers(KeyReqStruct *req_struct,
   TriggerPtr trigPtr;
   triggerList.first(trigPtr);
   while (trigPtr.i != RNIL) {
-    ljam();
+    jam();
     if (trigPtr.p->monitorAllAttributes ||
         trigPtr.p->attributeMask.overlaps(req_struct->changeMask)) {
-      ljam();
+      jam();
       executeTrigger(req_struct,
                      trigPtr.p,
                      regOperPtr);
@@ -575,10 +573,10 @@ Dbtup::fireDeferredTriggers(Signal* signal,
   TriggerPtr trigPtr;
   triggerList.first(trigPtr);
   while (trigPtr.i != RNIL) {
-    ljam();
+    jam();
     if (trigPtr.p->monitorAllAttributes ||
         trigPtr.p->attributeMask.overlaps(req_struct->changeMask)) {
-      ljam();
+      jam();
       executeTrigger(req_struct,
                      trigPtr,
                      regOperPtr);
@@ -604,12 +602,12 @@ Dbtup::fireDetachedTriggers(KeyReqStruct *req_struct,
   ndbrequire(regOperPtr->is_first_operation());
   triggerList.first(trigPtr);
   while (trigPtr.i != RNIL) {
-    ljam();
+    jam();
     if ((trigPtr.p->monitorReplicas ||
          regOperPtr->op_struct.primary_replica) &&
         (trigPtr.p->monitorAllAttributes ||
          trigPtr.p->attributeMask.overlaps(req_struct->changeMask))) {
-      ljam();
+      jam();
       executeTrigger(req_struct,
                      trigPtr.p,
                      regOperPtr);
@@ -625,7 +623,7 @@ void Dbtup::executeTriggers(KeyReqStruct *req_struct,
   TriggerPtr trigPtr;
   triggerList.first(trigPtr);
   while (trigPtr.i != RNIL) {
-    ljam();
+    jam();
     executeTrigger(req_struct,
                    trigPtr.p,
                    regOperPtr);
@@ -675,7 +673,7 @@ void Dbtup::executeTrigger(KeyReqStruct *req_struct,
   ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
 
   if (ref == BACKUP) {
-    ljam();
+    jam();
     /*
     In order for the implementation of BACKUP to work even when changing
     primaries in the middle of the backup we need to set the trigger on
@@ -688,9 +686,9 @@ void Dbtup::executeTrigger(KeyReqStruct *req_struct,
     signal->theData[0] = trigPtr->triggerId;
     signal->theData[1] = regFragPtr.p->fragmentId;
     EXECUTE_DIRECT(BACKUP, GSN_BACKUP_TRIG_REQ, signal, 2);
-    ljamEntry();
+    jamEntry();
     if (signal->theData[0] == 0) {
-      ljam();
+      jam();
       return;
     }
   }
@@ -704,7 +702,7 @@ void Dbtup::executeTrigger(KeyReqStruct *req_struct,
                        noAfterWords,
                        beforeBuffer,
                        noBeforeWords)) {
-    ljam();
+    jam();
     return;
   }
 //--------------------------------------------------------------------
@@ -720,13 +718,13 @@ void Dbtup::executeTrigger(KeyReqStruct *req_struct,
 
   switch(trigPtr->triggerType) {
   case (TriggerType::SECONDARY_INDEX):
-    ljam();
+    jam();
     ref = req_struct->TC_ref;
     executeDirect = false;
     break;
   case (TriggerType::SUBSCRIPTION):
   case (TriggerType::SUBSCRIPTION_BEFORE):
-    ljam();
+    jam();
     // Since only backup uses subscription triggers we send to backup directly for now
     ref = trigPtr->m_receiverBlock;
     executeDirect = true;
@@ -747,22 +745,22 @@ void Dbtup::executeTrigger(KeyReqStruct *req_struct,
 
   switch(regOperPtr->op_struct.op_type) {
   case(ZINSERT):
-    ljam();
+    jam();
     // Send AttrInfo signals with new attribute values
     trigAttrInfo->setAttrInfoType(TrigAttrInfo::AFTER_VALUES);
     sendTrigAttrInfo(signal, afterBuffer, noAfterWords, executeDirect, ref);
     break;
   case(ZDELETE):
     if (trigPtr->sendBeforeValues) {
-      ljam();
+      jam();
       trigAttrInfo->setAttrInfoType(TrigAttrInfo::BEFORE_VALUES);
       sendTrigAttrInfo(signal, beforeBuffer, noBeforeWords, executeDirect,ref);
     }
     break;
   case(ZUPDATE):
-    ljam();
+    jam();
     if (trigPtr->sendBeforeValues) {
-      ljam();
+      jam();
       trigAttrInfo->setAttrInfoType(TrigAttrInfo::BEFORE_VALUES);
       sendTrigAttrInfo(signal, beforeBuffer, noBeforeWords, executeDirect,ref);
     }
@@ -788,9 +786,9 @@ Uint32 Dbtup::setAttrIds(Bitmask<MAXNROFATTRIBUTESINWORDS>& attributeMask,
 {
   Uint32 bufIndx = 0;
   for (Uint32 i = 0; i < m_no_of_attributesibutes; i++) {
-    ljam();
+    jam();
     if (attributeMask.get(i)) {
-      ljam();
+      jam();
       AttributeHeader::init(&inBuffer[bufIndx++], i, 0);
     }
   }
@@ -858,7 +856,7 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr,
   Uint32 numAttrsToRead;
   if ((regOperPtr->op_struct.op_type == ZUPDATE) &&
       (trigPtr->sendOnlyChangedAttributes)) {
-    ljam();
+    jam();
 //--------------------------------------------------------------------
 // Update that sends only changed information
 //--------------------------------------------------------------------
@@ -870,13 +868,13 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr,
     
   } else if ((regOperPtr->op_struct.op_type == ZDELETE) &&
              (!trigPtr->sendBeforeValues)) {
-    ljam();
+    jam();
 //--------------------------------------------------------------------
 // Delete without sending before values only read Primary Key
 //--------------------------------------------------------------------
     return true;
   } else {
-    ljam();
+    jam();
 //--------------------------------------------------------------------
 // All others send all attributes that are monitored, except:
 // Omit unchanged blob inlines on update i.e.
@@ -898,7 +896,7 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr,
 //--------------------------------------------------------------------
   if (regOperPtr->op_struct.op_type != ZDELETE)
   {
-    ljam();
+    jam();
     int ret = readAttributes(req_struct,
 			     &readBuffer[0],
 			     numAttrsToRead,
@@ -908,7 +906,7 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr,
     ndbrequire(ret != -1);
     noAfterWords= ret;
   } else {
-    ljam();
+    jam();
     noAfterWords = 0;
   }
 
@@ -920,7 +918,7 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr,
   if ((regOperPtr->op_struct.op_type == ZUPDATE || 
        regOperPtr->op_struct.op_type == ZDELETE) &&
       (trigPtr->sendBeforeValues)) {
-    ljam();
+    jam();
     
     Tuple_header *save= req_struct->m_tuple_ptr;
     PagePtr tmp;
@@ -956,7 +954,7 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr,
 // Although a trigger was fired it was not necessary since the old
 // value and the new value was exactly the same
 //--------------------------------------------------------------------
-      ljam();
+      jam();
       //XXX does this work with collations?
       return false;
     }
@@ -976,21 +974,21 @@ void Dbtup::sendTrigAttrInfo(Signal* signal,
   do {
     sigLen = dataLen - dataIndex;
     if (sigLen > TrigAttrInfo::DataLength) {
-      ljam();
+      jam();
       sigLen = TrigAttrInfo::DataLength;
     }
     MEMCOPY_NO_WORDS(trigAttrInfo->getData(), 
                      data + dataIndex,
                      sigLen);
     if (executeDirect) {
-      ljam();
+      jam();
       EXECUTE_DIRECT(receiverReference, 
                      GSN_TRIG_ATTRINFO,
                      signal,
 		     TrigAttrInfo::StaticLength + sigLen);
-      ljamEntry();
+      jamEntry();
     } else {
-      ljam();
+      jam();
       sendSignal(receiverReference, 
                  GSN_TRIG_ATTRINFO, 
                  signal, 
@@ -1018,15 +1016,15 @@ void Dbtup::sendFireTrigOrd(Signal* signal,
 
   switch(regOperPtr->op_struct.op_type) {
   case(ZINSERT):
-    ljam();
+    jam();
     fireTrigOrd->setTriggerEvent(TriggerEvent::TE_INSERT);
     break;
   case(ZDELETE):
-    ljam();
+    jam();
     fireTrigOrd->setTriggerEvent(TriggerEvent::TE_DELETE);
     break;
   case(ZUPDATE):
-    ljam();
+    jam();
     fireTrigOrd->setTriggerEvent(TriggerEvent::TE_UPDATE);
     break;
   default:
@@ -1040,12 +1038,12 @@ void Dbtup::sendFireTrigOrd(Signal* signal,
 
   switch(trigPtr->triggerType) {
   case (TriggerType::SECONDARY_INDEX):
-    ljam();
+    jam();
     sendSignal(req_struct->TC_ref, GSN_FIRE_TRIG_ORD, 
                signal, FireTrigOrd::SignalLength, JBB);
     break;
   case (TriggerType::SUBSCRIPTION_BEFORE): // Only Suma
-    ljam();
+    jam();
     // Since only backup uses subscription triggers we 
     // send to backup directly for now
     fireTrigOrd->setGCI(req_struct->gci);
@@ -1056,7 +1054,7 @@ void Dbtup::sendFireTrigOrd(Signal* signal,
 		   FireTrigOrd::SignalWithHashValueLength);
     break;
   case (TriggerType::SUBSCRIPTION):
-    ljam();
+    jam();
     // Since only backup uses subscription triggers we 
     // send to backup directly for now
     fireTrigOrd->setGCI(req_struct->gci);
@@ -1123,7 +1121,7 @@ Dbtup::addTuxEntries(Signal* signal,
                      Tablerec* regTabPtr)
 {
   if (ERROR_INSERTED(4022)) {
-    ljam();
+    jam();
     CLEAR_ERROR_INSERT_VALUE;
     terrorCode = 9999;
     return -1;
@@ -1134,12 +1132,12 @@ Dbtup::addTuxEntries(Signal* signal,
   Uint32 failPtrI;
   triggerList.first(triggerPtr);
   while (triggerPtr.i != RNIL) {
-    ljam();
+    jam();
     req->indexId = triggerPtr.p->indexId;
     req->errorCode = RNIL;
     if (ERROR_INSERTED(4023) &&
         ! triggerList.hasNext(triggerPtr)) {
-      ljam();
+      jam();
       CLEAR_ERROR_INSERT_VALUE;
       terrorCode = 9999;
       failPtrI = triggerPtr.i;
@@ -1147,9 +1145,9 @@ Dbtup::addTuxEntries(Signal* signal,
     }
     EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
         signal, TuxMaintReq::SignalLength);
-    ljamEntry();
+    jamEntry();
     if (req->errorCode != 0) {
-      ljam();
+      jam();
       terrorCode = req->errorCode;
       failPtrI = triggerPtr.i;
       goto fail;
@@ -1161,12 +1159,12 @@ fail:
   req->opInfo = TuxMaintReq::OpRemove;
   triggerList.first(triggerPtr);
   while (triggerPtr.i != failPtrI) {
-    ljam();
+    jam();
     req->indexId = triggerPtr.p->indexId;
     req->errorCode = RNIL;
     EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
         signal, TuxMaintReq::SignalLength);
-    ljamEntry();
+    jamEntry();
     ndbrequire(req->errorCode == 0);
     triggerList.next(triggerPtr);
   }
@@ -1197,15 +1195,15 @@ Dbtup::executeTuxCommitTriggers(Signal* signal,
   if (regOperPtr->op_struct.op_type == ZINSERT) {
     if (! regOperPtr->op_struct.delete_insert_flag)
       return;
-    ljam();
+    jam();
     tupVersion= decr_tup_version(regOperPtr->tupVersion);
   } else if (regOperPtr->op_struct.op_type == ZUPDATE) {
-    ljam();
+    jam();
     tupVersion= decr_tup_version(regOperPtr->tupVersion);
   } else if (regOperPtr->op_struct.op_type == ZDELETE) {
     if (regOperPtr->op_struct.delete_insert_flag)
       return;
-    ljam();
+    jam();
     tupVersion= regOperPtr->tupVersion;
   } else {
     ndbrequire(false);
@@ -1231,13 +1229,13 @@ Dbtup::executeTuxAbortTriggers(Signal* signal,
   // get version
   Uint32 tupVersion;
   if (regOperPtr->op_struct.op_type == ZINSERT) {
-    ljam();
+    jam();
     tupVersion = regOperPtr->tupVersion;
   } else if (regOperPtr->op_struct.op_type == ZUPDATE) {
-    ljam();
+    jam();
     tupVersion = regOperPtr->tupVersion;
   } else if (regOperPtr->op_struct.op_type == ZDELETE) {
-    ljam();
+    jam();
     return;
   } else {
     ndbrequire(false);
@@ -1262,12 +1260,12 @@ Dbtup::removeTuxEntries(Signal* signal,
   TriggerPtr triggerPtr;
   triggerList.first(triggerPtr);
   while (triggerPtr.i != RNIL) {
-    ljam();
+    jam();
     req->indexId = triggerPtr.p->indexId;
     req->errorCode = RNIL,
     EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
         signal, TuxMaintReq::SignalLength);
-    ljamEntry();
+    jamEntry();
     // must succeed
     ndbrequire(req->errorCode == 0);
     triggerList.next(triggerPtr);
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupVarAlloc.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupVarAlloc.cpp
index 072bd69da97..763bbaf9906 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupVarAlloc.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupVarAlloc.cpp
@@ -14,12 +14,9 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_VAR_ALLOC_CPP
 #include "Dbtup.hpp"
 
-#define ljam() { jamLine(32000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(32000 + __LINE__); }
-
-
 void Dbtup::init_list_sizes(void)
 {
   c_min_list_size[0]= 200;
@@ -109,9 +106,9 @@ Dbtup::alloc_var_part(Fragrecord* fragPtr,
   PagePtr pagePtr;
   pagePtr.i= get_alloc_page(fragPtr, (alloc_size + 1));
   if (pagePtr.i == RNIL) { 
-    ljam();
+    jam();
     if ((pagePtr.i= get_empty_var_page(fragPtr)) == RNIL) {
-      ljam();
+      jam();
       return 0;
     }
     c_page_pool.getPtr(pagePtr);
@@ -127,7 +124,7 @@ Dbtup::alloc_var_part(Fragrecord* fragPtr,
     pagePtr.p->page_state = ZTH_MM_FREE;
   } else {
     c_page_pool.getPtr(pagePtr);
-    ljam();
+    jam();
   }
   Uint32 idx= ((Var_page*)pagePtr.p)
     ->alloc_record(alloc_size, (Var_page*)ctemp_page, Var_page::CHAIN);
@@ -177,7 +174,7 @@ void Dbtup::free_var_rec(Fragrecord* fragPtr,
   ndbassert(pagePtr.p->free_space <= Var_page::DATA_WORDS);
   if (pagePtr.p->free_space == Var_page::DATA_WORDS - 1)
   {
-    ljam();
+    jam();
     /*
       This code could be used when we release pages.
       remove_free_page(signal,fragPtr,page_header,page_header->list_index);
@@ -185,7 +182,7 @@ void Dbtup::free_var_rec(Fragrecord* fragPtr,
     */
     update_free_page_list(fragPtr, pagePtr);
   } else {
-    ljam();
+    jam();
     update_free_page_list(fragPtr, pagePtr);
   }
   return;
@@ -259,16 +256,16 @@ Dbtup::get_alloc_page(Fragrecord* fragPtr, Uint32 alloc_size)
   
   start_index= calculate_free_list_impl(alloc_size);
   if (start_index == (MAX_FREE_LIST - 1)) {
-    ljam();
+    jam();
   } else {
-    ljam();
+    jam();
     ndbrequire(start_index < (MAX_FREE_LIST - 1));
     start_index++;
   }
   for (i= start_index; i < MAX_FREE_LIST; i++) {
-    ljam();
+    jam();
     if (!fragPtr->free_var_page_array[i].isEmpty()) {
-      ljam();
+      jam();
       return fragPtr->free_var_page_array[i].firstItem;
     }
   }
@@ -277,9 +274,9 @@ Dbtup::get_alloc_page(Fragrecord* fragPtr, Uint32 alloc_size)
   LocalDLList<Page> list(c_page_pool, fragPtr->free_var_page_array[i]);
   for(list.first(pagePtr); !pagePtr.isNull() && loop < 16; )
   {
-    ljam();
+    jam();
     if (pagePtr.p->free_space >= alloc_size) {
-      ljam();
+      jam();
       return pagePtr.i;
     }
     loop++;
@@ -346,7 +343,7 @@ void Dbtup::update_free_page_list(Fragrecord* fragPtr,
       (free_space > c_max_list_size[list_index])) {
     Uint32 new_list_index= calculate_free_list_impl(free_space);
     if (list_index != MAX_FREE_LIST) {
-      ljam();
+      jam();
       /*
        * Only remove it from its list if it is in a list
        */
@@ -361,11 +358,11 @@ void Dbtup::update_free_page_list(Fragrecord* fragPtr,
 	This can only happen for the free list with least guaranteed 
 	free space.
       */
-      ljam();
+      jam();
       ndbrequire(new_list_index == 0);
       pagePtr.p->list_index= MAX_FREE_LIST;
     } else {
-      ljam();
+      jam();
       LocalDLList<Page> list(c_page_pool, 
 			     fragPtr->free_var_page_array[new_list_index]);
       list.add(pagePtr);
@@ -381,9 +378,9 @@ Uint32 Dbtup::calculate_free_list_impl(Uint32 free_space_size) const
 {
   Uint32 i;
   for (i = 0; i < MAX_FREE_LIST; i++) {
-    ljam();
+    jam();
     if (free_space_size <= c_max_list_size[i]) {
-      ljam();
+      jam();
       return i;
     }
   }
diff --git a/storage/ndb/src/kernel/error/ErrorReporter.cpp b/storage/ndb/src/kernel/error/ErrorReporter.cpp
index 3d1b7fad7f3..43307d43139 100644
--- a/storage/ndb/src/kernel/error/ErrorReporter.cpp
+++ b/storage/ndb/src/kernel/error/ErrorReporter.cpp
@@ -24,6 +24,7 @@
 #include <NdbHost.h>
 #include <NdbConfig.h>
 #include <Configuration.hpp>
+#include "EventLogger.hpp"
 
 #include <NdbAutoPtr.hpp>
 
@@ -39,7 +40,7 @@ static void dumpJam(FILE* jamStream,
 		    Uint32 thrdTheEmulatedJamIndex, 
 		    Uint8 thrdTheEmulatedJam[]);
 
-
+extern EventLogger g_eventLogger;
 const char*
 ErrorReporter::formatTimeStampString(){
   TimeModule DateTime;          /* To create "theDateTimeString" */
@@ -196,6 +197,9 @@ ErrorReporter::handleError(int messageID,
   WriteMessage(messageID, problemData,
 	       objRef, theEmulatedJamIndex, theEmulatedJam);
 
+  g_eventLogger.info(problemData);
+  g_eventLogger.info(objRef);
+
   childReportError(messageID);
 
   if(messageID == NDBD_EXIT_ERROR_INSERT){
diff --git a/storage/ndb/src/mgmclient/CommandInterpreter.cpp b/storage/ndb/src/mgmclient/CommandInterpreter.cpp
index 7c57d9eabbc..fdcea63640c 100644
--- a/storage/ndb/src/mgmclient/CommandInterpreter.cpp
+++ b/storage/ndb/src/mgmclient/CommandInterpreter.cpp
@@ -2056,6 +2056,7 @@ CommandInterpreter::executeStatus(int processId,
   }
   if (cl->node_states[i].node_type != NDB_MGM_NODE_TYPE_NDB){
     if (cl->node_states[i].version != 0){
+      version = cl->node_states[i].version;
       ndbout << "Node "<< cl->node_states[i].node_id <<": connected" ;
       ndbout_c(" (Version %d.%d.%d)",
              getMajor(version) ,
@@ -2065,7 +2066,7 @@ CommandInterpreter::executeStatus(int processId,
     }else
      ndbout << "Node "<< cl->node_states[i].node_id <<": not connected" << endl;
     return 0;
-  } 
+  }
   status = cl->node_states[i].node_status;
   startPhase = cl->node_states[i].start_phase;
   version = cl->node_states[i].version;
diff --git a/storage/ndb/src/mgmsrv/ConfigInfo.cpp b/storage/ndb/src/mgmsrv/ConfigInfo.cpp
index e7c6122d846..6351af7246e 100644
--- a/storage/ndb/src/mgmsrv/ConfigInfo.cpp
+++ b/storage/ndb/src/mgmsrv/ConfigInfo.cpp
@@ -449,7 +449,7 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
     ConfigInfo::CI_INT,
     "128",
     "8",
-    STR_VALUE(MAX_INT_RNIL) },
+    STR_VALUE(MAX_TABLES) },
   
   {
     CFG_DB_NO_ORDERED_INDEXES,
diff --git a/storage/ndb/src/mgmsrv/ParamInfo.cpp b/storage/ndb/src/mgmsrv/ParamInfo.cpp
index 4a4e80eb079..888b7948c05 100644
--- a/storage/ndb/src/mgmsrv/ParamInfo.cpp
+++ b/storage/ndb/src/mgmsrv/ParamInfo.cpp
@@ -275,7 +275,7 @@ const ParamInfo ParamInfoArray[] = {
     CI_INT,
     "128",
     "8",
-    STR_VALUE(MAX_INT_RNIL) },
+    STR_VALUE(MAX_TABLES) },
   
   {
     CFG_DB_NO_ORDERED_INDEXES,
diff --git a/storage/ndb/src/ndbapi/NdbScanFilter.cpp b/storage/ndb/src/ndbapi/NdbScanFilter.cpp
index 6ff7485416b..89abba2eddc 100644
--- a/storage/ndb/src/ndbapi/NdbScanFilter.cpp
+++ b/storage/ndb/src/ndbapi/NdbScanFilter.cpp
@@ -42,7 +42,9 @@ public:
 
   int m_label;
   State m_current;
+  Uint32 m_negative;    //used for translating NAND/NOR to AND/OR, equal 0 or 1 
   Vector<State> m_stack;
+  Vector<Uint32> m_stack2;    //to store info of m_negative
   NdbOperation * m_operation;
   Uint32 m_latestAttrib;
 
@@ -66,6 +68,7 @@ NdbScanFilter::NdbScanFilter(class NdbOperation * op)
   m_impl.m_label = 0;
   m_impl.m_latestAttrib = ~0;
   m_impl.m_operation = op;
+  m_impl.m_negative = 0;
 }
 
 NdbScanFilter::~NdbScanFilter(){
@@ -75,18 +78,39 @@ NdbScanFilter::~NdbScanFilter(){
 int
 NdbScanFilter::begin(Group group){
 
+  m_impl.m_stack2.push_back(m_impl.m_negative);
   switch(group){
   case NdbScanFilter::AND:
     INT_DEBUG(("Begin(AND)"));
+    if(m_impl.m_negative == 1){
+      group = NdbScanFilter::OR;
+    }
     break;
   case NdbScanFilter::OR:
     INT_DEBUG(("Begin(OR)"));
+    if(m_impl.m_negative == 1){
+      group = NdbScanFilter::AND;
+    }
     break;
   case NdbScanFilter::NAND:
     INT_DEBUG(("Begin(NAND)"));
+    if(m_impl.m_negative == 0){
+      group = NdbScanFilter::OR;
+      m_impl.m_negative = 1; 
+    }else{
+      group = NdbScanFilter::AND;
+      m_impl.m_negative = 0; 
+    }
     break;
   case NdbScanFilter::NOR:
     INT_DEBUG(("Begin(NOR)"));
+    if(m_impl.m_negative == 0){
+      group = NdbScanFilter::AND;
+      m_impl.m_negative = 1; 
+    }else{
+      group = NdbScanFilter::OR;
+      m_impl.m_negative = 0; 
+    }
     break;
   }
 
@@ -130,6 +154,13 @@ NdbScanFilter::begin(Group group){
 int
 NdbScanFilter::end(){
 
+  if(m_impl.m_stack2.size() == 0){
+    m_impl.m_operation->setErrorCodeAbort(4259);
+    return -1;
+  }
+  m_impl.m_negative = m_impl.m_stack2.back();
+  m_impl.m_stack2.erase(m_impl.m_stack2.size() - 1);
+
   switch(m_impl.m_current.m_group){
   case NdbScanFilter::AND:
     INT_DEBUG(("End(AND pc=%d)", m_impl.m_current.m_popCount));
@@ -151,6 +182,10 @@ NdbScanFilter::end(){
   }
   
   NdbScanFilterImpl::State tmp = m_impl.m_current;  
+  if(m_impl.m_stack.size() == 0){
+    m_impl.m_operation->setErrorCodeAbort(4259);
+    return -1;
+  }
   m_impl.m_current = m_impl.m_stack.back();
   m_impl.m_stack.erase(m_impl.m_stack.size() - 1);
   
@@ -395,8 +430,17 @@ NdbScanFilterImpl::cond_col_const(Interpreter::BinaryCondition op,
     m_operation->setErrorCodeAbort(4260);
     return -1;
   }
+
+  StrBranch2 branch;
+  if(m_negative == 1){  //change NdbOperation to its negative
+    if(m_current.m_group == NdbScanFilter::AND)
+      branch = table3[op].m_branches[(Uint32)(m_current.m_group) + 1];
+    if(m_current.m_group == NdbScanFilter::OR)
+      branch = table3[op].m_branches[(Uint32)(m_current.m_group) - 1];
+  }else{
+    branch = table3[op].m_branches[(Uint32)(m_current.m_group)];
+  }
   
-  StrBranch2 branch = table3[op].m_branches[m_current.m_group];
   const NdbDictionary::Column * col = 
     m_operation->m_currentTable->getColumn(AttrId);
   
diff --git a/storage/ndb/test/include/NDBT_Test.hpp b/storage/ndb/test/include/NDBT_Test.hpp
index 46d27ec1c3c..ad09f04e814 100644
--- a/storage/ndb/test/include/NDBT_Test.hpp
+++ b/storage/ndb/test/include/NDBT_Test.hpp
@@ -333,6 +333,12 @@ public:
   // supply argc and argv as parameters
   int execute(int, const char**);
 
+  // NDBT's test tables are fixed and it always create 
+  // and drop fixed table when execute, add this method 
+  // in order to run CTX only and adapt to some new 
+  // customized testsuite
+  int executeOneCtx(Ndb_cluster_connection&,
+		 const NdbDictionary::Table* ptab, const char* testname = NULL);
 
   // These function can be used from main in the test program 
   // to control the behaviour of the testsuite
diff --git a/storage/ndb/test/ndbapi/Makefile.am b/storage/ndb/test/ndbapi/Makefile.am
index 3209a8be523..ad509dbbafe 100644
--- a/storage/ndb/test/ndbapi/Makefile.am
+++ b/storage/ndb/test/ndbapi/Makefile.am
@@ -39,6 +39,7 @@ testOperations \
 testRestartGci \
 testScan \
 testInterpreter \
+testScanFilter \
 testScanInterpreter \
 testScanPerf \
 testSystemRestart \
@@ -85,6 +86,7 @@ testOperations_SOURCES = testOperations.cpp
 testRestartGci_SOURCES = testRestartGci.cpp
 testScan_SOURCES = testScan.cpp ScanFunctions.hpp
 testInterpreter_SOURCES = testInterpreter.cpp
+testScanFilter_SOURCES = testScanFilter.cpp
 testScanInterpreter_SOURCES = testScanInterpreter.cpp ScanFilter.hpp ScanInterpretTest.hpp 
 testScanPerf_SOURCES = testScanPerf.cpp
 testSystemRestart_SOURCES = testSystemRestart.cpp
diff --git a/storage/ndb/test/ndbapi/testScanFilter.cpp b/storage/ndb/test/ndbapi/testScanFilter.cpp
new file mode 100644
index 00000000000..ba869dc8ce4
--- /dev/null
+++ b/storage/ndb/test/ndbapi/testScanFilter.cpp
@@ -0,0 +1,851 @@
+/* Copyright (C) 2007, Justin He, MySQL AB
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+
+#include <NDBT.hpp>
+#include <NDBT_Test.hpp>
+
+#define ERR_EXIT(obj, msg) \
+do \
+{ \
+fprintf(stderr, "%s: %s (%d) in %s:%d\n", \
+msg, obj->getNdbError().message, obj->getNdbError().code, __FILE__, __LINE__); \
+exit(-1); \
+} \
+while (0);
+
+#define PRINT_ERROR(code,msg) \
+do \
+{ \
+fprintf(stderr, "Error in %s, line: %d, code: %d, msg: %s.\n", __FILE__, __LINE__, code, msg); \
+} \
+while (0);
+
+#define MYSQLERROR(mysql) { \
+  PRINT_ERROR(mysql_errno(&mysql),mysql_error(&mysql)); \
+  exit(-1); }
+#define APIERROR(error) { \
+  PRINT_ERROR(error.code,error.message); \
+  exit(-1); }
+
+#define TEST_NAME "TestScanFilter" 
+#define TABLE_NAME "TABLE_SCAN"
+
+const char *COL_NAME[] = {"id", "i", "j", "k", "l", "m", "n"}; 
+const char COL_LEN = 7;
+/*
+* Not to change TUPLE_NUM, because the column in TABLE_NAME is fixed,
+* there are six columns, 'i', 'j', 'k', 'l', 'm', 'n', and each on is equal to 1 or 1,
+* Since each tuple should be unique in this case, then TUPLE_NUM = 2 power 6 = 64 
+*/
+const int TUPLE_NUM = (int)pow(2, COL_LEN-1);    
+
+/*
+* the recursive level of random scan filter, can 
+* modify this parameter more or less, range from 
+* 1 to 100, larger num consumes more scan time
+*/
+const int RECURSIVE_LEVEL = 10;
+
+const int MAX_STR_LEN = (RECURSIVE_LEVEL * (COL_LEN+1) * 4);
+
+/*
+* Each time stands for one test, it will produce a random 
+* filter string, and scan through ndb api and through 
+* calculation with tuples' data, then compare the result, 
+* if they are equal, this test passed, or failed.
+* Only all TEST_NUM times tests passed, we can believe 
+* the suite of test cases are okay.
+* Change TEST_NUM to larger will need more time to test
+*/
+const int TEST_NUM = 5000;
+
+
+/* Table definition*/
+static
+const
+NDBT_Attribute MYTAB1Attribs[] = {
+  NDBT_Attribute("id", NdbDictionary::Column::Unsigned, 1, true), 
+  NDBT_Attribute("i", NdbDictionary::Column::Unsigned),
+  NDBT_Attribute("j", NdbDictionary::Column::Unsigned),
+  NDBT_Attribute("k", NdbDictionary::Column::Unsigned),
+  NDBT_Attribute("l", NdbDictionary::Column::Unsigned),
+  NDBT_Attribute("m", NdbDictionary::Column::Unsigned),
+  NDBT_Attribute("n", NdbDictionary::Column::Unsigned),
+};
+static
+const
+NDBT_Table MYTAB1(TABLE_NAME, sizeof(MYTAB1Attribs)/sizeof(NDBT_Attribute), MYTAB1Attribs);
+
+
+int createTable(Ndb* pNdb, const NdbDictionary::Table* tab, bool _temp, 
+			 bool existsOk, NDBT_CreateTableHook f)
+{
+  int r = 0;
+  do{
+    NdbDictionary::Table tmpTab(* tab);
+    tmpTab.setStoredTable(_temp ? 0 : 1);
+    if(f != 0 && f(pNdb, tmpTab, 0, NULL))
+    {
+      ndbout << "Failed to create table" << endl;
+      return NDBT_FAILED;
+    }      
+    r = pNdb->getDictionary()->createTable(tmpTab);
+    if(r == -1){
+      if(!existsOk){
+	ndbout << "Error: " << pNdb->getDictionary()->getNdbError() << endl;
+	break;
+      }
+      if(pNdb->getDictionary()->getNdbError().code != 721){
+	ndbout << "Error: " << pNdb->getDictionary()->getNdbError() << endl;
+	break;
+      }
+      r = 0;
+    }
+  }while(false);
+  
+  return r;
+}
+
+/*
+* Function to produce the tuples' data
+*/
+int runPopulate(NDBT_Context* ctx, NDBT_Step* step)
+{
+  Ndb *myNdb = GETNDB(step);
+  const NdbDictionary::Dictionary* myDict= myNdb->getDictionary();
+  const NdbDictionary::Table *myTable= myDict->getTable(TABLE_NAME);
+  if(myTable == NULL) 
+    APIERROR(myDict->getNdbError());
+
+  NdbTransaction* myTrans = myNdb->startTransaction();
+  if (myTrans == NULL)
+    APIERROR(myNdb->getNdbError());
+
+  for(int num = 0; num < TUPLE_NUM; num++) 
+  {
+    NdbOperation* myNdbOperation = myTrans->getNdbOperation(myTable);
+    if(myNdbOperation == NULL) 
+    {
+      APIERROR(myTrans->getNdbError());
+    }
+
+/* the tuples' data in TABLE_NAME
++----+---+---+---+---+---+---+
+| id | i | j | k | l | m | n |
++----+---+---+---+---+---+---+
+|  0 | 0 | 0 | 0 | 0 | 0 | 0 |
+|  1 | 0 | 0 | 0 | 0 | 0 | 1 |
+|  2 | 0 | 0 | 0 | 0 | 1 | 0 |
+|  3 | 0 | 0 | 0 | 0 | 1 | 1 |
+|  4 | 0 | 0 | 0 | 1 | 0 | 0 |
+|  5 | 0 | 0 | 0 | 1 | 0 | 1 |
+|  6 | 0 | 0 | 0 | 1 | 1 | 0 |
+|  7 | 0 | 0 | 0 | 1 | 1 | 1 |
+|  8 | 0 | 0 | 1 | 0 | 0 | 0 |
+|  9 | 0 | 0 | 1 | 0 | 0 | 1 |
+| 10 | 0 | 0 | 1 | 0 | 1 | 0 |
+| 11 | 0 | 0 | 1 | 0 | 1 | 1 |
+| 12 | 0 | 0 | 1 | 1 | 0 | 0 |
+| 13 | 0 | 0 | 1 | 1 | 0 | 1 |
+| 14 | 0 | 0 | 1 | 1 | 1 | 0 |
+| 15 | 0 | 0 | 1 | 1 | 1 | 1 |
+| 16 | 0 | 1 | 0 | 0 | 0 | 0 |
+| 17 | 0 | 1 | 0 | 0 | 0 | 1 |
+| 18 | 0 | 1 | 0 | 0 | 1 | 0 |
+| 19 | 0 | 1 | 0 | 0 | 1 | 1 |
+| 20 | 0 | 1 | 0 | 1 | 0 | 0 |
+| 21 | 0 | 1 | 0 | 1 | 0 | 1 |
+| 22 | 0 | 1 | 0 | 1 | 1 | 0 |
+| 23 | 0 | 1 | 0 | 1 | 1 | 1 |
+| 24 | 0 | 1 | 1 | 0 | 0 | 0 |
+| 25 | 0 | 1 | 1 | 0 | 0 | 1 |
+| 26 | 0 | 1 | 1 | 0 | 1 | 0 |
+| 27 | 0 | 1 | 1 | 0 | 1 | 1 |
+| 28 | 0 | 1 | 1 | 1 | 0 | 0 |
+| 29 | 0 | 1 | 1 | 1 | 0 | 1 |
+| 30 | 0 | 1 | 1 | 1 | 1 | 0 |
+| 31 | 0 | 1 | 1 | 1 | 1 | 1 |
+| 32 | 1 | 0 | 0 | 0 | 0 | 0 |
+| 33 | 1 | 0 | 0 | 0 | 0 | 1 |
+| 34 | 1 | 0 | 0 | 0 | 1 | 0 |
+| 35 | 1 | 0 | 0 | 0 | 1 | 1 |
+| 36 | 1 | 0 | 0 | 1 | 0 | 0 |
+| 37 | 1 | 0 | 0 | 1 | 0 | 1 |
+| 38 | 1 | 0 | 0 | 1 | 1 | 0 |
+| 39 | 1 | 0 | 0 | 1 | 1 | 1 |
+| 40 | 1 | 0 | 1 | 0 | 0 | 0 |
+| 41 | 1 | 0 | 1 | 0 | 0 | 1 |
+| 42 | 1 | 0 | 1 | 0 | 1 | 0 |
+| 43 | 1 | 0 | 1 | 0 | 1 | 1 |
+| 44 | 1 | 0 | 1 | 1 | 0 | 0 |
+| 45 | 1 | 0 | 1 | 1 | 0 | 1 |
+| 46 | 1 | 0 | 1 | 1 | 1 | 0 |
+| 47 | 1 | 0 | 1 | 1 | 1 | 1 |
+| 48 | 1 | 1 | 0 | 0 | 0 | 0 |
+| 49 | 1 | 1 | 0 | 0 | 0 | 1 |
+| 50 | 1 | 1 | 0 | 0 | 1 | 0 |
+| 51 | 1 | 1 | 0 | 0 | 1 | 1 |
+| 52 | 1 | 1 | 0 | 1 | 0 | 0 |
+| 53 | 1 | 1 | 0 | 1 | 0 | 1 |
+| 54 | 1 | 1 | 0 | 1 | 1 | 0 |
+| 55 | 1 | 1 | 0 | 1 | 1 | 1 |
+| 56 | 1 | 1 | 1 | 0 | 0 | 0 |
+| 57 | 1 | 1 | 1 | 0 | 0 | 1 |
+| 58 | 1 | 1 | 1 | 0 | 1 | 0 |
+| 59 | 1 | 1 | 1 | 0 | 1 | 1 |
+| 60 | 1 | 1 | 1 | 1 | 0 | 0 |
+| 61 | 1 | 1 | 1 | 1 | 0 | 1 |
+| 62 | 1 | 1 | 1 | 1 | 1 | 0 |
+| 63 | 1 | 1 | 1 | 1 | 1 | 1 |
++----+---+---+---+---+---+---+
+*/
+    myNdbOperation->insertTuple();
+    myNdbOperation->equal(COL_NAME[0], num);
+    for(int col = 1; col < COL_LEN; col++)
+    {
+      myNdbOperation->setValue(COL_NAME[col], (num>>(COL_LEN-1-col))&1);
+    }
+  }
+
+  int check = myTrans->execute(NdbTransaction::Commit);
+
+  myTrans->close();
+
+  if (check == -1)
+    return NDBT_FAILED;
+  else
+    return NDBT_OK;
+
+}
+
+
+
+/*
+* a=AND, o=OR, A=NAND, O=NOR
+*/
+char op_string[] = "aoAO";
+/*
+* the six columns' name of test table
+*/
+char col_string[] = "ijklmn";
+const int op_len = strlen(op_string);
+const int col_len = strlen(col_string);
+
+/*
+* get a random op from "aoAO"
+*/
+int get_rand_op_ch(char *ch)
+{
+  static unsigned int num = 0;
+  if(++num == 0) 
+    num = 1;
+  srand(num*time(NULL));
+  *ch = op_string[rand() % op_len];
+  return 1;
+}
+
+/*
+* get a random order form of "ijklmn" trough exchanging letter
+*/
+void change_col_order()
+{
+  int pos1,pos2;
+  char temp;
+  for (int i = 0; i < 10; i++)  //exchange for 10 times
+  {
+    srand(time(NULL)/(i+1));
+    pos1 = rand() % col_len;
+    srand((i+1)*time(NULL));
+    pos2 = rand() % col_len;
+    if (pos1 == pos2)
+      continue;
+    temp = col_string[pos1];
+    col_string[pos1] = col_string[pos2];
+    col_string[pos2] = temp; 
+  }
+}
+
+/*
+* get a random sub string of "ijklmn" 
+*/
+int get_rand_col_str(char *str)
+{
+  int len;
+  static unsigned int num = 0;
+  if(++num == 0) 
+    num = 1;
+  srand(num*time(NULL));
+  len = rand() % col_len + 1;
+  change_col_order();
+  snprintf(str, len+1, "%s", col_string);  //len+1, including '\0'
+  return len;
+}
+
+/*
+* get a random string including operation and column 
+* eg, Alnikx
+*/
+int get_rand_op_str(char *str)
+{
+  char temp[256];
+  int len1, len2, len;
+  len1 = get_rand_op_ch(temp);
+  len2 = get_rand_col_str(temp+len1);
+  len = len1 + len2;
+  temp[len] = 'x';
+  snprintf(str, len+1+1, "%s", temp);  //len+1, including '\0'
+  return len+1;
+}
+
+/*
+* replace a letter of source string with a new string 
+* e.g., source string: 'Aijkx', replace i with new string 'olmx'
+* then source string is changed to 'Aolmxjkx'
+* source: its format should be produced from get_rand_op_str() 
+* pos: range from 1 to strlen(source)-2
+*/
+int replace_a_to_str(char *source, int pos, char *newstr)
+{
+  char temp[MAX_STR_LEN];
+  snprintf(temp, pos+1, "%s", source);
+  snprintf(temp+pos, strlen(newstr)+1, "%s", newstr);
+  snprintf(temp+pos+strlen(newstr), strlen(source)-pos, "%s", source+pos+1);
+  snprintf(source, strlen(temp)+1, "%s", temp); 
+  return strlen(source);
+}
+
+/*
+* check whether the inputed char is an operation 
+*/
+bool check_op(char ch)
+{
+  if( ch == 'a' || ch == 'A' || ch == 'o' || ch == 'O')
+    return true;
+  else
+    return false;
+}
+
+/*
+* check whether the inputed char is end flag 
+*/
+bool check_end(char ch)
+{
+  return (ch == 'x');
+}
+
+/*
+* check whether the inputed char is end flag 
+*/
+bool check_col(char ch)
+{
+  if( ch == 'i' || ch == 'j' || ch == 'k' 
+    || ch == 'l' || ch == 'm' || ch == 'n' )
+    return true;
+  else
+    return false;
+}
+
+/*
+* To ensure we can get a random string with RECURSIVE_LEVEL,
+* we need a position where can replace a letter with a new string. 
+*/
+int get_rand_replace_pos(char *str, int len)
+{
+  int pos_op = 0;
+  int pos_x = 0;
+  int pos_col = 0;
+  int span = 0;
+  static int num = 0;
+  char temp;
+
+  for(int i = 0; i < len; i++)
+  {
+    temp = str[i];
+    if(! check_end(temp))
+    {
+      if(check_op(temp))  
+        pos_op = i;
+    }
+    else
+    {
+      pos_x = i;
+      break;
+    }
+  }
+
+  if(++num == 0) 
+    num = 1;
+
+  span = pos_x - pos_op - 1;
+  if(span <= 1)
+  {
+    pos_col = pos_op + 1;
+  }
+  else
+  {
+    srand(num*time(NULL));
+    pos_col = pos_op + rand() % span + 1;
+  }
+  return pos_col;
+}
+
+/*
+* Check whether the given random string is valid
+* and applicable for this test case
+*/
+bool check_random_str(char *str)
+{
+  char *p;
+  int op_num = 0;
+  int end_num = 0;
+
+  for(p = str; *p; p++)
+  {
+    bool tmp1 = false, tmp2 = false;
+    if(tmp1 = check_op(*p))
+      op_num++;
+    if(tmp2 = check_end(*p))
+      end_num++;
+    if(!(tmp1 || tmp2 || check_col(*p)))   //there are illegal letters
+      return false;
+  }
+
+  if(op_num != end_num)     //begins are not equal to ends
+    return false;
+
+  return true;
+}
+
+/*
+* Get a random string with RECURSIVE_LEVEL 
+*/
+void get_rand_op_str_compound(char *str)
+{
+  char small_str[256];
+  int pos;
+  int tmp;
+  int level;
+  static int num = 0;
+
+  if(++num == 0)
+    num = 1;
+
+  srand(num*time(NULL));
+  level = 1 + rand() % RECURSIVE_LEVEL;
+ 
+  get_rand_op_str(str);
+
+  for(int i = 0; i < level; i++)
+  {
+    get_rand_op_str(small_str);
+    tmp = strlen(small_str);
+    get_rand_op_str(small_str + tmp);   //get two operations
+    pos = get_rand_replace_pos(str, strlen(str));
+    replace_a_to_str(str, pos, small_str);
+  }
+
+  //check the random string
+  if(!check_random_str(str))
+  {
+    fprintf(stderr, "Error random string! \n");
+    exit(-1);
+  }
+}
+
+/*
+* get column id of i,j,k,l,m,n
+*/
+int get_column_id(char ch)
+{
+  return (ch - 'i' + 1);  //from 1 to 6
+}
+
+/*
+* check whether column value of the NO. tuple is equal to 1
+* col_id: column id, range from 1 to 6
+* tuple_no: record NO., range from 0 to 63 
+*/
+bool check_col_equal_one(int tuple_no, int col_id)
+{
+  int i = (int)pow(2, 6 - col_id);
+  int j = tuple_no / i;
+  if(j % 2)
+    return true;
+  else
+    return false;
+}
+
+/*
+* get a result after all elements in the array with AND
+* value: pointer to a bool array
+* len: length of the bool array
+*/
+bool AND_op(bool *value, int len)
+{
+  for(int i = 0; i < len; i++)
+  {
+    if(! value[i])
+      return false;
+  }
+  return true;
+}
+
+/*
+* get a result after all elements in the array with OR
+* value: pointer to a bool array
+* len: length of the bool array
+*/
+bool OR_op(bool *value, int len)
+{
+  for(int i = 0; i < len; i++)
+  {
+    if(value[i])
+      return true;
+  }
+  return false;
+}
+
+/*
+* get a result after all elements in the array with NAND
+* value: pointer to a bool array
+* len: length of the bool array
+*/
+bool NAND_op(bool *value, int len)
+{
+  return (! AND_op(value, len));
+}
+
+/*
+* get a result after all elements in the array with NOR
+* value: pointer to a bool array
+* len: length of the bool array
+*/
+bool NOR_op(bool *value, int len)
+{
+  return (! OR_op(value, len));
+}
+
+/*
+* AND/NAND/OR/NOR operation for a bool array 
+*/
+bool calculate_one_op(char op_type, bool *value, int len)
+{
+  switch(op_type)
+  {
+    case 'a':
+      return AND_op(value, len);
+      break;
+    case 'o':
+      return OR_op(value, len);
+      break;
+    case 'A':
+      return NAND_op(value, len);
+      break;
+    case 'O':
+      return NOR_op(value, len);
+      break;
+  }
+  return false;   //make gcc happy
+}
+
+typedef struct _stack_element
+{
+  char type;
+  int num;
+}stack_element;
+
+/*
+* stack_op, store info for AND,OR,NAND,NOR
+* stack_col, store value of column(i,j,k,l,m,n) and temporary result for an operation
+*/
+stack_element stack_op[RECURSIVE_LEVEL * COL_LEN];
+bool stack_col[RECURSIVE_LEVEL * COL_LEN * 2];
+
+/*
+* check whether the given tuple is chosen by judgement condition 
+* tuple_no, the NO of tuple in TABLE_NAME, range from 0 to TUPLE_NUM
+* str: a random string of scan opearation and condition
+* len: length of str
+*/
+bool check_one_tuple(int tuple_no, char *str, int len)
+{
+  int pop_op = 0;
+  int pop_col = 0;
+  for(int i = 0; i < len; i++)
+  {
+    char letter = *(str + i);
+    if(check_op(letter))    //push
+    {
+      stack_op[pop_op].type = letter;
+      stack_op[pop_op].num = 0;
+      pop_op++;
+    }
+    if(check_col(letter))   //push
+    {
+      stack_col[pop_col] = check_col_equal_one(tuple_no, get_column_id(letter));  
+      pop_col++;
+      stack_op[pop_op-1].num += 1;
+    }
+    if(check_end(letter))
+    {
+      if(pop_op <= 1)
+      {
+        return calculate_one_op(stack_op[pop_op-1].type, 
+                                stack_col, 
+                                stack_op[pop_op-1].num);
+      }
+      else
+      {
+        bool tmp1 = calculate_one_op(stack_op[pop_op-1].type, 
+                                    stack_col + pop_col - stack_op[pop_op-1].num, 
+                                    stack_op[pop_op-1].num);
+        pop_col -= stack_op[pop_op-1].num;    //pop
+        pop_op--;
+        stack_col[pop_col] = tmp1;    //push
+        pop_col++;
+        stack_op[pop_op-1].num += 1;
+      }
+    }
+  }
+  return false;   //make gcc happy
+}
+
+/*
+* get lists of tuples which match the scan condiction through calculating
+* str: a random string of scan opearation and condition
+*/
+void check_all_tuples(char *str, bool *res)
+{    
+  for (int i = 0; i < TUPLE_NUM; i++)
+  {
+    if(check_one_tuple(i, str, strlen(str)))
+      res[i] = true;
+  }
+}
+
+/*
+* convert a letter to group number what ndbapi need
+*/
+NdbScanFilter::Group get_api_group(char op_name)
+{
+  switch (op_name) {
+  case 'a': return NdbScanFilter::AND;
+  case 'o': return NdbScanFilter::OR;
+  case 'A': return NdbScanFilter::NAND;
+  case 'O': return NdbScanFilter::NOR;
+  default: 
+    fprintf(stderr, "Invalid group name %c !\n", op_name);
+    exit(3);
+  }
+}
+
+/*
+* with ndbapi, call begin, eq/ne/lt/gt/le/ge..., end
+*/
+NdbScanFilter * call_ndbapi(char *str, NdbTransaction *transaction, 
+  NdbScanOperation *scan, NdbDictionary::Column const *col[])
+{
+  NdbScanFilter *scanfilter = new NdbScanFilter(scan);
+  char *p;
+
+  for (p = str; *p; p++) 
+  {
+    if(check_op(*p))
+    {
+       if(scanfilter->begin(get_api_group(*p))) 
+          ERR_EXIT(transaction, "filter begin() failed");
+    }
+    if(check_col(*p))
+    {
+       if(scanfilter->eq(col[*p-'i'+1]->getColumnNo(), (Uint32)1)) 
+          ERR_EXIT(transaction, "filter eq() failed"); 
+    }
+    if(check_end(*p))
+    {
+      if(scanfilter->end()) 
+        ERR_EXIT(transaction, "filter end() failed");
+    }
+  }
+  
+  return scanfilter;
+}
+
+/*
+* get the tuples through ndbapi, and save the tuples NO.
+* str: a random string of scan opearation and condition
+*/
+void ndbapi_tuples(Ndb *ndb, char *str, bool *res)
+{
+	const NdbDictionary::Dictionary *dict  = ndb->getDictionary();
+	if (!dict) 
+    ERR_EXIT(ndb, "Can't get dict");
+
+	const NdbDictionary::Table *table = dict->getTable(TABLE_NAME);
+	if (!table) 
+    ERR_EXIT(dict, "Can't get table"TABLE_NAME);
+	
+	const NdbDictionary::Column *col[COL_LEN];
+  for(int i = 0; i < COL_LEN; i++)
+  {
+    char tmp[128];
+    col[i] = table->getColumn(COL_NAME[i]);
+	  if(!col[i]) 
+    {
+      snprintf(tmp, 128, "Can't get column %s", COL_NAME[i]);
+      ERR_EXIT(dict, tmp);
+    }
+  }
+
+  NdbTransaction *transaction;
+  NdbScanOperation *scan;
+  NdbScanFilter *filter;
+
+  transaction = ndb->startTransaction();
+  if (!transaction) 
+    ERR_EXIT(ndb, "Can't start transaction");
+
+  scan = transaction->getNdbScanOperation(table);	
+  if (!scan) 
+    ERR_EXIT(transaction, "Can't get scan op");
+	  
+  if (scan->readTuples(NdbOperation::LM_Exclusive)) 
+    ERR_EXIT(scan, "Can't set up read");
+  
+  NdbRecAttr *rec[COL_LEN];
+  for(int i = 0; i < COL_LEN; i++)
+  {
+    char tmp[128];
+    rec[i] = scan->getValue(COL_NAME[i]);
+	  if(!rec[i]) 
+    {
+      snprintf(tmp, 128, "Can't get rec of %s", COL_NAME[i]);
+      ERR_EXIT(scan, tmp);
+    }
+  }
+
+  filter = call_ndbapi(str, transaction, scan, col);
+	  
+  if (transaction->execute(NdbTransaction::NoCommit)) 
+    ERR_EXIT(transaction, "Can't execute");
+	  
+  int i,j,k,l,m,n;
+  while (scan->nextResult(true) == 0) 
+  {
+    do 
+    {
+      i = rec[1]->u_32_value();
+      j = rec[2]->u_32_value();
+      k = rec[3]->u_32_value();
+      l = rec[4]->u_32_value();
+      m = rec[5]->u_32_value();
+      n = rec[6]->u_32_value();
+      res[32*i+16*j+8*k+4*l+2*m+n] = true;
+    } while (scan->nextResult(false) == 0);
+  }
+	  
+  delete filter;
+  transaction->close();
+}
+
+/*
+* compare the result between calculation and NDBAPI
+* str: a random string of scan opearation and condition
+* return: true stands for ndbapi ok, false stands for ndbapi failed
+*/
+bool compare_cal_ndb(char *str, Ndb *ndb)
+{
+  bool res_cal[TUPLE_NUM], res_ndb[TUPLE_NUM];
+
+  for(int i = 0; i < TUPLE_NUM; i++)
+  {
+    res_cal[i] = false;
+    res_ndb[i] = false;
+  }
+
+  check_all_tuples(str, res_cal);
+  ndbapi_tuples(ndb, str, res_ndb);
+
+  for(int i = 0; i < TUPLE_NUM; i++)
+  {
+    if(res_cal[i] != res_ndb[i])
+      return false;
+  }
+  return true;
+}
+
+
+int runCreateTables(NDBT_Context* ctx, NDBT_Step* step)
+{
+  Ndb *pNdb = GETNDB(step);
+  pNdb->getDictionary()->dropTable(MYTAB1.getName());
+  int ret = createTable(pNdb, &MYTAB1, false, true, 0); 
+  if(ret)
+    return ret;
+  return NDBT_OK;
+}
+
+
+int runDropTables(NDBT_Context* ctx, NDBT_Step* step)
+{
+ int ret = GETNDB(step)->getDictionary()->dropTable(MYTAB1.getName());
+ if(ret == -1)
+   return NDBT_FAILED;
+  
+  return NDBT_OK;
+}
+
+int runScanRandomFilterTest(NDBT_Context* ctx, NDBT_Step* step)
+{
+  char random_str[MAX_STR_LEN];
+  Ndb *myNdb = GETNDB(step);
+  bool res = true;
+
+  for(int i = 0; i < TEST_NUM; i++)
+  {
+    get_rand_op_str_compound(random_str);
+    if( !compare_cal_ndb(random_str, myNdb)) 
+      return NDBT_FAILED;
+  }
+
+  return NDBT_OK;
+}
+
+NDBT_TESTSUITE(testScanFilter);
+TESTCASE(TEST_NAME, 
+	 "Scan table TABLE_NAME for the records which accord with \
+   conditions of logical scan operations: AND/OR/NAND/NOR")
+{
+  INITIALIZER(runCreateTables);
+  INITIALIZER(runPopulate);
+  INITIALIZER(runScanRandomFilterTest);
+  FINALIZER(runDropTables);
+}
+
+NDBT_TESTSUITE_END(testScanFilter);
+
+
+int main(int argc, const char** argv)
+{
+  ndb_init();
+
+  Ndb_cluster_connection con;
+  if(con.connect(12, 5, 1))
+  {
+    return NDBT_ProgramExit(NDBT_FAILED);
+  }
+  
+  return testScanFilter.executeOneCtx(con, &MYTAB1, TEST_NAME);
+}
diff --git a/storage/ndb/test/src/NDBT_Test.cpp b/storage/ndb/test/src/NDBT_Test.cpp
index 9c908ab27c6..1245d004aff 100644
--- a/storage/ndb/test/src/NDBT_Test.cpp
+++ b/storage/ndb/test/src/NDBT_Test.cpp
@@ -947,6 +947,63 @@ NDBT_TestSuite::executeOne(Ndb_cluster_connection& con,
   }
 }
 
+int 
+NDBT_TestSuite::executeOneCtx(Ndb_cluster_connection& con,
+			   const NdbDictionary::Table *ptab, const char* _testname){
+  
+  testSuiteTimer.doStart(); 
+  
+  do{
+    if(tests.size() == 0)
+      break;
+
+    Ndb ndb(&con, "TEST_DB");
+    ndb.init(1024);
+
+    int result = ndb.waitUntilReady(300); // 5 minutes
+    if (result != 0){
+      g_err << name <<": Ndb was not ready" << endl;
+      break;
+    }
+
+    ndbout << name << " started [" << getDate() << "]" << endl;
+    ndbout << "|- " << ptab->getName() << endl;
+
+    for (unsigned t = 0; t < tests.size(); t++){
+
+      if (_testname != NULL && 
+	      strcasecmp(tests[t]->getName(), _testname) != 0)
+        continue;
+
+      tests[t]->initBeforeTest();
+    
+      ctx = new NDBT_Context(con);
+      ctx->setTab(ptab);
+      ctx->setNumRecords(records);
+      ctx->setNumLoops(loops);
+      if(remote_mgm != NULL)
+        ctx->setRemoteMgm(remote_mgm);
+      ctx->setSuite(this);
+    
+      result = tests[t]->execute(ctx);
+      if (result != NDBT_OK)
+        numTestsFail++;
+      else
+        numTestsOk++;
+      numTestsExecuted++;
+
+    delete ctx;
+  }
+
+    if (numTestsFail > 0)
+      break;
+  }while(0);
+
+  testSuiteTimer.doStop();
+  int res = report(_testname);
+  return NDBT_ProgramExit(res);
+}
+
 int
 NDBT_TestSuite::createHook(Ndb* ndb, NdbDictionary::Table& tab, int when)
 {
diff --git a/storage/ndb/tools/restore/consumer.hpp b/storage/ndb/tools/restore/consumer.hpp
index b05f7e00402..4121cc4e1b4 100644
--- a/storage/ndb/tools/restore/consumer.hpp
+++ b/storage/ndb/tools/restore/consumer.hpp
@@ -41,6 +41,7 @@ public:
   NODE_GROUP_MAP *m_nodegroup_map;
   uint            m_nodegroup_map_len;
   virtual bool has_temp_error() {return false;}
+  virtual bool table_equal(const TableS &) {return true;}
 };
 
 #endif
diff --git a/storage/ndb/tools/restore/consumer_restore.cpp b/storage/ndb/tools/restore/consumer_restore.cpp
index 03cf3e6ddb7..7e3395c36f6 100644
--- a/storage/ndb/tools/restore/consumer_restore.cpp
+++ b/storage/ndb/tools/restore/consumer_restore.cpp
@@ -668,6 +668,62 @@ err:
 }
 
 bool
+BackupRestore::table_equal(const TableS &tableS){
+  const char *tablename = tableS.getTableName();
+
+  if(tableS.m_dictTable == NULL){
+    ndbout<<"Table %s has no m_dictTable " << tablename << endl;
+    return false;
+  }
+  /**
+   * Ignore blob tables
+   */
+  if(match_blob(tablename) >= 0)
+    return true;
+
+  const NdbTableImpl & tmptab = NdbTableImpl::getImpl(* tableS.m_dictTable);
+  if ((int) tmptab.m_indexType != (int) NdbDictionary::Index::Undefined){
+    return true;
+  }
+
+  BaseString tmp(tablename);
+  Vector<BaseString> split;
+  if(tmp.split(split, "/") != 3){
+    err << "Invalid table name format " << tablename << endl;
+    return false;
+  }
+
+  m_ndb->setDatabaseName(split[0].c_str());
+  m_ndb->setSchemaName(split[1].c_str());
+
+  NdbDictionary::Dictionary* dict = m_ndb->getDictionary();  
+  const NdbDictionary::Table* tab = dict->getTable(split[2].c_str());
+  if(tab == 0){
+    err << "Unable to find table: " << split[2].c_str() << endl;
+    return false;
+  }
+
+  if(tab->getNoOfColumns() != tableS.m_dictTable->getNoOfColumns())
+  {
+    ndbout_c("m_columns.size %d != %d",tab->getNoOfColumns(),
+                       tableS.m_dictTable->getNoOfColumns());
+    return false;
+  }
+
+ for(int i = 0; i<tab->getNoOfColumns(); i++)
+  {
+    if(!tab->getColumn(i)->equal(*(tableS.m_dictTable->getColumn(i))))
+    {
+      ndbout_c("m_columns %s != %s",tab->getColumn(i)->getName(),
+                tableS.m_dictTable->getColumn(i)->getName());
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool
 BackupRestore::createSystable(const TableS & tables){
   if (!m_restore && !m_restore_meta && !m_restore_epoch)
     return true;
diff --git a/storage/ndb/tools/restore/consumer_restore.hpp b/storage/ndb/tools/restore/consumer_restore.hpp
index 5063619d3c3..0bc9d8e8d20 100644
--- a/storage/ndb/tools/restore/consumer_restore.hpp
+++ b/storage/ndb/tools/restore/consumer_restore.hpp
@@ -73,6 +73,7 @@ public:
   virtual bool finalize_table(const TableS &);
   virtual bool has_temp_error();
   virtual bool createSystable(const TableS & table);
+  virtual bool table_equal(const TableS & table);
   virtual bool update_apply_status(const RestoreMetaData &metaData);
   void connectToMysql();
   bool map_in_frm(char *new_data, const char *data,
diff --git a/storage/ndb/tools/restore/restore_main.cpp b/storage/ndb/tools/restore/restore_main.cpp
index 4734e9f609d..ee3af467aa7 100644
--- a/storage/ndb/tools/restore/restore_main.cpp
+++ b/storage/ndb/tools/restore/restore_main.cpp
@@ -50,6 +50,7 @@ NDB_STD_OPTS_VARS;
 static bool ga_restore_epoch = false;
 static bool ga_restore = false;
 static bool ga_print = false;
+static bool ga_skip_table_check = false;
 static int _print = 0;
 static int _print_meta = 0;
 static int _print_data = 0;
@@ -91,6 +92,9 @@ static struct my_option my_long_options[] =
     NDB_REP_DB "." NDB_APPLY_TABLE " with id 0 will be updated/inserted.", 
     (gptr*) &ga_restore_epoch, (gptr*) &ga_restore_epoch,  0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
+  { "skip-table-check", 's', "Skip table structure check during restore of data",
+   (gptr*) &ga_skip_table_check, (gptr*) &ga_skip_table_check, 0,
+   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "parallelism", 'p',
     "No of parallel transactions during restore of data."
     "(parallelism can be 1 to 1024)", 
@@ -459,6 +463,8 @@ main(int argc, char** argv)
   g_options.appfmt(" -n %d", ga_nodeId);
   if (_restore_meta)
     g_options.appfmt(" -m");
+  if (ga_skip_table_check)
+    g_options.appfmt(" -s");
   if (_restore_data)
     g_options.appfmt(" -r");
   if (ga_restore_epoch)
@@ -589,6 +595,20 @@ main(int argc, char** argv)
   {
     if(_restore_data || _print_data)
     {
+      if (!ga_skip_table_check){
+        for(i=0; i < metaData.getNoOfTables(); i++){
+          if (checkSysTable(metaData, i))
+          {
+            for(Uint32 j= 0; j < g_consumers.size(); j++)
+              if (!g_consumers[j]->table_equal(* metaData[i]))
+              {
+                err << "Restore: Failed to restore data, ";
+                err << metaData[i]->getTableName() << " table structure doesn't match backup ... Exiting " << endl;
+                exitHandler(NDBT_FAILED);
+              }
+          }
+        }
+      }
       RestoreDataIterator dataIter(metaData, &free_data_callback);
       
       // Read data file header