List:Commits« Previous MessageNext Message »
From:Maitrayi Sabaratnam Date:October 1 2010 11:09am
Subject:bzr push into mysql-5.1-telco-7.0-mai branch (msabaratnam:3252 to 3254)
View as plain text  
 3254 Maitrayi Sabaratnam	2010-10-01 [merge]
      Merge with 7.0 - revno 3815

    added:
      storage/ndb/src/ndbapi/trp_client.hpp
    modified:
      storage/ndb/include/kernel/signaldata/WaitGCP.hpp
      storage/ndb/include/ndbapi/Ndb.hpp
      storage/ndb/include/ndbapi/NdbDictionary.hpp
      storage/ndb/include/ndbapi/NdbTransaction.hpp
      storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp
      storage/ndb/src/mgmsrv/MgmtSrvr.cpp
      storage/ndb/src/mgmsrv/MgmtSrvr.hpp
      storage/ndb/src/ndbapi/Ndb.cpp
      storage/ndb/src/ndbapi/NdbDictionary.cpp
      storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp
      storage/ndb/src/ndbapi/NdbDictionaryImpl.hpp
      storage/ndb/src/ndbapi/NdbImpl.hpp
      storage/ndb/src/ndbapi/NdbTransaction.cpp
      storage/ndb/src/ndbapi/Ndbif.cpp
      storage/ndb/src/ndbapi/SignalSender.cpp
      storage/ndb/src/ndbapi/SignalSender.hpp
      storage/ndb/src/ndbapi/TransporterFacade.cpp
      storage/ndb/src/ndbapi/TransporterFacade.hpp
      storage/ndb/test/ndbapi/testDict.cpp
      storage/ndb/test/ndbapi/testRestartGci.cpp
 3253 Maitrayi Sabaratnam	2010-10-01 [merge]
      Merge with 7.0 - revno 3811

    removed:
      cluster_change_hist.txt
    added:
      storage/ndb/src/ndbapi/ndb_internal.cpp
    modified:
      configure.in
      mysql-test/suite/ndb_team/t/ndb_restart.test
      sql/ha_ndbcluster_binlog.cc
      storage/ndb/include/mgmapi/mgmapi.h
      storage/ndb/include/ndb_version.h.in
      storage/ndb/include/ndbapi/Ndb.hpp
      storage/ndb/include/ndbapi/NdbIndexOperation.hpp
      storage/ndb/include/ndbapi/NdbOperation.hpp
      storage/ndb/include/ndbapi/NdbTransaction.hpp
      storage/ndb/ndb_configure.m4
      storage/ndb/src/common/portlib/NdbDir.cpp
      storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
      storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
      storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp
      storage/ndb/src/kernel/blocks/dbtux/Dbtux.hpp
      storage/ndb/src/kernel/blocks/dbtux/DbtuxBuild.cpp
      storage/ndb/src/kernel/blocks/dbtux/DbtuxMaint.cpp
      storage/ndb/src/kernel/blocks/dbtux/DbtuxNode.cpp
      storage/ndb/src/kernel/blocks/dbtux/DbtuxTree.cpp
      storage/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp
      storage/ndb/src/kernel/blocks/ndbfs/PosixAsyncFile.cpp
      storage/ndb/src/kernel/blocks/suma/Suma.cpp
      storage/ndb/src/kernel/blocks/suma/Suma.hpp
      storage/ndb/src/mgmapi/mgmapi.cpp
      storage/ndb/src/mgmclient/CommandInterpreter.cpp
      storage/ndb/src/mgmsrv/ConfigManager.cpp
      storage/ndb/src/mgmsrv/MgmtSrvr.cpp
      storage/ndb/src/mgmsrv/MgmtSrvr.hpp
      storage/ndb/src/mgmsrv/Services.cpp
      storage/ndb/src/mgmsrv/main.cpp
      storage/ndb/src/ndbapi/API.hpp
      storage/ndb/src/ndbapi/CMakeLists.txt
      storage/ndb/src/ndbapi/ClusterMgr.cpp
      storage/ndb/src/ndbapi/ClusterMgr.hpp
      storage/ndb/src/ndbapi/Makefile.am
      storage/ndb/src/ndbapi/Ndb.cpp
      storage/ndb/src/ndbapi/NdbApiSignal.cpp
      storage/ndb/src/ndbapi/NdbApiSignal.hpp
      storage/ndb/src/ndbapi/NdbBlob.cpp
      storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp
      storage/ndb/src/ndbapi/NdbDictionaryImpl.hpp
      storage/ndb/src/ndbapi/NdbEventOperationImpl.cpp
      storage/ndb/src/ndbapi/NdbEventOperationImpl.hpp
      storage/ndb/src/ndbapi/NdbImpl.hpp
      storage/ndb/src/ndbapi/NdbIndexOperation.cpp
      storage/ndb/src/ndbapi/NdbInfoScanOperation.cpp
      storage/ndb/src/ndbapi/NdbInterpretedCode.cpp
      storage/ndb/src/ndbapi/NdbOperation.cpp
      storage/ndb/src/ndbapi/NdbOperationDefine.cpp
      storage/ndb/src/ndbapi/NdbOperationExec.cpp
      storage/ndb/src/ndbapi/NdbOperationInt.cpp
      storage/ndb/src/ndbapi/NdbOperationSearch.cpp
      storage/ndb/src/ndbapi/NdbReceiver.cpp
      storage/ndb/src/ndbapi/NdbScanFilter.cpp
      storage/ndb/src/ndbapi/NdbScanOperation.cpp
      storage/ndb/src/ndbapi/NdbTransaction.cpp
      storage/ndb/src/ndbapi/NdbTransactionScan.cpp
      storage/ndb/src/ndbapi/NdbWaiter.hpp
      storage/ndb/src/ndbapi/Ndberr.cpp
      storage/ndb/src/ndbapi/Ndbif.cpp
      storage/ndb/src/ndbapi/Ndbinit.cpp
      storage/ndb/src/ndbapi/Ndblist.cpp
      storage/ndb/src/ndbapi/SignalSender.cpp
      storage/ndb/src/ndbapi/SignalSender.hpp
      storage/ndb/src/ndbapi/TransporterFacade.cpp
      storage/ndb/src/ndbapi/TransporterFacade.hpp
      storage/ndb/src/ndbapi/ndb_cluster_connection.cpp
      storage/ndb/src/ndbapi/ndb_cluster_connection_impl.hpp
      storage/ndb/src/ndbapi/ndb_internal.hpp
      storage/ndb/test/include/NdbRestarter.hpp
      storage/ndb/test/ndbapi/testIndex.cpp
      storage/ndb/test/ndbapi/testNdbinfo.cpp
      storage/ndb/test/ndbapi/testNodeRestart.cpp
      storage/ndb/test/run-test/daily-basic-tests.txt
      storage/ndb/test/src/NDBT_Test.cpp
      storage/ndb/test/src/NdbRestarter.cpp
 3252 Maitrayi Sabaratnam	2010-09-30 [merge]
      Merge with 7.0

    removed:
      storage/ndb/src/kernel/blocks/ndbfs/CircularIndex.cpp
      storage/ndb/src/kernel/blocks/ndbfs/CircularIndex.hpp
      storage/ndb/test/tools/transproxy.cpp
    added:
      storage/ndb/src/kernel/vm/ArenaPool.cpp
      storage/ndb/src/kernel/vm/ArenaPool.hpp
    renamed:
      mysql-test/include/ndb_desc_print.inc => mysql-test/suite/ndb/include/ndb_desc_print.inc
      mysql-test/include/ndb_execute_count.inc => mysql-test/suite/ndb/include/ndb_execute_count.inc
      mysql-test/include/ndb_init_execute_count.inc => mysql-test/suite/ndb/include/ndb_init_execute_count.inc
      mysql-test/include/ndb_init_scan_counts.inc => mysql-test/suite/ndb/include/ndb_init_scan_counts.inc
      mysql-test/include/ndb_scan_counts.inc => mysql-test/suite/ndb/include/ndb_scan_counts.inc
    modified:
      client/mysqldump.c
      include/config-win.h
      include/sha1.h
      mysql-test/collections/default.experimental
      mysql-test/r/mysqldump.result
      mysql-test/suite/funcs_1/t/disabled.def
      mysql-test/suite/ndb/r/ndb_database.result
      mysql-test/suite/ndb/r/ndb_partition_range.result
      mysql-test/suite/ndb/t/ndb_bulk_delete.test
      mysql-test/suite/ndb/t/ndb_database.test
      mysql-test/suite/ndb/t/ndb_native_default_support.test
      mysql-test/suite/ndb/t/ndb_partition_hash.test
      mysql-test/suite/ndb/t/ndb_partition_key.test
      mysql-test/suite/ndb/t/ndb_partition_list.test
      mysql-test/suite/ndb/t/ndb_partition_range.test
      mysql-test/suite/ndb/t/ndb_read_multi_range.test
      mysql-test/suite/ndb/t/ndb_sql_allow_batching.test
      mysql-test/suite/ndb/t/ndb_update_no_read.test
      mysql-test/suite/ndb/t/test_mgmd.cnf
      mysql-test/suite/ndb_binlog/r/ndb_binlog_multi.result
      mysql-test/suite/ndb_binlog/t/ndb_binlog_multi.test
      mysql-test/t/mysqldump.test
      mysys/sha1.c
      sql/ha_ndbcluster.cc
      sql/ha_ndbcluster.h
      sql/ha_ndbcluster_binlog.cc
      sql/handler.cc
      sql/handler.h
      sql/sql_show.cc
      sql/sql_table.cc
      storage/ndb/include/kernel/GlobalSignalNumbers.h
      storage/ndb/include/kernel/signaldata/ConfigChange.hpp
      storage/ndb/include/kernel/signaldata/DiGetNodes.hpp
      storage/ndb/include/kernel/signaldata/FsReadWriteReq.hpp
      storage/ndb/include/mgmapi/mgmapi.h
      storage/ndb/include/ndb_global.h
      storage/ndb/include/ndbapi/NdbDictionary.hpp
      storage/ndb/include/portlib/NdbCondition.h
      storage/ndb/include/portlib/NdbDir.hpp
      storage/ndb/include/portlib/NdbMem.h
      storage/ndb/include/portlib/NdbSleep.h
      storage/ndb/include/portlib/NdbThread.h
      storage/ndb/include/util/BaseString.hpp
      storage/ndb/include/util/Bitmask.hpp
      storage/ndb/include/util/HashMap.hpp
      storage/ndb/include/util/NdbAutoPtr.hpp
      storage/ndb/include/util/NdbSqlUtil.hpp
      storage/ndb/include/util/NdbTap.hpp
      storage/ndb/include/util/azlib.h
      storage/ndb/include/util/ndb_opts.h
      storage/ndb/src/common/portlib/NdbCondition.c
      storage/ndb/src/common/portlib/NdbDir.cpp
      storage/ndb/src/common/util/BaseString.cpp
      storage/ndb/src/common/util/NdbSqlUtil.cpp
      storage/ndb/src/common/util/azio.c
      storage/ndb/src/common/util/ndb_init.cpp
      storage/ndb/src/common/util/ndb_opts.c
      storage/ndb/src/cw/cpcd/main.cpp
      storage/ndb/src/kernel/angel.cpp
      storage/ndb/src/kernel/angel.hpp
      storage/ndb/src/kernel/blocks/CMakeLists.txt
      storage/ndb/src/kernel/blocks/ERROR_codes.txt
      storage/ndb/src/kernel/blocks/Makefile.am
      storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
      storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp
      storage/ndb/src/kernel/blocks/dblqh/Dblqh.hpp
      storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
      storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
      storage/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp
      storage/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp
      storage/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp
      storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp
      storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp
      storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
      storage/ndb/src/kernel/blocks/dbtup/DbtupScan.cpp
      storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp
      storage/ndb/src/kernel/blocks/dbtup/tuppage.hpp
      storage/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp
      storage/ndb/src/kernel/blocks/ndbfs/AsyncIoThread.cpp
      storage/ndb/src/kernel/blocks/ndbfs/AsyncIoThread.hpp
      storage/ndb/src/kernel/blocks/ndbfs/Filename.cpp
      storage/ndb/src/kernel/blocks/ndbfs/MemoryChannel.hpp
      storage/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp
      storage/ndb/src/kernel/blocks/ndbfs/Ndbfs.hpp
      storage/ndb/src/kernel/blocks/ndbfs/VoidFs.cpp
      storage/ndb/src/kernel/blocks/ndbfs/Win32AsyncFile.cpp
      storage/ndb/src/kernel/blocks/ndbfs/Win32AsyncFile.hpp
      storage/ndb/src/kernel/blocks/qmgr/Qmgr.hpp
      storage/ndb/src/kernel/blocks/suma/Suma.cpp
      storage/ndb/src/kernel/error/ErrorReporter.cpp
      storage/ndb/src/kernel/main.cpp
      storage/ndb/src/kernel/ndbd.cpp
      storage/ndb/src/kernel/vm/CMakeLists.txt
      storage/ndb/src/kernel/vm/Makefile.am
      storage/ndb/src/kernel/vm/Pool.hpp
      storage/ndb/src/kernel/vm/RWPool.hpp
      storage/ndb/src/kernel/vm/SafeCounter.hpp
      storage/ndb/src/kernel/vm/WOPool.hpp
      storage/ndb/src/kernel/vm/mt.cpp
      storage/ndb/src/mgmapi/mgmapi.cpp
      storage/ndb/src/mgmapi/mgmapi_internal.h
      storage/ndb/src/mgmapi/ndb_logevent.cpp
      storage/ndb/src/mgmclient/CommandInterpreter.cpp
      storage/ndb/src/mgmclient/main.cpp
      storage/ndb/src/mgmsrv/ConfigManager.cpp
      storage/ndb/src/mgmsrv/ConfigManager.hpp
      storage/ndb/src/mgmsrv/MgmtSrvr.cpp
      storage/ndb/src/mgmsrv/main.cpp
      storage/ndb/src/ndbapi/DictCache.cpp
      storage/ndb/src/ndbapi/DictCache.hpp
      storage/ndb/src/ndbapi/NdbDictionary.cpp
      storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp
      storage/ndb/src/ndbapi/NdbDictionaryImpl.hpp
      storage/ndb/test/include/NdbRestarter.hpp
      storage/ndb/test/ndbapi/testBitfield.cpp
      storage/ndb/test/ndbapi/testIndexStat.cpp
      storage/ndb/test/ndbapi/testMgmd.cpp
      storage/ndb/test/ndbapi/testOIBasic.cpp
      storage/ndb/test/ndbapi/testRestartGci.cpp
      storage/ndb/test/ndbapi/testSystemRestart.cpp
      storage/ndb/test/ndbapi/test_event.cpp
      storage/ndb/test/run-test/daily-basic-tests.txt
      storage/ndb/test/run-test/files.cpp
      storage/ndb/test/src/NDBT_Test.cpp
      storage/ndb/test/src/NdbBackup.cpp
      storage/ndb/test/src/NdbRestarter.cpp
      storage/ndb/test/tools/CMakeLists.txt
      storage/ndb/test/tools/Makefile.am
      storage/ndb/tools/delete_all.cpp
      storage/ndb/tools/desc.cpp
      storage/ndb/tools/drop_index.cpp
      storage/ndb/tools/drop_tab.cpp
      storage/ndb/tools/listTables.cpp
      storage/ndb/tools/ndb_config.cpp
      storage/ndb/tools/restore/consumer_restore.cpp
      storage/ndb/tools/restore/restore_main.cpp
      storage/ndb/tools/select_all.cpp
      storage/ndb/tools/select_count.cpp
      storage/ndb/tools/waiter.cpp
=== removed file 'cluster_change_hist.txt'
--- a/cluster_change_hist.txt	2009-12-14 10:18:40 +0000
+++ b/cluster_change_hist.txt	1970-01-01 00:00:00 +0000
@@ -1,276 +0,0 @@
-==================================================
-mysql-5.1.X-ndb-6.2.Y
-==================================================
-
-mysql-5.1.19-ndb-6.2.4 (released 2007-07-04)
-
-  Bug #29525 batching incorrect
-  Bug #28720 Disk data meta information is not visible in mysqld but exists in ndbd
-  Bug #28642 Tablespace returning incorrect usage status
-  Bug #29501 DN crashes in LGMAN during NR while DD schema operations are being handled
-  Bug #29354 Incorrect handling of replica REDO during SR (5.0)
-  Bug #29364 SQL queries hang while data node in start phase 5
-  Bug #27404 util thd mysql_parse sig11 when mysqld default multibyte charset
-
-mysql-5.1.19-ndb-6.2.3 (released 2007-07-02)
-(additional bugs fixed compared to mysql-5.1.19)
-
-  Bug #29331 Incorrect node killed on GCP Stop (COPY_GCI)
-  Bug #29057 Incorrect handling of file 0 during redo execution(Error while reading REDO log)
-  Bug #29067 Incorrect order during redo invalidation(Error while reading REDO log)
-  Bug #29118 Incorrect handling of loglap in redo invalidation (Error while reading REDO log)
-  Bug #29229 memory corruption in dbtup
-  Bug #29185 Large IN list crashes mysqld with cluster and condition pushdown
-  Bug #29176 drop table can crash pgman
-  Bug #28989 hpux11 ps_row warnings
-  Bug #25305 rpl_ndb_UUID.test fails on pb-valgrind
-  Bug #29167 Insufficient nodes for SR
-  Bug #27640 backup id not displayed in the output of "ndb_mgm start backup wait completed"
-  Bug #28949 n_mix valgrind failing in pushbuild
-  Bug #29099 slow backup for disk data
-  Bug #26342 auto_increment_increment AND auto_increment_offset REALLY REALLY anger NDB cluster
-  Bug #29103 ndb_restore segfaults on NULL var[char|binary]
-  Bug #29074 preserve file timestamps in ndb_error_reporter
-  Bug #29073 Store history for ndb_mgm
-  Bug #29063 mgmapi: connect timeout set incorrectly
-  Bug #29044 blob code sets error code on transaction object
-  Bug #28724 for blobs, op flag to not set error on trans
-  Bug #28751 Lots of memory locked in memory causes high kswapd
-  Bug #28899 not possible to set separate watchdog timeout at startup
-  Bug# 28726 LCP files not removed after initial system restart
-  Bug #20612 failed ndbrequire in PGMAN
-  Bug #28443 transporter gets stuck when >1024 signals received at once
-  Bug #28770 file already opened error when corrupt schema file
-  Bug #28749 MaxNoOfOpenFiles offset by 1
-  Bug #26783 replication status unknown after cluster or mysqld failure
-  Bug #28717 Race between NODE_FAILREP and COPY_GCIREQ
-  Bug #28719 multi pk update ignore corrupts data
-  Bug #28653 Fast GCP + high load + high RedoBuffer causes ndbrequire
-  Bug #28525 Node failures in PGMAN at ndbrequire (line 430)
-
-
-==================================================
-mysql-5.1.15-ndb-6.1.X
-==================================================
-
-mysql-5.1.15-ndb-6.1.16 (2007-06-28)
-
-  Bug #29331 Incorrect node killed on GCP Stop (COPY_GCI)
-  Bug #29057 Incorrect handling of file 0 during redo execution(Error while reading REDO log)
-  Bug #29067 Incorrect order during redo invalidation(Error while reading REDO log)
-  Bug #29118 Incorrect handling of loglap in redo invalidation (Error while reading REDO log)
-  Bug #29176 drop table can crash pgman
-
-mysql-5.1.15-ndb-6.1.15 (2007-06-20)
-
-  Bug #29229 memory corruption in dbtup
-
-mysql-5.1.15-ndb-6.1.14 (2007-06-19)
-
-  Bug #29176 missing stack pruning in drop_page
-  Bug #29167 Insufficient nodes for SR
-
-mysql-5.1.15-ndb-6.1.13 (2007-06-15)
-
-  Bug #29099 slow backup for disk data
-
-mysql-5.1.15-ndb-6.1.12 (2007-06-13)
-
-  Bug #29044 memory buddy allocator "unoptimal" memory handling
-  extend backup dump to give more info
-
-mysql-5.1.15-ndb-6.1.11 (2007-06-06)
-
-  Bug #28751 Lots of memory locked in memory causes high kswapd
-  Bug #28899 not possible to set separate watchdog timeout at startup
-  Bug #28726 LCP files not removed after initial system restart
-  Bug #20612 failed ndbrequire in PGMAN
-  make size of redo log files (fragment log files) configurable (error 1220)
-
-mysql-5.1.15-ndb-6.1.10 (2007-05-30)
-
-  Bug #28783 heartbeat failures under high load
-  Bug #28770 file already opened error when corrupt schema file
-  Bug #28717 Race between NODE_FAILREP and COPY_GCIREQ
-  Bug #28525 Node failures in PGMAN at ndbrequire (line 430)
-  Bug #28653 Fast GCP + high load + high RedoBuffer causes ndbrequire
-  Bug #28749 MaxNoOfOpenFiles offset by 1
-  Added addditional 'times' printout in ndbd WatchDog thread
-  Some filename changes to avoid 'tar' issues with 99 char limit
-  Removed some extra printouts in ndbd out file
-
-mysql-5.1.15-ndb-6.1.9 (2007-05-24)
-
-  Bug #28593 cluster backup scans in acc index order, bad for disk data
-  Bug #28443 transporter gets stuck when >1024 signals received at once
- 
-mysql-5.1.15-ndb-6.1.8 (2007-05-18)
-
-  Bug #28491 Expand check gets disabled in some cases (initial node restart)
-  Bug #28348 Dropped tables not removed from LCP
-  Bug #20535 NDB API implicit insert of NULL does not overwrite old value
-  Bug #27437 NDB Data node crashes during mysqldump inserts
-  Bug #27942 node failure during massive insert
-
-mysql-5.1.15-ndb-6.1.7 (2007-05-05)
-
-  Bug #26121 mysqldump includes LOCK TABLES general_log WRITE
-  Bug #28161 Detached triggers + DD and only MM update could cause node failure
-  Bug #25530 --with-readline fails with commercial source packages
-  Bug #25741 AllocNodeIdRef::NodeFailureHandlingNotCompleted
-  Bug #27205 Occational 899 if delete+insert during LCP
-  Bug #24667 After ALTER TABLE operation ndb_dd table becomes regular ndb
-  Bug #28093 ndb: retry sleep in get table stats 30s instead of 30ms
-  Bug #28073 Infinite loop in lock queue.
-  Bug #27495 Missing implementation of NdbTransaction::executeAsynch().
-  Bug #28023 NR can fail to update GCI
-  Bug #27756 Memleak with insert+delete
-  Bug #27757 Tup scan cant see own records
-  Bug #27748 Inconsistent replication(backup) with some multi-update combinations
-  Bug #27651 Very high load can cause event api to get out of sync, "out of order buckets"
-  Bug #27728 Partially connected API's can cause problem for SUMA
-  Bug #27663 Missmatched free/delete in listObjects
-  Bug #27560 Memory usage of mysqld grows while doing nothing
-  Bug #27581 Drop/truncate table can result in node/cluster-crash
-
-  (no bug number) fix bug in my.cnf config handling, put64 for 64-bit variables
-
-  Other changes:
-  - Force varpart, such that tables can handle online add column when feature arrives
-
-  Test tools update for measuring replication latency:
-
-  - new ndb tool 'rep_latency' to measure replication latency
-  - simple extend of 'listen_event' to do apply on remote cluster
-
-mysql-5.1.15-ndb-6.1.6 (2007-03-30)
-
-  Bug #27529 Slave crashes on lots of updates
-  Bug #27512 Inconsistent tuples when using variable size and >16Gb datamemory
-  Bug #27378 update becomes delete on slave
-  Bug #27466 nf during nr can leave cluster in inconsistent state
-  Bug #27444 DataMemory missing from report in cluster logs
-  Bug #27044 replicated with unique field ndb table allows duplicate key inserts
-  Bug #26286 row-based logging scales worse than statement-based logging
-  Bug #19896 Last_Errno: 4294967295, Error in Write_rows event: (error number 4 billion ?)
-  Bug #27320 ndb handler does not reset extra flags on reset()
-  Bug #27283 Race condition in GCP Master take-over
-  Bug #26825 MySQL Server Crashes in high load
-  Bug #27286 Rare racecondition in nodeid allocation on master failure
-  Bug #27291 Setting LockPagesInMainMemory to zero doesn't work
-  Bug #20185 Node failure might cause other node failure
-  Bug #27203 ScanDelete+Scan+Insert could cause node crash
-  Bug #27169 xtra word sent in SUMA::resend_bucket causing crash of mysqld(event listener)
-  Bug #27005 Node failure + API failure can crash SUMA resend
-  Bug #27087 Unoptimal handling of failed API in SUMA
-  Bug #27102 Node can crash during flush of undo during restart with filesystem error
-  Bug #27003 Failure during noderestart could crash/hang alive node (and hence cluster)
-  (not reported) correct event buffer status reporting
-
-mysql-5.1.15-ndb-6.1.5 (2007-03-15)
-
-  Bug #26997 - mysqld segfault when in single user mode
-  Bug #26825 - MySQL Server Crashes in high load
-  Bug #25743 - If undo_buffer_size (for LG) greater than the inital shared memory (default 20M), ndbd nodes are crashed
-  Bug #26899 - ndb_restore cannot restore selected tables and databases
-  Bug #26900 - ndb_restore printout option does not give structured data
-  Bug #26720 - Infinite loop on unknown signal in logging function
-
-  * ndb_apply_status schema change
-  * ndb_restore options for printing to file
-
-  Note: since ndb_apply_status schema change this version is not backwards compatible
-
-mysql-5.1.15-ndb-6.1.4 (limited test release)
-
-  Bug #26741 - ndb_restore with only print_data seg faults
-  Bug #26739 - ndb_restore segfault on some 64-bit architectures
-  Bug #26663 - cluster have issues with api nodeids > 63
-
-mysql-5.1.15-ndb-6.1.3 (25 Feb 2007)
-
-  Bug #26515 - Incorrect pointer after FSCLOSECONF in REDO invalidation
-  Bug #26514 - Invalid memory access could occur during DD usage
-  Bug #26490 - duplicate cluster error code
-  Bug #26487 - Bug in extent/page allocation when *using* >1gb datafiles
-  Bug #25801 - Internal error if starting partially with missing REDO
-  Bug #26481 - Node failure during initial node restart, can lead to subsequent node failures
-  Bug #26457 - Incorrect handling of LCP take-over during multi-master-node-failure
-  Bug #26454 - LockPagesInMemory=1 is called after distributed communcation has started
-  Bug #25239 - Out of memory problem can cause crash in SUMA
-  Bug #21033 - Error 0 in readAutoIncrementValue()
-  Bug #26293 - cluster mgmt node sometimes doesn't receive events from all nodes on restart
-
-  * listEvents ndbapi extension
-  * Modified ndb_show_tables to also handle Table Events
-  * mysqld option --ndb-wait-connected
-  * Possibility to disable arbitration by setting arbitrationrank=0 on all nodes
-  * All dump 2352
-  * Different READ/SCAN (EX-SH)
-  * New dump commands for tracking hanging locks
-  * Change level on StartREDOLog to make it default come up in cluster log
-  * Make ndbd_redo_log_reader be build default
-
----------------------------------------------------
-
-mysql-5.1.16-ndb-6.2.0 (2007-03-09)
-
-  * WAN settings for TCP transporters
-  * moved initialization of ndbd fs block first to ensure that it gets enough space for allocation of file system thread stacks
-  * added listEvents
-  * modified ndb_show_tables to also handle Table Events
-  * added mysqld option --ndb-wait-connected
-  * Add possibility to disable arbitration by setting arbitrationrank=0 on all nodes
-  * Add all dump 2352
-  * Add different READ/SCAN (EX-SH)
-  * ndb - add new dump commands for tracking hanging locks
-  * Change level on StartREDOLog to make it default come up in cluster log
-  * Make ndbd_redo_log_reader be build default
-  * Integrate mem-manager with TUP removing need for DataMemory2
-  * New interface(ndbapi) for iterating over ndb-object connected to a Ndb_cluster_connection
-  * New interface(ndbapi) for starting transaction with hints
-  * Different handling of AbortOption in ndbapi
-
----------------------------------------------------
-
-mysql-5.1.15-ndb-6.1.2 (7 Feb 2007)
-
-  Bug #26267 - using node ids > 48 causes invalid memory access
-
----------------------------------------------------
-
-mysql-5.1.15-ndb-6.1.1 (31 Jan 2007)
-
-  Bug #25997 - Valgrind reports leak in event code in mysqld during hadeling of NF and CF
-  Bug #25794 - Delete+Read (in same op) crashes datanodes if >5 cols or disk/varchar
-  Bug #25286 - NDB data node crashed in DBLQH, Line 2483
-
-  (* added extra version info to API to enable support for non-supported online software upgrade)
-  * 255 node support
-
-  Notes:
-
-  - This release is not online upgradable with ndb-6.1.0.
-  - All executables needs to be replaced
-  - All ndbapi/mgmapi application should be recompiled
-
----------------------------------------------------
-
-mysql-5.1.14-ndb-6.1.0 (20 Dec 2006)
-
-  Bug #25059 - Unique index lookup execute(Commit) on non existing tuple can lead to 4012
-  Bug #25090 - Incorrect handling of execute(Commit, AO_IgnoreError), can lead to DBCT crash
-  Bug #19956 - Problems with VARCHAR primary key and BLOB fields
-  Bug #24949 - Pulling cable from _last_ db-node can cause 6min timeout in api
-  Bug #25001 - MEDIUMTEXT column not stored on disk
-  Bug #24664 - Rare problem in LCP, can lead to unability to restart
-  Bug #24917 - Makeing node restart with "newly" dropped disk table can cause failure during restart
-  Bug #24914 - Start Transaction with hint guessed incorrectly
-  Bug #21948 - Repeated create/drop/truncate(DD) together with restarts can cause SR failure
-  Bug #17605 - DD Extents are not available until after LCP
-  Bug #22773 - NDB_LE_Connected sent when it should be NDB_LE_Disconnected
-  Bug #24166 - SR-crash if DD and hidden key
-
-  * add support for periodic mem-reporting, config.ini parameter "MemReportFrequency" which is specified in seconds
-
-

=== modified file 'configure.in'
--- a/configure.in	2010-08-30 08:53:28 +0000
+++ b/configure.in	2010-09-29 11:53:30 +0000
@@ -12,7 +12,7 @@ dnl
 dnl When changing the major version number please also check the switch
 dnl statement in mysqlbinlog::check_master_version().  You may also need
 dnl to update version.c in ndb.
-AC_INIT([MySQL Server], [5.1.47-ndb-7.0.19], [], [mysql])
+AC_INIT([MySQL Server], [5.1.47-ndb-7.0.20], [], [mysql])
 
 AC_CONFIG_SRCDIR([sql/mysqld.cc])
 AC_CANONICAL_SYSTEM

=== modified file 'mysql-test/suite/ndb_team/t/ndb_restart.test'
--- a/mysql-test/suite/ndb_team/t/ndb_restart.test	2010-06-11 07:27:59 +0000
+++ b/mysql-test/suite/ndb_team/t/ndb_restart.test	2010-09-29 10:27:39 +0000
@@ -15,7 +15,7 @@ insert into t1 values (1, 2);
 #
 # Restart node 1
 #
---exec $ndb_mgm_cmd -e "1 RESTART"
+--exec $ndb_mgm_cmd -e "1 RESTART -n"
 --exec $ndb_waiter_cmd --nowait-nodes=2 --not-started > /dev/null
 --exec $ndb_mgm_cmd -e "1 START"
 --exec $ndb_waiter_cmd  > /dev/null
@@ -27,7 +27,7 @@ insert into t1 values (2, 3);
 #
 # Restart node 1 --initial
 #
---exec $ndb_mgm_cmd -e "1 RESTART -I"
+--exec $ndb_mgm_cmd -e "1 RESTART -n -I"
 --exec $ndb_waiter_cmd --nowait-nodes=2 --not-started  > /dev/null
 --exec $ndb_mgm_cmd -e "1 START"
 --exec $ndb_waiter_cmd  > /dev/null

=== modified file 'sql/ha_ndbcluster_binlog.cc'
--- a/sql/ha_ndbcluster_binlog.cc	2010-09-15 18:38:13 +0000
+++ b/sql/ha_ndbcluster_binlog.cc	2010-09-29 11:01:55 +0000
@@ -6541,7 +6541,24 @@ restart_cluster_failure:
           DBUG_PRINT("info", ("COMMIT gci: %lu", (ulong) gci));
           if (opt_ndb_log_binlog_index)
           {
-            ndb_add_ndb_binlog_index(thd, rows);
+            if (ndb_add_ndb_binlog_index(thd, rows))
+            {
+              /* 
+                 Writing to ndb_binlog_index failed, check if we are
+                 being killed and retry
+              */
+              if (thd->killed)
+              {
+                (void) pthread_mutex_lock(&LOCK_thread_count);
+                volatile THD::killed_state killed= thd->killed;
+                /* We are cleaning up, allow for flushing last epoch */
+                thd->killed= THD::NOT_KILLED;
+                ndb_add_ndb_binlog_index(thd, rows);
+                /* Restore kill flag */
+                thd->killed= killed;
+                (void) pthread_mutex_unlock(&LOCK_thread_count);
+              }
+            }
           }
           ndb_latest_applied_binlog_epoch= gci;
           break;

=== modified file 'storage/ndb/include/kernel/signaldata/WaitGCP.hpp'
--- a/storage/ndb/include/kernel/signaldata/WaitGCP.hpp	2009-05-27 15:21:45 +0000
+++ b/storage/ndb/include/kernel/signaldata/WaitGCP.hpp	2010-09-30 14:27:18 +0000
@@ -51,7 +51,8 @@ public:
     CurrentGCI        = 8,  ///< Immediately return current GCI
     BlockStartGcp     = 9,
     UnblockStartGcp   = 10,
-    WaitEpoch         = 11  // If GCP is blocked, wait for epoch to not start
+    WaitEpoch         = 11, // If GCP is blocked, wait for epoch to not start
+    RestartGCI        = 12  // Return restart GCI
   };
 
   Uint32 senderRef;
@@ -98,6 +99,7 @@ class WaitGCPRef {
   friend class Dbdict;
   friend class Backup;
   friend class Trix;
+  friend class NdbDictInterface;
 
 public:
   STATIC_CONST( SignalLength = 2 );

=== modified file 'storage/ndb/include/mgmapi/mgmapi.h'
--- a/storage/ndb/include/mgmapi/mgmapi.h	2010-09-22 14:19:12 +0000
+++ b/storage/ndb/include/mgmapi/mgmapi.h	2010-09-29 08:45:11 +0000
@@ -771,6 +771,29 @@ extern "C" {
   int ndb_mgm_stop3(NdbMgmHandle handle, int no_of_nodes,
 		    const int * node_list, int abort, int *disconnect);
 
+  /**
+   * Stops cluster nodes
+   *
+    * @param   handle        Management handle.
+   * @param   no_of_nodes   Number of database nodes to stop<br>
+   *                         -1: All database and management nodes<br>
+   *                          0: All database nodes in cluster<br>
+   *                          n: Stop the <var>n</var> node(s) specified in
+   *                            the array node_list
+   * @param   node_list     List of node IDs of database nodes to be stopped
+   * @param   abort         Don't perform graceful stop,
+   *                        but rather stop immediately
+   * @param   force         Force stop of nodes even if it means the
+   *                        whole cluster will be shutdown
+   * @param   disconnect    Returns true if you need to disconnect to apply
+   *                        the stop command (e.g. stopping the mgm server
+   *                        that handle is connected to)
+   *
+   * @return                Number of nodes stopped (-1 on error).
+   */
+   int ndb_mgm_stop4(NdbMgmHandle handle, int no_of_nodes,
+		    const int * node_list, int abort, int force,
+                    int *disconnect);
 
   /**
    * Restart database nodes
@@ -837,6 +860,33 @@ extern "C" {
 		       int nostart, int abort, int *disconnect);
 
   /**
+   * Restart nodes
+   *
+   * @param   handle        Management handle.
+   * @param   no_of_nodes   Number of database nodes to be restarted:<br>
+   *                          0: Restart all database nodes in the cluster<br>
+   *                          n: Restart the <var>n</var> node(s) specified
+   *                             in the array node_list
+   * @param   node_list     List of node IDs of database nodes to be restarted
+   * @param   initial       Remove filesystem from restarting node(s)
+   * @param   nostart       Don't actually start node(s) but leave them
+   *                        waiting for start command
+   * @param   abort         Don't perform graceful restart,
+   *                        but rather restart immediately
+   * @param   force         Force restart of nodes even if it means the
+   *                        whole cluster will be restarted
+   * @param   disconnect    Returns true if mgmapi client must disconnect from
+   *                        server to apply the requested operation. (e.g.
+   *                        restart the management server)
+   *
+   *
+   * @return                Number of nodes stopped (-1 on error).
+   */
+  int ndb_mgm_restart4(NdbMgmHandle handle, int no_of_nodes,
+		       const int * node_list, int initial,
+		       int nostart, int abort, int force, int *disconnect);
+
+  /**
    * Start database nodes
    *
    * @param   handle        Management handle.

=== modified file 'storage/ndb/include/ndb_version.h.in'
--- a/storage/ndb/include/ndb_version.h.in	2010-08-26 12:33:33 +0000
+++ b/storage/ndb/include/ndb_version.h.in	2010-09-29 08:45:11 +0000
@@ -119,8 +119,6 @@ Uint32 ndbGetOwnVersion();
 #define NDBD_MT_LQH_VERSION MAKE_VERSION(6,4,0)
 
 #define NDBD_SCHEMA_TRANS_VERSION NDB_MAKE_VERSION(6,4,0)
-#define MGMD_MGMAPI_PROTOCOL_CHANGE NDB_MAKE_VERSION(6,4,0)
-
 
 static
 inline

=== modified file 'storage/ndb/include/ndbapi/Ndb.hpp'
--- a/storage/ndb/include/ndbapi/Ndb.hpp	2010-02-11 10:59:05 +0000
+++ b/storage/ndb/include/ndbapi/Ndb.hpp	2010-09-30 14:27:18 +0000
@@ -1664,23 +1664,6 @@ public:
   };
 
   /**
-   * For testing purposes it is possible to tamper with the NDB Cluster
-   * (i.e. send a special signal to DBDIH, the NDB distribution handler).
-   * <b>This feature should only used for debugging purposes.</b>
-   * In a release versions of NDB Cluster,
-   * this call always return -1 and does nothing.
-   * 
-   * @param aAction Action to be taken according to TamperType above
-   *
-   * @param aNode  Which node the action will be taken
-   *              -1:   Master DIH.
-   *            0-16:   Nodnumber.
-   * @return -1 indicates error, other values have meaning dependent 
-   *          on type of tampering.
-   */
-  int NdbTamper(TamperType aAction, int aNode);  
-
-  /**
    * Return a unique tuple id for a table.  The id sequence is
    * ascending but may contain gaps.  Methods which have no
    * TupleIdRange argument use NDB API dict cache.  They may
@@ -1837,7 +1820,8 @@ private:
 
   // Handle a received signal. Used by both
   // synchronous and asynchronous interface
-  void handleReceivedSignal(NdbApiSignal* anApiSignal, struct LinearSectionPtr ptr[3]);
+  void handleReceivedSignal(const NdbApiSignal* anApiSignal,
+			    const struct LinearSectionPtr ptr[3]);
   
   int			sendRecSignal(Uint16 aNodeId,
 				      Uint32 aWaitState,
@@ -1845,9 +1829,6 @@ private:
                                       Uint32 nodeSequence,
                                       Uint32 *ret_conn_seq= 0);
   
-  // Sets Restart GCI in Ndb object
-  void			RestartGCI(int aRestartGCI);
-
   // Get block number of this NDBAPI object
   int			getBlockNumber();
   
@@ -1999,8 +1980,8 @@ private:
   int creleaseSignals;
 #endif
 
-  static void executeMessage(void*, NdbApiSignal *, 
-			     struct LinearSectionPtr ptr[3]);
+  static void executeMessage(void*, const NdbApiSignal *,
+			     const struct LinearSectionPtr ptr[3]);
   static void statusMessage(void*, Uint32, bool, bool);
 #ifdef VM_TRACE
 #include <my_attribute.h>

=== modified file 'storage/ndb/include/ndbapi/NdbDictionary.hpp'
--- a/storage/ndb/include/ndbapi/NdbDictionary.hpp	2010-09-30 13:15:22 +0000
+++ b/storage/ndb/include/ndbapi/NdbDictionary.hpp	2010-10-01 10:27:55 +0000
@@ -2325,6 +2325,11 @@ public:
      */
     int forceGCPWait();
     int forceGCPWait(int type);
+
+    /**
+     * Get restart gci
+     */
+    int getRestartGCI(Uint32 * gci);
 #endif
 
     /** @} *******************************************************************/

=== modified file 'storage/ndb/include/ndbapi/NdbIndexOperation.hpp'
--- a/storage/ndb/include/ndbapi/NdbIndexOperation.hpp	2009-05-26 18:53:34 +0000
+++ b/storage/ndb/include/ndbapi/NdbIndexOperation.hpp	2010-09-29 13:25:19 +0000
@@ -177,7 +177,7 @@ private:
   NdbIndexOperation(Ndb* aNdb);
   ~NdbIndexOperation();
 
-  int receiveTCINDXREF(NdbApiSignal* aSignal);
+  int receiveTCINDXREF(const NdbApiSignal* aSignal);
 
   // Overloaded methods from NdbCursorOperation
   int indxInit(const class NdbIndexImpl* anIndex,

=== modified file 'storage/ndb/include/ndbapi/NdbOperation.hpp'
--- a/storage/ndb/include/ndbapi/NdbOperation.hpp	2010-06-08 14:37:15 +0000
+++ b/storage/ndb/include/ndbapi/NdbOperation.hpp	2010-09-29 13:25:19 +0000
@@ -1272,11 +1272,11 @@ protected:
   int    insertATTRINFOData_NdbRecord(const char *value,
                                       Uint32 size);
 
-  int	 receiveTCKEYREF(NdbApiSignal*); 
+  int	 receiveTCKEYREF(const NdbApiSignal*);
 
   int	 checkMagicNumber(bool b = true); // Verify correct object
 
-  int    checkState_TransId(NdbApiSignal* aSignal);
+  int    checkState_TransId(const NdbApiSignal* aSignal);
 
 /******************************************************************************
  *	These are support methods only used locally in this class.

=== modified file 'storage/ndb/include/ndbapi/NdbTransaction.hpp'
--- a/storage/ndb/include/ndbapi/NdbTransaction.hpp	2010-01-28 15:16:46 +0000
+++ b/storage/ndb/include/ndbapi/NdbTransaction.hpp	2010-09-30 14:27:18 +0000
@@ -942,23 +942,22 @@ private:
   Uint32        get_send_size();                  // Get size to send
   void          set_send_size(Uint32);            // Set size to send;
   
-  int  receiveDIHNDBTAMPER(NdbApiSignal* anApiSignal);
-  int  receiveTCSEIZECONF(NdbApiSignal* anApiSignal); 
-  int  receiveTCSEIZEREF(NdbApiSignal* anApiSignal);	
-  int  receiveTCRELEASECONF(NdbApiSignal* anApiSignal);	
-  int  receiveTCRELEASEREF(NdbApiSignal* anApiSignal);	
+  int  receiveTCSEIZECONF(const NdbApiSignal* anApiSignal);
+  int  receiveTCSEIZEREF(const NdbApiSignal* anApiSignal);
+  int  receiveTCRELEASECONF(const NdbApiSignal* anApiSignal);
+  int  receiveTCRELEASEREF(const NdbApiSignal* anApiSignal);
   int  receiveTC_COMMITCONF(const class TcCommitConf *, Uint32 len);
   int  receiveTCKEYCONF(const class TcKeyConf *, Uint32 aDataLength);
   int  receiveTCKEY_FAILCONF(const class TcKeyFailConf *);
-  int  receiveTCKEY_FAILREF(NdbApiSignal* anApiSignal);
-  int  receiveTC_COMMITREF(NdbApiSignal* anApiSignal);		    	
-  int  receiveTCROLLBACKCONF(NdbApiSignal* anApiSignal); // Rec TCPREPARECONF ?
-  int  receiveTCROLLBACKREF(NdbApiSignal* anApiSignal);  // Rec TCPREPAREREF ?
-  int  receiveTCROLLBACKREP(NdbApiSignal* anApiSignal);
+  int  receiveTCKEY_FAILREF(const NdbApiSignal* anApiSignal);
+  int  receiveTC_COMMITREF(const NdbApiSignal* anApiSignal);
+  int  receiveTCROLLBACKCONF(const NdbApiSignal* anApiSignal);
+  int  receiveTCROLLBACKREF(const NdbApiSignal* anApiSignal);
+  int  receiveTCROLLBACKREP(const NdbApiSignal* anApiSignal);
   int  receiveTCINDXCONF(const class TcIndxConf *, Uint32 aDataLength);
-  int  receiveTCINDXREF(NdbApiSignal*);
-  int  receiveSCAN_TABREF(NdbApiSignal*);
-  int  receiveSCAN_TABCONF(NdbApiSignal*, const Uint32*, Uint32 len);
+  int  receiveTCINDXREF(const NdbApiSignal*);
+  int  receiveSCAN_TABREF(const NdbApiSignal*);
+  int  receiveSCAN_TABCONF(const NdbApiSignal*, const Uint32*, Uint32 len);
 
   int 	doSend();	                // Send all operations
   int 	sendROLLBACK();	                // Send of an ROLLBACK

=== modified file 'storage/ndb/ndb_configure.m4'
--- a/storage/ndb/ndb_configure.m4	2010-08-30 09:51:49 +0000
+++ b/storage/ndb/ndb_configure.m4	2010-09-29 11:51:14 +0000
@@ -2,7 +2,7 @@
 # Should be updated when creating a new NDB version
 NDB_VERSION_MAJOR=7
 NDB_VERSION_MINOR=0
-NDB_VERSION_BUILD=19
+NDB_VERSION_BUILD=20
 NDB_VERSION_STATUS=""
 
 dnl for build ndb docs

=== modified file 'storage/ndb/src/common/portlib/NdbDir.cpp'
--- a/storage/ndb/src/common/portlib/NdbDir.cpp	2010-09-23 09:10:53 +0000
+++ b/storage/ndb/src/common/portlib/NdbDir.cpp	2010-09-29 07:54:14 +0000
@@ -209,7 +209,7 @@ NdbDir::create(const char *dir, mode_t m
       return true;
 
     fprintf(stderr,
-            "Failed to create directory '%s', error: %d",
+            "Failed to create directory '%s', error: %d\n",
             dir, GetLastError());
     return false;
   }
@@ -220,7 +220,7 @@ NdbDir::create(const char *dir, mode_t m
       return true;
 
     fprintf(stderr,
-            "Failed to create directory '%s', error: %d",
+            "Failed to create directory '%s', error: %d\n",
             dir, errno);
     return false;
   }

=== modified file 'storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp'
--- a/storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp	2010-09-13 14:31:30 +0000
+++ b/storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp	2010-09-30 14:27:18 +0000
@@ -17993,6 +17993,18 @@ void Dbdih::execWAIT_GCP_REQ(Signal* sig
     return;
   }//if
 
+  if(requestType == WaitGCPReq::RestartGCI)
+  {
+    jam();
+    conf->senderData = senderData;
+    conf->gci_hi = Uint32(crestartGci);
+    conf->gci_lo = 0;
+    conf->blockStatus = cgcpOrderBlocked;
+    sendSignal(senderRef, GSN_WAIT_GCP_CONF, signal,
+	       WaitGCPConf::SignalLength, JBB);
+    return;
+  }//if
+
   if (requestType == WaitGCPReq::BlockStartGcp)
   {
     jam();

=== modified file 'storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp'
--- a/storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp	2010-09-23 07:31:28 +0000
+++ b/storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp	2010-09-27 08:52:07 +0000
@@ -17897,8 +17897,18 @@ void Dblqh::readFileInInvalidate(Signal*
              logPartPtr.p->logPartNo, logFilePtr.p->fileNo, stepNext);
   }
 
+  if (stepNext == 0)
+  {
+    jam();
+    // Contact NDBFS. Real time break.
+    readSinglePage(signal, logPartPtr.p->invalidatePageNo);
+    lfoPtr.p->lfoState = LogFileOperationRecord::READ_SR_INVALIDATE_PAGES;
+    return;
+  }
+
   if (stepNext == 1)
   {
+    jam();
     logPartPtr.p->invalidatePageNo++;
     if (logPartPtr.p->invalidatePageNo == (clogFileSize * ZPAGES_IN_MBYTE))
     {

=== modified file 'storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp'
--- a/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp	2010-09-30 13:15:22 +0000
+++ b/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp	2010-10-01 08:53:44 +0000
@@ -1741,7 +1741,7 @@ public:
    * index node.  TUX reads and writes the node directly via pointer.
    */
   int tuxAllocNode(EmulatedJamBuffer*, Uint32 fragPtrI, Uint32& pageId, Uint32& pageOffset, Uint32*& node);
-  void tuxFreeNode(Signal* signal, Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32* node);
+  void tuxFreeNode(Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32* node);
   void tuxGetNode(Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32*& node);
 
   /*

=== modified file 'storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp'
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp	2010-09-03 05:35:51 +0000
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp	2010-09-24 18:19:07 +0000
@@ -75,10 +75,8 @@ Dbtup::tuxAllocNode(EmulatedJamBuffer *
   return 0;
 }
 
-#if 0
 void
-Dbtup::tuxFreeNode(Signal* signal,
-                   Uint32 fragPtrI,
+Dbtup::tuxFreeNode(Uint32 fragPtrI,
                    Uint32 pageId,
                    Uint32 pageOffset,
                    Uint32* node)
@@ -90,15 +88,19 @@ Dbtup::tuxFreeNode(Signal* signal,
   TablerecPtr tablePtr;
   tablePtr.i= fragPtr.p->fragTableId;
   ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
+
+  Local_key key;
+  key.m_page_no = pageId;
+  key.m_page_idx = pageOffset;
   PagePtr pagePtr;
-  pagePtr.i= pageId;
-  ptrCheckGuard(pagePtr, cnoOfPage, cpage);
+  Tuple_header* ptr = (Tuple_header*)get_ptr(&pagePtr, &key, tablePtr.p);
+
   Uint32 attrDescIndex= tablePtr.p->tabDescriptor + (0 << ZAD_LOG_SIZE);
   Uint32 attrDataOffset= AttributeOffset::getOffset(tableDescriptor[attrDescIndex + 1].tabDescr);
-  ndbrequire(node == &pagePtr.p->pageWord[pageOffset] + attrDataOffset);
-  freeTh(fragPtr.p, tablePtr.p, signal, pagePtr.p, pageOffset);
+  ndbrequire(node == (Uint32*)ptr + attrDataOffset);
+
+  free_fix_rec(fragPtr.p, tablePtr.p, &key, (Fix_page*)pagePtr.p);
 }
-#endif
 
 void
 Dbtup::tuxGetNode(Uint32 fragPtrI,

=== modified file 'storage/ndb/src/kernel/blocks/dbtux/Dbtux.hpp'
--- a/storage/ndb/src/kernel/blocks/dbtux/Dbtux.hpp	2010-08-20 11:10:25 +0000
+++ b/storage/ndb/src/kernel/blocks/dbtux/Dbtux.hpp	2010-09-24 18:19:07 +0000
@@ -492,7 +492,7 @@ private:
     Uint16 m_numAttrs;
     bool m_storeNullKey;
     TreeHead m_tree;
-    TupLoc m_freeLoc;           // list of free index nodes
+    TupLoc m_freeLoc;           // one free node for next op
     DLList<ScanOp> m_scanList;  // current scans on this fragment
     Uint32 m_tupIndexFragPtrI;
     Uint32 m_tupTableFragPtrI;
@@ -604,9 +604,11 @@ private:
    * DbtuxNode.cpp
    */
   int allocNode(TuxCtx&, NodeHandle& node);
+  void freeNode(NodeHandle& node);
   void selectNode(NodeHandle& node, TupLoc loc);
   void insertNode(NodeHandle& node);
   void deleteNode(NodeHandle& node);
+  void freePreallocatedNode(Frag& frag);
   void setNodePref(struct TuxCtx &, NodeHandle& node);
   // node operations
   void nodePushUp(TuxCtx&, NodeHandle& node, unsigned pos, const TreeEnt& ent, Uint32 scanList);

=== modified file 'storage/ndb/src/kernel/blocks/dbtux/DbtuxBuild.cpp'
--- a/storage/ndb/src/kernel/blocks/dbtux/DbtuxBuild.cpp	2010-01-12 08:25:40 +0000
+++ b/storage/ndb/src/kernel/blocks/dbtux/DbtuxBuild.cpp	2010-09-24 18:19:07 +0000
@@ -141,8 +141,6 @@ Dbtux::mt_buildIndexFragment(mt_BuildInd
       {
         break;
       }
-      // link to freelist
-      node.setLink(0, frag.m_freeLoc);
       frag.m_freeLoc = node.m_loc;
       ndbrequire(frag.m_freeLoc != NullTupLoc);
     }

=== modified file 'storage/ndb/src/kernel/blocks/dbtux/DbtuxMaint.cpp'
--- a/storage/ndb/src/kernel/blocks/dbtux/DbtuxMaint.cpp	2009-12-14 10:58:03 +0000
+++ b/storage/ndb/src/kernel/blocks/dbtux/DbtuxMaint.cpp	2010-09-24 11:06:19 +0000
@@ -146,8 +146,6 @@ Dbtux::execTUX_MAINT_REQ(Signal* signal)
         jam();
         break;
       }
-      // link to freelist
-      node.setLink(0, frag.m_freeLoc);
       frag.m_freeLoc = node.m_loc;
       ndbrequire(frag.m_freeLoc != NullTupLoc);
     }

=== modified file 'storage/ndb/src/kernel/blocks/dbtux/DbtuxNode.cpp'
--- a/storage/ndb/src/kernel/blocks/dbtux/DbtuxNode.cpp	2009-12-14 22:14:34 +0000
+++ b/storage/ndb/src/kernel/blocks/dbtux/DbtuxNode.cpp	2010-09-24 18:19:07 +0000
@@ -54,6 +54,24 @@ Dbtux::allocNode(TuxCtx& ctx, NodeHandle
 }
 
 /*
+ * Free index node in TUP
+ */
+void
+Dbtux::freeNode(NodeHandle& node)
+{
+  Frag& frag = node.m_frag;
+  Uint32 pageId = node.m_loc.getPageId();
+  Uint32 pageOffset = node.m_loc.getPageOffset();
+  Uint32* node32 = reinterpret_cast<Uint32*>(node.m_node);
+  c_tup->tuxFreeNode(frag.m_tupIndexFragPtrI,
+                     pageId, pageOffset, node32);
+  jamEntry();
+  // invalidate the handle
+  node.m_loc = NullTupLoc;
+  node.m_node = 0;
+}
+
+/*
  * Set handle to point to existing node.
  */
 void
@@ -77,9 +95,9 @@ void
 Dbtux::insertNode(NodeHandle& node)
 {
   Frag& frag = node.m_frag;
-  // unlink from freelist
+  // use up pre-allocated node
   selectNode(node, frag.m_freeLoc);
-  frag.m_freeLoc = node.getLink(0);
+  frag.m_freeLoc = NullTupLoc;
   new (node.m_node) TreeNode();
 #ifdef VM_TRACE
   TreeHead& tree = frag.m_tree;
@@ -90,19 +108,44 @@ Dbtux::insertNode(NodeHandle& node)
 }
 
 /*
- * Delete existing node.  Simply put it on the freelist.
+ * Delete existing node.  Make it the pre-allocated free node if there
+ * is none.  Otherwise return it to fragment's free list.
  */
 void
 Dbtux::deleteNode(NodeHandle& node)
 {
   Frag& frag = node.m_frag;
   ndbrequire(node.getOccup() == 0);
-  // link to freelist
-  node.setLink(0, frag.m_freeLoc);
-  frag.m_freeLoc = node.m_loc;
-  // invalidate the handle
-  node.m_loc = NullTupLoc;
-  node.m_node = 0;
+  if (frag.m_freeLoc == NullTupLoc)
+  {
+    jam();
+    frag.m_freeLoc = node.m_loc;
+    // invalidate the handle
+    node.m_loc = NullTupLoc;
+    node.m_node = 0;
+  }
+  else
+  {
+    jam();
+    freeNode(node);
+  }
+}
+
+/*
+ * Free the pre-allocated node, called when tree is empty.  This avoids
+ * leaving any used pages in DataMemory.
+ */
+void
+Dbtux::freePreallocatedNode(Frag& frag)
+{
+  if (frag.m_freeLoc != NullTupLoc)
+  {
+    jam();
+    NodeHandle node(frag);
+    selectNode(node, frag.m_freeLoc);
+    freeNode(node);
+    frag.m_freeLoc = NullTupLoc;
+  }
 }
 
 /*

=== modified file 'storage/ndb/src/kernel/blocks/dbtux/DbtuxTree.cpp'
--- a/storage/ndb/src/kernel/blocks/dbtux/DbtuxTree.cpp	2009-12-14 22:14:34 +0000
+++ b/storage/ndb/src/kernel/blocks/dbtux/DbtuxTree.cpp	2010-09-24 18:19:07 +0000
@@ -328,6 +328,8 @@ Dbtux::treeRemoveNode(Frag& frag, NodeHa
   }
   // tree is now empty
   tree.m_root = NullTupLoc;
+  // free even the pre-allocated node
+  freePreallocatedNode(frag);
 }
 
 /*

=== modified file 'storage/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp'
--- a/storage/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp	2010-09-23 09:36:19 +0000
+++ b/storage/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp	2010-09-29 07:54:14 +0000
@@ -137,7 +137,8 @@ bool
 do_mkdir(const char * path)
 {
   return NdbDir::create(path,
-                        NdbDir::u_rwx() | NdbDir::g_r() | NdbDir::g_x());
+                        NdbDir::u_rwx() | NdbDir::g_r() | NdbDir::g_x(),
+                        true /* ignore_existing */);
 }
 
 static

=== modified file 'storage/ndb/src/kernel/blocks/ndbfs/PosixAsyncFile.cpp'
--- a/storage/ndb/src/kernel/blocks/ndbfs/PosixAsyncFile.cpp	2010-08-17 09:54:53 +0000
+++ b/storage/ndb/src/kernel/blocks/ndbfs/PosixAsyncFile.cpp	2010-09-24 15:10:46 +0000
@@ -42,6 +42,8 @@
 #include <sys/uio.h>
 #include <dirent.h>
 
+#include <sys/stat.h>
+
 PosixAsyncFile::PosixAsyncFile(SimulatedBlock& fs) :
   AsyncFile(fs),
   theFd(-1),

=== modified file 'storage/ndb/src/kernel/blocks/suma/Suma.cpp'
--- a/storage/ndb/src/kernel/blocks/suma/Suma.cpp	2010-09-06 08:20:33 +0000
+++ b/storage/ndb/src/kernel/blocks/suma/Suma.cpp	2010-09-29 07:39:42 +0000
@@ -1251,10 +1251,10 @@ Suma::execNODE_FAILREP(Signal* signal){
 	  progError(__LINE__, NDBD_EXIT_SYSTEM_ERROR, 
 		    "Nodefailure during SUMA takeover");
 	}
-        else if (state & Bucket::BUCKET_SHUTDOWN)
+        else if (state & Bucket::BUCKET_SHUTDOWN_TO)
         {
           jam();
-          c_buckets[i].m_state &= ~Uint32(Bucket::BUCKET_SHUTDOWN);
+          c_buckets[i].m_state &= ~Uint32(Bucket::BUCKET_SHUTDOWN_TO);
           m_switchover_buckets.clear(i);
           ndbrequire(get_responsible_node(i, tmp) == getOwnNodeId());
           start_resend(signal, i);
@@ -3964,7 +3964,11 @@ Suma::get_responsible_node(Uint32 bucket
 bool
 Suma::check_switchover(Uint32 bucket, Uint64 gci)
 {
-  const Uint32 send_mask = (Bucket::BUCKET_STARTING | Bucket::BUCKET_TAKEOVER);
+  const Uint32 send_mask = 
+    Bucket::BUCKET_STARTING |
+    Bucket::BUCKET_TAKEOVER |
+    Bucket::BUCKET_SHUTDOWN_TO;
+
   bool send = c_buckets[bucket].m_state & send_mask;
   ndbassert(m_switchover_buckets.get(bucket));
   if(unlikely(gci > c_buckets[bucket].m_switchover_gci))
@@ -4453,27 +4457,27 @@ found:
         }
         else if (state & Bucket::BUCKET_SHUTDOWN)
         {
+          jam();
           Uint32 nodeId = c_buckets[i].m_switchover_node;
-          if (nodeId == getOwnNodeId())
-          {
-            jam();
-            m_active_buckets.clear(i);
-            m_gcp_complete_rep_count--;
-            ndbout_c("shutdown handover");
-          }
-          else
-          {
-            jam();
-            NdbNodeBitmask nodegroup = c_nodes_in_nodegroup_mask;
-            nodegroup.clear(nodeId);
-            ndbrequire(get_responsible_node(i) == nodeId &&
-                       get_responsible_node(i, nodegroup) == getOwnNodeId());
-            m_active_buckets.set(i);
-            m_gcp_complete_rep_count++;
-            ndbout_c("shutdown takover");
-          }
+          ndbrequire(nodeId == getOwnNodeId());
+          m_active_buckets.clear(i);
+          m_gcp_complete_rep_count--;
+          ndbout_c("shutdown handover");
           c_buckets[i].m_state &= ~(Uint32)Bucket::BUCKET_SHUTDOWN;
         }
+        else if (state & Bucket::BUCKET_SHUTDOWN_TO)
+        {
+          jam();
+          Uint32 nodeId = c_buckets[i].m_switchover_node;
+          NdbNodeBitmask nodegroup = c_nodes_in_nodegroup_mask;
+          nodegroup.clear(nodeId);
+          ndbrequire(get_responsible_node(i) == nodeId &&
+                     get_responsible_node(i, nodegroup) == getOwnNodeId());
+          m_active_buckets.set(i);
+          m_gcp_complete_rep_count++;
+          ndbout_c("shutdown takover");
+          c_buckets[i].m_state &= ~(Uint32)Bucket::BUCKET_SHUTDOWN_TO;
+        }
       }
     }
 
@@ -5482,7 +5486,7 @@ Suma::execSUMA_HANDOVER_REQ(Signal* sign
         tmp.set(i);
         m_switchover_buckets.set(i);
         c_buckets[i].m_switchover_gci = (Uint64(start_gci) << 32) - 1;
-        c_buckets[i].m_state |= Bucket::BUCKET_SHUTDOWN;
+        c_buckets[i].m_state |= Bucket::BUCKET_SHUTDOWN_TO;
         c_buckets[i].m_switchover_node = nodeId;
         ndbout_c("prepare to takeover bucket: %d", i);
       }

=== modified file 'storage/ndb/src/kernel/blocks/suma/Suma.hpp'
--- a/storage/ndb/src/kernel/blocks/suma/Suma.hpp	2010-08-26 12:33:33 +0000
+++ b/storage/ndb/src/kernel/blocks/suma/Suma.hpp	2010-09-29 07:39:42 +0000
@@ -589,6 +589,7 @@ private:
       ,BUCKET_DROPPED_OTHER = 0x80 // New nodegroup (not me)
       ,BUCKET_DROPPED_MASK  = (BUCKET_DROPPED_SELF | BUCKET_DROPPED_OTHER)
       ,BUCKET_SHUTDOWN = 0x100 // Graceful shutdown
+      ,BUCKET_SHUTDOWN_TO = 0x200 // Graceful shutdown
     };
     Uint16 m_state;
     Uint16 m_switchover_node;

=== modified file 'storage/ndb/src/mgmapi/mgmapi.cpp'
--- a/storage/ndb/src/mgmapi/mgmapi.cpp	2010-09-22 10:07:28 +0000
+++ b/storage/ndb/src/mgmapi/mgmapi.cpp	2010-09-29 08:45:11 +0000
@@ -107,11 +107,78 @@ struct ndb_mgm_handle {
   int mgmd_version_major;
   int mgmd_version_minor;
   int mgmd_version_build;
+
+  int mgmd_version(void) const {
+    // Must be connected
+    assert(connected);
+    // Check that version has been read
+    assert(mgmd_version_major >= 0 &&
+           mgmd_version_minor >= 0 &&
+           mgmd_version_build >= 0);
+    return NDB_MAKE_VERSION(mgmd_version_major,
+                            mgmd_version_minor,
+                            mgmd_version_build);
+  }
+
   char * m_bindaddress;
   int m_bindaddress_port;
   bool ignore_sigpipe;
 };
 
+
+/*
+  Check if version "curr" is greater than or equal to
+  a list of given versions
+
+  NOTE! The list of versions to check against must be listed
+  with the highest version first and terminated with version 0
+*/
+static inline
+bool check_version_ge(Uint32 curr, ...)
+{
+  Uint32 version, last = ~0;
+
+  va_list versions;
+  va_start(versions, curr);
+  while ((version= va_arg(versions, Uint32)))
+  {
+    if (curr >= version)
+    {
+      va_end(versions);
+      return true;
+    }
+    assert(version < last); // check that version list is descending
+    last = version;
+  }
+
+  va_end(versions);
+  return false;
+}
+
+static inline void
+test_check_version_ge(void)
+{
+  assert(check_version_ge(NDB_MAKE_VERSION(7,0,19),
+                          NDB_MAKE_VERSION(7,0,20),
+                          0) == false);
+  assert(check_version_ge(NDB_MAKE_VERSION(7,0,19),
+                          NDB_MAKE_VERSION(7,1,6),
+                          NDB_MAKE_VERSION(7,0,20),
+                          0) == false);
+  assert(check_version_ge(NDB_MAKE_VERSION(7,0,19),
+                          NDB_MAKE_VERSION(7,1,6),
+                          NDB_MAKE_VERSION(7,0,18),
+                          0));
+  assert(check_version_ge(NDB_MAKE_VERSION(7,1,8),
+                          NDB_MAKE_VERSION(7,1,6),
+                          NDB_MAKE_VERSION(7,0,18),
+                          0));
+  assert(check_version_ge(NDB_MAKE_VERSION(5,5,6),
+                          NDB_MAKE_VERSION(7,1,6),
+                          NDB_MAKE_VERSION(7,0,18),
+                          0) == false);
+}
+
 #define SET_ERROR(h, e, s) setError((h), (e), __LINE__, (s))
 
 static
@@ -535,6 +602,26 @@ int ndb_mgm_number_of_mgmd_in_connect_st
   return count;
 }
 
+
+static inline
+bool get_mgmd_version(NdbMgmHandle handle)
+{
+  assert(handle->connected);
+
+  if (handle->mgmd_version_major >= 0)
+    return true; // Already fetched version of mgmd
+
+  char buf[2]; // Not used -> keep short
+  if (!ndb_mgm_get_version(handle,
+                           &(handle->mgmd_version_major),
+                           &(handle->mgmd_version_minor),
+                           &(handle->mgmd_version_build),
+                           sizeof(buf), buf))
+    return false;
+  return true;
+}
+
+
 /**
  * Connect to a management server
  */
@@ -683,6 +770,11 @@ ndb_mgm_connect(NdbMgmHandle handle, int
   handle->socket    = sockfd;
   handle->connected = 1;
 
+  // Version of the connected ndb_mgmd is not yet known
+  handle->mgmd_version_major= -1;
+  handle->mgmd_version_minor= -1;
+  handle->mgmd_version_build= -1;
+
   DBUG_RETURN(0);
 }
 
@@ -1135,7 +1227,6 @@ extern "C"
 int 
 ndb_mgm_stop(NdbMgmHandle handle, int no_of_nodes, const int * node_list)
 {
-  SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_stop");
   return ndb_mgm_stop2(handle, no_of_nodes, node_list, 0);
 }
 
@@ -1148,36 +1239,23 @@ ndb_mgm_stop2(NdbMgmHandle handle, int n
   return ndb_mgm_stop3(handle, no_of_nodes, node_list, abort, &disconnect);
 }
 
-
 extern "C"
 int
-ndb_mgm_obtain_mgmd_version(NdbMgmHandle handle)
+ndb_mgm_stop3(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
+	      int abort, int *disconnect)
 {
-  if (handle->mgmd_version_build == -1)
-  {
-    char verStr[64]; /* Long enough? */
-
-    if (!ndb_mgm_get_version(handle,
-                             &(handle->mgmd_version_major),
-                             &(handle->mgmd_version_minor),
-                             &(handle->mgmd_version_build),
-                             sizeof(verStr),
-                             verStr))
-    {
-      return -1;
-    }
-  }
-  return 0;
+  return ndb_mgm_stop4(handle, no_of_nodes, node_list, abort,
+                       false, disconnect);
 }
 
 extern "C"
 int
-ndb_mgm_stop3(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
-	      int abort, int *disconnect)
+ndb_mgm_stop4(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
+	      int abort, int force, int *disconnect)
 {
-  DBUG_ENTER("ndb_mgm_stop3");
+  DBUG_ENTER("ndb_mgm_stop4");
   CHECK_HANDLE(handle, -1);
-  SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_stop3");
+  SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_stop4");
   const ParserRow<ParserDummy> stop_reply_v1[] = {
     MGM_CMD("stop reply", NULL, ""),
     MGM_ARG("stopped", Int, Optional, "No of stopped nodes"),
@@ -1194,10 +1272,8 @@ ndb_mgm_stop3(NdbMgmHandle handle, int n
 
   CHECK_CONNECTED(handle, -1);
 
-  if(ndb_mgm_obtain_mgmd_version(handle) == -1)
-  {
+  if (!get_mgmd_version(handle))
     DBUG_RETURN(-1);
-  }
 
   int use_v2= ((handle->mgmd_version_major==5)
     && (
@@ -1223,6 +1299,7 @@ ndb_mgm_stop3(NdbMgmHandle handle, int n
     args.put("abort", abort);
     if(use_v2)
       args.put("stop", (no_of_nodes==-1)?"mgm,db":"db");
+    // force has no effect, continue anyway for consistency
     const Properties *reply;
     if(use_v2)
       reply = ndb_mgm_call(handle, stop_reply_v2, "stop all", &args);
@@ -1263,6 +1340,14 @@ ndb_mgm_stop3(NdbMgmHandle handle, int n
   
   args.put("node", node_list_str.c_str());
   args.put("abort", abort);
+  if (check_version_ge(handle->mgmd_version(),
+                       NDB_MAKE_VERSION(7,1,8),
+                       NDB_MAKE_VERSION(7,0,19),
+                       0))
+    args.put("force", force);
+  else
+    SET_ERROR(handle, NDB_MGM_STOP_FAILED,
+	      "The connected mgm server does not support 'stop --force'");
 
   const Properties *reply;
   if(use_v2)
@@ -1296,7 +1381,6 @@ extern "C"
 int
 ndb_mgm_restart(NdbMgmHandle handle, int no_of_nodes, const int *node_list) 
 {
-  SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_restart");
   return ndb_mgm_restart2(handle, no_of_nodes, node_list, 0, 0, 0);
 }
 
@@ -1316,9 +1400,19 @@ int
 ndb_mgm_restart3(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
 		 int initial, int nostart, int abort, int *disconnect)
 {
-  DBUG_ENTER("ndb_mgm_restart3");
+  return ndb_mgm_restart4(handle, no_of_nodes, node_list, initial,
+                          nostart, abort, false, disconnect);
+}
+
+extern "C"
+int
+ndb_mgm_restart4(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
+                 int initial, int nostart, int abort, int force,
+                 int *disconnect)
+{
+  DBUG_ENTER("ndb_mgm_restart");
   CHECK_HANDLE(handle, -1);
-  SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_restart3");
+  SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_restart4");
   Uint32 restarted = 0;
   const ParserRow<ParserDummy> restart_reply_v1[] = {
     MGM_CMD("restart reply", NULL, ""),
@@ -1336,19 +1430,9 @@ ndb_mgm_restart3(NdbMgmHandle handle, in
 
   CHECK_CONNECTED(handle, -1);
 
-  if(handle->mgmd_version_build==-1)
-  {
-    char verstr[50];
-    if(!ndb_mgm_get_version(handle,
-                        &(handle->mgmd_version_major),
-                        &(handle->mgmd_version_minor),
-                        &(handle->mgmd_version_build),
-                        sizeof(verstr),
-                            verstr))
-    {
-      DBUG_RETURN(-1);
-    }
-  }
+  if (!get_mgmd_version(handle))
+    DBUG_RETURN(-1);
+
   int use_v2= ((handle->mgmd_version_major==5)
     && (
         (handle->mgmd_version_minor==0 && handle->mgmd_version_build>=21)
@@ -1369,6 +1453,7 @@ ndb_mgm_restart3(NdbMgmHandle handle, in
     args.put("abort", abort);
     args.put("initialstart", initial);
     args.put("nostart", nostart);
+    // force has no effect, continue anyway for consistency
     const Properties *reply;
     const int timeout = handle->timeout;
     handle->timeout= 5*60*1000; // 5 minutes
@@ -1405,6 +1490,15 @@ ndb_mgm_restart3(NdbMgmHandle handle, in
   args.put("initialstart", initial);
   args.put("nostart", nostart);
 
+  if (check_version_ge(handle->mgmd_version(),
+                       NDB_MAKE_VERSION(7,1,8),
+                       NDB_MAKE_VERSION(7,0,19),
+                       0))
+    args.put("force", force);
+  else
+    SET_ERROR(handle, NDB_MGM_RESTART_FAILED,
+	      "The connected mgm server does not support 'restart --force'");
+
   const Properties *reply;
   const int timeout = handle->timeout;
   handle->timeout= 5*60*1000; // 5 minutes
@@ -2229,19 +2323,6 @@ ndb_mgm_start_backup3(NdbMgmHandle handl
 		     unsigned int backuppoint) 
 {
   DBUG_ENTER("ndb_mgm_start_backup");
-  /* Before we start the backup, first get the version of the
-   * management node we are connected to
-   */
-  if (ndb_mgm_obtain_mgmd_version(handle) == -1)
-  {
-    DBUG_RETURN(-1);
-  }
-
-  Uint32 mgmdVersion = NDB_MAKE_VERSION(handle->mgmd_version_major,
-                                        handle->mgmd_version_minor,
-                                        handle->mgmd_version_build);
-  
-  bool sendBackupPoint = (mgmdVersion >= MGMD_MGMAPI_PROTOCOL_CHANGE);
 
   CHECK_HANDLE(handle, -1);
   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_start_backup");
@@ -2253,6 +2334,11 @@ ndb_mgm_start_backup3(NdbMgmHandle handl
   };
   CHECK_CONNECTED(handle, -1);
 
+  if (!get_mgmd_version(handle))
+    DBUG_RETURN(-1);
+
+  bool sendBackupPoint = (handle->mgmd_version() >= NDB_MAKE_VERSION(6,4,0));
+
   Properties args;
   args.put("completed", wait_completed);
   if(input_backupId > 0)
@@ -2344,24 +2430,17 @@ ndb_mgm_get_configuration2(NdbMgmHandle
                            enum ndb_mgm_node_type nodetype)
 {
   DBUG_ENTER("ndb_mgm_get_configuration2");
-  /* Before we get the config, first get the version of the
-   * managment node we are connected to
-   */
-  if (ndb_mgm_obtain_mgmd_version(handle) == -1)
-  {
-    DBUG_RETURN(NULL);
-  }
-
-  Uint32 mgmdVersion = NDB_MAKE_VERSION(handle->mgmd_version_major,
-                                        handle->mgmd_version_minor,
-                                        handle->mgmd_version_build);
-  
-  bool getConfigUsingNodetype = (mgmdVersion >= MGMD_MGMAPI_PROTOCOL_CHANGE); 
 
   CHECK_HANDLE(handle, 0);
   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_get_configuration");
   CHECK_CONNECTED(handle, 0);
 
+  if (!get_mgmd_version(handle))
+    DBUG_RETURN(NULL);
+
+  bool getConfigUsingNodetype =
+    (handle->mgmd_version() >= NDB_MAKE_VERSION(6,4,0));
+
   Properties args;
   args.put("version", version);
   if (getConfigUsingNodetype)
@@ -3041,24 +3120,28 @@ int ndb_mgm_get_version(NdbMgmHandle han
 
   Uint32 id;
   if(!prop->get("id",&id)){
-    fprintf(handle->errstream, "Unable to get value\n");
+    SET_ERROR(handle, NDB_MGM_ILLEGAL_SERVER_REPLY,
+              "Unable to get version id");
     DBUG_RETURN(0);
   }
   *build= getBuild(id);
 
   if(!prop->get("major",(Uint32*)major)){
-    fprintf(handle->errstream, "Unable to get value\n");
+    SET_ERROR(handle, NDB_MGM_ILLEGAL_SERVER_REPLY,
+              "Unable to get version major");
     DBUG_RETURN(0);
   }
 
   if(!prop->get("minor",(Uint32*)minor)){
-    fprintf(handle->errstream, "Unable to get value\n");
+    SET_ERROR(handle, NDB_MGM_ILLEGAL_SERVER_REPLY,
+              "Unable to get version minor");
     DBUG_RETURN(0);
   }
 
   BaseString result;
   if(!prop->get("string", result)){
-    fprintf(handle->errstream, "Unable to get value\n");
+    SET_ERROR(handle, NDB_MGM_ILLEGAL_SERVER_REPLY,
+              "Unable to get version string");
     DBUG_RETURN(0);
   }
 

=== modified file 'storage/ndb/src/mgmclient/CommandInterpreter.cpp'
--- a/storage/ndb/src/mgmclient/CommandInterpreter.cpp	2010-08-17 11:56:12 +0000
+++ b/storage/ndb/src/mgmclient/CommandInterpreter.cpp	2010-09-29 08:45:11 +0000
@@ -25,16 +25,10 @@
 #include <util/Vector.hpp>
 #include <kernel/BlockNumbers.h>
 
-class MgmtSrvr;
-
 /** 
  *  @class CommandInterpreter
  *  @brief Reads command line in management client
  *
- *  This class has one public method which reads a command line 
- *  from a stream. It then interpret that commmand line and calls a suitable 
- *  method in the MgmtSrvr class which executes the command.
- *
  *  For command syntax, see the HELP command.
  */ 
 class CommandInterpreter {
@@ -228,8 +222,8 @@ static const char* helpText =
 "CLUSTERLOG TOGGLE [<severity>] ...     Toggle severity filter on/off\n"
 "CLUSTERLOG INFO                        Print cluster log information\n"
 "<id> START                             Start data node (started with -n)\n"
-"<id> RESTART [-n] [-i] [-a]            Restart data or management server node\n"
-"<id> STOP [-a]                         Stop data or management server node\n"
+"<id> RESTART [-n] [-i] [-a] [-f]       Restart data or management server node\n"
+"<id> STOP [-a] [-f]                    Stop data or management server node\n"
 "ENTER SINGLE USER MODE <id>            Enter single user mode\n"
 "EXIT SINGLE USER MODE                  Exit single user mode\n"
 "<id> STATUS                            Print status\n"
@@ -397,7 +391,7 @@ static const char* helpTextRestart =
 " NDB Cluster -- Management Client -- Help for RESTART command\n"
 "---------------------------------------------------------------------------\n"
 "RESTART  Restart data or management server node\n\n"
-"<id> RESTART [-n] [-i] [-a]\n"
+"<id> RESTART [-n] [-i] [-a] [-f]\n"
 "                   Restart the data or management node <id>(or All data nodes).\n\n"
 "                   -n (--nostart) restarts the node but does not\n"
 "                   make it join the cluster. Use '<id> START' to\n"
@@ -407,8 +401,10 @@ static const char* helpTextRestart =
 "                   and the node will copy data from another node\n"
 "                   in the same node group during start up.\n\n"
 "                   Consult the documentation before using -i.\n\n" 
-"                   INCORRECT USE OF -i WILL CAUSE DATA LOSS!\n"
-"                   -a Aborts the node, not syncing GCP.\n"
+"                   INCORRECT USE OF -i WILL CAUSE DATA LOSS!\n\n"
+"                   -a Aborts the node, not syncing GCP.\n\n"
+"                   -f Force restart even if that would mean the\n"
+"                      whole cluster would need to be restarted\n"
 ;
 
 static const char* helpTextStop =
@@ -416,11 +412,14 @@ static const char* helpTextStop =
 " NDB Cluster -- Management Client -- Help for STOP command\n"
 "---------------------------------------------------------------------------\n"
 "STOP  Stop data or management server node\n\n"
-"<id> STOP [-a]     Stop the data or management server node <id>.\n\n"
+"<id> STOP [-a] [-f]\n"
+"                   Stop the data or management server node <id>.\n\n"
 "                   ALL STOP will just stop all data nodes.\n\n"
 "                   If you desire to also shut down management servers,\n"
-"                   use SHUTDOWN instead.\n"
-"                   -a Aborts the node, not syncing GCP.\n"
+"                   use SHUTDOWN instead.\n\n"
+"                   -a Aborts the node, not syncing GCP.\n\n"
+"                   -f Force stop even if that would mean the\n"
+"                      whole cluster would need to be stopped\n"
 ;
 
 static const char* helpTextEnterSingleUserMode =
@@ -2044,6 +2043,7 @@ CommandInterpreter::executeStop(Vector<B
   int need_disconnect;
   int abort= 0;
   int retval = 0;
+  int force = 0;
 
   for (; command_pos < command_list.size(); command_pos++)
   {
@@ -2053,13 +2053,18 @@ CommandInterpreter::executeStop(Vector<B
       abort= 1;
       continue;
     }
-    ndbout_c("Invalid option: %s. Expecting -A after STOP",
+    if (strcasecmp(item, "-F") == 0)
+    {
+      force = 1;
+      continue;
+    }
+    ndbout_c("Invalid option: %s. Expecting -A or -F after STOP",
              item);
     return -1;
   }
 
-  int result= ndb_mgm_stop3(m_mgmsrv, no_of_nodes, node_ids, abort,
-                            &need_disconnect);
+  int result= ndb_mgm_stop4(m_mgmsrv, no_of_nodes, node_ids, abort,
+                            force, &need_disconnect);
   if (result < 0)
   {
     ndbout_c("Shutdown failed.");
@@ -2207,6 +2212,7 @@ CommandInterpreter::executeRestart(Vecto
   int initialstart= 0;
   int abort= 0;
   int need_disconnect= 0;
+  int force = 0;
 
   for (; command_pos < command_list.size(); command_pos++)
   {
@@ -2226,7 +2232,12 @@ CommandInterpreter::executeRestart(Vecto
       abort= 1;
       continue;
     }
-    ndbout_c("Invalid option: %s. Expecting -A,-N or -I after RESTART",
+    if (strcasecmp(item, "-F") == 0)
+    {
+      force = 1;
+      continue;
+    }
+    ndbout_c("Invalid option: %s. Expecting -A,-N,-I or -F after RESTART",
              item);
     return -1;
   }
@@ -2275,8 +2286,9 @@ CommandInterpreter::executeRestart(Vecto
     }
   }
 
-  result= ndb_mgm_restart3(m_mgmsrv, no_of_nodes, node_ids,
-                           initialstart, nostart, abort, &need_disconnect);
+  result= ndb_mgm_restart4(m_mgmsrv, no_of_nodes, node_ids,
+                           initialstart, nostart, abort, force,
+                           &need_disconnect);
 
   if (result <= 0) {
     ndbout_c("Restart failed.");

=== modified file 'storage/ndb/src/mgmsrv/ConfigManager.cpp'
--- a/storage/ndb/src/mgmsrv/ConfigManager.cpp	2010-09-21 12:02:05 +0000
+++ b/storage/ndb/src/mgmsrv/ConfigManager.cpp	2010-09-30 09:32:28 +0000
@@ -20,6 +20,7 @@
 
 #include <NdbConfig.h>
 #include <NdbSleep.h>
+#include <kernel/GlobalSignalNumbers.h>
 #include <SignalSender.hpp>
 #include <NdbApiSignal.hpp>
 #include <signaldata/NFCompleteRep.hpp>
@@ -27,6 +28,8 @@
 #include <signaldata/ApiRegSignalData.hpp>
 #include <ndb_version.h>
 
+#include <EventLogger.hpp>
+extern EventLogger * g_eventLogger;
 
 extern "C" const char* opt_ndb_connectstring;
 extern "C" int opt_ndb_nodeid;

=== modified file 'storage/ndb/src/mgmsrv/MgmtSrvr.cpp'
--- a/storage/ndb/src/mgmsrv/MgmtSrvr.cpp	2010-09-23 07:31:51 +0000
+++ b/storage/ndb/src/mgmsrv/MgmtSrvr.cpp	2010-10-01 07:38:17 +0000
@@ -408,9 +408,7 @@ MgmtSrvr::start_transporter(const Config
     Register ourself at TransporterFacade to be able to receive signals
     and to be notified when a database process has died.
   */
-  if ((_blockNumber= theFacade->open(this,
-                                     signalReceivedNotification,
-                                     nodeStatusNotification)) == -1)
+  if ((_blockNumber= theFacade->open(this)) == -1)
   {
     g_eventLogger->error("Failed to open block in TransporterFacade");
     theFacade->stop_instance();
@@ -2457,7 +2455,8 @@ const char* MgmtSrvr::getErrorText(int e
 
 
 void
-MgmtSrvr::handleReceivedSignal(NdbApiSignal* signal)
+MgmtSrvr::trp_deliver_signal(const NdbApiSignal* signal,
+                             const LinearSectionPtr ptr[3])
 {
   int gsn = signal->readSignalNumber();
 
@@ -2492,16 +2491,7 @@ MgmtSrvr::handleReceivedSignal(NdbApiSig
 
 
 void
-MgmtSrvr::signalReceivedNotification(void* mgmtSrvr,
-                                     NdbApiSignal* signal,
-				     LinearSectionPtr ptr[3])
-{
-  ((MgmtSrvr*)mgmtSrvr)->handleReceivedSignal(signal);
-}
-
-
-void
-MgmtSrvr::handleStatus(NodeId nodeId, bool alive, bool nfComplete)
+MgmtSrvr::trp_node_status(Uint32 nodeId, bool alive, bool nfComplete)
 {
   DBUG_ENTER("MgmtSrvr::handleStatus");
   DBUG_PRINT("enter",("nodeid: %d, alive: %d, nfComplete: %d",
@@ -2532,15 +2522,6 @@ MgmtSrvr::handleStatus(NodeId nodeId, bo
   DBUG_VOID_RETURN;
 }
 
-
-void
-MgmtSrvr::nodeStatusNotification(void* mgmSrv, Uint32 nodeId,
-				 bool alive, bool nfComplete)
-{
-  ((MgmtSrvr*)mgmSrv)->handleStatus(nodeId, alive, nfComplete);
-}
-
-
 enum ndb_mgm_node_type 
 MgmtSrvr::getNodeType(NodeId nodeId) const 
 {

=== modified file 'storage/ndb/src/mgmsrv/MgmtSrvr.hpp'
--- a/storage/ndb/src/mgmsrv/MgmtSrvr.hpp	2010-06-11 13:46:40 +0000
+++ b/storage/ndb/src/mgmsrv/MgmtSrvr.hpp	2010-10-01 07:38:17 +0000
@@ -73,7 +73,7 @@ public:
   @class MgmtSrvr
   @brief Main class for the management server.
  */
-class MgmtSrvr : private ConfigSubscriber {
+class MgmtSrvr : private ConfigSubscriber, public trp_client {
 
 public:
   // some compilers need all of this
@@ -469,30 +469,12 @@ private:
   NodeBitmask m_reserved_nodes;
   struct in_addr m_connect_address[MAX_NODES];
 
-  void handleReceivedSignal(NdbApiSignal* signal);
-  void handleStatus(NodeId nodeId, bool alive, bool nfComplete);
-
   /**
-     Callback function installed into TransporterFacade, will be called
-     once for each new signal received to the MgmtSrvr.
-     @param  mgmtSrvr: The MgmtSrvr object which shall recieve the signal.
-     @param  signal: The received signal.
-     @param  ptr: The long part(s) of the signal
-   */
-  static void signalReceivedNotification(void* mgmtSrvr, 
-					 NdbApiSignal* signal, 
-					 struct LinearSectionPtr ptr[3]);
-
-  /**
-     Callback function installed into TransporterFacade, will be called
-     when status of a node changes.
-     @param  mgmtSrvr: The MgmtSrvr object which shall receive
-     the notification.
-     @param  processId: Id of the node whose status changed.
-     @param alive: true if the other node is alive
+   * trp_client interface
    */
-  static void nodeStatusNotification(void* mgmSrv, Uint32 nodeId, 
-				     bool alive, bool nfCompleted);
+  virtual void trp_deliver_signal(const NdbApiSignal* signal,
+                                  const struct LinearSectionPtr ptr[3]);
+  virtual void trp_node_status(Uint32 nodeId, bool alive, bool nfCompleted);
   
   /**
    * An event from <i>nodeId</i> has arrived

=== modified file 'storage/ndb/src/mgmsrv/Services.cpp'
--- a/storage/ndb/src/mgmsrv/Services.cpp	2010-08-28 09:37:09 +0000
+++ b/storage/ndb/src/mgmsrv/Services.cpp	2010-09-29 08:45:11 +0000
@@ -33,6 +33,8 @@
 #include "Services.hpp"
 #include "../mgmapi/ndb_logevent.hpp"
 
+#include "ndb_mgmd_error.h"
+
 #include <base64.h>
 #include <ndberror.h>
 
@@ -158,6 +160,7 @@ ParserRow<MgmApiSession> commands[] = {
     MGM_ARG("initialstart", Int, Optional, "Initial start"),
     MGM_ARG("nostart", Int, Optional, "No start"),
     MGM_ARG("abort", Int, Optional, "Abort"),
+    MGM_ARG("force", Int, Optional, "Force"),
 
   MGM_CMD("restart all", &MgmApiSession::restartAll, ""),
     MGM_ARG("initialstart", Int, Optional, "Initial start"),
@@ -203,6 +206,7 @@ ParserRow<MgmApiSession> commands[] = {
   MGM_CMD("stop v2", &MgmApiSession::stop_v2, ""),
     MGM_ARG("node", String, Mandatory, "Node"),
     MGM_ARG("abort", Int, Mandatory, "Node"),
+    MGM_ARG("force", Int, Optional, "Force"),
 
   MGM_CMD("stop all", &MgmApiSession::stopAll, ""),
     MGM_ARG("abort", Int, Mandatory, "Node"),
@@ -924,7 +928,7 @@ MgmApiSession::restart(Properties const
   Uint32
     nostart = 0,
     initialstart = 0,
-    abort = 0;
+    abort = 0, force = 0;
   char *nodes_str;
   Vector<NodeId> nodes;
     
@@ -932,6 +936,7 @@ MgmApiSession::restart(Properties const
   args.get("nostart", &nostart);
   args.get("abort", &abort);
   args.get("node", (const char **)&nodes_str);
+  args.get("force", &force);
 
   char *p, *last;
   for((p = strtok_r(nodes_str, " ", &last));
@@ -947,7 +952,15 @@ MgmApiSession::restart(Properties const
                                     initialstart != 0,
                                     abort != 0,
                                     &m_stopSelf);
-  
+
+  if (force &&
+      (result == NODE_SHUTDOWN_WOULD_CAUSE_SYSTEM_CRASH ||
+       result == UNSUPPORTED_NODE_SHUTDOWN))
+  {
+    // Force restart by restarting all nodes
+    result = m_mgmsrv.restartDB(nostart, initialstart, false, &restarted);
+  }
+
   m_output->println("restart reply");
   if(result != 0){
     m_output->println("result: %d-%s", result, get_error_text(result));
@@ -1102,7 +1115,7 @@ MgmApiSession::stop_v2(Parser<MgmApiSess
 
 void
 MgmApiSession::stop(Properties const &args, int version) {
-  Uint32 abort;
+  Uint32 abort, force = 0;
   char *nodes_str;
   Vector<NodeId> nodes;
 
@@ -1115,6 +1128,7 @@ MgmApiSession::stop(Properties const &ar
     return;
   }
   args.get("abort", &abort);
+  args.get("force", &force);
 
   char *p, *last;
   for((p = strtok_r(nodes_str, " ", &last));
@@ -1126,8 +1140,18 @@ MgmApiSession::stop(Properties const &ar
   int stopped= 0;
   int result= 0;
   if (nodes.size())
+  {
     result= m_mgmsrv.stopNodes(nodes, &stopped, abort != 0, &m_stopSelf);
 
+    if (force &&
+        (result == NODE_SHUTDOWN_WOULD_CAUSE_SYSTEM_CRASH ||
+         result == UNSUPPORTED_NODE_SHUTDOWN))
+    {
+      // Force stop and shutdown all remaining nodes
+      result = m_mgmsrv.shutdownDB(&stopped, false);
+    }
+  }
+
   m_output->println("stop reply");
   if(result != 0)
     m_output->println("result: %s", get_error_text(result));

=== modified file 'storage/ndb/src/mgmsrv/main.cpp'
--- a/storage/ndb/src/mgmsrv/main.cpp	2010-09-23 07:31:51 +0000
+++ b/storage/ndb/src/mgmsrv/main.cpp	2010-09-30 09:32:28 +0000
@@ -34,6 +34,10 @@
 #include <NdbAutoPtr.hpp>
 #include <ndb_mgmclient.hpp>
 
+#include <EventLogger.hpp>
+extern EventLogger * g_eventLogger;
+
+
 const char *load_default_groups[]= { "mysql_cluster","ndb_mgmd",0 };
 
 // copied from mysql.cc to get readline

=== modified file 'storage/ndb/src/ndbapi/API.hpp'
--- a/storage/ndb/src/ndbapi/API.hpp	2009-05-26 18:53:34 +0000
+++ b/storage/ndb/src/ndbapi/API.hpp	2010-09-30 09:32:28 +0000
@@ -19,11 +19,35 @@
 #ifndef API_H
 #define API_H
 
+#include <ndb_global.h>
 #include <BlockNumbers.h>
 #include <GlobalSignalNumbers.h>
 #include <RefConvert.hpp>
-#include "NdbImpl.hpp"
+#include <NdbOut.hpp>
+
+#include "NdbApiSignal.hpp"
 #include "NdbDictionaryImpl.hpp"
 #include "NdbRecord.hpp"
+#include "NdbUtil.hpp"
+
+#include <Ndb.hpp>
+#include <NdbTransaction.hpp>
+#include <NdbOperation.hpp>
+#include <NdbIndexOperation.hpp>
+#include <NdbScanOperation.hpp>
+#include <NdbIndexScanOperation.hpp>
+#include <NdbRecAttr.hpp>
+#include <NdbReceiver.hpp>
+#include <NdbBlob.hpp>
+#include <NdbBlobImpl.hpp>
+#include <NdbInterpretedCode.hpp>
+
+#include <NdbEventOperation.hpp>
+#include "NdbEventOperationImpl.hpp"
+
+#include <NdbReceiver.hpp>
+#include "NdbImpl.hpp"
+
+#include "TransporterFacade.hpp"
 
 #endif

=== modified file 'storage/ndb/src/ndbapi/CMakeLists.txt'
--- a/storage/ndb/src/ndbapi/CMakeLists.txt	2009-11-08 12:52:27 +0000
+++ b/storage/ndb/src/ndbapi/CMakeLists.txt	2010-09-30 09:32:28 +0000
@@ -56,5 +56,6 @@ ADD_LIBRARY(ndbapi STATIC
             SignalSender.cpp
             ObjectMap.cpp
             NdbInfo.cpp
-            NdbInfoScanOperation.cpp)
+            NdbInfoScanOperation.cpp
+            ndb_internal.cpp)
 

=== modified file 'storage/ndb/src/ndbapi/ClusterMgr.cpp'
--- a/storage/ndb/src/ndbapi/ClusterMgr.cpp	2010-08-03 07:25:36 +0000
+++ b/storage/ndb/src/ndbapi/ClusterMgr.cpp	2010-09-30 09:32:28 +0000
@@ -21,10 +21,11 @@
 #include <util/version.h>
 
 #include "TransporterFacade.hpp"
+#include <kernel/GlobalSignalNumbers.h>
+
 #include "ClusterMgr.hpp"
 #include <IPCConfig.hpp>
 #include "NdbApiSignal.hpp"
-#include "API.hpp"
 #include <NdbSleep.h>
 #include <NdbOut.hpp>
 #include <NdbTick.h>

=== modified file 'storage/ndb/src/ndbapi/ClusterMgr.hpp'
--- a/storage/ndb/src/ndbapi/ClusterMgr.hpp	2010-01-28 15:16:46 +0000
+++ b/storage/ndb/src/ndbapi/ClusterMgr.hpp	2010-09-30 09:32:28 +0000
@@ -19,7 +19,6 @@
 #ifndef ClusterMgr_H
 #define ClusterMgr_H
 
-#include "API.hpp"
 #include <ndb_limits.h>
 #include <NdbThread.h>
 #include <NdbMutex.h>

=== modified file 'storage/ndb/src/ndbapi/Makefile.am'
--- a/storage/ndb/src/ndbapi/Makefile.am	2009-11-08 12:52:27 +0000
+++ b/storage/ndb/src/ndbapi/Makefile.am	2010-09-30 09:32:28 +0000
@@ -60,7 +60,8 @@ libndbapi_la_SOURCES = \
         ObjectMap.cpp \
 	NdbInterpretedCode.cpp \
 	NdbInfo.cpp \
-	NdbInfoScanOperation.cpp
+	NdbInfoScanOperation.cpp \
+        ndb_internal.cpp
 
 INCLUDES_LOC = -I$(top_srcdir)/storage/ndb/src/mgmapi
 

=== modified file 'storage/ndb/src/ndbapi/Ndb.cpp'
--- a/storage/ndb/src/ndbapi/Ndb.cpp	2010-08-26 12:33:33 +0000
+++ b/storage/ndb/src/ndbapi/Ndb.cpp	2010-09-30 14:27:18 +0000
@@ -25,19 +25,11 @@ Name:          Ndb.cpp
 
 #include <ndb_global.h>
 
-
-#include "NdbApiSignal.hpp"
-#include "NdbImpl.hpp"
-#include <NdbOperation.hpp>
-#include <NdbTransaction.hpp>
-#include <NdbEventOperation.hpp>
-#include <NdbEventOperationImpl.hpp>
-#include <NdbRecAttr.hpp>
+#include "API.hpp"
 #include <md5_hash.hpp>
 #include <NdbSleep.h>
 #include <NdbOut.hpp>
 #include <ndb_limits.h>
-#include "API.hpp"
 #include <NdbEnv.h>
 #include <BaseString.hpp>
 #include <NdbSqlUtil.hpp>
@@ -998,171 +990,6 @@ Ndb::closeTransaction(NdbTransaction* aC
   DBUG_VOID_RETURN;
 }//Ndb::closeTransaction()
 
-/*****************************************************************************
-int* NdbTamper(int aAction, int aNode);
-
-Parameters: aAction     Specifies what action to be taken
-            1: Lock global checkpointing    Can only be sent to master DIH, Parameter aNode ignored.
-            2: UnLock global checkpointing    Can only be sent to master DIH, Parameter aNode ignored.
-	    3: Crash node
-
-           aNode        Specifies which node the action will be taken
-     	  -1: Master DIH 
-       	0-16: Nodnumber
-
-Return Value: -1 Error  .
-                
-Remark:         Sends a signal to DIH.
-*****************************************************************************/ 
-int 
-Ndb::NdbTamper(TamperType aAction, int aNode)
-{
-  NdbTransaction*	tNdbConn;
-  NdbApiSignal		tSignal(theMyRef);
-  int			tNode;
-  int                   tAction;
-  int			ret_code;
-
-#ifdef CUSTOMER_RELEASE
-  return -1;
-#else
-  DBUG_ENTER("Ndb::NdbTamper");
-  CHECK_STATUS_MACRO;
-  checkFailedNode();
-
-  theRestartGCI = 0;
-  switch (aAction) {
-// Translate enum to integer. This is done because the SCI layer
-// expects integers. 
-     case LockGlbChp:
-        tAction = 1;
-        break;
-     case UnlockGlbChp:
-        tAction = 2;
-	break;
-     case CrashNode:
-        tAction = 3;
-        break;
-     case ReadRestartGCI:
-	tAction = 4;
-	break;
-     default:
-        theError.code = 4102;
-        DBUG_RETURN(-1);
-  }
-
-  tNdbConn = getNdbCon();	// Get free connection object
-  if (tNdbConn == NULL) {
-    theError.code = 4000;
-    DBUG_RETURN(-1);
-  }
-  tSignal.setSignal(GSN_DIHNDBTAMPER);
-  tSignal.setData (tAction, 1);
-  tSignal.setData(tNdbConn->ptr2int(),2);
-  tSignal.setData(theMyRef,3);		// Set return block reference
-  tNdbConn->Status(NdbTransaction::Connecting); // Set status to connecting
-  TransporterFacade *tp = theImpl->m_transporter_facade;
-  if (tAction == 3) {
-    tp->lock_mutex();
-    tp->sendSignal(&tSignal, aNode);
-    tp->unlock_mutex();
-    releaseNdbCon(tNdbConn);
-  } else if ( (tAction == 2) || (tAction == 1) ) {
-    tp->lock_mutex();
-    tNode = tp->get_an_alive_node();
-    if (tNode == 0) {
-      theError.code = 4002;
-      releaseNdbCon(tNdbConn);
-      DBUG_RETURN(-1);
-    }//if
-    ret_code = tp->sendSignal(&tSignal,aNode);
-    tp->unlock_mutex();
-    releaseNdbCon(tNdbConn);
-    DBUG_RETURN(ret_code);
-  } else {
-    do {
-      tp->lock_mutex();
-      // Start protected area
-      tNode = tp->get_an_alive_node();
-      tp->unlock_mutex();
-      // End protected area
-      if (tNode == 0) {
-        theError.code = 4009;
-        releaseNdbCon(tNdbConn);
-        DBUG_RETURN(-1);
-      }//if
-      ret_code = sendRecSignal(tNode, WAIT_NDB_TAMPER, &tSignal, 0);
-      if (ret_code == 0) {  
-        if (tNdbConn->Status() != NdbTransaction::Connected) {
-          theRestartGCI = 0;
-        }//if
-        releaseNdbCon(tNdbConn);
-        DBUG_RETURN(theRestartGCI);
-      } else if ((ret_code == -5) || (ret_code == -2)) {
-        TRACE_DEBUG("Continue DIHNDBTAMPER when node failed/stopping");
-      } else {
-        DBUG_RETURN(-1);
-      }//if
-    } while (1);
-  }
-  DBUG_RETURN(0);
-#endif
-}
-#if 0
-/****************************************************************************
-NdbSchemaCon* startSchemaTransaction();
-
-Return Value:   Returns a pointer to a schema connection object.
-                Return NULL otherwise.
-Remark:         Start schema transaction. Synchronous.
-****************************************************************************/ 
-NdbSchemaCon* 
-Ndb::startSchemaTransaction()
-{
-  NdbSchemaCon* tSchemaCon;
-  if (theSchemaConToNdbList != NULL) {
-    theError.code = 4321;
-    return NULL;
-  }//if
-  tSchemaCon = new NdbSchemaCon(this);
-  if (tSchemaCon == NULL) {
-    theError.code = 4000;
-    return NULL;
-  }//if 
-  theSchemaConToNdbList = tSchemaCon;
-  return tSchemaCon;  
-}
-/*****************************************************************************
-void closeSchemaTransaction(NdbSchemaCon* aSchemaCon);
-
-Parameters:     aSchemaCon: the schemacon used in the transaction.
-Remark:         Close transaction by releasing the schemacon and all schemaop.
-*****************************************************************************/
-void
-Ndb::closeSchemaTransaction(NdbSchemaCon* aSchemaCon)
-{
-  if (theSchemaConToNdbList != aSchemaCon) {
-    abort();
-    return;
-  }//if
-  aSchemaCon->release();
-  delete aSchemaCon;
-  theSchemaConToNdbList = NULL;
-  return;
-}//Ndb::closeSchemaTransaction()
-#endif
-
-/*****************************************************************************
-void RestartGCI(int aRestartGCI);
-
-Remark:		Set theRestartGCI on the NDB object
-*****************************************************************************/
-void
-Ndb::RestartGCI(int aRestartGCI)
-{
-  theRestartGCI = aRestartGCI;
-}
-
 /****************************************************************************
 int getBlockNumber(void);
 

=== modified file 'storage/ndb/src/ndbapi/NdbApiSignal.cpp'
--- a/storage/ndb/src/ndbapi/NdbApiSignal.cpp	2009-05-26 18:53:34 +0000
+++ b/storage/ndb/src/ndbapi/NdbApiSignal.cpp	2010-09-29 13:25:19 +0000
@@ -283,6 +283,8 @@ NdbApiSignal::copyFrom(const NdbApiSigna
   theSendersBlockRef      = src->theSendersBlockRef;
   theLength               = src->theLength;
   theTrace                = src->theTrace;
+  m_noOfSections          = src->m_noOfSections;
+  m_fragmentInfo          = src->m_fragmentInfo;
   
   Uint32 * dstData = getDataPtrSend();
   const Uint32 * srcData = src->getDataPtr();

=== modified file 'storage/ndb/src/ndbapi/NdbApiSignal.hpp'
--- a/storage/ndb/src/ndbapi/NdbApiSignal.hpp	2010-08-17 09:54:53 +0000
+++ b/storage/ndb/src/ndbapi/NdbApiSignal.hpp	2010-09-30 09:32:28 +0000
@@ -33,27 +33,10 @@
 #define NdbApiSignal_H
 
 #include <kernel_types.h>
-#include "TransporterFacade.hpp"
+#include <RefConvert.hpp>
 #include <TransporterDefinitions.hpp>
-#include "Ndb.hpp"
 
-#include <signaldata/GetTabInfo.hpp>
-#include <signaldata/DictTabInfo.hpp>
-#include <signaldata/CreateTable.hpp>
-#include <signaldata/CreateIndx.hpp>
-#include <signaldata/CreateEvnt.hpp>
-#include <signaldata/SumaImpl.hpp>
-#include <signaldata/DropTable.hpp>
-#include <signaldata/AlterTable.hpp>
-#include <signaldata/DropIndx.hpp>
-#include <signaldata/ListTables.hpp>
-#include <signaldata/DropFilegroup.hpp>
-#include <signaldata/CreateFilegroup.hpp>
-#include <signaldata/WaitGCP.hpp>
-#include <signaldata/SchemaTrans.hpp>
-#include <signaldata/CreateHashMap.hpp>
-#include <signaldata/ApiRegSignalData.hpp>
-#include <signaldata/ArbitSignalData.hpp>
+class Ndb;
 
 /**
  * A NdbApiSignal : public SignalHeader
@@ -80,7 +63,7 @@ public:
   Uint32 		readData(Uint32 aDataNo) const; // Read word in signal
   
   int 			setSignal(int NdbSignalType);  	// Set signal header  
-  int 			readSignalNumber();    		// Read signal number  
+  int 			readSignalNumber() const;	// Read signal number
   Uint32             	getLength() const;
   void	             	setLength(Uint32 aLength);
   void 			next(NdbApiSignal* anApiSignal);  
@@ -184,7 +167,7 @@ Remark:          Read signal number
 *****************************************************************************/
 inline
 int		
-NdbApiSignal::readSignalNumber()
+NdbApiSignal::readSignalNumber() const
 {
   return (int)theVerId_signalNumber;
 }

=== modified file 'storage/ndb/src/ndbapi/NdbBlob.cpp'
--- a/storage/ndb/src/ndbapi/NdbBlob.cpp	2010-02-26 12:44:34 +0000
+++ b/storage/ndb/src/ndbapi/NdbBlob.cpp	2010-09-30 09:32:28 +0000
@@ -16,20 +16,9 @@
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 */
 
-#include <Ndb.hpp>
-#include <NdbDictionaryImpl.hpp>
-#include <NdbTransaction.hpp>
-#include <NdbOperation.hpp>
-#include <NdbIndexOperation.hpp>
-#include <NdbRecAttr.hpp>
-#include <NdbBlob.hpp>
-#include "NdbBlobImpl.hpp"
-#include <NdbScanOperation.hpp>
+#include "API.hpp"
 #include <signaldata/TcKeyReq.hpp>
-#include <NdbEventOperationImpl.hpp>
 #include <NdbEnv.h>
-#include "NdbRecord.hpp"
-#include "NdbUtil.hpp"
 #include <ndb_version.h>
 
 /*

=== modified file 'storage/ndb/src/ndbapi/NdbDictionary.cpp'
--- a/storage/ndb/src/ndbapi/NdbDictionary.cpp	2010-09-30 13:15:22 +0000
+++ b/storage/ndb/src/ndbapi/NdbDictionary.cpp	2010-10-01 10:27:55 +0000
@@ -2568,6 +2568,12 @@ NdbDictionary::Dictionary::forceGCPWait(
   return m_impl.forceGCPWait(type);
 }
 
+int
+NdbDictionary::Dictionary::getRestartGCI(Uint32 * gci)
+{
+  return m_impl.getRestartGCI(gci);
+}
+
 void
 NdbDictionary::Dictionary::removeCachedIndex(const Index *index){
   DBUG_ENTER("NdbDictionary::Dictionary::removeCachedIndex");

=== modified file 'storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp'
--- a/storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp	2010-09-30 13:15:22 +0000
+++ b/storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp	2010-10-01 10:27:55 +0000
@@ -16,19 +16,11 @@
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 */
 
-#include "NdbDictionaryImpl.hpp"
 #include "API.hpp"
 #include <NdbOut.hpp>
-#include "NdbApiSignal.hpp"
-#include "TransporterFacade.hpp"
 #include <SimpleProperties.hpp>
 #include <Bitmask.hpp>
 #include <AttributeList.hpp>
-#include <NdbEventOperation.hpp>
-#include "NdbEventOperationImpl.hpp"
-#include <NdbBlob.hpp>
-#include "NdbBlobImpl.hpp"
-#include <NdbInterpretedCode.hpp>
 #include <AttributeHeader.hpp>
 #include <my_sys.h>
 #include <NdbEnv.h>
@@ -36,6 +28,23 @@
 #include <util/version.h>
 #include <NdbSleep.h>
 
+#include <signaldata/GetTabInfo.hpp>
+#include <signaldata/DictTabInfo.hpp>
+#include <signaldata/CreateTable.hpp>
+#include <signaldata/CreateIndx.hpp>
+#include <signaldata/CreateEvnt.hpp>
+#include <signaldata/SumaImpl.hpp>
+#include <signaldata/DropTable.hpp>
+#include <signaldata/AlterTable.hpp>
+#include <signaldata/DropIndx.hpp>
+#include <signaldata/ListTables.hpp>
+#include <signaldata/DropFilegroup.hpp>
+#include <signaldata/CreateFilegroup.hpp>
+#include <signaldata/WaitGCP.hpp>
+#include <signaldata/SchemaTrans.hpp>
+#include <signaldata/CreateHashMap.hpp>
+#include <signaldata/ApiRegSignalData.hpp>
+
 #define DEBUG_PRINT 0
 #define INCOMPATIBLE_VERSION -2
 
@@ -2070,8 +2079,8 @@ NdbDictInterface::~NdbDictInterface()
 
 void 
 NdbDictInterface::execSignal(void* dictImpl, 
-			     class NdbApiSignal* signal, 
-			     struct LinearSectionPtr ptr[3])
+			     const class NdbApiSignal* signal,
+			     const struct LinearSectionPtr ptr[3])
 {
   NdbDictInterface * tmp = (NdbDictInterface*)dictImpl;
   
@@ -2462,8 +2471,8 @@ NdbDictInterface::getTable(class NdbApiS
 }
 
 void
-NdbDictInterface::execGET_TABINFO_CONF(NdbApiSignal * signal, 
-				       LinearSectionPtr ptr[3])
+NdbDictInterface::execGET_TABINFO_CONF(const NdbApiSignal * signal,
+				       const LinearSectionPtr ptr[3])
 {
   const GetTabInfoConf* conf = CAST_CONSTPTR(GetTabInfoConf, signal->getDataPtr());
   const Uint32 i = GetTabInfoConf::DICT_TAB_INFO;
@@ -2493,8 +2502,8 @@ end:
 }
 
 void
-NdbDictInterface::execGET_TABINFO_REF(NdbApiSignal * signal,
-				      LinearSectionPtr ptr[3])
+NdbDictInterface::execGET_TABINFO_REF(const NdbApiSignal * signal,
+				      const LinearSectionPtr ptr[3])
 {
   const GetTabInfoRef* ref = CAST_CONSTPTR(GetTabInfoRef, 
 					   signal->getDataPtr());
@@ -3661,8 +3670,8 @@ NdbDictInterface::sendCreateTable(const
 }
 
 void
-NdbDictInterface::execCREATE_TABLE_CONF(NdbApiSignal * signal,
-					LinearSectionPtr ptr[3])
+NdbDictInterface::execCREATE_TABLE_CONF(const NdbApiSignal * signal,
+					const LinearSectionPtr ptr[3])
 {
   const CreateTableConf* const conf=
     CAST_CONSTPTR(CreateTableConf, signal->getDataPtr());
@@ -3674,8 +3683,8 @@ NdbDictInterface::execCREATE_TABLE_CONF(
 }
 
 void
-NdbDictInterface::execCREATE_TABLE_REF(NdbApiSignal * sig,
-				       LinearSectionPtr ptr[3])
+NdbDictInterface::execCREATE_TABLE_REF(const NdbApiSignal * sig,
+				       const LinearSectionPtr ptr[3])
 {
   const CreateTableRef* ref = CAST_CONSTPTR(CreateTableRef, sig->getDataPtr());
   m_error.code= ref->errorCode;
@@ -3684,15 +3693,15 @@ NdbDictInterface::execCREATE_TABLE_REF(N
 }
 
 void
-NdbDictInterface::execALTER_TABLE_CONF(NdbApiSignal * signal,
-                                       LinearSectionPtr ptr[3])
+NdbDictInterface::execALTER_TABLE_CONF(const NdbApiSignal * signal,
+                                       const LinearSectionPtr ptr[3])
 {
   m_waiter.signal(NO_WAIT);
 }
 
 void
-NdbDictInterface::execALTER_TABLE_REF(NdbApiSignal * sig,
-				      LinearSectionPtr ptr[3])
+NdbDictInterface::execALTER_TABLE_REF(const NdbApiSignal * sig,
+				      const LinearSectionPtr ptr[3])
 {
   const AlterTableRef * ref = CAST_CONSTPTR(AlterTableRef, sig->getDataPtr());
   m_error.code= ref->errorCode;
@@ -3887,8 +3896,8 @@ NdbDictInterface::dropTable(const NdbTab
 }
 
 void
-NdbDictInterface::execDROP_TABLE_CONF(NdbApiSignal * signal,
-				       LinearSectionPtr ptr[3])
+NdbDictInterface::execDROP_TABLE_CONF(const NdbApiSignal * signal,
+				      const LinearSectionPtr ptr[3])
 {
   DBUG_ENTER("NdbDictInterface::execDROP_TABLE_CONF");
   //DropTableConf* const conf = CAST_CONSTPTR(DropTableConf, signal->getDataPtr());
@@ -3898,8 +3907,8 @@ NdbDictInterface::execDROP_TABLE_CONF(Nd
 }
 
 void
-NdbDictInterface::execDROP_TABLE_REF(NdbApiSignal * signal,
-				      LinearSectionPtr ptr[3])
+NdbDictInterface::execDROP_TABLE_REF(const NdbApiSignal * signal,
+				     const LinearSectionPtr ptr[3])
 {
   DBUG_ENTER("NdbDictInterface::execDROP_TABLE_REF");
   const DropTableRef* ref = CAST_CONSTPTR(DropTableRef, signal->getDataPtr());
@@ -4148,15 +4157,15 @@ NdbDictInterface::createIndex(Ndb & ndb,
 }
 
 void
-NdbDictInterface::execCREATE_INDX_CONF(NdbApiSignal * signal,
-				       LinearSectionPtr ptr[3])
+NdbDictInterface::execCREATE_INDX_CONF(const NdbApiSignal * signal,
+				       const LinearSectionPtr ptr[3])
 {
   m_waiter.signal(NO_WAIT);  
 }
 
 void
-NdbDictInterface::execCREATE_INDX_REF(NdbApiSignal * sig,
-				      LinearSectionPtr ptr[3])
+NdbDictInterface::execCREATE_INDX_REF(const NdbApiSignal * sig,
+				      const LinearSectionPtr ptr[3])
 {
   const CreateIndxRef* ref = CAST_CONSTPTR(CreateIndxRef, sig->getDataPtr());
   m_error.code = ref->errorCode;
@@ -4284,15 +4293,15 @@ NdbDictInterface::dropIndex(const NdbInd
 }
 
 void
-NdbDictInterface::execDROP_INDX_CONF(NdbApiSignal * signal,
-				       LinearSectionPtr ptr[3])
+NdbDictInterface::execDROP_INDX_CONF(const NdbApiSignal * signal,
+				       const LinearSectionPtr ptr[3])
 {
   m_waiter.signal(NO_WAIT);  
 }
 
 void
-NdbDictInterface::execDROP_INDX_REF(NdbApiSignal * signal,
-				      LinearSectionPtr ptr[3])
+NdbDictInterface::execDROP_INDX_REF(const NdbApiSignal * signal,
+				      const LinearSectionPtr ptr[3])
 {
   const DropIndxRef* ref = CAST_CONSTPTR(DropIndxRef, signal->getDataPtr());
   m_error.code = ref->errorCode;
@@ -4600,7 +4609,7 @@ NdbDictInterface::executeSubscribeEvent(
                        errCodes, -1);
   if (ret == 0)
   {
-    buckets =m_sub_start_conf.m_buckets;
+    buckets = m_data.m_sub_start_conf.m_buckets;
   }
 
   DBUG_RETURN(ret);
@@ -4777,8 +4786,8 @@ NdbDictionaryImpl::getBlobEvent(const Nd
 }
 
 void
-NdbDictInterface::execCREATE_EVNT_CONF(NdbApiSignal * signal,
-				       LinearSectionPtr ptr[3])
+NdbDictInterface::execCREATE_EVNT_CONF(const NdbApiSignal * signal,
+				       const LinearSectionPtr ptr[3])
 {
   DBUG_ENTER("NdbDictInterface::execCREATE_EVNT_CONF");
 
@@ -4810,8 +4819,8 @@ NdbDictInterface::execCREATE_EVNT_CONF(N
 }
 
 void
-NdbDictInterface::execCREATE_EVNT_REF(NdbApiSignal * signal,
-				      LinearSectionPtr ptr[3])
+NdbDictInterface::execCREATE_EVNT_REF(const NdbApiSignal * signal,
+				      const LinearSectionPtr ptr[3])
 {
   DBUG_ENTER("NdbDictInterface::execCREATE_EVNT_REF");
 
@@ -4827,8 +4836,8 @@ NdbDictInterface::execCREATE_EVNT_REF(Nd
 }
 
 void
-NdbDictInterface::execSUB_STOP_CONF(NdbApiSignal * signal,
-				      LinearSectionPtr ptr[3])
+NdbDictInterface::execSUB_STOP_CONF(const NdbApiSignal * signal,
+				      const LinearSectionPtr ptr[3])
 {
   DBUG_ENTER("NdbDictInterface::execSUB_STOP_CONF");
   const SubStopConf * const subStopConf=
@@ -4859,8 +4868,8 @@ NdbDictInterface::execSUB_STOP_CONF(NdbA
 }
 
 void
-NdbDictInterface::execSUB_STOP_REF(NdbApiSignal * signal,
-				     LinearSectionPtr ptr[3])
+NdbDictInterface::execSUB_STOP_REF(const NdbApiSignal * signal,
+				     const LinearSectionPtr ptr[3])
 {
   DBUG_ENTER("NdbDictInterface::execSUB_STOP_REF");
   const SubStopRef * const subStopRef=
@@ -4883,8 +4892,8 @@ NdbDictInterface::execSUB_STOP_REF(NdbAp
 }
 
 void
-NdbDictInterface::execSUB_START_CONF(NdbApiSignal * signal,
-				     LinearSectionPtr ptr[3])
+NdbDictInterface::execSUB_START_CONF(const NdbApiSignal * signal,
+				     const LinearSectionPtr ptr[3])
 {
   DBUG_ENTER("NdbDictInterface::execSUB_START_CONF");
   const SubStartConf * const subStartConf=
@@ -4915,7 +4924,7 @@ NdbDictInterface::execSUB_START_CONF(Ndb
 
   if (signal->getLength() == SubStartConf::SignalLength)
   {
-    m_sub_start_conf.m_buckets = subStartConf->bucketCount;
+    m_data.m_sub_start_conf.m_buckets = subStartConf->bucketCount;
   }
   else
   {
@@ -4923,7 +4932,7 @@ NdbDictInterface::execSUB_START_CONF(Ndb
      * 6.3 doesn't send required bucketCount.  
      * ~0 indicates no bucketCount received
      */
-    m_sub_start_conf.m_buckets = ~0;
+    m_data.m_sub_start_conf.m_buckets = ~0;
   }
   DBUG_PRINT("info",("subscriptionId=%d,subscriptionKey=%d,subscriberData=%d",
 		     subscriptionId,subscriptionKey,subscriberData));
@@ -4932,8 +4941,8 @@ NdbDictInterface::execSUB_START_CONF(Ndb
 }
 
 void
-NdbDictInterface::execSUB_START_REF(NdbApiSignal * signal,
-				    LinearSectionPtr ptr[3])
+NdbDictInterface::execSUB_START_REF(const NdbApiSignal * signal,
+				    const LinearSectionPtr ptr[3])
 {
   DBUG_ENTER("NdbDictInterface::execSUB_START_REF");
   const SubStartRef * const subStartRef=
@@ -5073,8 +5082,8 @@ NdbDictInterface::dropEvent(const NdbEve
 }
 
 void
-NdbDictInterface::execDROP_EVNT_CONF(NdbApiSignal * signal,
-				     LinearSectionPtr ptr[3])
+NdbDictInterface::execDROP_EVNT_CONF(const NdbApiSignal * signal,
+				     const LinearSectionPtr ptr[3])
 {
   DBUG_ENTER("NdbDictInterface::execDROP_EVNT_CONF");
   m_waiter.signal(NO_WAIT);  
@@ -5082,8 +5091,8 @@ NdbDictInterface::execDROP_EVNT_CONF(Ndb
 }
 
 void
-NdbDictInterface::execDROP_EVNT_REF(NdbApiSignal * signal,
-				    LinearSectionPtr ptr[3])
+NdbDictInterface::execDROP_EVNT_REF(const NdbApiSignal * signal,
+				    const LinearSectionPtr ptr[3])
 {
   DBUG_ENTER("NdbDictInterface::execDROP_EVNT_REF");
   const DropEvntRef* const ref=
@@ -5098,7 +5107,6 @@ NdbDictInterface::execDROP_EVNT_REF(NdbA
   DBUG_VOID_RETURN;
 }
 
-#include <NdbScanOperation.hpp>
 static int scanEventTable(Ndb* pNdb, 
                           const NdbDictionary::Table* pTab,
                           NdbDictionary::Dictionary::List &list)
@@ -5670,8 +5678,8 @@ NdbDictInterface::listObjects(NdbApiSign
 }
 
 void
-NdbDictInterface::execLIST_TABLES_CONF(NdbApiSignal* signal,
-                                       LinearSectionPtr ptr[3])
+NdbDictInterface::execLIST_TABLES_CONF(const NdbApiSignal* signal,
+                                       const LinearSectionPtr ptr[3])
 {
   Uint16 nodeId = refToNode(signal->theSendersBlockRef);
   NodeInfo info = m_transporter->theClusterMgr->getNodeInfo(nodeId).m_info;
@@ -5748,8 +5756,8 @@ NdbDictInterface::execLIST_TABLES_CONF(N
 
 
 void
-NdbDictInterface::execOLD_LIST_TABLES_CONF(NdbApiSignal* signal,
-                                           LinearSectionPtr ptr[3])
+NdbDictInterface::execOLD_LIST_TABLES_CONF(const NdbApiSignal* signal,
+                                           const LinearSectionPtr ptr[3])
 {
   const unsigned off = OldListTablesConf::HeaderLength;
   const unsigned len = (signal->getLength() - off);
@@ -5773,12 +5781,15 @@ int
 NdbDictInterface::forceGCPWait(int type)
 {
   NdbApiSignal tSignal(m_reference);
-  if (type == 0)
+  if (type == 0 || type == 2)
   {
     WaitGCPReq* const req = CAST_PTR(WaitGCPReq, tSignal.getDataPtrSend());
     req->senderRef = m_reference;
     req->senderData = 0;
-    req->requestType = WaitGCPReq::CompleteForceStart;
+    req->requestType = 
+      type == 0 ? 
+      WaitGCPReq::CompleteForceStart : WaitGCPReq::RestartGCI;
+      
     tSignal.theReceiversBlockNumber = DBDIH;
     tSignal.theVerId_signalNumber = GSN_WAIT_GCP_REQ;
     tSignal.theLength = WaitGCPReq::SignalLength;
@@ -5803,7 +5814,7 @@ NdbDictInterface::forceGCPWait(int type)
       m_waiter.m_state = WAIT_LIST_TABLES_CONF;
       m_waiter.wait(DICT_WAITFOR_TIMEOUT);
       m_transporter->unlock_mutex();
-      return 0;
+      return m_error.code == 0 ? 0 : -1;
     }
     return -1;
   }
@@ -5832,22 +5843,44 @@ NdbDictInterface::forceGCPWait(int type)
       m_transporter->forceSend(refToBlock(m_reference));
       m_transporter->unlock_mutex();
     }
-    return 0;
+    return m_error.code == 0 ? 0 : -1;
+  }
+  else
+  {
+    m_error.code = 4003;
   }
   return -1;
 }
 
+int
+NdbDictionaryImpl::getRestartGCI(Uint32 * gci)
+{
+  int res = m_receiver.forceGCPWait(2);
+  if (res == 0 && gci != 0)
+  {
+    * gci = m_receiver.m_data.m_wait_gcp_conf.gci_hi;
+  }
+  return res;
+}
+
 void
-NdbDictInterface::execWAIT_GCP_CONF(NdbApiSignal* signal,
-				    LinearSectionPtr ptr[3])
+NdbDictInterface::execWAIT_GCP_CONF(const NdbApiSignal* signal,
+				    const LinearSectionPtr ptr[3])
 {
+  const WaitGCPConf* conf = CAST_CONSTPTR(WaitGCPConf, signal->getDataPtr());
+
+  m_data.m_wait_gcp_conf.gci_lo = conf->gci_lo;
+  m_data.m_wait_gcp_conf.gci_hi = conf->gci_hi;
   m_waiter.signal(NO_WAIT);
 }
 
 void
-NdbDictInterface::execWAIT_GCP_REF(NdbApiSignal* signal,
-                                   LinearSectionPtr ptr[3])
+NdbDictInterface::execWAIT_GCP_REF(const NdbApiSignal* signal,
+                                   const LinearSectionPtr ptr[3])
 {
+  const WaitGCPRef* ref = CAST_CONSTPTR(WaitGCPRef, signal->getDataPtr());
+  m_error.code = ref->errorCode;
+
   m_waiter.signal(NO_WAIT);
 }
 
@@ -7235,8 +7268,8 @@ NdbDictInterface::create_file(const NdbF
 }
 
 void
-NdbDictInterface::execCREATE_FILE_CONF(NdbApiSignal * signal,
-				       LinearSectionPtr ptr[3])
+NdbDictInterface::execCREATE_FILE_CONF(const NdbApiSignal * signal,
+				       const LinearSectionPtr ptr[3])
 {
   const CreateFileConf* conf=
     CAST_CONSTPTR(CreateFileConf, signal->getDataPtr());
@@ -7250,8 +7283,8 @@ NdbDictInterface::execCREATE_FILE_CONF(N
 }
 
 void
-NdbDictInterface::execCREATE_FILE_REF(NdbApiSignal * signal,
-				      LinearSectionPtr ptr[3])
+NdbDictInterface::execCREATE_FILE_REF(const NdbApiSignal * signal,
+				      const LinearSectionPtr ptr[3])
 {
   const CreateFileRef* ref = 
     CAST_CONSTPTR(CreateFileRef, signal->getDataPtr());
@@ -7288,15 +7321,15 @@ NdbDictInterface::drop_file(const NdbFil
 }
 
 void
-NdbDictInterface::execDROP_FILE_CONF(NdbApiSignal * signal,
-					    LinearSectionPtr ptr[3])
+NdbDictInterface::execDROP_FILE_CONF(const NdbApiSignal * signal,
+					    const LinearSectionPtr ptr[3])
 {
   m_waiter.signal(NO_WAIT);  
 }
 
 void
-NdbDictInterface::execDROP_FILE_REF(NdbApiSignal * signal,
-					   LinearSectionPtr ptr[3])
+NdbDictInterface::execDROP_FILE_REF(const NdbApiSignal * signal,
+					   const LinearSectionPtr ptr[3])
 {
   const DropFileRef* ref = 
     CAST_CONSTPTR(DropFileRef, signal->getDataPtr());
@@ -7404,8 +7437,8 @@ NdbDictInterface::create_filegroup(const
 }
 
 void
-NdbDictInterface::execCREATE_FILEGROUP_CONF(NdbApiSignal * signal,
-					    LinearSectionPtr ptr[3])
+NdbDictInterface::execCREATE_FILEGROUP_CONF(const NdbApiSignal * signal,
+					    const LinearSectionPtr ptr[3])
 {
   const CreateFilegroupConf* conf=
     CAST_CONSTPTR(CreateFilegroupConf, signal->getDataPtr());
@@ -7418,8 +7451,8 @@ NdbDictInterface::execCREATE_FILEGROUP_C
 }
 
 void
-NdbDictInterface::execCREATE_FILEGROUP_REF(NdbApiSignal * signal,
-					   LinearSectionPtr ptr[3])
+NdbDictInterface::execCREATE_FILEGROUP_REF(const NdbApiSignal * signal,
+					   const LinearSectionPtr ptr[3])
 {
   const CreateFilegroupRef* ref = 
     CAST_CONSTPTR(CreateFilegroupRef, signal->getDataPtr());
@@ -7456,15 +7489,15 @@ NdbDictInterface::drop_filegroup(const N
 }
 
 void
-NdbDictInterface::execDROP_FILEGROUP_CONF(NdbApiSignal * signal,
-					    LinearSectionPtr ptr[3])
+NdbDictInterface::execDROP_FILEGROUP_CONF(const NdbApiSignal * signal,
+					    const LinearSectionPtr ptr[3])
 {
   m_waiter.signal(NO_WAIT);  
 }
 
 void
-NdbDictInterface::execDROP_FILEGROUP_REF(NdbApiSignal * signal,
-					   LinearSectionPtr ptr[3])
+NdbDictInterface::execDROP_FILEGROUP_REF(const NdbApiSignal * signal,
+					   const LinearSectionPtr ptr[3])
 {
   const DropFilegroupRef* ref = 
     CAST_CONSTPTR(DropFilegroupRef, signal->getDataPtr());
@@ -7915,7 +7948,8 @@ NdbDictInterface::create_hashmap(const N
                                  Uint32 flags)
 {
   DictHashMapInfo::HashMap hm; hm.init();
-  BaseString::snprintf(hm.HashMapName, sizeof(hm.HashMapName), src.getName());
+  BaseString::snprintf(hm.HashMapName, sizeof(hm.HashMapName), 
+                       "%s", src.getName());
   hm.HashMapBuckets = src.getMapLen();
   for (Uint32 i = 0; i<hm.HashMapBuckets; i++)
   {
@@ -7986,8 +8020,8 @@ NdbDictInterface::create_hashmap(const N
 }
 
 void
-NdbDictInterface::execCREATE_HASH_MAP_REF(NdbApiSignal * signal,
-                                          LinearSectionPtr ptr[3])
+NdbDictInterface::execCREATE_HASH_MAP_REF(const NdbApiSignal * signal,
+                                          const LinearSectionPtr ptr[3])
 {
   const CreateHashMapRef* ref =
     CAST_CONSTPTR(CreateHashMapRef, signal->getDataPtr());
@@ -7998,8 +8032,8 @@ NdbDictInterface::execCREATE_HASH_MAP_RE
 
 
 void
-NdbDictInterface::execCREATE_HASH_MAP_CONF(NdbApiSignal * signal,
-                                           LinearSectionPtr ptr[3])
+NdbDictInterface::execCREATE_HASH_MAP_CONF(const NdbApiSignal * signal,
+                                           const LinearSectionPtr ptr[3])
 {
   const CreateHashMapConf* conf=
     CAST_CONSTPTR(CreateHashMapConf, signal->getDataPtr());
@@ -8210,8 +8244,8 @@ NdbDictInterface::endSchemaTrans(Uint32
 }
 
 void
-NdbDictInterface::execSCHEMA_TRANS_BEGIN_CONF(NdbApiSignal * signal,
-                                              LinearSectionPtr ptr[3])
+NdbDictInterface::execSCHEMA_TRANS_BEGIN_CONF(const NdbApiSignal * signal,
+                                              const LinearSectionPtr ptr[3])
 {
   const SchemaTransBeginConf* conf=
     CAST_CONSTPTR(SchemaTransBeginConf, signal->getDataPtr());
@@ -8221,8 +8255,8 @@ NdbDictInterface::execSCHEMA_TRANS_BEGIN
 }
 
 void
-NdbDictInterface::execSCHEMA_TRANS_BEGIN_REF(NdbApiSignal * signal,
-                                             LinearSectionPtr ptr[3])
+NdbDictInterface::execSCHEMA_TRANS_BEGIN_REF(const NdbApiSignal * signal,
+                                             const LinearSectionPtr ptr[3])
 {
   const SchemaTransBeginRef* ref =
     CAST_CONSTPTR(SchemaTransBeginRef, signal->getDataPtr());
@@ -8232,8 +8266,8 @@ NdbDictInterface::execSCHEMA_TRANS_BEGIN
 }
 
 void
-NdbDictInterface::execSCHEMA_TRANS_END_CONF(NdbApiSignal * signal,
-                                            LinearSectionPtr ptr[3])
+NdbDictInterface::execSCHEMA_TRANS_END_CONF(const NdbApiSignal * signal,
+                                            const LinearSectionPtr ptr[3])
 {
   const SchemaTransEndConf* conf=
     CAST_CONSTPTR(SchemaTransEndConf, signal->getDataPtr());
@@ -8242,8 +8276,8 @@ NdbDictInterface::execSCHEMA_TRANS_END_C
 }
 
 void
-NdbDictInterface::execSCHEMA_TRANS_END_REF(NdbApiSignal * signal,
-                                           LinearSectionPtr ptr[3])
+NdbDictInterface::execSCHEMA_TRANS_END_REF(const NdbApiSignal * signal,
+                                           const LinearSectionPtr ptr[3])
 {
   const SchemaTransEndRef* ref =
     CAST_CONSTPTR(SchemaTransEndRef, signal->getDataPtr());
@@ -8254,8 +8288,8 @@ NdbDictInterface::execSCHEMA_TRANS_END_R
 }
 
 void
-NdbDictInterface::execSCHEMA_TRANS_END_REP(NdbApiSignal * signal,
-                                           LinearSectionPtr ptr[3])
+NdbDictInterface::execSCHEMA_TRANS_END_REP(const NdbApiSignal * signal,
+                                           const LinearSectionPtr ptr[3])
 {
   const SchemaTransEndRep* rep =
     CAST_CONSTPTR(SchemaTransEndRep, signal->getDataPtr());

=== modified file 'storage/ndb/src/ndbapi/NdbDictionaryImpl.hpp'
--- a/storage/ndb/src/ndbapi/NdbDictionaryImpl.hpp	2010-09-30 13:15:22 +0000
+++ b/storage/ndb/src/ndbapi/NdbDictionaryImpl.hpp	2010-10-01 10:27:55 +0000
@@ -662,6 +662,7 @@ public:
 			  Uint32 noOfSections, bool fullyQualifiedNames);
 
   int forceGCPWait(int type);
+  int getRestartGCI(Uint32 *);
 
   static int parseTableInfo(NdbTableImpl ** dst, 
 			    const Uint32 * data, Uint32 len,
@@ -713,63 +714,74 @@ private:
   class TransporterFacade * m_transporter;
   
   friend class Ndb;
+  friend class NdbImpl;
   friend class NdbDictionaryImpl;
   static void execSignal(void* dictImpl, 
-			 class NdbApiSignal* signal, 
-			 struct LinearSectionPtr ptr[3]);
+			 const class NdbApiSignal* signal,
+			 const struct LinearSectionPtr ptr[3]);
   
   static void execNodeStatus(void* dictImpl, Uint32, 
 			     bool alive, bool nfCompleted);  
   
-  void execGET_TABINFO_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execGET_TABINFO_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execCREATE_TABLE_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execCREATE_TABLE_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execALTER_TABLE_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execALTER_TABLE_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-
-  void execCREATE_INDX_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execCREATE_INDX_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execDROP_INDX_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execDROP_INDX_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-
-  void execCREATE_EVNT_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execCREATE_EVNT_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execSUB_START_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execSUB_START_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execSUB_STOP_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execSUB_STOP_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execDROP_EVNT_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execDROP_EVNT_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-
-  void execDROP_TABLE_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execDROP_TABLE_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execOLD_LIST_TABLES_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execLIST_TABLES_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-
-  void execCREATE_FILE_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execCREATE_FILE_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  
-  void execCREATE_FILEGROUP_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execCREATE_FILEGROUP_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-
-  void execDROP_FILE_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execDROP_FILE_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  
-  void execDROP_FILEGROUP_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execDROP_FILEGROUP_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-
-  void execSCHEMA_TRANS_BEGIN_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execSCHEMA_TRANS_BEGIN_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execSCHEMA_TRANS_END_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execSCHEMA_TRANS_END_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execSCHEMA_TRANS_END_REP(NdbApiSignal *, LinearSectionPtr ptr[3]);
-
-  void execWAIT_GCP_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execWAIT_GCP_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-
-  void execCREATE_HASH_MAP_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
-  void execCREATE_HASH_MAP_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
+  void execGET_TABINFO_REF(const NdbApiSignal *, const LinearSectionPtr p[3]);
+  void execGET_TABINFO_CONF(const NdbApiSignal *, const LinearSectionPtr p[3]);
+  void execCREATE_TABLE_REF(const NdbApiSignal *, const LinearSectionPtr p[3]);
+  void execCREATE_TABLE_CONF(const NdbApiSignal *, const LinearSectionPtr [3]);
+  void execALTER_TABLE_REF(const NdbApiSignal *, const LinearSectionPtr pr[3]);
+  void execALTER_TABLE_CONF(const NdbApiSignal *, const LinearSectionPtr p[3]);
+
+  void execCREATE_INDX_REF(const NdbApiSignal *, const LinearSectionPtr pr[3]);
+  void execCREATE_INDX_CONF(const NdbApiSignal *, const LinearSectionPtr p[3]);
+  void execDROP_INDX_REF(const NdbApiSignal *, const LinearSectionPtr ptr[3]);
+  void execDROP_INDX_CONF(const NdbApiSignal *, const LinearSectionPtr ptr[3]);
+
+  void execCREATE_EVNT_REF(const NdbApiSignal *, const LinearSectionPtr pr[3]);
+  void execCREATE_EVNT_CONF(const NdbApiSignal *, const LinearSectionPtr p[3]);
+  void execSUB_START_CONF(const NdbApiSignal*, const LinearSectionPtr ptr[3]);
+  void execSUB_START_REF(const NdbApiSignal*, const LinearSectionPtr ptr[3]);
+  void execSUB_STOP_CONF(const NdbApiSignal*, const LinearSectionPtr ptr[3]);
+  void execSUB_STOP_REF(const NdbApiSignal*, const LinearSectionPtr ptr[3]);
+  void execDROP_EVNT_REF(const NdbApiSignal*, const LinearSectionPtr ptr[3]);
+  void execDROP_EVNT_CONF(const NdbApiSignal*, const LinearSectionPtr ptr[3]);
+
+  void execDROP_TABLE_REF(const NdbApiSignal*, const LinearSectionPtr ptr[3]);
+  void execDROP_TABLE_CONF(const NdbApiSignal*, const LinearSectionPtr ptr[3]);
+  void execOLD_LIST_TABLES_CONF(const NdbApiSignal*,
+				const LinearSectionPtr ptr[3]);
+  void execLIST_TABLES_CONF(const NdbApiSignal*, const LinearSectionPtr pt[3]);
+
+  void execCREATE_FILE_REF(const NdbApiSignal*, const LinearSectionPtr ptr[3]);
+  void execCREATE_FILE_CONF(const NdbApiSignal*, const LinearSectionPtr pr[3]);
+
+  void execCREATE_FILEGROUP_REF(const NdbApiSignal*,
+				const LinearSectionPtr ptr[3]);
+  void execCREATE_FILEGROUP_CONF(const NdbApiSignal*,
+				 const LinearSectionPtr ptr[3]);
+
+  void execDROP_FILE_REF(const NdbApiSignal*, const LinearSectionPtr ptr[3]);
+  void execDROP_FILE_CONF(const NdbApiSignal*, const LinearSectionPtr ptr[3]);
+
+  void execDROP_FILEGROUP_REF(const NdbApiSignal*, const LinearSectionPtr [3]);
+  void execDROP_FILEGROUP_CONF(const NdbApiSignal*,
+			       const LinearSectionPtr ptr[3]);
+
+  void execSCHEMA_TRANS_BEGIN_CONF(const NdbApiSignal*,
+				   const LinearSectionPtr ptr[3]);
+  void execSCHEMA_TRANS_BEGIN_REF(const NdbApiSignal*,
+				  const LinearSectionPtr ptr[3]);
+  void execSCHEMA_TRANS_END_CONF(const NdbApiSignal*,
+				 const LinearSectionPtr ptr[3]);
+  void execSCHEMA_TRANS_END_REF(const NdbApiSignal*,
+				const LinearSectionPtr ptr[3]);
+  void execSCHEMA_TRANS_END_REP(const NdbApiSignal*, const LinearSectionPtr ptr[3]);
+
+  void execWAIT_GCP_CONF(const NdbApiSignal*, const LinearSectionPtr ptr[3]);
+  void execWAIT_GCP_REF(const NdbApiSignal*, const LinearSectionPtr ptr[3]);
+
+  void execCREATE_HASH_MAP_REF(const NdbApiSignal*,
+			       const LinearSectionPtr ptr[3]);
+  void execCREATE_HASH_MAP_CONF(const NdbApiSignal*,
+				const LinearSectionPtr ptr[3]);
 
   Uint32 m_fragmentId;
   UtilBuffer m_buffer;
@@ -778,9 +790,15 @@ private:
   UtilBuffer m_tableData;
   UtilBuffer m_tableNames;
 
-  struct {
-    Uint32 m_buckets;
-  } m_sub_start_conf;
+  union {
+    struct SubStartConfData {
+      Uint32 m_buckets;
+    } m_sub_start_conf;
+    struct WaitGcpData {
+      Uint32 gci_hi;
+      Uint32 gci_lo;
+    } m_wait_gcp_conf;
+  } m_data;
 };
 
 class NdbDictionaryImpl;
@@ -837,6 +855,7 @@ public:
   int stopSubscribeEvent(NdbEventOperationImpl &);
 
   int forceGCPWait(int type);
+  int getRestartGCI(Uint32*);
 
   int listObjects(List& list, NdbDictionary::Object::Type type, 
                   bool fullyQualified);

=== modified file 'storage/ndb/src/ndbapi/NdbEventOperationImpl.cpp'
--- a/storage/ndb/src/ndbapi/NdbEventOperationImpl.cpp	2010-08-20 11:26:54 +0000
+++ b/storage/ndb/src/ndbapi/NdbEventOperationImpl.cpp	2010-09-30 09:32:28 +0000
@@ -20,11 +20,9 @@
 #include <ndb_global.h>
 #include <kernel_types.h>
 
-#include "NdbDictionaryImpl.hpp"
 #include "API.hpp"
 #include <NdbOut.hpp>
-#include "NdbApiSignal.hpp"
-#include "TransporterFacade.hpp"
+
 #include <signaldata/CreateEvnt.hpp>
 #include <signaldata/SumaImpl.hpp>
 #include <SimpleProperties.hpp>
@@ -34,15 +32,7 @@
 #include <NdbError.hpp>
 #include <BaseString.hpp>
 #include <UtilBuffer.hpp>
-#include <NdbDictionary.hpp>
-#include <Ndb.hpp>
-#include "NdbImpl.hpp"
-#include "DictCache.hpp"
 #include <portlib/NdbMem.h>
-#include <NdbRecAttr.hpp>
-#include <NdbBlob.hpp>
-#include <NdbEventOperation.hpp>
-#include "NdbEventOperationImpl.hpp"
 #include <signaldata/AlterTable.hpp>
 #include "ndb_internal.hpp"
 
@@ -769,8 +759,8 @@ NdbEventOperationImpl::getLatestGCI()
 }
 
 bool
-NdbEventOperationImpl::execSUB_TABLE_DATA(NdbApiSignal * signal, 
-                                          LinearSectionPtr ptr[3])
+NdbEventOperationImpl::execSUB_TABLE_DATA(const NdbApiSignal * signal,
+                                          const LinearSectionPtr ptr[3])
 {
   DBUG_ENTER("NdbEventOperationImpl::execSUB_TABLE_DATA");
   const SubTableData * const sdata=

=== modified file 'storage/ndb/src/ndbapi/NdbEventOperationImpl.hpp'
--- a/storage/ndb/src/ndbapi/NdbEventOperationImpl.hpp	2010-03-12 11:56:09 +0000
+++ b/storage/ndb/src/ndbapi/NdbEventOperationImpl.hpp	2010-09-29 13:25:19 +0000
@@ -383,8 +383,8 @@ public:
   Uint64 getGCI();
   Uint32 getAnyValue() const;
   Uint64 getLatestGCI();
-  bool execSUB_TABLE_DATA(NdbApiSignal * signal, 
-                          LinearSectionPtr ptr[3]);
+  bool execSUB_TABLE_DATA(const NdbApiSignal * signal,
+                          const LinearSectionPtr ptr[3]);
 
   NdbDictionary::Event::TableEvent getEventType();
 

=== modified file 'storage/ndb/src/ndbapi/NdbImpl.hpp'
--- a/storage/ndb/src/ndbapi/NdbImpl.hpp	2010-01-28 15:16:46 +0000
+++ b/storage/ndb/src/ndbapi/NdbImpl.hpp	2010-10-01 07:38:17 +0000
@@ -20,12 +20,8 @@
 #define NDB_IMPL_HPP
 
 #include <ndb_global.h>
-#include <Ndb.hpp>
+#include "API.hpp"
 #include <NdbOut.hpp>
-#include <NdbError.hpp>
-#include <NdbCondition.h>
-#include <NdbReceiver.hpp>
-#include <NdbOperation.hpp>
 #include <kernel/ndb_limits.h>
 
 #include <NdbTick.h>
@@ -33,6 +29,7 @@
 #include "ndb_cluster_connection_impl.hpp"
 #include "NdbDictionaryImpl.hpp"
 #include "ObjectMap.hpp"
+#include "trp_client.hpp"
 
 template <class T>
 struct Ndb_free_list_t 
@@ -53,7 +50,8 @@ struct Ndb_free_list_t
 /**
  * Private parts of the Ndb object (corresponding to Ndb.hpp in public API)
  */
-class NdbImpl {
+class NdbImpl : public trp_client
+{
 public:
   NdbImpl(Ndb_cluster_connection *, Ndb&);
   ~NdbImpl();
@@ -117,6 +115,13 @@ public:
     ndb->theImpl->forceShortRequests = val;
   }
 
+  Uint32 get_waitfor_timeout() const {
+    return m_ndb_cluster_connection.m_config.m_waitfor_timeout;
+  }
+  const NdbApiConfig& get_ndbapi_config_parameters() const {
+    return m_ndb_cluster_connection.m_config;
+  }
+
 
   BaseString m_systemPrefix; // Buffer for preformatted for <sys>/<def>/
 
@@ -139,6 +144,13 @@ public:
   Ndb_free_list_t<NdbOperation>  theOpIdleList;  
   Ndb_free_list_t<NdbIndexOperation> theIndexOpIdleList;
   Ndb_free_list_t<NdbTransaction> theConIdleList; 
+
+  /**
+   * trp_client interface
+   */
+  virtual void trp_deliver_signal(const NdbApiSignal*,
+                                  const LinearSectionPtr p[3]);
+  virtual void trp_node_status(Uint32, bool nodeAlive, bool nfComplete);
 };
 
 #ifdef VM_TRACE

=== modified file 'storage/ndb/src/ndbapi/NdbIndexOperation.cpp'
--- a/storage/ndb/src/ndbapi/NdbIndexOperation.cpp	2009-05-26 18:53:34 +0000
+++ b/storage/ndb/src/ndbapi/NdbIndexOperation.cpp	2010-09-29 13:25:19 +0000
@@ -16,11 +16,7 @@
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 */
 
-#include <ndb_global.h>
-#include <NdbIndexOperation.hpp>
-#include <Ndb.hpp>
-#include <NdbTransaction.hpp>
-#include "NdbApiSignal.hpp"
+#include "API.hpp"
 #include <AttributeHeader.hpp>
 #include <signaldata/TcIndx.hpp>
 #include <signaldata/TcKeyReq.hpp>
@@ -188,7 +184,7 @@ Parameters:     aSignal: the signal obje
 Remark:         Handles the reception of the TCKEYREF signal.
 ***************************************************************************/
 int
-NdbIndexOperation::receiveTCINDXREF( NdbApiSignal* aSignal)
+NdbIndexOperation::receiveTCINDXREF(const NdbApiSignal* aSignal)
 {
   return receiveTCKEYREF(aSignal);
 }//NdbIndexOperation::receiveTCINDXREF()

=== modified file 'storage/ndb/src/ndbapi/NdbInfoScanOperation.cpp'
--- a/storage/ndb/src/ndbapi/NdbInfoScanOperation.cpp	2010-08-17 09:54:53 +0000
+++ b/storage/ndb/src/ndbapi/NdbInfoScanOperation.cpp	2010-09-30 09:32:28 +0000
@@ -18,7 +18,7 @@
 
 #include "NdbInfo.hpp"
 #include "SignalSender.hpp"
-
+#include <kernel/GlobalSignalNumbers.h>
 #include <AttributeHeader.hpp>
 #include <signaldata/DbinfoScan.hpp>
 #include <signaldata/TransIdAI.hpp>

=== modified file 'storage/ndb/src/ndbapi/NdbInterpretedCode.cpp'
--- a/storage/ndb/src/ndbapi/NdbInterpretedCode.cpp	2010-06-10 07:21:34 +0000
+++ b/storage/ndb/src/ndbapi/NdbInterpretedCode.cpp	2010-09-29 13:27:36 +0000
@@ -706,7 +706,7 @@ NdbInterpretedCode::interpret_exit_nok(U
 int
 NdbInterpretedCode::interpret_exit_nok()
 {
-  return add1((899 << 16) | Interpreter::EXIT_REFUSE);
+  return add1((626 << 16) | Interpreter::EXIT_REFUSE);
 }
 
 int

=== modified file 'storage/ndb/src/ndbapi/NdbOperation.cpp'
--- a/storage/ndb/src/ndbapi/NdbOperation.cpp	2010-01-28 15:16:46 +0000
+++ b/storage/ndb/src/ndbapi/NdbOperation.cpp	2010-09-30 09:32:28 +0000
@@ -16,19 +16,8 @@
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 */
 
-#include <ndb_global.h>
-#include <NdbTransaction.hpp>
-#include <NdbOperation.hpp>
-#include "NdbApiSignal.hpp"
-#include "NdbRecAttr.hpp"
-#include "NdbUtil.hpp"
-#include "NdbBlob.hpp"
-#include "ndbapi_limits.h"
-#include <signaldata/TcKeyReq.hpp>
-#include "NdbDictionaryImpl.hpp"
-
 #include "API.hpp"
-#include <NdbOut.hpp>
+#include <signaldata/TcKeyReq.hpp>
 
 
 /******************************************************************************

=== modified file 'storage/ndb/src/ndbapi/NdbOperationDefine.cpp'
--- a/storage/ndb/src/ndbapi/NdbOperationDefine.cpp	2010-06-08 14:37:15 +0000
+++ b/storage/ndb/src/ndbapi/NdbOperationDefine.cpp	2010-09-29 13:25:19 +0000
@@ -16,16 +16,8 @@
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 */
 
-#include <ndb_global.h>
-#include <NdbOperation.hpp>
-#include "NdbApiSignal.hpp"
-#include <NdbTransaction.hpp>
-#include <Ndb.hpp>
-#include <NdbRecAttr.hpp>
-#include "NdbUtil.hpp"
+#include "API.hpp"
 #include "NdbOut.hpp"
-#include "NdbImpl.hpp"
-#include <NdbIndexScanOperation.hpp>
 #include <NdbBlob.hpp>
 
 #include <Interpreter.hpp>

=== modified file 'storage/ndb/src/ndbapi/NdbOperationExec.cpp'
--- a/storage/ndb/src/ndbapi/NdbOperationExec.cpp	2010-06-08 14:37:15 +0000
+++ b/storage/ndb/src/ndbapi/NdbOperationExec.cpp	2010-09-30 09:32:28 +0000
@@ -17,14 +17,7 @@
 */
 
 #include <ndb_global.h>
-#include <NdbOperation.hpp>
-#include <NdbTransaction.hpp>
-#include <NdbBlob.hpp>
-#include "NdbApiSignal.hpp"
-#include <Ndb.hpp>
-#include <NdbRecAttr.hpp>
-#include "NdbUtil.hpp"
-#include "NdbInterpretedCode.hpp"
+#include "API.hpp"
 
 #include "Interpreter.hpp"
 #include <AttributeHeader.hpp>
@@ -1696,7 +1689,7 @@ NdbOperation::insertATTRINFOData_NdbReco
 }
 
 int
-NdbOperation::checkState_TransId(NdbApiSignal* aSignal)
+NdbOperation::checkState_TransId(const NdbApiSignal* aSignal)
 {
   Uint64 tRecTransId, tCurrTransId;
   Uint32 tTmp1, tTmp2;
@@ -1731,7 +1724,7 @@ Parameters:     aSignal: the signal obje
 Remark:         Handles the reception of the TCKEYREF signal.
 ***************************************************************************/
 int
-NdbOperation::receiveTCKEYREF( NdbApiSignal* aSignal)
+NdbOperation::receiveTCKEYREF(const NdbApiSignal* aSignal)
 {
   if (checkState_TransId(aSignal) == -1) {
     return -1;

=== modified file 'storage/ndb/src/ndbapi/NdbOperationInt.cpp'
--- a/storage/ndb/src/ndbapi/NdbOperationInt.cpp	2009-05-27 15:21:45 +0000
+++ b/storage/ndb/src/ndbapi/NdbOperationInt.cpp	2010-09-29 13:25:19 +0000
@@ -16,15 +16,8 @@
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 */
 
-#include <ndb_global.h>
-#include <NdbOperation.hpp>
-#include "NdbApiSignal.hpp"
-#include <NdbTransaction.hpp>
-#include <Ndb.hpp>
-#include <NdbRecAttr.hpp>
-#include "NdbUtil.hpp"
+#include "API.hpp"
 #include "Interpreter.hpp"
-#include <NdbIndexScanOperation.hpp>
 #include <signaldata/AttrInfo.hpp>
 
 #ifdef VM_TRACE

=== modified file 'storage/ndb/src/ndbapi/NdbOperationSearch.cpp'
--- a/storage/ndb/src/ndbapi/NdbOperationSearch.cpp	2009-11-27 14:47:24 +0000
+++ b/storage/ndb/src/ndbapi/NdbOperationSearch.cpp	2010-09-30 09:32:28 +0000
@@ -31,18 +31,10 @@ Adjust:  971022  UABMNST   First version
  *****************************************************************************/
 #include "API.hpp"
 
-#include <NdbOperation.hpp>
-#include "NdbApiSignal.hpp"
-#include <NdbTransaction.hpp>
-#include <Ndb.hpp>
-#include "NdbImpl.hpp"
-#include <NdbOut.hpp>
-#include "NdbBlob.hpp"
 
 #include <AttributeHeader.hpp>
 #include <signaldata/TcKeyReq.hpp>
 #include <signaldata/KeyInfo.hpp>
-#include "NdbDictionaryImpl.hpp"
 #include <md5_hash.hpp>
 
 /******************************************************************************

=== modified file 'storage/ndb/src/ndbapi/NdbReceiver.cpp'
--- a/storage/ndb/src/ndbapi/NdbReceiver.cpp	2010-03-10 07:43:06 +0000
+++ b/storage/ndb/src/ndbapi/NdbReceiver.cpp	2010-09-30 10:36:47 +0000
@@ -16,15 +16,8 @@
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 */
 
-#include <ndb_global.h>
-#include "NdbImpl.hpp"
-#include <NdbReceiver.hpp>
-#include "NdbDictionaryImpl.hpp"
-#include <NdbRecAttr.hpp>
+#include "API.hpp"
 #include <AttributeHeader.hpp>
-#include <NdbTransaction.hpp>
-#include <TransporterFacade.hpp>
-#include <NdbBlob.hpp>
 #include <signaldata/TcKeyConf.hpp>
 #include <signaldata/DictTabInfo.hpp>
 
@@ -147,10 +140,10 @@ NdbReceiver::calculate_batch_size(Uint32
                                   Uint32& first_batch_size,
                                   const NdbRecord *record)
 {
-  TransporterFacade *tp= m_ndb->theImpl->m_transporter_facade;
-  Uint32 max_scan_batch_size= tp->get_scan_batch_size();
-  Uint32 max_batch_byte_size= tp->get_batch_byte_size();
-  Uint32 max_batch_size= tp->get_batch_size();
+  const NdbApiConfig & cfg = m_ndb->theImpl->get_ndbapi_config_parameters();
+  Uint32 max_scan_batch_size= cfg.m_scan_batch_size;
+  Uint32 max_batch_byte_size= cfg.m_batch_byte_size;
+  Uint32 max_batch_size= cfg.m_batch_size;
   Uint32 tot_size= (key_size ? (key_size + 32) : 0); //key + signal overhead
 
   if (record)

=== modified file 'storage/ndb/src/ndbapi/NdbScanFilter.cpp'
--- a/storage/ndb/src/ndbapi/NdbScanFilter.cpp	2009-05-27 15:21:45 +0000
+++ b/storage/ndb/src/ndbapi/NdbScanFilter.cpp	2010-09-30 09:32:28 +0000
@@ -16,18 +16,12 @@
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 */
 
+#include "API.hpp"
 #include <NdbScanFilter.hpp>
-#include <Ndb.hpp>
-#include <NdbOperation.hpp>
-#include <NdbScanOperation.hpp>
-#include "NdbDictionaryImpl.hpp"
 #include <Vector.hpp>
 #include <NdbOut.hpp>
 #include <Interpreter.hpp>
 #include <signaldata/AttrInfo.hpp>
-#include "NdbApiSignal.hpp"
-#include "NdbUtil.hpp"
-#include <NdbInterpretedCode.hpp>
 
 #ifdef VM_TRACE
 #include <NdbEnv.h>

=== modified file 'storage/ndb/src/ndbapi/NdbScanOperation.cpp'
--- a/storage/ndb/src/ndbapi/NdbScanOperation.cpp	2010-08-20 11:10:25 +0000
+++ b/storage/ndb/src/ndbapi/NdbScanOperation.cpp	2010-09-30 10:36:47 +0000
@@ -16,21 +16,8 @@
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 */
 
-#include <ndb_global.h>
-#include <Ndb.hpp>
-#include <NdbScanOperation.hpp>
-#include <NdbIndexScanOperation.hpp>
-#include <NdbTransaction.hpp>
-#include "NdbApiSignal.hpp"
-#include <NdbOut.hpp>
-#include "NdbDictionaryImpl.hpp"
-#include <NdbBlob.hpp>
-#include <NdbInterpretedCode.hpp>
+#include "API.hpp"
 
-#include <NdbRecAttr.hpp>
-#include <NdbReceiver.hpp>
-
-#include <stdlib.h>
 #include <NdbSqlUtil.hpp>
 #include <AttributeHeader.hpp>
 
@@ -1842,6 +1829,7 @@ NdbScanOperation::nextResultNdbRecord(co
 
   /* Now we have to wait for more rows (or end-of-file on all receivers). */
   Uint32 nodeId = theNdbCon->theDBnode;
+  Uint32 timeout= theNdb->theImpl->get_waitfor_timeout();
   TransporterFacade* tp = theNdb->theImpl->m_transporter_facade;
   int retVal= 2;
   Uint32 idx, last;
@@ -1864,7 +1852,6 @@ NdbScanOperation::nextResultNdbRecord(co
   {
     idx= m_current_api_receiver;
     last= m_api_receivers_count;
-    Uint32 timeout= tp->m_waitfor_timeout;
 
     do {
       if (theError.code){
@@ -3722,6 +3709,7 @@ NdbIndexScanOperation::ordered_insert_re
 int
 NdbIndexScanOperation::ordered_send_scan_wait_for_all(bool forceSend)
 {
+  Uint32 timeout= theNdb->theImpl->get_waitfor_timeout();
   TransporterFacade* tp= theNdb->theImpl->m_transporter_facade;
 
   PollGuard poll_guard(tp, &theNdb->theImpl->theWaiter,
@@ -3731,7 +3719,6 @@ NdbIndexScanOperation::ordered_send_scan
 
   Uint32 seq= theNdbCon->theNodeSequence;
   Uint32 nodeId= theNdbCon->theDBnode;
-  Uint32 timeout= tp->m_waitfor_timeout;
   if (seq == tp->getNodeSequence(nodeId) &&
       !send_next_scan_ordered(m_current_api_receiver))
   {
@@ -3821,6 +3808,7 @@ int
 NdbScanOperation::close_impl(TransporterFacade* tp, bool forceSend,
                              PollGuard *poll_guard)
 {
+  Uint32 timeout= theNdb->theImpl->get_waitfor_timeout();
   Uint32 seq = theNdbCon->theNodeSequence;
   Uint32 nodeId = theNdbCon->theDBnode;
   
@@ -3830,7 +3818,6 @@ NdbScanOperation::close_impl(Transporter
     return -1;
   }
   
-  Uint32 timeout = tp->m_waitfor_timeout;
   /**
    * Wait for outstanding
    */

=== modified file 'storage/ndb/src/ndbapi/NdbTransaction.cpp'
--- a/storage/ndb/src/ndbapi/NdbTransaction.cpp	2010-08-09 10:20:17 +0000
+++ b/storage/ndb/src/ndbapi/NdbTransaction.cpp	2010-09-30 14:27:18 +0000
@@ -18,17 +18,7 @@
 
 #include <ndb_global.h>
 #include <NdbOut.hpp>
-#include <NdbTransaction.hpp>
-#include <NdbOperation.hpp>
-#include <NdbScanOperation.hpp>
-#include <NdbIndexScanOperation.hpp>
-#include <NdbIndexOperation.hpp>
-#include <NdbDictionaryImpl.hpp>
-#include "NdbApiSignal.hpp"
-#include "TransporterFacade.hpp"
 #include "API.hpp"
-#include "NdbBlob.hpp"
-#include "NdbUtil.hpp"
 
 #include <AttributeHeader.hpp>
 #include <signaldata/TcKeyConf.hpp>
@@ -535,7 +525,7 @@ NdbTransaction::executeNoBlobs(NdbTransa
 //------------------------------------------------------------------------
   Ndb* tNdb = theNdb;
 
-  Uint32 timeout = theNdb->theImpl->m_transporter_facade->m_waitfor_timeout;
+  Uint32 timeout = theNdb->theImpl->get_waitfor_timeout();
   m_waitForReply = false;
   executeAsynchPrepare(aTypeOfExec, NULL, NULL, abortOption);
   if (m_waitForReply){
@@ -1636,26 +1626,6 @@ NdbTransaction::getNdbIndexOperation(con
 
 
 /*******************************************************************************
-int  receiveDIHNDBTAMPER(NdbApiSignal* aSignal)
-
-Return Value:  Return 0 : receiveDIHNDBTAMPER was successful.
-               Return -1: In all other case.
-Parameters:    aSignal: The signal object pointer.
-Remark:        Sets theRestartGCI in the NDB object. 
-*******************************************************************************/
-int			
-NdbTransaction::receiveDIHNDBTAMPER(NdbApiSignal* aSignal)
-{
-  if (theStatus != Connecting) {
-    return -1;
-  } else {
-    theNdb->RestartGCI((Uint32)aSignal->readData(2));
-    theStatus = Connected;
-  }//if
-  return 0;  
-}//NdbTransaction::receiveDIHNDBTAMPER()
-
-/*******************************************************************************
 int  receiveTCSEIZECONF(NdbApiSignal* aSignal);
 
 Return Value:  Return 0 : receiveTCSEIZECONF was successful.
@@ -1664,7 +1634,7 @@ Parameters:    aSignal: The signal objec
 Remark:        Sets TC Connect pointer at reception of TCSEIZECONF. 
 *******************************************************************************/
 int			
-NdbTransaction::receiveTCSEIZECONF(NdbApiSignal* aSignal)
+NdbTransaction::receiveTCSEIZECONF(const NdbApiSignal* aSignal)
 {
   if (theStatus != Connecting)
   {
@@ -1686,7 +1656,7 @@ Parameters:    aSignal: The signal objec
 Remark:        Sets TC Connect pointer. 
 *******************************************************************************/
 int			
-NdbTransaction::receiveTCSEIZEREF(NdbApiSignal* aSignal)
+NdbTransaction::receiveTCSEIZEREF(const NdbApiSignal* aSignal)
 {
   DBUG_ENTER("NdbTransaction::receiveTCSEIZEREF");
   if (theStatus != Connecting)
@@ -1712,7 +1682,7 @@ Parameters:    aSignal: The signal objec
 Remark:         DisConnect TC Connect pointer to NDBAPI. 
 *******************************************************************************/
 int			
-NdbTransaction::receiveTCRELEASECONF(NdbApiSignal* aSignal)
+NdbTransaction::receiveTCRELEASECONF(const NdbApiSignal* aSignal)
 {
   if (theStatus != DisConnecting)
   {
@@ -1733,7 +1703,7 @@ Parameters:    aSignal: The signal objec
 Remark:        DisConnect TC Connect pointer to NDBAPI Failure. 
 *******************************************************************************/
 int			
-NdbTransaction::receiveTCRELEASEREF(NdbApiSignal* aSignal)
+NdbTransaction::receiveTCRELEASEREF(const NdbApiSignal* aSignal)
 {
   if (theStatus != DisConnecting) {
     return -1;
@@ -1788,7 +1758,7 @@ Parameters:    aSignal: The signal objec
 Remark:        
 ******************************************************************************/
 int			
-NdbTransaction::receiveTC_COMMITREF(NdbApiSignal* aSignal)
+NdbTransaction::receiveTC_COMMITREF(const NdbApiSignal* aSignal)
 {
   const TcCommitRef * ref = CAST_CONSTPTR(TcCommitRef, aSignal->getDataPtr());
   if(checkState_TransId(&ref->transId1)){
@@ -1815,7 +1785,7 @@ Parameters:    aSignal: The signal objec
 Remark:        
 ******************************************************************************/
 int			
-NdbTransaction::receiveTCROLLBACKCONF(NdbApiSignal* aSignal)
+NdbTransaction::receiveTCROLLBACKCONF(const NdbApiSignal* aSignal)
 {
   if(checkState_TransId(aSignal->getDataPtr() + 1)){
     theCommitStatus = Aborted;
@@ -1839,7 +1809,7 @@ Parameters:    aSignal: The signal objec
 Remark:        
 *******************************************************************************/
 int			
-NdbTransaction::receiveTCROLLBACKREF(NdbApiSignal* aSignal)
+NdbTransaction::receiveTCROLLBACKREF(const NdbApiSignal* aSignal)
 {
   if(checkState_TransId(aSignal->getDataPtr() + 1)){
     setOperationErrorCodeAbort(aSignal->readData(4));
@@ -1866,7 +1836,7 @@ Parameters:     aSignal: the signal obje
 Remark:         Handles the reception of the ROLLBACKREP signal.
 *****************************************************************************/
 int
-NdbTransaction::receiveTCROLLBACKREP( NdbApiSignal* aSignal)
+NdbTransaction::receiveTCROLLBACKREP( const NdbApiSignal* aSignal)
 {
   DBUG_ENTER("NdbTransaction::receiveTCROLLBACKREP");
 
@@ -2062,7 +2032,7 @@ Parameters:     aSignal: the signal obje
 Remark:         Handles the reception of the TCKEY_FAILREF signal.
 **************************************************************************/
 int
-NdbTransaction::receiveTCKEY_FAILREF(NdbApiSignal* aSignal)
+NdbTransaction::receiveTCKEY_FAILREF(const NdbApiSignal* aSignal)
 {
   /*
     Check that we are expecting signals from this transaction and

=== modified file 'storage/ndb/src/ndbapi/NdbTransactionScan.cpp'
--- a/storage/ndb/src/ndbapi/NdbTransactionScan.cpp	2009-05-26 18:53:34 +0000
+++ b/storage/ndb/src/ndbapi/NdbTransactionScan.cpp	2010-09-30 09:32:28 +0000
@@ -19,15 +19,7 @@
 
 #include <ndb_global.h>
 
-#include <Ndb.hpp>
-#include <NdbTransaction.hpp>
-#include <NdbOperation.hpp>
-#include <NdbScanOperation.hpp>
-#include "NdbApiSignal.hpp"
-#include "TransporterFacade.hpp"
-#include "NdbUtil.hpp"
 #include "API.hpp"
-#include "NdbImpl.hpp"
 
 #include <signaldata/ScanTab.hpp>
 
@@ -42,7 +34,7 @@
  *
  ****************************************************************************/
 int			
-NdbTransaction::receiveSCAN_TABREF(NdbApiSignal* aSignal){
+NdbTransaction::receiveSCAN_TABREF(const NdbApiSignal* aSignal){
   const ScanTabRef * ref = CAST_CONSTPTR(ScanTabRef, aSignal->getDataPtr());
   
   if(checkState_TransId(&ref->transId1)){
@@ -83,7 +75,7 @@ NdbTransaction::receiveSCAN_TABREF(NdbAp
  * 
  *****************************************************************************/
 int			
-NdbTransaction::receiveSCAN_TABCONF(NdbApiSignal* aSignal, 
+NdbTransaction::receiveSCAN_TABCONF(const NdbApiSignal* aSignal,
 				   const Uint32 * ops, Uint32 len)
 {
   const ScanTabConf * conf = CAST_CONSTPTR(ScanTabConf, aSignal->getDataPtr());

=== modified file 'storage/ndb/src/ndbapi/NdbWaiter.hpp'
--- a/storage/ndb/src/ndbapi/NdbWaiter.hpp	2009-05-27 15:21:45 +0000
+++ b/storage/ndb/src/ndbapi/NdbWaiter.hpp	2010-09-30 09:32:28 +0000
@@ -20,14 +20,9 @@
 #define NDB_WAITER_HPP
 
 #include <ndb_global.h>
-#include <NdbOut.hpp>
-#include <NdbError.hpp>
-#include <NdbCondition.h>
-#include <NdbReceiver.hpp>
-#include <NdbOperation.hpp>
-#include <kernel/ndb_limits.h>
-
 #include <NdbTick.h>
+#include <NdbCondition.h>
+#include <NdbOut.hpp>
 
 enum WaitSignalType { 
   NO_WAIT           = 0,

=== modified file 'storage/ndb/src/ndbapi/Ndberr.cpp'
--- a/storage/ndb/src/ndbapi/Ndberr.cpp	2009-05-26 18:53:34 +0000
+++ b/storage/ndb/src/ndbapi/Ndberr.cpp	2010-09-30 09:32:28 +0000
@@ -16,14 +16,7 @@
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 */
 
-
-#include <NdbError.hpp>
-#include "NdbImpl.hpp"
-#include "NdbDictionaryImpl.hpp"
-#include <NdbOperation.hpp>
-#include <NdbTransaction.hpp>
-#include <NdbBlob.hpp>
-#include "NdbEventOperationImpl.hpp"
+#include "API.hpp"
 
 static void
 update(const NdbError & _err){

=== modified file 'storage/ndb/src/ndbapi/Ndbif.cpp'
--- a/storage/ndb/src/ndbapi/Ndbif.cpp	2010-08-26 12:33:33 +0000
+++ b/storage/ndb/src/ndbapi/Ndbif.cpp	2010-10-01 07:38:17 +0000
@@ -19,16 +19,7 @@
 
 #include <ndb_global.h>
 
-#include "NdbApiSignal.hpp"
-#include "NdbImpl.hpp"
-#include <NdbTransaction.hpp>
-#include <NdbOperation.hpp>
-#include <NdbIndexOperation.hpp>
-#include <NdbScanOperation.hpp>
-#include <NdbRecAttr.hpp>
-#include <NdbReceiver.hpp>
 #include "API.hpp"
-#include "NdbEventOperationImpl.hpp"
 
 #include <signaldata/TcCommit.hpp>
 #include <signaldata/TcKeyFailConf.hpp>
@@ -82,9 +73,8 @@ Ndb::init(int aMaxNoOfTransactions)
   TransporterFacade * theFacade =  theImpl->m_transporter_facade;
   theFacade->lock_mutex();
   
-  const int tBlockNo = theFacade->open(this,
-                                       executeMessage, 
-                                       statusMessage);  
+  const int tBlockNo = theFacade->open(theImpl);
+
   if ( tBlockNo == -1 ) {
     theError.code = 4105;
     theFacade->unlock_mutex();
@@ -150,7 +140,7 @@ error_handler:
   ndbout << "error_handler" << endl;
   releaseTransactionArrays();
   delete theDictionary;
-  theImpl->m_transporter_facade->close(theNdbBlockNumber, 0);
+  theImpl->m_transporter_facade->close(theNdbBlockNumber);
   DBUG_RETURN(-1);
 }
 
@@ -171,12 +161,10 @@ Ndb::releaseTransactionArrays()
 }//Ndb::releaseTransactionArrays()
 
 void
-Ndb::executeMessage(void* NdbObject,
-                    NdbApiSignal * aSignal,
-                    LinearSectionPtr ptr[3])
+NdbImpl::trp_deliver_signal(const NdbApiSignal * aSignal,
+                            const LinearSectionPtr ptr[3])
 {
-  Ndb* tNdb = (Ndb*)NdbObject;
-  tNdb->handleReceivedSignal(aSignal, ptr);
+  m_ndb.handleReceivedSignal(aSignal, ptr);
 }
 
 void Ndb::connected(Uint32 ref)
@@ -199,9 +187,8 @@ void Ndb::connected(Uint32 ref)
   }
   theImpl->theNoOfDBnodes = n;
   
-  theFirstTransId = ((Uint64)tBlockNo << 52)+
+  theFirstTransId += ((Uint64)tBlockNo << 52)+
     ((Uint64)tmpTheNode << 40);
-  theFirstTransId += theFacade->m_max_trans_id;
   //      assert(0);
   DBUG_PRINT("info",("connected with ref=%x, id=%d, no_db_nodes=%d, first_trans_id: 0x%lx",
 		     theMyRef,
@@ -225,12 +212,12 @@ void Ndb::report_node_connected(Uint32 n
 }
 
 void
-Ndb::statusMessage(void* NdbObject, Uint32 a_node, bool alive, bool nfComplete)
+NdbImpl::trp_node_status(Uint32 a_node, bool alive, bool nfComplete)
 {
   DBUG_ENTER("Ndb::statusMessage");
   DBUG_PRINT("info", ("a_node: %u  alive: %u  nfComplete: %u",
                       a_node, alive, nfComplete));
-  Ndb* tNdb = (Ndb*)NdbObject;
+  Ndb* tNdb = (Ndb*)&m_ndb;
   if (alive) {
     if (nfComplete) {
       // cluster connect, a_node == own reference
@@ -343,7 +330,8 @@ Parameters:     aSignal: The signal obje
 Remark:         Send all operations belonging to this connection. 
 *****************************************************************************/
 void	
-Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
+Ndb::handleReceivedSignal(const NdbApiSignal* aSignal,
+			  const LinearSectionPtr ptr[3])
 {
   NdbOperation* tOp;
   NdbIndexOperation* tIndexOp;
@@ -763,9 +751,15 @@ Ndb::handleReceivedSignal(NdbApiSignal*
         !op->execSUB_TABLE_DATA(aSignal, ptr))
       return;
     
-    for (int i= aSignal->m_noOfSections;i < 3; i++) {
-      ptr[i].p = NULL;
-      ptr[i].sz = 0;
+    LinearSectionPtr copy[3];
+    for (int i = 0; i<aSignal->m_noOfSections; i++)
+    {
+      copy[i] = ptr[i];
+    }
+    for (int i = aSignal->m_noOfSections; i < 3; i++)
+    {
+      copy[i].p = NULL;
+      copy[i].sz = 0;
     }
     DBUG_PRINT("info",("oid=senderData: %d, gci{hi/lo}: %d/%d, operation: %d, "
 		       "tableId: %d",
@@ -773,24 +767,9 @@ Ndb::handleReceivedSignal(NdbApiSignal*
 		       SubTableData::getOperation(sdata->requestInfo),
 		       sdata->tableId));
 
-    theEventBuffer->insertDataL(op, sdata, tLen, ptr);
+    theEventBuffer->insertDataL(op, sdata, tLen, copy);
     return;
   }
-  case GSN_DIHNDBTAMPER:
-    {
-      tFirstDataPtr = int2void(tFirstData);
-      if (tFirstDataPtr == 0) goto InvalidSignal;
-      
-      if (tWaitState != WAIT_NDB_TAMPER)
-	return;
-      tCon = void2con(tFirstDataPtr);
-      if (tCon->checkMagicNumber() != 0)
-	return;
-      tReturnCode = tCon->receiveDIHNDBTAMPER(aSignal);
-      if (tReturnCode != -1)
-	theImpl->theWaiter.m_state = NO_WAIT;
-      break;
-    }
   case GSN_SCAN_TABCONF:
     {
       tFirstDataPtr = int2void(tFirstData);
@@ -1087,7 +1066,7 @@ Ndb::pollCompleted(NdbTransaction** aCop
 void
 Ndb::check_send_timeout()
 {
-  Uint32 timeout = theImpl->m_transporter_facade->m_waitfor_timeout;
+  Uint32 timeout = theImpl->get_ndbapi_config_parameters().m_waitfor_timeout;
   NDB_TICKS current_time = NdbTick_CurrentMillisecond();
   assert(current_time >= the_last_check_time);
   if (current_time - the_last_check_time > 1000) {

=== modified file 'storage/ndb/src/ndbapi/Ndbinit.cpp'
--- a/storage/ndb/src/ndbapi/Ndbinit.cpp	2010-01-28 15:16:46 +0000
+++ b/storage/ndb/src/ndbapi/Ndbinit.cpp	2010-09-30 11:52:49 +0000
@@ -19,23 +19,15 @@
 
 #include <ndb_global.h>
 
+#include "API.hpp"
 #include "NdbApiSignal.hpp"
 #include "NdbImpl.hpp"
-#include <NdbOperation.hpp>
-#include <NdbTransaction.hpp>
-#include <NdbRecAttr.hpp>
-#include <IPCConfig.hpp>
-#include "TransporterFacade.hpp"
 #include <ConfigRetriever.hpp>
 #include <ndb_limits.h>
 #include <NdbOut.hpp>
 #include <NdbSleep.h>
 #include "ObjectMap.hpp"
-#include <NdbIndexScanOperation.hpp>
-#include <NdbIndexOperation.hpp>
 #include "NdbUtil.hpp"
-#include <NdbBlob.hpp>
-#include "NdbEventOperationImpl.hpp"
 
 #include <EventLogger.hpp>
 extern EventLogger * g_eventLogger;
@@ -153,7 +145,7 @@ Ndb::~Ndb()
 
   /* Disconnect from transporter to stop signals from coming in */
   if (theImpl->m_transporter_facade != NULL && theNdbBlockNumber > 0){
-    theImpl->m_transporter_facade->close(theNdbBlockNumber, theFirstTransId);
+    theImpl->m_transporter_facade->close(theNdbBlockNumber);
   }
 
   delete theEventBuffer;

=== modified file 'storage/ndb/src/ndbapi/Ndblist.cpp'
--- a/storage/ndb/src/ndbapi/Ndblist.cpp	2010-01-28 15:16:46 +0000
+++ b/storage/ndb/src/ndbapi/Ndblist.cpp	2010-09-30 09:32:28 +0000
@@ -16,16 +16,7 @@
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 */
 
-#include <NdbOut.hpp>
-#include <Ndb.hpp>
-#include <NdbOperation.hpp>
-#include <NdbIndexOperation.hpp>
-#include <NdbIndexScanOperation.hpp>
-#include "NdbApiSignal.hpp"
-#include <NdbRecAttr.hpp>
-#include "NdbUtil.hpp"
 #include "API.hpp"
-#include "NdbBlob.hpp"
 
 void
 Ndb::checkFailedNode()

=== modified file 'storage/ndb/src/ndbapi/SignalSender.cpp'
--- a/storage/ndb/src/ndbapi/SignalSender.cpp	2010-02-19 11:11:09 +0000
+++ b/storage/ndb/src/ndbapi/SignalSender.cpp	2010-10-01 07:38:17 +0000
@@ -17,6 +17,7 @@
 */
 
 #include "SignalSender.hpp"
+#include <kernel/GlobalSignalNumbers.h>
 #include <NdbSleep.h>
 #include <SignalLoggerManager.hpp>
 #include <signaldata/NFCompleteRep.hpp>
@@ -80,7 +81,7 @@ SignalSender::SignalSender(TransporterFa
   m_cond = NdbCondition_Create();
   theFacade = facade;
   lock();
-  m_blockNo = theFacade->open(this, execSignal, execNodeStatus, blockNo);
+  m_blockNo = theFacade->open(this, blockNo);
   unlock();
   assert(m_blockNo > 0);
 }
@@ -90,7 +91,7 @@ SignalSender::SignalSender(Ndb_cluster_c
   m_cond = NdbCondition_Create();
   theFacade = connection->m_impl.m_transporter_facade;
   lock();
-  m_blockNo = theFacade->open(this, execSignal, execNodeStatus, -1);
+  m_blockNo = theFacade->open(this, -1);
   unlock();
   assert(m_blockNo > 0);
 }
@@ -99,7 +100,7 @@ SignalSender::~SignalSender(){
   int i;
   if (m_lock)
     unlock();
-  theFacade->close(m_blockNo,0);
+  theFacade->close(m_blockNo);
   // free these _after_ closing theFacade to ensure that
   // we delete all signals
   for (i= m_jobBuffer.size()-1; i>= 0; i--)
@@ -253,37 +254,12 @@ SignalSender::waitFor(Uint32 timeOutMill
   return waitFor(timeOutMillis, w);
 }
 
-class WaitForNode {
-public:
-  WaitForNode() {}
-  Uint32 m_nodeId;
-  SimpleSignal * check(Vector<SimpleSignal*> & m_jobBuffer){
-    Uint32 len = m_jobBuffer.size();
-    for(Uint32 i = 0; i<len; i++){
-      if(refToNode(m_jobBuffer[i]->header.theSendersBlockRef) == m_nodeId){
-	SimpleSignal * s = m_jobBuffer[i];
-	m_jobBuffer.erase(i);
-	return s;
-      }
-    }
-    return 0;
-  }
-};
-
-SimpleSignal *
-SignalSender::waitFor(Uint16 nodeId, Uint32 timeOutMillis){
-  
-  WaitForNode w;
-  w.m_nodeId = nodeId;
-  return waitFor(timeOutMillis, w);
-}
-
 #include <NdbApiSignal.hpp>
 
 void
-SignalSender::execSignal(void* signalSender, 
-			 NdbApiSignal* signal, 
-			 struct LinearSectionPtr ptr[3]){
+SignalSender::trp_deliver_signal(const NdbApiSignal* signal,
+                                 const struct LinearSectionPtr ptr[3])
+{
   SimpleSignal * s = new SimpleSignal(true);
   s->header = * signal;
   memcpy(&s->theData[0], signal->getDataPtr(), 4 * s->header.theLength);
@@ -292,23 +268,20 @@ SignalSender::execSignal(void* signalSen
     s->ptr[i].sz = ptr[i].sz;
     memcpy(s->ptr[i].p, ptr[i].p, 4 * ptr[i].sz);
   }
-  SignalSender * ss = (SignalSender*)signalSender;
-  ss->m_jobBuffer.push_back(s);
-  NdbCondition_Signal(ss->m_cond);
+  m_jobBuffer.push_back(s);
+  NdbCondition_Signal(m_cond);
 }
   
 void 
-SignalSender::execNodeStatus(void* signalSender, 
-			     Uint32 nodeId, 
-			     bool alive, 
-			     bool nfCompleted){
+SignalSender::trp_node_status(Uint32 nodeId,
+                              bool alive,
+                              bool nfCompleted){
   if (alive) {
     // node connected
     return;
   }
 
   SimpleSignal * s = new SimpleSignal(true);
-  SignalSender * ss = (SignalSender*)signalSender;
 
   // node disconnected
   if(nfCompleted)
@@ -333,13 +306,13 @@ SignalSender::execNodeStatus(void* signa
     NdbNodeBitmask::clear(rep->theNodes);
 
     // Mark ndb nodes as failed in bitmask
-    const ClusterMgr::Node node= ss->getNodeInfo(nodeId);
+    const ClusterMgr::Node node= getNodeInfo(nodeId);
     if (node.m_info.getType() ==  NodeInfo::DB)
       NdbNodeBitmask::set(rep->theNodes, nodeId);
   }
 
-  ss->m_jobBuffer.push_back(s);
-  NdbCondition_Signal(ss->m_cond);
+  m_jobBuffer.push_back(s);
+  NdbCondition_Signal(m_cond);
 }
 
 
@@ -411,7 +384,6 @@ SignalSender::find_alive_node(const Node
 
 
 #if __SUNPRO_CC != 0x560
-template SimpleSignal* SignalSender::waitFor<WaitForNode>(unsigned, WaitForNode&);
 template SimpleSignal* SignalSender::waitFor<WaitForAny>(unsigned, WaitForAny&);
 template NodeId SignalSender::find_node<FindConfirmedNode>(const NodeBitmask&,
                                                            FindConfirmedNode&);

=== modified file 'storage/ndb/src/ndbapi/SignalSender.hpp'
--- a/storage/ndb/src/ndbapi/SignalSender.hpp	2010-03-16 08:54:58 +0000
+++ b/storage/ndb/src/ndbapi/SignalSender.hpp	2010-10-01 07:38:17 +0000
@@ -21,6 +21,7 @@
 
 #include <ndb_global.h>
 #include "TransporterFacade.hpp"
+#include "trp_client.hpp"
 #include <Vector.hpp>
 
 #include <signaldata/TestOrd.hpp>
@@ -84,7 +85,7 @@ private:
   bool deallocSections;
 };
 
-class SignalSender {
+class SignalSender  : public trp_client {
 public:
   SignalSender(TransporterFacade *facade, int blockNo = -1);
   SignalSender(Ndb_cluster_connection* connection);
@@ -110,8 +111,6 @@ public:
                               Uint16 recBlock, Uint16 gsn, Uint32 len);
 
   SimpleSignal * waitFor(Uint32 timeOutMillis = 0);
-  SimpleSignal * waitFor(Uint16 nodeId, Uint32 timeOutMillis = 0);
-  SimpleSignal * waitFor(Uint16 nodeId, Uint16 gsn, Uint32 timeOutMillis = 0);  
 
   Uint32 get_an_alive_node() const { return theFacade->get_an_alive_node(); }
   Uint32 getAliveNode() const { return get_an_alive_node(); }
@@ -121,13 +120,16 @@ private:
   int m_blockNo;
   TransporterFacade * theFacade;
   
-  static void execSignal(void* signalSender, 
-			 NdbApiSignal* signal, 
-			 struct LinearSectionPtr ptr[3]);
+public:
+  /**
+   * trp_client interface
+   */
+  virtual void trp_deliver_signal(const NdbApiSignal* signal,
+                                  const struct LinearSectionPtr ptr[3]);
   
-  static void execNodeStatus(void* signalSender, Uint32 nodeId, 
-			     bool alive, bool nfCompleted);
+  virtual void trp_node_status(Uint32 nodeId, bool alive, bool nfCompleted);
   
+private:
   int m_lock;
   struct NdbCondition * m_cond;
   Vector<SimpleSignal *> m_jobBuffer;

=== modified file 'storage/ndb/src/ndbapi/TransporterFacade.cpp'
--- a/storage/ndb/src/ndbapi/TransporterFacade.cpp	2010-08-20 08:35:41 +0000
+++ b/storage/ndb/src/ndbapi/TransporterFacade.cpp	2010-10-01 07:38:17 +0000
@@ -17,19 +17,20 @@
 */
 
 #include <ndb_global.h>
-#include <my_pthread.h>
 #include <ndb_limits.h>
+#include "trp_client.hpp"
 #include "TransporterFacade.hpp"
 #include "ClusterMgr.hpp"
 #include <IPCConfig.hpp>
 #include <TransporterCallback.hpp>
 #include <TransporterRegistry.hpp>
 #include "NdbApiSignal.hpp"
+#include "NdbWaiter.hpp"
 #include <NdbOut.hpp>
 #include <NdbEnv.h>
 #include <NdbSleep.h>
 
-#include "API.hpp"
+#include <kernel/GlobalSignalNumbers.h>
 #include <mgmapi_config_parameters.h>
 #include <mgmapi_configuration.hpp>
 #include <NdbConfig.h>
@@ -210,24 +211,24 @@ TransporterFacade::deliver_signal(Signal
                                   Uint8 prio, Uint32 * const theData,
                                   LinearSectionPtr ptr[3])
 {
-
-  TransporterFacade::ThreadData::Object_Execute oe; 
   Uint32 tRecBlockNo = header->theReceiversBlockNumber;
   
 #ifdef API_TRACE
   if(setSignalLog() && TRACE_GSN(header->theVerId_signalNumber)){
     signalLogger.executeSignal(* header, 
-			       prio,
+                               prio,
                                theData,
-			       ownId(),
+                               ownId(),
                                ptr, header->m_noOfSections);
     signalLogger.flushSignalLog();
   }
 #endif  
 
-  if (tRecBlockNo >= MIN_API_BLOCK_NO) {
-    oe = m_threads.get(tRecBlockNo);
-    if (oe.m_object != 0 && oe.m_executeFunction != 0) {
+  if (tRecBlockNo >= MIN_API_BLOCK_NO)
+  {
+    trp_client * clnt = m_threads.get(tRecBlockNo);
+    if (clnt != 0)
+    {
       /**
        * Handle received signal immediately to avoid any unnecessary
        * copying of data, allocation of memory and other things. Copying
@@ -242,9 +243,11 @@ TransporterFacade::deliver_signal(Signal
       NdbApiSignal tmpSignal(*header);
       NdbApiSignal * tSignal = &tmpSignal;
       tSignal->setDataPtr(theData);
-      (* oe.m_executeFunction) (oe.m_object, tSignal, ptr);
+      clnt->trp_deliver_signal(tSignal, ptr);
     }//if
-  } else if (tRecBlockNo == API_PACKED) {
+  }
+  else if (tRecBlockNo == API_PACKED)
+  {
     /**
      * Block number == 2047 is used to signal a signal that consists of
      * multiple instances of the same signal. This is an effort to
@@ -262,150 +265,162 @@ TransporterFacade::deliver_signal(Signal
       Tsent++;
       Uint32 TpacketLen = (Theader & 0x1F) + 3;
       tRecBlockNo = Theader >> 16;
-      if (TpacketLen <= 25) {
-	if ((TpacketLen + Tsent) <= Tlength) {
-	  /**
-	   * Set the data length of the signal and the receivers block
-	   * reference and then call the API.
-	   */
-	  header->theLength = TpacketLen;
-	  header->theReceiversBlockNumber = tRecBlockNo;
-	  Uint32* tDataPtr = &theData[Tsent];
-	  Tsent += TpacketLen;
-	  if (tRecBlockNo >= MIN_API_BLOCK_NO) {
-	    oe = m_threads.get(tRecBlockNo);
-	    if(oe.m_object != 0 && oe.m_executeFunction != 0){
-	      NdbApiSignal tmpSignal(*header);
-	      NdbApiSignal * tSignal = &tmpSignal;
-	      tSignal->setDataPtr(tDataPtr);
-	      (*oe.m_executeFunction)(oe.m_object, tSignal, 0);
-	    }
-	  }
-	}
+      if (TpacketLen <= 25)
+      {
+        if ((TpacketLen + Tsent) <= Tlength)
+        {
+          /**
+           * Set the data length of the signal and the receivers block
+           * reference and then call the API.
+           */
+          header->theLength = TpacketLen;
+          header->theReceiversBlockNumber = tRecBlockNo;
+          Uint32* tDataPtr = &theData[Tsent];
+          Tsent += TpacketLen;
+          if (tRecBlockNo >= MIN_API_BLOCK_NO)
+          {
+            trp_client * clnt = m_threads.get(tRecBlockNo);
+            if(clnt != 0)
+            {
+              NdbApiSignal tmpSignal(*header);
+              NdbApiSignal * tSignal = &tmpSignal;
+              tSignal->setDataPtr(tDataPtr);
+              clnt->trp_deliver_signal(tSignal, 0);
+            }
+          }
+        }
+      }
+    }
+    return;
+  }
+  else if (tRecBlockNo == API_CLUSTERMGR)
+  {
+    /**
+     * The signal was aimed for the Cluster Manager. 
+     * We handle it immediately here.
+     */     
+    ClusterMgr * clusterMgr = theClusterMgr;
+    const Uint32 gsn = header->theVerId_signalNumber;
+    
+    switch (gsn){
+    case GSN_API_REGREQ:
+      clusterMgr->execAPI_REGREQ(theData);
+      break;
+      
+    case GSN_API_REGCONF:
+    {
+      clusterMgr->execAPI_REGCONF(theData);
+      
+      // Distribute signal to all threads/blocks
+      NdbApiSignal tSignal(* header);
+      tSignal.setDataPtr(theData);
+      for_each(&tSignal, ptr);
+      break;
+    }
+    
+    case GSN_API_REGREF:
+      clusterMgr->execAPI_REGREF(theData);
+      break;
+      
+    case GSN_NODE_FAILREP:
+      clusterMgr->execNODE_FAILREP(theData);
+      break;
+      
+    case GSN_NF_COMPLETEREP:
+      clusterMgr->execNF_COMPLETEREP(theData);
+      break;
+      
+    case GSN_ARBIT_STARTREQ:
+      if (theArbitMgr != NULL)
+        theArbitMgr->doStart(theData);
+      break;
+      
+    case GSN_ARBIT_CHOOSEREQ:
+      if (theArbitMgr != NULL)
+        theArbitMgr->doChoose(theData);
+      break;
+      
+    case GSN_ARBIT_STOPORD:
+      if(theArbitMgr != NULL)
+        theArbitMgr->doStop(theData);
+      break;
+      
+    case GSN_ALTER_TABLE_REP:
+    {
+      if (m_globalDictCache == NULL)
+        break;
+      const AlterTableRep* rep = (const AlterTableRep*)theData;
+      m_globalDictCache->lock();
+      m_globalDictCache->
+        alter_table_rep((const char*)ptr[0].p, 
+                        rep->tableId,
+                        rep->tableVersion,
+                        rep->changeType == AlterTableRep::CT_ALTERED);
+      m_globalDictCache->unlock();
+      break;
+    }
+    case GSN_SUB_GCP_COMPLETE_REP:
+    {
+      /**
+       * Report
+       */
+      NdbApiSignal tSignal(* header);
+      tSignal.setDataPtr(theData);
+      for_each(&tSignal, ptr);
+      
+      /**
+       * Reply
+       */
+      {
+        Uint32* send= tSignal.getDataPtrSend();
+        memcpy(send, theData, tSignal.getLength() << 2);
+        CAST_PTR(SubGcpCompleteAck, send)->rep.senderRef = 
+          numberToRef(API_CLUSTERMGR, theOwnId);
+        Uint32 ref= header->theSendersBlockRef;
+        Uint32 aNodeId= refToNode(ref);
+        tSignal.theReceiversBlockNumber= refToBlock(ref);
+        tSignal.theVerId_signalNumber= GSN_SUB_GCP_COMPLETE_ACK;
+        sendSignalUnCond(&tSignal, aNodeId);
       }
+      break;
+    }
+    case GSN_TAKE_OVERTCCONF:
+    {
+      /**
+       * Report
+       */
+      NdbApiSignal tSignal(* header);
+      tSignal.setDataPtr(theData);
+      for_each(&tSignal, ptr);
+      return;
+    }
+    default:
+      break;
+      
     }
     return;
-  } else if (tRecBlockNo == API_CLUSTERMGR) {
-     /**
-      * The signal was aimed for the Cluster Manager. 
-      * We handle it immediately here.
-      */     
-     ClusterMgr * clusterMgr = theClusterMgr;
-     const Uint32 gsn = header->theVerId_signalNumber;
-
-     switch (gsn){
-     case GSN_API_REGREQ:
-       clusterMgr->execAPI_REGREQ(theData);
-       break;
-
-     case GSN_API_REGCONF:
-     {
-       clusterMgr->execAPI_REGCONF(theData);
-
-       // Distribute signal to all threads/blocks
-       NdbApiSignal tSignal(* header);
-       tSignal.setDataPtr(theData);
-       for_each(&tSignal, ptr);
-       break;
-     }
-
-     case GSN_API_REGREF:
-       clusterMgr->execAPI_REGREF(theData);
-       break;
-
-     case GSN_NODE_FAILREP:
-       clusterMgr->execNODE_FAILREP(theData);
-       break;
-       
-     case GSN_NF_COMPLETEREP:
-       clusterMgr->execNF_COMPLETEREP(theData);
-       break;
-
-     case GSN_ARBIT_STARTREQ:
-       if (theArbitMgr != NULL)
-	 theArbitMgr->doStart(theData);
-       break;
-       
-     case GSN_ARBIT_CHOOSEREQ:
-       if (theArbitMgr != NULL)
-	 theArbitMgr->doChoose(theData);
-       break;
-       
-     case GSN_ARBIT_STOPORD:
-       if(theArbitMgr != NULL)
-	 theArbitMgr->doStop(theData);
-       break;
-
-     case GSN_ALTER_TABLE_REP:
-     {
-       if (m_globalDictCache == NULL)
-         break;
-       const AlterTableRep* rep = (const AlterTableRep*)theData;
-       m_globalDictCache->lock();
-       m_globalDictCache->
-	 alter_table_rep((const char*)ptr[0].p, 
-			 rep->tableId,
-			 rep->tableVersion,
-			 rep->changeType == AlterTableRep::CT_ALTERED);
-       m_globalDictCache->unlock();
-       break;
-     }
-     case GSN_SUB_GCP_COMPLETE_REP:
-     {
-       /**
-	* Report
-	*/
-       NdbApiSignal tSignal(* header);
-       tSignal.setDataPtr(theData);
-       for_each(&tSignal, ptr);
-
-       /**
-	* Reply
-	*/
-       {
-	 Uint32* send= tSignal.getDataPtrSend();
-	 memcpy(send, theData, tSignal.getLength() << 2);
-	 CAST_PTR(SubGcpCompleteAck, send)->rep.senderRef = 
-	   numberToRef(API_CLUSTERMGR, theOwnId);
-	 Uint32 ref= header->theSendersBlockRef;
-	 Uint32 aNodeId= refToNode(ref);
-	 tSignal.theReceiversBlockNumber= refToBlock(ref);
-	 tSignal.theVerId_signalNumber= GSN_SUB_GCP_COMPLETE_ACK;
-	 sendSignalUnCond(&tSignal, aNodeId);
-       }
-       break;
-     }
-     case GSN_TAKE_OVERTCCONF:
-     {
-       /**
-	* Report
-	*/
-       NdbApiSignal tSignal(* header);
-       tSignal.setDataPtr(theData);
-       for_each(&tSignal, ptr);
-       return;
-     }
-     default:
-       break;
-       
-     }
-     return;
-  } else if (tRecBlockNo >= MIN_API_FIXED_BLOCK_NO &&
-             tRecBlockNo <= MAX_API_FIXED_BLOCK_NO) {
+  }
+  else if (tRecBlockNo >= MIN_API_FIXED_BLOCK_NO &&
+           tRecBlockNo <= MAX_API_FIXED_BLOCK_NO) 
+  {
     Uint32 dynamic= m_fixed2dynamic[tRecBlockNo - MIN_API_FIXED_BLOCK_NO];
-    oe = m_threads.get(dynamic);
-    if (oe.m_object != 0 && oe.m_executeFunction != 0) {
+    trp_client * clnt = m_threads.get(dynamic);
+    if (clnt != 0)
+    {
       NdbApiSignal tmpSignal(*header);
       NdbApiSignal * tSignal = &tmpSignal;
       tSignal->setDataPtr(theData);
-      (* oe.m_executeFunction) (oe.m_object, tSignal, ptr);
+      clnt->trp_deliver_signal(tSignal, ptr);
     }//if   
-  } else {
-    ; // Ignore all other block numbers.
-    if(header->theVerId_signalNumber != GSN_API_REGREQ) {
+  }
+  else
+  {
+    // Ignore all other block numbers.
+    if(header->theVerId_signalNumber != GSN_API_REGREQ)
+    {
       TRP_DEBUG( "TransporterFacade received signal to unknown block no." );
       ndbout << "BLOCK NO: "  << tRecBlockNo << " sig " 
-	     << header->theVerId_signalNumber  << endl;
+             << header->theVerId_signalNumber  << endl;
       abort();
     }
   }
@@ -724,13 +739,9 @@ TransporterFacade::TransporterFacade(Glo
   theArbitMgr(NULL),
   checkCounter(4),
   currentSendLimit(1),
-  m_scan_batch_size(MAX_SCAN_BATCH_SIZE),
-  m_batch_byte_size(SCAN_BATCH_SIZE),
-  m_batch_size(DEF_BATCH_SIZE),
   theStopReceive(0),
   theSendThread(NULL),
   theReceiveThread(NULL),
-  m_max_trans_id(0),
   m_fragmented_signal_id(0),
   m_globalDictCache(cache)
 {
@@ -848,20 +859,6 @@ TransporterFacade::configure(NodeId node
     theArbitMgr= NULL;
   }
 
-  // Configure scan settings
-  Uint32 scan_batch_size= 0;
-  if (!iter.get(CFG_MAX_SCAN_BATCH_SIZE, &scan_batch_size)) {
-    m_scan_batch_size= scan_batch_size;
-  }
-  Uint32 batch_byte_size= 0;
-  if (!iter.get(CFG_BATCH_BYTE_SIZE, &batch_byte_size)) {
-    m_batch_byte_size= batch_byte_size;
-  }
-  Uint32 batch_size= 0;
-  if (!iter.get(CFG_BATCH_SIZE, &batch_size)) {
-    m_batch_size= batch_size;
-  }
-
   Uint32 auto_reconnect=1;
   iter.get(CFG_AUTO_RECONNECT, &auto_reconnect);
 
@@ -879,19 +876,6 @@ TransporterFacade::configure(NodeId node
     theClusterMgr->m_auto_reconnect = auto_reconnect;
   }
   
-  // Configure timeouts
-  Uint32 timeout = 120000;
-  for (iter.first(); iter.valid(); iter.next())
-  {
-    Uint32 tmp1 = 0, tmp2 = 0;
-    iter.get(CFG_DB_TRANSACTION_CHECK_INTERVAL, &tmp1);
-    iter.get(CFG_DB_TRANSACTION_DEADLOCK_TIMEOUT, &tmp2);
-    tmp1 += tmp2;
-    if (tmp1 > timeout)
-      timeout = tmp1;
-  }
-  m_waitfor_timeout = timeout;
-
 #ifdef API_TRACE
   signalLogger.logOn(true, 0, SignalLoggerManager::LogInOut);
 #endif
@@ -907,13 +891,12 @@ void
 TransporterFacade::for_each(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
 {
   Uint32 sz = m_threads.m_statusNext.size();
-  TransporterFacade::ThreadData::Object_Execute oe; 
   for (Uint32 i = 0; i < sz ; i ++) 
   {
-    oe = m_threads.m_objectExecute[i];
-    if (m_threads.getInUse(i))
+    trp_client * clnt = m_threads.m_objectExecute[i];
+    if (clnt != 0)
     {
-      (* oe.m_executeFunction) (oe.m_object, aSignal, ptr);
+      clnt->trp_deliver_signal(aSignal, ptr);
     }
   }
 }
@@ -923,11 +906,12 @@ TransporterFacade::connected()
 {
   DBUG_ENTER("TransporterFacade::connected");
   Uint32 sz = m_threads.m_statusNext.size();
-  for (Uint32 i = 0; i < sz ; i ++) {
-    if (m_threads.getInUse(i)){
-      void * obj = m_threads.m_objectExecute[i].m_object;
-      NodeStatusFunction RegPC = m_threads.m_statusFunction[i];
-      (*RegPC) (obj, numberToRef(indexToNumber(i), theOwnId), true, true);
+  for (Uint32 i = 0; i < sz ; i ++)
+  {
+    trp_client * clnt = m_threads.m_objectExecute[i];
+    if (clnt != 0)
+    {
+      clnt->trp_node_status(numberToRef(indexToNumber(i), theOwnId), true, true);
     }
   }
   DBUG_VOID_RETURN;
@@ -947,11 +931,12 @@ TransporterFacade::ReportNodeDead(NodeId
    * might not have noticed the failure.
    */
   Uint32 sz = m_threads.m_statusNext.size();
-  for (Uint32 i = 0; i < sz ; i ++) {
-    if (m_threads.getInUse(i)){
-      void * obj = m_threads.m_objectExecute[i].m_object;
-      NodeStatusFunction RegPC = m_threads.m_statusFunction[i];
-      (*RegPC) (obj, tNodeId, false, false);
+  for (Uint32 i = 0; i < sz ; i ++)
+  {
+    trp_client * clnt = m_threads.m_objectExecute[i];
+    if (clnt != 0)
+    {
+      clnt->trp_node_status(tNodeId, false, false);
     }
   }
   DBUG_VOID_RETURN;
@@ -972,11 +957,12 @@ TransporterFacade::ReportNodeFailureComp
   DBUG_ENTER("TransporterFacade::ReportNodeFailureComplete");
   DBUG_PRINT("enter",("nodeid= %d", tNodeId));
   Uint32 sz = m_threads.m_statusNext.size();
-  for (Uint32 i = 0; i < sz ; i ++) {
-    if (m_threads.getInUse(i)){
-      void * obj = m_threads.m_objectExecute[i].m_object;
-      NodeStatusFunction RegPC = m_threads.m_statusFunction[i];
-      (*RegPC) (obj, tNodeId, false, true);
+  for (Uint32 i = 0; i < sz ; i ++)
+  {
+    trp_client * clnt = m_threads.m_objectExecute[i];
+    if (clnt != 0)
+    {
+      clnt->trp_node_status(tNodeId, false, true);
     }
   }
   DBUG_VOID_RETURN;
@@ -995,21 +981,20 @@ TransporterFacade::ReportNodeAlive(NodeI
    * might not have noticed the failure.
    */
   Uint32 sz = m_threads.m_statusNext.size();
-  for (Uint32 i = 0; i < sz ; i ++) {
-    if (m_threads.getInUse(i)){
-      void * obj = m_threads.m_objectExecute[i].m_object;
-      NodeStatusFunction RegPC = m_threads.m_statusFunction[i];
-      (*RegPC) (obj, tNodeId, true, false);
+  for (Uint32 i = 0; i < sz ; i ++)
+  {
+    trp_client * clnt = m_threads.m_objectExecute[i];
+    if (clnt != 0)
+    {
+      clnt->trp_node_status(tNodeId, true, false);
     }
   }
 }
 
 int 
-TransporterFacade::close(BlockNumber blockNumber, Uint64 trans_id)
+TransporterFacade::close(BlockNumber blockNumber)
 {
   NdbMutex_Lock(theMutexPtr);
-  Uint32 low_bits = (Uint32)trans_id;
-  m_max_trans_id = m_max_trans_id > low_bits ? m_max_trans_id : low_bits;
   close_local(blockNumber);
   NdbMutex_Unlock(theMutexPtr);
   return 0;
@@ -1022,29 +1007,30 @@ TransporterFacade::close_local(BlockNumb
 }
 
 int
-TransporterFacade::open(void* objRef, 
-                        ExecuteFunction fun, 
-                        NodeStatusFunction statusFun,
-                        int blockNo)
+TransporterFacade::open(trp_client * clnt, int blockNo)
 {
   DBUG_ENTER("TransporterFacade::open");
-  int r= m_threads.open(objRef, fun, statusFun);
+  int r= m_threads.open(clnt);
   if (r < 0)
+  {
     DBUG_RETURN(r);
+  }
 
-  if (unlikely(blockNo != -1)){
+  if (unlikely(blockNo != -1))
+  {
     // Using fixed block number, add fixed->dymamic mapping
-    Uint32 fixed_index= blockNo - MIN_API_FIXED_BLOCK_NO;
-
+    Uint32 fixed_index = blockNo - MIN_API_FIXED_BLOCK_NO;
+    
     assert(blockNo >= MIN_API_FIXED_BLOCK_NO &&
            fixed_index <= NO_API_FIXED_BLOCKS);
-
+    
     m_fixed2dynamic[fixed_index]= r;
   }
 
 #if 1
-  if (theOwnId > 0) {
-    (*statusFun)(objRef, numberToRef(r, theOwnId), true, true);
+  if (theOwnId > 0)
+  {
+    clnt->trp_node_status(numberToRef(r, theOwnId), true, true);
   }
 #endif
   DBUG_RETURN(r);
@@ -1778,12 +1764,10 @@ TransporterFacade::ThreadData::ThreadDat
 
 void
 TransporterFacade::ThreadData::expand(Uint32 size){
-  Object_Execute oe = { 0 ,0 };
-  NodeStatusFunction fun = 0;
+  trp_client * oe = 0;
 
   const Uint32 sz = m_statusNext.size();
   m_objectExecute.fill(sz + size, oe);
-  m_statusFunction.fill(sz + size, fun);
   for(Uint32 i = 0; i<size; i++){
     m_statusNext.push_back(sz + i + 1);
   }
@@ -1794,9 +1778,7 @@ TransporterFacade::ThreadData::expand(Ui
 
 
 int
-TransporterFacade::ThreadData::open(void* objRef, 
-				    ExecuteFunction fun, 
-				    NodeStatusFunction fun2)
+TransporterFacade::ThreadData::open(trp_client * clnt)
 {
   Uint32 nextFree = m_firstFree;
 
@@ -1812,11 +1794,8 @@ TransporterFacade::ThreadData::open(void
   m_use_cnt++;
   m_firstFree = m_statusNext[nextFree];
 
-  Object_Execute oe = { objRef , fun };
-
   m_statusNext[nextFree] = INACTIVE;
-  m_objectExecute[nextFree] = oe;
-  m_statusFunction[nextFree] = fun2;
+  m_objectExecute[nextFree] = clnt;
 
   return indexToNumber(nextFree);
 }
@@ -1824,14 +1803,12 @@ TransporterFacade::ThreadData::open(void
 int
 TransporterFacade::ThreadData::close(int number){
   number= numberToIndex(number);
-  assert(getInUse(number));
+  assert(m_objectExecute[number] != 0);
   m_statusNext[number] = m_firstFree;
   assert(m_use_cnt);
   m_use_cnt--;
   m_firstFree = number;
-  Object_Execute oe = { 0, 0 };
-  m_objectExecute[number] = oe;
-  m_statusFunction[number] = 0;
+  m_objectExecute[number] = 0;
   return 0;
 }
 
@@ -2014,8 +1991,7 @@ void PollGuard::unlock_and_signal()
   m_locked=false;
 }
 
-template class Vector<NodeStatusFunction>;
-template class Vector<TransporterFacade::ThreadData::Object_Execute>;
+template class Vector<trp_client*>;
 
 #include "SignalSender.hpp"
 

=== modified file 'storage/ndb/src/ndbapi/TransporterFacade.hpp'
--- a/storage/ndb/src/ndbapi/TransporterFacade.hpp	2010-08-26 12:33:33 +0000
+++ b/storage/ndb/src/ndbapi/TransporterFacade.hpp	2010-10-01 07:38:17 +0000
@@ -35,14 +35,11 @@ struct ndb_mgm_configuration;
 class Ndb;
 class NdbApiSignal;
 class NdbWaiter;
-
-typedef void (* ExecuteFunction)(void *, NdbApiSignal *, LinearSectionPtr ptr[3]);
-typedef void (* NodeStatusFunction)(void *, Uint32, bool nodeAlive, bool nfComplete);
+class trp_client;
 
 extern "C" {
   void* runSendRequest_C(void*);
   void* runReceiveResponse_C(void*);
-  void atexit_stop_instance();
 }
 
 class TransporterFacade : public TransporterCallback
@@ -70,11 +67,10 @@ public:
    * @blockNo block number to use, -1 => any blockNumber
    * @return BlockNumber or -1 for failure
    */
-  int open(void* objRef, ExecuteFunction, NodeStatusFunction,
-           int blockNo = -1);
+  int open(trp_client*, int blockNo = -1);
   
   // Close this block number
-  int close(BlockNumber blockNumber, Uint64 trans_id);
+  int close(BlockNumber blockNumber);
   Uint32 get_active_ndb_objects() const;
 
   // Only sends to nodes which are alive
@@ -131,12 +127,6 @@ public:
   // Close this block number
   int close_local(BlockNumber blockNumber);
 
-  // Scan batch configuration parameters
-  Uint32 get_scan_batch_size();
-  Uint32 get_batch_byte_size();
-  Uint32 get_batch_size();
-  Uint32 m_waitfor_timeout; // in milli seconds...
-
   TransporterRegistry* get_registry() { return theTransporterRegistry;};
 
 /*
@@ -244,11 +234,6 @@ private:
   
   void calculateSendLimit();
 
-  // Scan batch configuration parameters
-  Uint32 m_scan_batch_size;
-  Uint32 m_batch_byte_size;
-  Uint32 m_batch_size;
-
   // Declarations for the receive and send thread
   int  theStopReceive;
 
@@ -259,7 +244,6 @@ private:
 
   friend void* runSendRequest_C(void*);
   friend void* runReceiveResponse_C(void*);
-  friend void atexit_stop_instance();
 
   bool do_connect_mgm(NodeId, const ndb_mgm_configuration*);
 
@@ -275,48 +259,26 @@ private:
     
     ThreadData(Uint32 initialSize = 32);
     
-    /**
-     * Split "object" into 3 list
-     *   This to improve locality
-     *   when iterating over lists
-     */
-    struct Object_Execute {
-      void * m_object;
-      ExecuteFunction m_executeFunction;
-    };
-    struct NodeStatus_NextFree {
-      NodeStatusFunction m_statusFunction;
-    };
-
     Uint32 m_use_cnt;
     Uint32 m_firstFree;
     Vector<Uint32> m_statusNext;
-    Vector<Object_Execute> m_objectExecute;
-    Vector<NodeStatusFunction> m_statusFunction;
+    Vector<trp_client*> m_objectExecute;
     
-    int open(void* objRef, ExecuteFunction, NodeStatusFunction);
+    int open(trp_client*);
     int close(int number);
     void expand(Uint32 size);
 
-    inline Object_Execute get(Uint16 blockNo) const {
+    inline trp_client* get(Uint16 blockNo) const {
       blockNo -= MIN_API_BLOCK_NO;
-      if(likely (blockNo < m_objectExecute.size())){
-	return m_objectExecute[blockNo];
+      if(likely (blockNo < m_objectExecute.size()))
+      {
+        return m_objectExecute.getBase()[blockNo];
       }
-      Object_Execute oe = { 0, 0 };
-      return oe;
-    }
-
-    /**
-     * Is the block number used currently
-     */
-    inline bool getInUse(Uint16 index) const {
-      return (m_statusNext[index] & (1 << 16)) != 0;
+      return 0;
     }
   } m_threads;
 
   Uint32 m_fixed2dynamic[NO_API_FIXED_BLOCKS];
-  Uint32 m_max_trans_id;
   Uint32 m_fragmented_signal_id;
 
 public:
@@ -360,6 +322,7 @@ TransporterFacade::unlock_mutex()
 }
 
 #include "ClusterMgr.hpp"
+#include "ndb_cluster_connection_impl.hpp"
 
 inline
 unsigned Ndb_cluster_connection_impl::get_connect_count() const
@@ -455,24 +418,6 @@ TransporterFacade::getMinDbNodeVersion()
     return 0;
 }
 
-inline
-Uint32
-TransporterFacade::get_scan_batch_size() {
-  return m_scan_batch_size;
-}
-
-inline
-Uint32
-TransporterFacade::get_batch_byte_size() {
-  return m_batch_byte_size;
-}
-
-inline
-Uint32
-TransporterFacade::get_batch_size() {
-  return m_batch_size;
-}
-
 /** 
  * LinearSectionIterator
  *

=== modified file 'storage/ndb/src/ndbapi/ndb_cluster_connection.cpp'
--- a/storage/ndb/src/ndbapi/ndb_cluster_connection.cpp	2010-05-04 14:34:54 +0000
+++ b/storage/ndb/src/ndbapi/ndb_cluster_connection.cpp	2010-09-30 11:52:49 +0000
@@ -23,7 +23,7 @@
 #include "ndb_cluster_connection_impl.hpp"
 #include <mgmapi_configuration.hpp>
 #include <mgmapi_config_parameters.h>
-#include <TransporterFacade.hpp>
+#include "TransporterFacade.hpp"
 #include <NdbOut.hpp>
 #include <NdbSleep.h>
 #include <NdbThread.h>
@@ -33,6 +33,8 @@
 #include <mgmapi_debug.h>
 #include <mgmapi_internal.h>
 #include <md5_hash.hpp>
+#include "NdbImpl.hpp"
+#include "NdbDictionaryImpl.hpp"
 
 #include <NdbMutex.h>
 #ifdef VM_TRACE
@@ -302,7 +304,8 @@ Ndb_cluster_connection_impl(const char *
     m_latest_trans_gci(0),
     m_first_ndb_object(0),
     m_latest_error_msg(),
-    m_latest_error(0)
+    m_latest_error(0),
+    m_max_trans_id(0)
 {
   DBUG_ENTER("Ndb_cluster_connection");
   DBUG_PRINT("enter",("Ndb_cluster_connection this=0x%lx", (long) this));
@@ -453,6 +456,7 @@ Ndb_cluster_connection_impl::link_ndb_ob
   p->theImpl->m_next_ndb_object = m_first_ndb_object;
   m_first_ndb_object = p;
   
+  p->theFirstTransId += m_max_trans_id;
   unlock_ndb_objects();
 }
 
@@ -481,6 +485,12 @@ Ndb_cluster_connection_impl::unlink_ndb_
   p->theImpl->m_prev_ndb_object = 0;
   p->theImpl->m_next_ndb_object = 0;
 
+  Uint32 transId = (Uint32)p->theFirstTransId;
+  if (transId > m_max_trans_id)
+  {
+    m_max_trans_id = transId;
+  }
+
   unlock_ndb_objects();  
 }
 
@@ -590,6 +600,46 @@ Ndb_cluster_connection_impl::init_nodes_
   DBUG_RETURN(0);
 }
 
+int
+Ndb_cluster_connection_impl::configure(Uint32 nodeId,
+                                       const ndb_mgm_configuration &config)
+{
+  DBUG_ENTER("Ndb_cluster_connection_impl::configure");
+  {
+    ndb_mgm_configuration_iterator iter(config, CFG_SECTION_NODE);
+    if(iter.find(CFG_NODE_ID, nodeId))
+      DBUG_RETURN(-1);
+
+    // Configure scan settings
+    Uint32 scan_batch_size= 0;
+    if (!iter.get(CFG_MAX_SCAN_BATCH_SIZE, &scan_batch_size)) {
+      m_config.m_scan_batch_size= scan_batch_size;
+    }
+    Uint32 batch_byte_size= 0;
+    if (!iter.get(CFG_BATCH_BYTE_SIZE, &batch_byte_size)) {
+      m_config.m_batch_byte_size= batch_byte_size;
+    }
+    Uint32 batch_size= 0;
+    if (!iter.get(CFG_BATCH_SIZE, &batch_size)) {
+      m_config.m_batch_size= batch_size;
+    }
+
+    // Configure timeouts
+    Uint32 timeout = 120000;
+    for (iter.first(); iter.valid(); iter.next())
+    {
+      Uint32 tmp1 = 0, tmp2 = 0;
+      iter.get(CFG_DB_TRANSACTION_CHECK_INTERVAL, &tmp1);
+      iter.get(CFG_DB_TRANSACTION_DEADLOCK_TIMEOUT, &tmp2);
+      tmp1 += tmp2;
+      if (tmp1 > timeout)
+        timeout = tmp1;
+    }
+    m_config.m_waitfor_timeout = timeout;
+  }
+  DBUG_RETURN(init_nodes_vector(nodeId, config));
+}
+
 void
 Ndb_cluster_connection_impl::do_test()
 {
@@ -684,16 +734,16 @@ int Ndb_cluster_connection_impl::connect
     if(props == 0)
       break;
 
-    if (m_transporter_facade->start_instance(nodeId, props) < 0)
+    if (configure(nodeId, *props))
     {
       ndb_mgm_destroy_configuration(props);
+      DBUG_PRINT("exit", ("malloc failure, ret: -1"));
       DBUG_RETURN(-1);
     }
 
-    if (init_nodes_vector(nodeId, *props))
+    if (m_transporter_facade->start_instance(nodeId, props) < 0)
     {
       ndb_mgm_destroy_configuration(props);
-      DBUG_PRINT("exit", ("malloc failure, ret: -1"));
       DBUG_RETURN(-1);
     }
 

=== modified file 'storage/ndb/src/ndbapi/ndb_cluster_connection_impl.hpp'
--- a/storage/ndb/src/ndbapi/ndb_cluster_connection_impl.hpp	2010-05-04 14:34:54 +0000
+++ b/storage/ndb/src/ndbapi/ndb_cluster_connection_impl.hpp	2010-09-30 11:52:49 +0000
@@ -37,6 +37,21 @@ extern "C" {
   void* run_ndb_cluster_connection_connect_thread(void*);
 }
 
+struct NdbApiConfig
+{
+  NdbApiConfig() :
+    m_scan_batch_size(MAX_SCAN_BATCH_SIZE),
+    m_batch_byte_size(SCAN_BATCH_SIZE),
+    m_batch_size(DEF_BATCH_SIZE),
+    m_waitfor_timeout(120000)
+    {}
+
+  Uint32 m_scan_batch_size;
+  Uint32 m_batch_byte_size;
+  Uint32 m_batch_size;
+  Uint32 m_waitfor_timeout; // in milli seconds...
+};
+
 class Ndb_cluster_connection_impl : public Ndb_cluster_connection
 {
   Ndb_cluster_connection_impl(const char *connectstring,
@@ -75,6 +90,7 @@ private:
 
   Vector<Node> m_all_nodes;
   int init_nodes_vector(Uint32 nodeid, const ndb_mgm_configuration &config);
+  int configure(Uint32 nodeid, const ndb_mgm_configuration &config);
   void connect_thread();
   void set_name(const char *name);
 
@@ -101,6 +117,12 @@ private:
 
   BaseString m_latest_error_msg;
   unsigned m_latest_error;
+
+  // Scan batch configuration parameters
+  NdbApiConfig m_config;
+  
+  // keep initial transId's increasing...
+  Uint32 m_max_trans_id;
 };
 
 #endif

=== added file 'storage/ndb/src/ndbapi/ndb_internal.cpp'
--- a/storage/ndb/src/ndbapi/ndb_internal.cpp	1970-01-01 00:00:00 +0000
+++ b/storage/ndb/src/ndbapi/ndb_internal.cpp	2010-09-30 09:32:28 +0000
@@ -0,0 +1,34 @@
+/*
+   Copyright (C) 2007 MySQL AB
+    All rights reserved. Use is subject to license terms.
+
+   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; version 2 of the License.
+
+   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+
+#include "API.hpp"
+#include "ndb_internal.hpp"
+
+int
+Ndb_internal::send_event_report(bool has_lock, 
+                                Ndb *ndb, Uint32 *data, Uint32 length)
+{
+  return ndb->theImpl->send_event_report(has_lock, data, length);
+}
+
+void
+Ndb_internal::setForceShortRequests(Ndb* ndb, bool val)
+{
+  ndb->theImpl->forceShortRequests = val;
+}
+                                    

=== modified file 'storage/ndb/src/ndbapi/ndb_internal.hpp'
--- a/storage/ndb/src/ndbapi/ndb_internal.hpp	2009-06-22 08:23:35 +0000
+++ b/storage/ndb/src/ndbapi/ndb_internal.hpp	2010-09-30 12:52:55 +0000
@@ -16,15 +16,20 @@
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 */
 
-#include "NdbImpl.hpp"
+#ifndef NDB_INTERNAL_HPP
+#define NDB_INTERNAL_HPP
 
+/**
+ * This class exposes non-public funcionality to various test/utility programs
+ */
 class Ndb_internal
 {
-private:
-  friend class NdbEventBuffer;
-  friend class BackupRestore;
+public:
   Ndb_internal() {}
   virtual ~Ndb_internal() {}
-  static int send_event_report(bool has_lock, Ndb *ndb, Uint32 *data, Uint32 length)
-    { return ndb->theImpl->send_event_report(has_lock, data, length); }
+
+  static int send_event_report(bool has_lock, Ndb *ndb, Uint32*data,Uint32 len);
+  static void setForceShortRequests(Ndb*, bool val);
 };
+
+#endif

=== added file 'storage/ndb/src/ndbapi/trp_client.hpp'
--- a/storage/ndb/src/ndbapi/trp_client.hpp	1970-01-01 00:00:00 +0000
+++ b/storage/ndb/src/ndbapi/trp_client.hpp	2010-10-01 07:44:39 +0000
@@ -0,0 +1,37 @@
+/*
+   Copyright (C) 2003 MySQL AB
+    All rights reserved. Use is subject to license terms.
+
+   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; version 2 of the License.
+
+   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+
+#ifndef trp_client_hpp
+#define trp_client_hpp
+
+#include <ndb_global.h>
+
+class NdbApiSignal;
+struct LinearSectionPtr;
+
+class trp_client
+{
+public:
+  virtual ~trp_client() {}
+
+  virtual void trp_deliver_signal(const NdbApiSignal *,
+                                  const LinearSectionPtr ptr[3]) = 0;
+  virtual void trp_node_status(Uint32, bool nodeAlive, bool nfComplete) = 0;
+};
+
+#endif

=== modified file 'storage/ndb/test/include/NdbRestarter.hpp'
--- a/storage/ndb/test/include/NdbRestarter.hpp	2010-09-20 13:09:18 +0000
+++ b/storage/ndb/test/include/NdbRestarter.hpp	2010-09-29 08:45:11 +0000
@@ -33,29 +33,34 @@ public:
   enum RestartFlags {
     NRRF_INITIAL = 0x1,
     NRRF_NOSTART = 0x2,
-    NRRF_ABORT   = 0x4
+    NRRF_ABORT   = 0x4,
+    NRRF_FORCE   = 0x8
   };
 
   int restartOneDbNode(int _nodeId, 
 		       bool initial = false, 
 		       bool nostart = false, 
-		       bool abort = false);
+		       bool abort = false,
+                       bool force = false);
 
   int restartOneDbNode2(int _nodeId, Uint32 flags){
     return restartOneDbNode(_nodeId,
                             flags & NRRF_INITIAL,
                             flags & NRRF_NOSTART,
-                            flags & NRRF_ABORT);
+                            flags & NRRF_ABORT,
+                            flags & NRRF_FORCE);
   }
 
   int restartAll(bool initial = false, 
 		 bool nostart = false, 
-		 bool abort = false);
+		 bool abort = false,
+                 bool force = false);
   
   int restartAll2(Uint32 flags){
     return restartAll(flags & NRRF_INITIAL,
                       flags & NRRF_NOSTART,
-                      flags & NRRF_ABORT);
+                      flags & NRRF_ABORT,
+                      flags & NRRF_FORCE);
   }
 
   int restartNodes(int * nodes, int num_nodes, Uint32 flags);

=== modified file 'storage/ndb/test/ndbapi/testDict.cpp'
--- a/storage/ndb/test/ndbapi/testDict.cpp	2010-08-26 12:33:33 +0000
+++ b/storage/ndb/test/ndbapi/testDict.cpp	2010-09-30 14:27:18 +0000
@@ -7749,8 +7749,10 @@ runBug46585(NDBT_Context* ctx, NDBT_Step
     CHECK2(res.waitClusterStarted() == 0,
            "wait cluster started failed");
 
-    int restartGCI = pNdb->NdbTamper(Ndb::ReadRestartGCI, 0);
-    ndbout_c("restartGCI: %d", restartGCI);
+    Uint32 restartGCI = 0;
+    CHECK2(pDic->getRestartGCI(&restartGCI) == 0,
+           "getRestartGCI failed");
+    ndbout_c("restartGCI: %u", restartGCI);
 
     pDic->invalidateTable(tab.getName());
     {

=== modified file 'storage/ndb/test/ndbapi/testIndex.cpp'
--- a/storage/ndb/test/ndbapi/testIndex.cpp	2010-03-19 14:15:57 +0000
+++ b/storage/ndb/test/ndbapi/testIndex.cpp	2010-09-24 18:19:07 +0000
@@ -24,6 +24,9 @@
 #include <NdbRestarts.hpp>
 #include <Vector.hpp>
 #include <signaldata/DumpStateOrd.hpp>
+#include <NodeBitmask.hpp>
+#include <NdbSqlUtil.hpp>
+#include <BlockNumbers.h>
 
 #define CHECK(b) if (!(b)) { \
   g_err << "ERR: "<< step->getName() \
@@ -2473,6 +2476,250 @@ runClearError(NDBT_Context* ctx, NDBT_St
   return NDBT_OK;
 }
 
+// bug#56829
+
+#undef CHECK2 // previous no good
+#define CHECK2(b, e) \
+  if (!(b)) { \
+    g_err << "ERR: " << #b << " failed at line " << __LINE__ \
+          << ": " << e << endl; \
+    result = NDBT_FAILED; \
+    break; \
+  }
+
+static int
+get_data_memory_pages(NdbMgmHandle h, NdbNodeBitmask dbmask, int* pages_out)
+{
+  int result = NDBT_OK;
+  int pages = 0;
+
+  while (1)
+  {
+    // sends dump 1000 and retrieves all replies
+    ndb_mgm_events* e = 0;
+    CHECK2((e = ndb_mgm_dump_events(h, NDB_LE_MemoryUsage, 0, 0)) != 0, ndb_mgm_get_latest_error_msg(h));
+
+    // sum up pages (also verify sanity)
+    for (int i = 0; i < e->no_of_events; i++)
+    {
+      ndb_logevent* le = &e->events[i];
+      CHECK2(le->type == NDB_LE_MemoryUsage, "bad event type " << le->type);
+      const ndb_logevent_MemoryUsage* lem = &le->MemoryUsage;
+      if (lem->block != DBTUP)
+        continue;
+      int nodeId = le->source_nodeid;
+      CHECK2(dbmask.get(nodeId), "duplicate event from node " << nodeId);
+      dbmask.clear(nodeId);
+      pages += lem->pages_used;
+      g_info << "i:" << i << " node:" << le->source_nodeid << " pages:" << lem->pages_used << endl;
+    }
+    free(e);
+    CHECK2(result == NDBT_OK, "failed");
+
+    char buf[NdbNodeBitmask::TextLength + 1];
+    CHECK2(dbmask.isclear(), "no response from nodes " << dbmask.getText(buf));
+    break;
+  }
+
+  *pages_out = pages;
+  return result;
+}
+
+int
+runBug56829(NDBT_Context* ctx, NDBT_Step* step)
+{
+  Ndb* pNdb = GETNDB(step);
+  NdbDictionary::Dictionary* pDic = pNdb->getDictionary();
+  const int loops = ctx->getNumLoops();
+  int result = NDBT_OK;
+  const NdbDictionary::Table tab(*ctx->getTab());
+  const int rows = ctx->getNumRecords();
+  const char* mgm = 0;//XXX ctx->getRemoteMgm();
+
+  char tabname[100];
+  strcpy(tabname, tab.getName());
+  char indname[100];
+  strcpy(indname, tabname);
+  strcat(indname, "X1");
+
+  (void)pDic->dropTable(tabname);
+
+  NdbMgmHandle h = 0;
+  NdbNodeBitmask dbmask;
+  // entry n marks if row with PK n exists
+  char* rowmask = new char [rows];
+  memset(rowmask, 0, rows);
+  int loop = 0;
+  while (loop < loops)
+  {
+    CHECK2(rows > 0, "rows must be != 0");
+    g_info << "loop " << loop << "<" << loops << endl;
+
+    // at first loop connect to mgm
+    if (loop == 0)
+    {
+      CHECK2((h = ndb_mgm_create_handle()) != 0, "mgm: failed to create handle");
+      CHECK2(ndb_mgm_set_connectstring(h, mgm) == 0, ndb_mgm_get_latest_error_msg(h));
+      CHECK2(ndb_mgm_connect(h, 0, 0, 0) == 0, ndb_mgm_get_latest_error_msg(h));
+      g_info << "mgm: connected to " << (mgm ? mgm : "default") << endl;
+
+      // make bitmask of DB nodes
+      dbmask.clear();
+      ndb_mgm_cluster_state* cs = 0;
+      CHECK2((cs = ndb_mgm_get_status(h)) != 0, ndb_mgm_get_latest_error_msg(h));
+      for (int j = 0; j < cs->no_of_nodes; j++)
+      {
+        ndb_mgm_node_state* ns = &cs->node_states[j];
+        if (ns->node_type == NDB_MGM_NODE_TYPE_NDB)
+        {
+          CHECK2(ns->node_status == NDB_MGM_NODE_STATUS_STARTED, "node " << ns->node_id << " not started status " << ns->node_status);
+          CHECK2(!dbmask.get(ns->node_id), "duplicate node id " << ns->node_id);
+          dbmask.set(ns->node_id);
+          g_info << "added DB node " << ns->node_id << endl;
+        }
+      }
+      free(cs);
+      CHECK2(result == NDBT_OK, "some DB nodes are not started");
+      CHECK2(!dbmask.isclear(), "found no DB nodes");
+    }
+
+    // data memory pages after following events
+    // 0-initial 1,2-create table,index 3-load 4-delete 5,6-drop index,table
+    int pages[7];
+
+    // initial
+    CHECK2(get_data_memory_pages(h, dbmask, &pages[0]) == NDBT_OK, "failed");
+    g_info << "initial pages " << pages[0] << endl;
+
+    // create table
+    g_info << "create table " << tabname << endl;
+    const NdbDictionary::Table* pTab = 0;
+    CHECK2(pDic->createTable(tab) == 0, pDic->getNdbError());
+    CHECK2((pTab = pDic->getTable(tabname)) != 0, pDic->getNdbError());
+    CHECK2(get_data_memory_pages(h, dbmask, &pages[1]) == NDBT_OK, "failed");
+    g_info << "create table pages " << pages[1] << endl;
+
+    // choice of index attributes is not relevant to this bug
+    // choose one non-PK updateable column
+    NdbDictionary::Index ind;
+    ind.setName(indname);
+    ind.setTable(tabname);
+    ind.setType(NdbDictionary::Index::OrderedIndex);
+    ind.setLogging(false);
+    {
+      HugoCalculator calc(*pTab);
+      for (int j = 0; j < pTab->getNoOfColumns(); j++)
+      {
+        const NdbDictionary::Column* col = pTab->getColumn(j);
+        if (col->getPrimaryKey() || calc.isUpdateCol(j))
+          continue;
+        CHARSET_INFO* cs = col->getCharset();
+        if (NdbSqlUtil::check_column_for_ordered_index(col->getType(), col->getCharset()) == 0)
+        {
+          ind.addColumn(*col);
+          break;
+        }
+      }
+    }
+    CHECK2(ind.getNoOfColumns() == 1, "cannot use table " << tabname);
+
+    // create index
+    g_info << "create index " << indname << " on " << ind.getColumn(0)->getName() << endl;
+    const NdbDictionary::Index* pInd = 0;
+    CHECK2(pDic->createIndex(ind, *pTab) == 0, pDic->getNdbError());
+    CHECK2((pInd = pDic->getIndex(indname, tabname)) != 0, pDic->getNdbError());
+    CHECK2(get_data_memory_pages(h, dbmask, &pages[2]) == NDBT_OK, "failed");
+    g_info << "create index pages " << pages[2] << endl;
+
+    HugoTransactions trans(*pTab);
+
+    // load all records
+    g_info << "load records" << endl;
+    CHECK2(trans.loadTable(pNdb, rows) == 0, trans.getNdbError());
+    memset(rowmask, 1, rows);
+    CHECK2(get_data_memory_pages(h, dbmask, &pages[3]) == NDBT_OK, "failed");
+    g_info << "load records pages " << pages[3] << endl;
+
+    // test index with random ops
+    g_info << "test index ops" << endl;
+    {
+      HugoOperations ops(*pTab);
+      for (int i = 0; i < rows; i++)
+      {
+        CHECK2(ops.startTransaction(pNdb) == 0, ops.getNdbError());
+        for (int j = 0; j < 32; j++)
+        {
+          int n = rand() % rows;
+          if (!rowmask[n])
+          {
+            CHECK2(ops.pkInsertRecord(pNdb, n) == 0, ops.getNdbError());
+            rowmask[n] = 1;
+          }
+          else if (rand() % 2 == 0)
+          {
+            CHECK2(ops.pkDeleteRecord(pNdb, n) == 0, ops.getNdbError());
+            rowmask[n] = 0;
+          }
+          else
+          {
+            CHECK2(ops.pkUpdateRecord(pNdb, n) == 0, ops.getNdbError());
+          }
+        }
+        CHECK2(result == NDBT_OK, "index ops batch failed");
+        CHECK2(ops.execute_Commit(pNdb) == 0, ops.getNdbError());
+        ops.closeTransaction(pNdb);
+      }
+      CHECK2(result == NDBT_OK, "index ops failed");
+    }
+
+    // delete all records
+    g_info << "delete records" << endl;
+    CHECK2(trans.clearTable(pNdb) == 0, trans.getNdbError());
+    memset(rowmask, 0, rows);
+    CHECK2(get_data_memory_pages(h, dbmask, &pages[4]) == NDBT_OK, "failed");
+    g_info << "delete records pages " << pages[4] << endl;
+
+    // drop index
+    g_info << "drop index" <<  endl;
+    CHECK2(pDic->dropIndex(indname, tabname) == 0, pDic->getNdbError());
+    CHECK2(get_data_memory_pages(h, dbmask, &pages[5]) == NDBT_OK, "failed");
+    g_info << "drop index pages " << pages[5] << endl;
+
+    // drop table
+    g_info << "drop table" << endl;
+    CHECK2(pDic->dropTable(tabname) == 0, pDic->getNdbError());
+    CHECK2(get_data_memory_pages(h, dbmask, &pages[6]) == NDBT_OK, "failed");
+    g_info << "drop table pages " << pages[6] << endl;
+
+    // verify
+    CHECK2(pages[1] == pages[0], "pages after create table " << pages[1]
+                                  << " not == initial pages " << pages[0]);
+    CHECK2(pages[2] == pages[0], "pages after create index " << pages[2]
+                                  << " not == initial pages " << pages[0]);
+    CHECK2(pages[3] >  pages[0], "pages after load " << pages[3]
+                                  << " not >  initial pages " << pages[0]);
+    CHECK2(pages[4] == pages[0], "pages after delete " << pages[4]
+                                  << " not == initial pages " << pages[0]);
+    CHECK2(pages[5] == pages[0], "pages after drop index " << pages[5]
+                                  << " not == initial pages " << pages[0]);
+    CHECK2(pages[6] == pages[0], "pages after drop table " << pages[6]
+                                  << " not == initial pages " << pages[0]);
+
+    loop++;
+
+    // at last loop disconnect from mgm
+    if (loop == loops)
+    {
+      CHECK2(ndb_mgm_disconnect(h) == 0, ndb_mgm_get_latest_error_msg(h));
+      ndb_mgm_destroy_handle(&h);
+      g_info << "mgm: disconnected" << endl;
+    }
+  }
+  delete [] rowmask;
+
+  return result;
+}
+
 
 NDBT_TESTSUITE(testIndex);
 TESTCASE("CreateAll", 
@@ -2874,6 +3121,11 @@ TESTCASE("FireTrigOverload", ""){
   FINALIZER(runClearError);
   FINALIZER(createRandomIndex_Drop);
 }
+TESTCASE("Bug56829",
+         "Return empty ordered index nodes to index fragment "
+         "so that empty fragment pages can be freed"){
+  STEP(runBug56829);
+}
   
 NDBT_TESTSUITE_END(testIndex);
 

=== modified file 'storage/ndb/test/ndbapi/testNdbinfo.cpp'
--- a/storage/ndb/test/ndbapi/testNdbinfo.cpp	2010-01-26 14:02:23 +0000
+++ b/storage/ndb/test/ndbapi/testNdbinfo.cpp	2010-09-29 10:40:31 +0000
@@ -534,6 +534,15 @@ int runRestarter(NDBT_Context* ctx, NDBT
 
 
 NDBT_TESTSUITE(testNdbinfo);
+#ifndef NDB_WIN
+/**
+ * TODO NdbRestarter does not work on windoze
+ */
+TESTCASE("NodeRestart", "Scan NdbInfo tables while restarting nodes"){
+  STEP(runRestarter);
+  STEPS(runTestTableUntilStopped, 1);
+}
+#endif
 TESTCASE("Ndbinfo",
          "Test ndbapi interface to NDB$INFO"){
   INITIALIZER(runTestNdbInfo);
@@ -566,15 +575,6 @@ TESTCASE("TestTable",
           "of rows which will depend on how many TUP blocks are configured"){
   STEP(runTestTable);
 }
-#ifndef NDB_WIN
-/**
- * TODO NdbRestarter does not work on windoze
- */
-TESTCASE("NodeRestart", "Scan NdbInfo tables while restarting nodes"){
-  STEP(runRestarter);
-  STEPS(runTestTableUntilStopped, 1);
-}
-#endif
 NDBT_TESTSUITE_END(testNdbinfo);
 
 

=== modified file 'storage/ndb/test/ndbapi/testNodeRestart.cpp'
--- a/storage/ndb/test/ndbapi/testNodeRestart.cpp	2010-08-17 10:11:01 +0000
+++ b/storage/ndb/test/ndbapi/testNodeRestart.cpp	2010-09-29 08:45:11 +0000
@@ -3976,6 +3976,95 @@ runBug56044(NDBT_Context* ctx, NDBT_Step
   return NDBT_OK;
 }
 
+int
+runForceStopAndRestart(NDBT_Context* ctx, NDBT_Step* step)
+{
+  NdbRestarter res;
+  if (res.getNumDbNodes() < 2)
+    return NDBT_OK;
+
+  Vector<int> group1;
+  Vector<int> group2;
+  Bitmask<256/32> nodeGroupMap;
+  for (int j = 0; j<res.getNumDbNodes(); j++)
+  {
+    int node = res.getDbNodeId(j);
+    int ng = res.getNodeGroup(node);
+    if (nodeGroupMap.get(ng))
+    {
+      group2.push_back(node);
+    }
+    else
+    {
+      group1.push_back(node);
+      nodeGroupMap.set(ng);
+    }
+  }
+
+  // Stop half of the cluster
+  res.restartNodes(group1.getBase(), (int)group1.size(),
+                   NdbRestarter::NRRF_NOSTART);
+  res.waitNodesNoStart(group1.getBase(), (int)group1.size());
+
+  // Try to stop first node in second half without force, should return error
+  if (res.restartOneDbNode(group2[0],
+                           false, /* initial */
+                           true,  /* nostart  */
+                           false, /* abort */
+                           false  /* force */) != -1)
+  {
+    g_err << "Restart suceeded without force" << endl;
+    return NDBT_FAILED;
+  }
+
+  // Now stop with force
+  if (res.restartOneDbNode(group2[0],
+                           false, /* initial */
+                           true,  /* nostart  */
+                           false, /* abort */
+                           true   /* force */) != 0)
+  {
+    g_err << "Could not restart with force" << endl;
+    return NDBT_FAILED;
+  }
+
+  // All nodes should now be in nostart, the above stop force
+  // cvaused the remainig nodes to be stopped(and restarted nostart)
+  res.waitClusterNoStart();
+
+  // Start second half back up again
+  res.startNodes(group2.getBase(), (int)group2.size());
+  res.waitNodesStarted(group2.getBase(), (int)group2.size());
+
+  // Try to stop remaining half without force, should return error
+  if (res.restartNodes(group2.getBase(), (int)group2.size(),
+                       NdbRestarter::NRRF_NOSTART) != -1)
+  {
+    g_err << "Restart suceeded without force" << endl;
+    return NDBT_FAILED;
+  }
+
+  // Now stop with force
+  if (res.restartNodes(group2.getBase(), (int)group2.size(),
+                       NdbRestarter::NRRF_NOSTART |
+                       NdbRestarter::NRRF_FORCE) != 0)
+  {
+    g_err << "Could not restart with force" << endl;
+    return NDBT_FAILED;
+  }
+  if (res.waitNodesNoStart(group2.getBase(), (int)group2.size()))
+  {
+    g_err << "Failed to waitNodesNoStart" << endl;
+    return NDBT_FAILED;
+  }
+
+  // Start all nodes again
+  res.startAll();
+  res.waitClusterStarted();
+
+  return NDBT_OK;
+}
+
 NDBT_TESTSUITE(testNodeRestart);
 TESTCASE("NoLoad", 
 	 "Test that one node at a time can be stopped and then restarted "\
@@ -4494,6 +4583,10 @@ TESTCASE("Bug56044", "")
 {
   INITIALIZER(runBug56044);
 }
+TESTCASE("ForceStopAndRestart", "Test restart and stop -with force flag")
+{
+  STEP(runForceStopAndRestart);
+}
 NDBT_TESTSUITE_END(testNodeRestart);
 
 int main(int argc, const char** argv){

=== modified file 'storage/ndb/test/ndbapi/testRestartGci.cpp'
--- a/storage/ndb/test/ndbapi/testRestartGci.cpp	2010-09-15 09:43:39 +0000
+++ b/storage/ndb/test/ndbapi/testRestartGci.cpp	2010-09-30 15:26:18 +0000
@@ -132,7 +132,14 @@ int runVerifyInserts(NDBT_Context* ctx,
   HugoOperations hugoOps(*ctx->getTab());
   NdbRestarter restarter;
 
-  int restartGCI = pNdb->NdbTamper(Ndb::ReadRestartGCI, 0);    
+  Uint32 restartGCI;
+  int res = pNdb->getDictionary()->getRestartGCI(&restartGCI);
+  if (res != 0)
+  {
+    ndbout << "Failed to retreive restart gci" << endl;
+    ndbout << pNdb->getDictionary()->getNdbError() << endl;
+    return NDBT_FAILED;
+  }
 
   ndbout << "restartGCI = " << restartGCI << endl;
   int count = 0;
@@ -145,7 +152,7 @@ int runVerifyInserts(NDBT_Context* ctx,
   int recordsWithLowerOrSameGci = 0;
   unsigned i; 
   for (i = 0; i < savedRecords.size(); i++){
-    if (savedRecords[i].m_gci <= restartGCI)
+    if (savedRecords[i].m_gci <= (int)restartGCI)
       recordsWithLowerOrSameGci++;
   }
   if (recordsWithLowerOrSameGci != count){
@@ -173,7 +180,7 @@ int runVerifyInserts(NDBT_Context* ctx,
       // Record was not found in db'
 
       // Check record gci
-      if (savedRecords[i].m_gci <= restartGCI){
+      if (savedRecords[i].m_gci <= (int)restartGCI){
 	ndbout << "ERR: Record "<<i<<" should have existed" << endl;
 	result = NDBT_FAILED;
       }
@@ -194,7 +201,7 @@ int runVerifyInserts(NDBT_Context* ctx,
 	result = NDBT_FAILED;
       }
       // Check record gci in range
-      if (savedRecords[i].m_gci > restartGCI){
+      if (savedRecords[i].m_gci > (int)restartGCI){
 	ndbout << "ERR: Record "<<i<<" should not have existed" << endl;
 	result = NDBT_FAILED;
       }

=== modified file 'storage/ndb/test/run-test/daily-basic-tests.txt'
--- a/storage/ndb/test/run-test/daily-basic-tests.txt	2010-09-23 06:22:44 +0000
+++ b/storage/ndb/test/run-test/daily-basic-tests.txt	2010-09-29 08:54:47 +0000
@@ -1593,3 +1593,12 @@ max-time: 500
 cmd: testDict
 args: -n Bug53944 T1
 
+max-time: 300
+cmd: testIndex
+args: -n Bug56829 T1
+
+max-time: 500
+cmd testNodeRestart
+args: -n ForceStopAndRestart T1
+
+

=== modified file 'storage/ndb/test/src/NDBT_Test.cpp'
--- a/storage/ndb/test/src/NDBT_Test.cpp	2010-08-16 17:02:58 +0000
+++ b/storage/ndb/test/src/NDBT_Test.cpp	2010-09-30 09:32:28 +0000
@@ -260,7 +260,7 @@ NDBT_Step::NDBT_Step(NDBT_TestCase* ptes
 {
 }
 
-#include <../../src/ndbapi/NdbImpl.hpp>
+#include "../../src/ndbapi/ndb_internal.hpp"
 
 int
 NDBT_Step::setUp(Ndb_cluster_connection& con){
@@ -275,8 +275,8 @@ NDBT_Step::setUp(Ndb_cluster_connection&
     m_ndb = new Ndb(&con, "TEST_DB" );
     m_ndb->init(1024);
 
-    NdbImpl::setForceShortRequests(m_ndb, 
-                                   m_ctx->suite->getForceShort());
+    Ndb_internal::setForceShortRequests(m_ndb, 
+                                        m_ctx->suite->getForceShort());
 
     int result = m_ndb->waitUntilReady(300); // 5 minutes
     if (result != 0){
@@ -931,7 +931,7 @@ NDBT_TestSuite::executeOneCtx(Ndb_cluste
     Ndb ndb(&con, "TEST_DB");
     ndb.init(1024);
 
-    NdbImpl::setForceShortRequests(&ndb, m_forceShort);
+    Ndb_internal::setForceShortRequests(&ndb, m_forceShort);
 
     int result = ndb.waitUntilReady(300); // 5 minutes
     if (result != 0){

=== modified file 'storage/ndb/test/src/NdbRestarter.cpp'
--- a/storage/ndb/test/src/NdbRestarter.cpp	2010-09-20 13:09:18 +0000
+++ b/storage/ndb/test/src/NdbRestarter.cpp	2010-09-29 08:45:11 +0000
@@ -73,11 +73,14 @@ int
 NdbRestarter::restartOneDbNode(int _nodeId,
 			       bool inital,
 			       bool nostart,
-			       bool abort){
+			       bool abort,
+                               bool force)
+{
   return restartNodes(&_nodeId, 1,
                       (inital ? NRRF_INITIAL : 0) |
                       (nostart ? NRRF_NOSTART : 0) |
-                      (abort ? NRRF_ABORT : 0));
+                      (abort ? NRRF_ABORT : 0) |
+                      (force ? NRRF_FORCE : 0));
 }
 
 int
@@ -88,14 +91,16 @@ NdbRestarter::restartNodes(int * nodes,
     return -1;
 
   int ret = 0;
-  
-  if ((ret = ndb_mgm_restart2(handle, cnt, nodes,
+  int unused;
+  if ((ret = ndb_mgm_restart4(handle, cnt, nodes,
                               (flags & NRRF_INITIAL),
                               (flags & NRRF_NOSTART),
-                              (flags & NRRF_ABORT))) <= 0)
+                              (flags & NRRF_ABORT),
+                              (flags & NRRF_FORCE),
+                              &unused)) <= 0)
   {
     /**
-     * ndb_mgm_restart2 returned error, one reason could
+     * ndb_mgm_restart4 returned error, one reason could
      * be that the node have not stopped fast enough!
      * Check status of the node to see if it's on the 
      * way down. If that's the case ignore the error
@@ -104,7 +109,7 @@ NdbRestarter::restartNodes(int * nodes,
     if (getStatus() != 0)
       return -1;
 
-    g_info << "ndb_mgm_restart2 returned with error, checking node state"
+    g_info << "ndb_mgm_restart4 returned with error, checking node state"
            << endl;
 
     for (int j = 0; j<cnt; j++)
@@ -623,12 +628,15 @@ int NdbRestarter::getNumDbNodes(){
 
 int NdbRestarter::restartAll(bool initial,
 			     bool nostart,
-			     bool abort){
-  
+			     bool abort,
+                             bool force)
+{
   if (!isConnected())
     return -1;
 
-  if (ndb_mgm_restart2(handle, 0, NULL, initial, 1, abort) == -1) {
+  int unused;
+  if (ndb_mgm_restart4(handle, 0, NULL, initial, 1, abort,
+                       force, &unused) == -1) {
     MGMERR(handle);
     g_err  << "Could not restart(stop) all nodes " << endl;
     // return -1; Continue anyway - Magnus


Attachment: [text/bzr-bundle] bzr/msabaratnam@mysql.com-20101001102755-bv0qo6tktp75bfsb.bundle
Thread
bzr push into mysql-5.1-telco-7.0-mai branch (msabaratnam:3252 to 3254) Maitrayi Sabaratnam1 Oct