Merge lp:~stewart/percona-server/5.5.13-merge into lp:percona-server/5.5

[Stewart Smith]

Merge of Yasufumi and Oleg merging patches to MySQL 5.5.13 base. Only patches that already in 5.5.12

http://jenkins.percona.com/job/percona-server-5.5-param/4/

passes as well as lp:percona-server does (better really)

[Oleg Tsarev (tsarev)]

https://code.launchpad.net/~tsarev/percona-server/5.5.13-merge/+merge/65172

review: Needs Fixing (dev)

=== modified file 'Makefile'
--- Makefile	2011-05-18 00:03:53 +0000
+++ Makefile	2011-06-20 09:04:39 +0000
@@ -1,7 +1,7 @@
 FETCH_CMD=wget
 MASTER_SITE=http://www.percona.com/downloads/community
-MYSQL_VERSION=5.5.12
-PERCONA_SERVER_VERSION=rel20.3
+MYSQL_VERSION=5.5.13
+PERCONA_SERVER_VERSION=rel20.4
 PERCONA_SERVER ?=Percona-Server-$(MYSQL_VERSION)-$(PERCONA_SERVER_VERSION)
 DEBUG_DIR ?= $(PERCONA_SERVER)-debug
 RELEASE_DIR ?= $(PERCONA_SERVER)-release

=== modified file 'control_online_alter_index.patch'
--- control_online_alter_index.patch	2011-05-10 11:57:42 +0000
+++ control_online_alter_index.patch	2011-06-20 09:04:39 +0000
@@ -8,7 +8,7 @@
 diff -ruN a/sql/handler.h b/sql/handler.h
 --- a/sql/handler.h	2010-11-03 07:01:14.000000000 +0900
 +++ b/sql/handler.h	2010-12-03 13:51:04.727293058 +0900
-@@ -203,6 +203,8 @@
+@@ -205,6 +205,8 @@
  #define HA_INPLACE_DROP_UNIQUE_INDEX_NO_WRITE      (1L << 9)
  #define HA_INPLACE_ADD_PK_INDEX_NO_WRITE           (1L << 10)
  #define HA_INPLACE_DROP_PK_INDEX_NO_WRITE          (1L << 11)

=== modified file 'innodb_adaptive_hash_index_partitions.patch'
--- innodb_adaptive_hash_index_partitions.patch	2011-06-03 13:00:05 +0000
+++ innodb_adaptive_hash_index_partitions.patch	2011-06-20 09:04:39 +0000
@@ -516,7 +516,7 @@
 +		}
 +		if (UNIV_LIKELY(!block->is_hashed)) {
 +			rw_lock_s_unlock(btr_search_latch);
-+			return;
++			goto retry;
 +		}
 +		index = block->index;
 +		ut_a(btr_search_latch == btr_search_get_latch(index->id));
@@ -1008,7 +1008,7 @@
  #endif /* UNIV_SYNC_DEBUG */
  	ut_ad(!btr_search_enabled);
  
-@@ -2633,6 +2638,7 @@
+@@ -2632,6 +2637,7 @@
  {
  	block->check_index_page_at_flush = FALSE;
  	block->index		= NULL;
@@ -1019,7 +1019,7 @@
 diff -ruN a/storage/innobase/buf/buf0lru.c b/storage/innobase/buf/buf0lru.c
 --- a/storage/innobase/buf/buf0lru.c	2010-12-04 15:35:29.137347521 +0900
 +++ b/storage/innobase/buf/buf0lru.c	2010-12-04 16:12:48.658550840 +0900
-@@ -1796,7 +1796,7 @@
+@@ -1798,7 +1798,7 @@
  
  		UNIV_MEM_VALID(((buf_block_t*) bpage)->frame,
  			       UNIV_PAGE_SIZE);
@@ -1031,7 +1031,7 @@
 diff -ruN a/storage/innobase/dict/dict0dict.c b/storage/innobase/dict/dict0dict.c
 --- a/storage/innobase/dict/dict0dict.c	2010-12-04 15:52:23.398513916 +0900
 +++ b/storage/innobase/dict/dict0dict.c	2010-12-04 16:12:48.662550715 +0900
-@@ -1812,7 +1812,7 @@
+@@ -1811,7 +1811,7 @@
  	zero. */
  
  	for (;;) {
@@ -1056,19 +1056,19 @@
 diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
 --- a/storage/innobase/handler/ha_innodb.cc	2010-12-04 16:12:20.185850734 +0900
 +++ b/storage/innobase/handler/ha_innodb.cc	2010-12-04 16:12:48.674552412 +0900
-@@ -11695,6 +11695,11 @@
+@@ -11702,6 +11702,11 @@
    "Disable with --skip-innodb-adaptive-hash-index.",
    NULL, innodb_adaptive_hash_index_update, TRUE);
  
 +static MYSQL_SYSVAR_ULONG(adaptive_hash_index_partitions, btr_search_index_num,
 +  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 +  "Number of InnoDB adaptive hash index partitions (default 1: disable partitioning)",
-+  NULL, NULL, 1, 1, 32, 0);
++  NULL, NULL, 1, 1, sizeof(ulint) * 8, 0);
 +
  static MYSQL_SYSVAR_ULONG(replication_delay, srv_replication_delay,
    PLUGIN_VAR_RQCMDARG,
    "Replication thread delay (ms) on the slave server if "
-@@ -12060,6 +12065,7 @@
+@@ -12068,6 +12073,7 @@
    MYSQL_SYSVAR(use_sys_stats_table),
    MYSQL_SYSVAR(stats_sample_pages),
    MYSQL_SYSVAR(adaptive_hash_index),
@@ -1264,7 +1264,7 @@
 diff -ruN a/storage/innobase/include/buf0buf.h b/storage/innobase/include/buf0buf.h
 --- a/storage/innobase/include/buf0buf.h	2010-12-15 19:00:07.713604580 +0900
 +++ b/storage/innobase/include/buf0buf.h	2010-12-15 20:58:03.546839883 +0900
-@@ -1547,7 +1547,7 @@
+@@ -1546,7 +1546,7 @@
  					pointers in the adaptive hash index
  					pointing to this frame */
  #endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
@@ -1273,7 +1273,7 @@
  					already been built on this
  					page; note that it does not
  					guarantee that the index is
-@@ -1561,6 +1561,7 @@
+@@ -1560,6 +1560,7 @@
  	unsigned	curr_left_side:1;/*!< TRUE or FALSE in hash indexing */
  	dict_index_t*	index;		/*!< Index for which the adaptive
  					hash index has been created. */
@@ -1389,7 +1389,7 @@
  #ifdef UNIV_SEARCH_DEBUG
  	ulint		cnt				= 0;
  #endif /* UNIV_SEARCH_DEBUG */
-@@ -3441,18 +3443,32 @@
+@@ -3446,18 +3448,33 @@
  	/* PHASE 0: Release a possible s-latch we are holding on the
  	adaptive hash index latch if there is someone waiting behind */
  
@@ -1397,9 +1397,9 @@
 -	    && trx->has_search_latch) {
 +	should_release = 0;
 +	for (i = 0; i < btr_search_index_num; i++) {
-+		if ((trx->has_search_latch & ((ulint)1 << i))
-+		    && rw_lock_get_writer(btr_search_latch_part[i])
-+		    		!= RW_LOCK_NOT_LOCKED) {
++		/* we should check all latches (fix Bug#791030) */
++		if (rw_lock_get_writer(btr_search_latch_part[i])
++		    != RW_LOCK_NOT_LOCKED) {
 +			should_release |= ((ulint)1 << i);
 +		}
 +	}
@@ -1414,9 +1414,10 @@
 -		rw_lock_s_unlock(&btr_search_latch);
 -		trx->has_search_latch = FALSE;
 +		for (i = 0; i < btr_search_index_num; i++) {
-+			if (should_release & ((ulint)1 << i)) {
++			/* we should release all s-latches (fix Bug#791030) */
++			if (trx->has_search_latch & ((ulint)1 << i)) {
 +				rw_lock_s_unlock(btr_search_latch_part[i]);
-+				trx->has_search_latch &= ~((ulint)1 << i);
++				trx->has_search_latch &= (~((ulint)1 << i));
 +			}
 +		}
  
@@ -1426,7 +1427,7 @@
  	}
  
  	/* Reset the new record lock info if srv_locks_unsafe_for_binlog
-@@ -3603,9 +3619,11 @@
+@@ -3608,9 +3625,28 @@
  			hash index semaphore! */
  
  #ifndef UNIV_SEARCH_DEBUG
@@ -1435,13 +1436,30 @@
 -				trx->has_search_latch = TRUE;
 +			if (!(trx->has_search_latch
 +			      & ((ulint)1 << (index->id % btr_search_index_num)))) {
-+				rw_lock_s_lock(btr_search_get_latch(index->id));
-+				trx->has_search_latch |=
-+					(ulint)1 << (index->id % btr_search_index_num);
++				if (trx->has_search_latch
++				    < ((ulint)1 << (index->id % btr_search_index_num))) {
++					rw_lock_s_lock(btr_search_get_latch(index->id));
++					trx->has_search_latch |=
++						((ulint)1 << (index->id % btr_search_index_num));
++				} else {
++					/* should re-lock to obay latch-order */
++					for (i = 0; i < btr_search_index_num; i++) {
++						if (trx->has_search_latch & ((ulint)1 << i)) {
++							rw_lock_s_unlock(btr_search_latch_part[i]);
++						}
++					}
++					trx->has_search_latch |=
++						((ulint)1 << (index->id % btr_search_index_num));
++					for (i = 0; i < btr_search_index_num; i++) {
++						if (trx->has_search_latch & ((ulint)1 << i)) {
++							rw_lock_s_lock(btr_search_latch_part[i]);
++						}
++					}
++				}
  			}
  #endif
  			switch (row_sel_try_search_shortcut_for_mysql(
-@@ -3666,7 +3684,11 @@
+@@ -3671,7 +3707,11 @@
  
  					trx->search_latch_timeout--;
  
@@ -1454,7 +1472,7 @@
  					trx->has_search_latch = FALSE;
  				}
  
-@@ -3690,7 +3712,12 @@
+@@ -3695,7 +3735,12 @@
  	/* PHASE 3: Open or restore index cursor position */
  
  	if (trx->has_search_latch) {
@@ -1471,7 +1489,7 @@
 diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
 --- a/storage/innobase/srv/srv0srv.c	2010-12-04 16:12:20.231484679 +0900
 +++ b/storage/innobase/srv/srv0srv.c	2010-12-04 16:12:48.726551018 +0900
-@@ -2035,7 +2035,9 @@
+@@ -2045,7 +2045,9 @@
  	      "-------------------------------------\n", file);
  	ibuf_print(file);
  
@@ -1482,7 +1500,7 @@
  
  	fprintf(file,
  		"%.2f hash searches/s, %.2f non-hash searches/s\n",
-@@ -2060,14 +2062,15 @@
+@@ -2070,14 +2072,15 @@
  			ut_total_allocated_memory,
  			mem_pool_get_reserved(mem_comm_pool));
  	/* Calcurate reserved memories */
@@ -1502,7 +1520,7 @@
  
  	lock_sys_subtotal = 0;
  	if (trx_sys) {
-@@ -2093,10 +2096,10 @@
+@@ -2103,10 +2106,10 @@
  			"    Recovery system     %lu \t(%lu + %lu)\n",
  
  			(ulong) (btr_search_sys
@@ -1518,7 +1536,7 @@
 diff -ruN a/storage/innobase/sync/sync0sync.c b/storage/innobase/sync/sync0sync.c
 --- a/storage/innobase/sync/sync0sync.c	2010-12-03 17:36:44.300986571 +0900
 +++ b/storage/innobase/sync/sync0sync.c	2010-12-04 16:12:48.729513564 +0900
-@@ -1178,7 +1178,6 @@
+@@ -1223,7 +1223,6 @@
  	case SYNC_OUTER_ANY_LATCH:
  	case SYNC_FILE_FORMAT_TAG:
  	case SYNC_DOUBLEWRITE:
@@ -1526,7 +1544,7 @@
  	case SYNC_SEARCH_SYS_CONF:
  	case SYNC_TRX_LOCK_HEAP:
  	case SYNC_KERNEL:
-@@ -1199,6 +1198,7 @@
+@@ -1244,6 +1243,7 @@
  			ut_error;
  		}
  		break;
@@ -1537,7 +1555,7 @@
 diff -ruN a/storage/innobase/trx/trx0trx.c b/storage/innobase/trx/trx0trx.c
 --- a/storage/innobase/trx/trx0trx.c	2010-12-03 17:49:11.623953784 +0900
 +++ b/storage/innobase/trx/trx0trx.c	2010-12-04 16:12:48.731513275 +0900
-@@ -266,8 +266,14 @@
+@@ -265,8 +265,14 @@
  /*=================================*/
  	trx_t*	   trx) /*!< in: transaction */
  {

=== modified file 'innodb_admin_command_base.patch'
--- innodb_admin_command_base.patch	2011-05-23 03:13:18 +0000
+++ innodb_admin_command_base.patch	2011-06-20 09:04:39 +0000
@@ -8,7 +8,7 @@
 diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
 --- a/storage/innobase/handler/ha_innodb.cc	2010-12-03 17:32:15.624039043 +0900
 +++ b/storage/innobase/handler/ha_innodb.cc	2010-12-03 17:32:35.424957827 +0900
-@@ -11856,7 +11856,8 @@
+@@ -11863,7 +11863,8 @@
  i_s_innodb_sys_foreign_cols,
  i_s_innodb_sys_stats,
  i_s_innodb_table_stats,

=== modified file 'innodb_buffer_pool_pages_i_s.patch'
--- innodb_buffer_pool_pages_i_s.patch	2011-05-23 03:13:18 +0000
+++ innodb_buffer_pool_pages_i_s.patch	2011-06-20 09:04:39 +0000
@@ -8,7 +8,7 @@
 diff -ruN a/storage/innobase/buf/buf0buf.c b/storage/innobase/buf/buf0buf.c
 --- a/storage/innobase/buf/buf0buf.c	2010-12-04 20:20:44.595483291 +0900
 +++ b/storage/innobase/buf/buf0buf.c	2010-12-06 19:28:04.055227506 +0900
-@@ -4536,6 +4536,36 @@
+@@ -4537,6 +4537,36 @@
  	mutex_exit(block_mutex);
  }
  
@@ -48,7 +48,7 @@
 diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
 --- a/storage/innobase/handler/ha_innodb.cc	2010-12-04 20:20:44.614551139 +0900
 +++ b/storage/innobase/handler/ha_innodb.cc	2010-12-06 19:23:47.622195800 +0900
-@@ -12140,6 +12140,9 @@
+@@ -12148,6 +12148,9 @@
  i_s_innodb_sys_stats,
  i_s_innodb_table_stats,
  i_s_innodb_index_stats,
@@ -786,7 +786,7 @@
 diff -ruN a/storage/innobase/include/buf0buf.h b/storage/innobase/include/buf0buf.h
 --- a/storage/innobase/include/buf0buf.h	2010-12-04 19:46:40.197471531 +0900
 +++ b/storage/innobase/include/buf0buf.h	2010-12-06 19:23:47.638195824 +0900
-@@ -1145,6 +1145,14 @@
+@@ -1144,6 +1144,14 @@
  /*===========*/
  	const buf_pool_t*	buf_pool)	/*!< in: buffer pool */
  	__attribute__((nonnull, const));

=== modified file 'innodb_buffer_pool_shm.patch'
--- innodb_buffer_pool_shm.patch	2011-05-10 11:57:42 +0000
+++ innodb_buffer_pool_shm.patch	2011-06-20 09:04:39 +0000
@@ -742,7 +742,7 @@
  
  
  static char*	internal_innobase_data_file_path	= NULL;
-@@ -2656,6 +2657,14 @@
+@@ -2670,6 +2671,14 @@
  	srv_buf_pool_size = (ulint) innobase_buffer_pool_size;
  	srv_buf_pool_instances = (ulint) innobase_buffer_pool_instances;
  
@@ -757,7 +757,7 @@
  	srv_mem_pool_size = (ulint) innobase_additional_mem_pool_size;
  
  	srv_n_file_io_threads = (ulint) innobase_file_io_threads;
-@@ -2672,6 +2681,7 @@
+@@ -2686,6 +2695,7 @@
  	srv_use_doublewrite_buf = (ibool) innobase_use_doublewrite;
  	srv_use_checksums = (ibool) innobase_use_checksums;
  	srv_fast_checksum = (ibool) innobase_fast_checksum;
@@ -765,7 +765,7 @@
  
  #ifdef HAVE_LARGE_PAGES
          if ((os_use_large_pages = (ibool) my_use_large_pages))
-@@ -11726,6 +11736,16 @@
+@@ -11733,6 +11743,16 @@
    "Number of buffer pool instances, set to higher value on high-end machines to increase scalability",
    NULL, NULL, 1L, 1L, MAX_BUFFER_POOLS, 1L);
  
@@ -782,7 +782,7 @@
  static MYSQL_SYSVAR_ULONG(commit_concurrency, innobase_commit_concurrency,
    PLUGIN_VAR_RQCMDARG,
    "Helps in performance tuning in heavily concurrent environments.",
-@@ -12019,6 +12039,8 @@
+@@ -12027,6 +12047,8 @@
    MYSQL_SYSVAR(autoextend_increment),
    MYSQL_SYSVAR(buffer_pool_size),
    MYSQL_SYSVAR(buffer_pool_instances),
@@ -802,7 +802,7 @@
  
  /** @name Modes for buf_page_get_gen */
  /* @{ */
-@@ -1594,9 +1595,12 @@
+@@ -1593,9 +1594,12 @@
  /**********************************************************************//**
  Compute the hash fold value for blocks in buf_pool->zip_hash. */
  /* @{ */
@@ -950,7 +950,7 @@
 diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
 --- a/storage/innobase/include/srv0srv.h	2011-04-09 18:48:45.000000000 +0400
 +++ b/storage/innobase/include/srv0srv.h	2011-04-09 18:48:48.000000000 +0400
-@@ -171,6 +171,10 @@
+@@ -168,6 +168,10 @@
  extern ulint	srv_mem_pool_size;
  extern ulint	srv_lock_table_size;
  
@@ -1204,7 +1204,7 @@
 diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
 --- a/storage/innobase/srv/srv0srv.c	2011-04-09 18:48:46.000000000 +0400
 +++ b/storage/innobase/srv/srv0srv.c	2011-04-09 18:48:48.000000000 +0400
-@@ -234,6 +234,11 @@
+@@ -228,6 +228,11 @@
  UNIV_INTERN ulint	srv_mem_pool_size	= ULINT_MAX;
  UNIV_INTERN ulint	srv_lock_table_size	= ULINT_MAX;
  

=== modified file 'innodb_deadlock_count.patch'
--- innodb_deadlock_count.patch	2011-05-10 11:57:42 +0000
+++ innodb_deadlock_count.patch	2011-06-20 09:04:39 +0000
@@ -31,7 +31,7 @@
 diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
 --- a/storage/innobase/include/srv0srv.h	2010-12-04 15:55:21.378480843 +0900
 +++ b/storage/innobase/include/srv0srv.h	2010-12-04 16:10:24.606550983 +0900
-@@ -761,6 +761,7 @@
+@@ -758,6 +758,7 @@
  	ulint innodb_buffer_pool_read_ahead_evicted;/*!< srv_read_ahead evicted*/
  	ulint innodb_dblwr_pages_written;	/*!< srv_dblwr_pages_written */
  	ulint innodb_dblwr_writes;		/*!< srv_dblwr_writes */
@@ -53,7 +53,7 @@
 diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
 --- a/storage/innobase/srv/srv0srv.c	2010-12-04 15:57:13.069513371 +0900
 +++ b/storage/innobase/srv/srv0srv.c	2010-12-04 16:10:24.610593039 +0900
-@@ -474,6 +474,7 @@
+@@ -468,6 +468,7 @@
  static ulint	srv_n_rows_deleted_old		= 0;
  static ulint	srv_n_rows_read_old		= 0;
  
@@ -61,7 +61,7 @@
  UNIV_INTERN ulint		srv_n_lock_wait_count		= 0;
  UNIV_INTERN ulint		srv_n_lock_wait_current_count	= 0;
  UNIV_INTERN ib_int64_t	srv_n_lock_wait_time		= 0;
-@@ -2272,6 +2273,7 @@
+@@ -2282,6 +2283,7 @@
  	export_vars.innodb_buffer_pool_pages_data = LRU_len;
  	export_vars.innodb_buffer_pool_pages_dirty = flush_list_len;
  	export_vars.innodb_buffer_pool_pages_free = free_len;

=== modified file 'innodb_dict_size_limit.patch'
--- innodb_dict_size_limit.patch	2011-05-10 11:57:42 +0000
+++ innodb_dict_size_limit.patch	2011-06-20 09:04:39 +0000
@@ -277,7 +277,7 @@
 diff -ruN a/storage/innobase/dict/dict0dict.c b/storage/innobase/dict/dict0dict.c
 --- a/storage/innobase/dict/dict0dict.c	2010-11-03 07:01:13.000000000 +0900
 +++ b/storage/innobase/dict/dict0dict.c	2010-12-03 15:45:47.525953769 +0900
-@@ -627,6 +627,8 @@
+@@ -626,6 +626,8 @@
  
  	table = dict_table_get_on_id_low(table_id);
  
@@ -286,7 +286,7 @@
  	mutex_exit(&(dict_sys->mutex));
  
  	return(table);
-@@ -745,6 +747,8 @@
+@@ -744,6 +746,8 @@
  		table->n_mysql_handles_opened++;
  	}
  
@@ -295,7 +295,7 @@
  	mutex_exit(&(dict_sys->mutex));
  
  	if (table != NULL) {
-@@ -1260,6 +1264,64 @@
+@@ -1259,6 +1263,64 @@
  	dict_mem_table_free(table);
  }
  
@@ -360,7 +360,7 @@
  /****************************************************************//**
  If the given column name is reserved for InnoDB system columns, return
  TRUE.
-@@ -1729,6 +1791,11 @@
+@@ -1728,6 +1790,11 @@
  	ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
  	ut_ad(mutex_own(&(dict_sys->mutex)));
  
@@ -384,7 +384,7 @@
    {"have_atomic_builtins",
    (char*) &export_vars.innodb_have_atomic_builtins,	  SHOW_BOOL},
    {"log_waits",
-@@ -11635,6 +11637,11 @@
+@@ -11642,6 +11644,11 @@
    "Choose method of innodb_adaptive_flushing. (native, [estimate], keep_average)",
    NULL, innodb_adaptive_flushing_method_update, 1, &adaptive_flushing_method_typelib);
  
@@ -396,7 +396,7 @@
  static struct st_mysql_sys_var* innobase_system_variables[]= {
    MYSQL_SYSVAR(additional_mem_pool_size),
    MYSQL_SYSVAR(autoextend_increment),
-@@ -11702,6 +11709,7 @@
+@@ -11709,6 +11716,7 @@
    MYSQL_SYSVAR(flush_neighbor_pages),
    MYSQL_SYSVAR(read_ahead),
    MYSQL_SYSVAR(adaptive_flushing_method),
@@ -500,7 +500,7 @@
 diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
 --- a/storage/innobase/include/srv0srv.h	2010-12-03 15:43:57.297067100 +0900
 +++ b/storage/innobase/include/srv0srv.h	2010-12-03 15:45:47.562024404 +0900
-@@ -232,6 +232,7 @@
+@@ -229,6 +229,7 @@
  extern ulint	srv_read_ahead;
  extern ulint	srv_adaptive_flushing_method;
  
@@ -508,7 +508,7 @@
  /*-------------------------------------------*/
  
  extern ulint	srv_n_rows_inserted;
-@@ -712,6 +713,7 @@
+@@ -709,6 +710,7 @@
  	ulint innodb_data_writes;		/*!< I/O write requests */
  	ulint innodb_data_written;		/*!< Data bytes written */
  	ulint innodb_data_reads;		/*!< I/O read requests */
@@ -519,7 +519,7 @@
 diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
 --- a/storage/innobase/srv/srv0srv.c	2010-12-03 15:43:57.301024390 +0900
 +++ b/storage/innobase/srv/srv0srv.c	2010-12-03 15:45:47.565023830 +0900
-@@ -421,6 +421,8 @@
+@@ -415,6 +415,8 @@
  UNIV_INTERN ulint	srv_enable_unsafe_group_commit = 0; /* 0:disable 1:enable */
  UNIV_INTERN ulint	srv_read_ahead = 3; /* 1: random  2: linear  3: Both */
  UNIV_INTERN ulint	srv_adaptive_flushing_method = 0; /* 0: native  1: estimate  2: keep_average */
@@ -528,7 +528,7 @@
  /*-------------------------------------------*/
  UNIV_INTERN ulong	srv_n_spin_wait_rounds	= 30;
  UNIV_INTERN ulong	srv_n_free_tickets_to_enter = 500;
-@@ -2211,6 +2213,7 @@
+@@ -2220,6 +2222,7 @@
  	export_vars.innodb_data_reads = os_n_file_reads;
  	export_vars.innodb_data_writes = os_n_file_writes;
  	export_vars.innodb_data_written = srv_data_written;

=== modified file 'innodb_expand_import.patch'
--- innodb_expand_import.patch	2011-05-10 11:57:42 +0000
+++ innodb_expand_import.patch	2011-06-20 09:04:39 +0000
@@ -5,10 +5,40 @@
 #!!! notice !!!
 # Any small change to this file in the main branch
 # should be done or reviewed by the maintainer!
+diff -ruN a/storage/innobase/btr/btr0btr.c b/storage/innobase/btr/btr0btr.c
+--- a/storage/innobase/btr/btr0btr.c	2011-04-11 19:44:03.000000000 +0900
++++ b/storage/innobase/btr/btr0btr.c	2011-05-24 20:30:12.455852287 +0900
+@@ -837,7 +837,7 @@
+ /**************************************************************//**
+ Creates a new index page (not the root, and also not
+ used in page reorganization).  @see btr_page_empty(). */
+-static
++UNIV_INTERN
+ void
+ btr_page_create(
+ /*============*/
+@@ -1707,7 +1707,7 @@
+ #ifndef UNIV_HOTBACKUP
+ /*************************************************************//**
+ Empties an index page.  @see btr_page_create(). */
+-static
++UNIV_INTERN
+ void
+ btr_page_empty(
+ /*===========*/
+@@ -2269,7 +2269,7 @@
+ /**************************************************************//**
+ Attaches the halves of an index page on the appropriate level in an
+ index tree. */
+-static
++UNIV_INTERN
+ void
+ btr_attach_half_pages(
+ /*==================*/
 diff -ruN a/storage/innobase/fil/fil0fil.c b/storage/innobase/fil/fil0fil.c
 --- a/storage/innobase/fil/fil0fil.c	2010-12-03 15:09:51.274957577 +0900
 +++ b/storage/innobase/fil/fil0fil.c	2010-12-03 15:52:23.553986552 +0900
-@@ -40,6 +40,12 @@
+@@ -40,6 +40,14 @@
  #include "dict0dict.h"
  #include "page0page.h"
  #include "page0zip.h"
@@ -18,10 +48,97 @@
 +#include "row0mysql.h"
 +#include "row0row.h"
 +#include "que0que.h"
++#include "btr0btr.h"
++#include "btr0sea.h"
  #ifndef UNIV_HOTBACKUP
  # include "buf0lru.h"
  # include "ibuf0ibuf.h"
-@@ -3078,7 +3084,7 @@
+@@ -3032,6 +3040,84 @@
+ }
+ 
+ /********************************************************************//**
++Checks if a page is corrupt. (for offline page)
++*/
++static
++ibool
++fil_page_buf_page_is_corrupted_offline(
++/*===================================*/
++	const byte*	page,		/*!< in: a database page */
++	ulint		zip_size)	/*!< in: size of compressed page;
++					0 for uncompressed pages */
++{
++	ulint		checksum_field;
++	ulint		old_checksum_field;
++
++	if (!zip_size
++	    && memcmp(page + FIL_PAGE_LSN + 4,
++		      page + UNIV_PAGE_SIZE
++		      - FIL_PAGE_END_LSN_OLD_CHKSUM + 4, 4)) {
++		return(TRUE);
++	}
++
++	checksum_field = mach_read_from_4(page
++					  + FIL_PAGE_SPACE_OR_CHKSUM);
++
++	if (zip_size) {
++		return(checksum_field != BUF_NO_CHECKSUM_MAGIC
++		       && checksum_field
++		       != page_zip_calc_checksum(page, zip_size));
++	}
++
++	old_checksum_field = mach_read_from_4(
++		page + UNIV_PAGE_SIZE
++		- FIL_PAGE_END_LSN_OLD_CHKSUM);
++
++	if (old_checksum_field != mach_read_from_4(page
++						   + FIL_PAGE_LSN)
++	    && old_checksum_field != BUF_NO_CHECKSUM_MAGIC
++	    && old_checksum_field
++	    != buf_calc_page_old_checksum(page)) {
++		return(TRUE);
++	}
++
++	if (checksum_field != 0
++	    && checksum_field != BUF_NO_CHECKSUM_MAGIC
++	    && checksum_field
++	    != buf_calc_page_new_checksum(page)) {
++		return(TRUE);
++	}
++
++	return(FALSE);
++}
++
++/********************************************************************//**
++*/
++static
++void
++fil_page_buf_page_store_checksum(
++/*=============================*/
++	byte*	page,
++	ulint	zip_size)
++{
++	if (!zip_size) {
++		mach_write_to_4(page + FIL_PAGE_SPACE_OR_CHKSUM,
++				srv_use_checksums
++				? buf_calc_page_new_checksum(page)
++						: BUF_NO_CHECKSUM_MAGIC);
++		mach_write_to_4(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
++				srv_use_checksums
++				? buf_calc_page_old_checksum(page)
++						: BUF_NO_CHECKSUM_MAGIC);
++	} else {
++		mach_write_to_4(page + FIL_PAGE_SPACE_OR_CHKSUM,
++				srv_use_checksums
++				? page_zip_calc_checksum(page, zip_size)
++				: BUF_NO_CHECKSUM_MAGIC);
++	}
++}
++
++/********************************************************************//**
+ Tries to open a single-table tablespace and optionally checks the space id is
+ right in it. If does not succeed, prints an error message to the .err log. This
+ function is used to open a tablespace when we start up mysqld, and also in
+@@ -3078,7 +3164,7 @@
  
  	file = os_file_create_simple_no_error_handling(
  		innodb_file_data_key, filepath, OS_FILE_OPEN,
@@ -30,7 +147,7 @@
  	if (!success) {
  		/* The following call prints an error message */
  		os_file_get_last_error(TRUE);
-@@ -3125,6 +3131,466 @@
+@@ -3125,6 +3211,445 @@
  	space_id = fsp_header_get_space_id(page);
  	space_flags = fsp_header_get_flags(page);
  
@@ -56,6 +173,7 @@
 +		fil_system_t*	system;
 +		fil_node_t*	node = NULL;
 +		fil_space_t*	space;
++		ulint		zip_size;
 +
 +		buf3 = ut_malloc(2 * UNIV_PAGE_SIZE);
 +		descr_page = ut_align(buf3, UNIV_PAGE_SIZE);
@@ -73,12 +191,15 @@
 +		/* store as first descr page */
 +		memcpy(descr_page, page, UNIV_PAGE_SIZE);
 +
++		zip_size = dict_table_flags_to_zip_size(flags);
++		ut_a(zip_size == dict_table_flags_to_zip_size(space_flags));
++
 +		/* get free limit (page number) of the table space */
 +/* these should be same to the definition in fsp0fsp.c */
 +#define FSP_HEADER_OFFSET	FIL_PAGE_DATA
 +#define	FSP_FREE_LIMIT		12
 +		free_limit = mach_read_from_4(FSP_HEADER_OFFSET + FSP_FREE_LIMIT + page);
-+		free_limit_bytes = (ib_int64_t)free_limit * (ib_int64_t)UNIV_PAGE_SIZE;
++		free_limit_bytes = (ib_int64_t)free_limit * (ib_int64_t)(zip_size ? zip_size : UNIV_PAGE_SIZE);
 +
 +		/* overwrite fsp header */
 +		fsp_header_init_fields(page, id, flags);
@@ -87,14 +208,9 @@
 +		space_flags = flags;
 +		if (mach_read_from_8(page + FIL_PAGE_FILE_FLUSH_LSN) > current_lsn)
 +			mach_write_to_8(page + FIL_PAGE_FILE_FLUSH_LSN, current_lsn);
-+		mach_write_to_4(page + FIL_PAGE_SPACE_OR_CHKSUM,
-+				srv_use_checksums
-+				? buf_calc_page_new_checksum(page)
-+						: BUF_NO_CHECKSUM_MAGIC);
-+		mach_write_to_4(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
-+				srv_use_checksums
-+				? buf_calc_page_old_checksum(page)
-+						: BUF_NO_CHECKSUM_MAGIC);
++
++		fil_page_buf_page_store_checksum(page, zip_size);
++
 +		success = os_file_write(filepath, file, page, 0, 0, UNIV_PAGE_SIZE);
 +
 +		/* get file size */
@@ -104,7 +220,7 @@
 +
 +		if (size_bytes < free_limit_bytes) {
 +			free_limit_bytes = size_bytes;
-+			if (size_bytes >= FSP_EXTENT_SIZE * UNIV_PAGE_SIZE) {
++			if (size_bytes >= (lint)FSP_EXTENT_SIZE * (lint)(zip_size ? zip_size : UNIV_PAGE_SIZE)) {
 +				fprintf(stderr, "InnoDB: free limit of %s is larger than its real size.\n", filepath);
 +				file_is_corrupt = TRUE;
 +			}
@@ -168,63 +284,41 @@
 +			size_bytes = ut_2pow_round(size_bytes, 1024 * 1024);
 +		}
 +		*/
-+		if (!(flags & DICT_TF_ZSSIZE_MASK)) {
++
++		if (zip_size) {
++			fprintf(stderr, "InnoDB: Warning: importing compressed table is still EXPERIMENTAL, currently.\n");
++		}
++
++		{
 +			mem_heap_t*	heap = NULL;
 +			ulint		offsets_[REC_OFFS_NORMAL_SIZE];
 +			ulint*		offsets = offsets_;
 +			ib_int64_t	offset;
 +
-+			size = (ulint) (size_bytes / UNIV_PAGE_SIZE);
++			size = (ulint) (size_bytes / (zip_size ? zip_size : UNIV_PAGE_SIZE));
 +			/* over write space id of all pages */
 +			rec_offs_init(offsets_);
 +
 +			fprintf(stderr, "InnoDB: Progress in %%:");
 +
-+			for (offset = 0; offset < free_limit_bytes; offset += UNIV_PAGE_SIZE) {
-+				ulint		checksum_field;
-+				ulint		old_checksum_field;
++			for (offset = 0; offset < free_limit_bytes;
++			     offset += zip_size ? zip_size : UNIV_PAGE_SIZE) {
 +				ibool		page_is_corrupt;
 +
 +				success = os_file_read(file, page,
 +							(ulint)(offset & 0xFFFFFFFFUL),
-+							(ulint)(offset >> 32), UNIV_PAGE_SIZE);
++							(ulint)(offset >> 32),
++							zip_size ? zip_size : UNIV_PAGE_SIZE);
 +
 +				page_is_corrupt = FALSE;
 +
 +				/* check consistency */
-+				if (memcmp(page + FIL_PAGE_LSN + 4,
-+					   page + UNIV_PAGE_SIZE
-+					   - FIL_PAGE_END_LSN_OLD_CHKSUM + 4, 4)) {
-+
++				if (fil_page_buf_page_is_corrupted_offline(page, zip_size)) {
 +					page_is_corrupt = TRUE;
 +				}
 +
 +				if (mach_read_from_4(page + FIL_PAGE_OFFSET)
-+				    != offset / UNIV_PAGE_SIZE) {
-+
-+					page_is_corrupt = TRUE;
-+				}
-+
-+				checksum_field = mach_read_from_4(page
-+								  + FIL_PAGE_SPACE_OR_CHKSUM);
-+
-+				old_checksum_field = mach_read_from_4(
-+					page + UNIV_PAGE_SIZE
-+					- FIL_PAGE_END_LSN_OLD_CHKSUM);
-+
-+				if (old_checksum_field != mach_read_from_4(page
-+									   + FIL_PAGE_LSN)
-+				    && old_checksum_field != BUF_NO_CHECKSUM_MAGIC
-+				    && old_checksum_field
-+				    != buf_calc_page_old_checksum(page)) {
-+
-+					page_is_corrupt = TRUE;
-+				}
-+
-+				if (checksum_field != 0
-+				    && checksum_field != BUF_NO_CHECKSUM_MAGIC
-+				    && checksum_field
-+				    != buf_calc_page_new_checksum(page)) {
++				    != offset / (zip_size ? zip_size : UNIV_PAGE_SIZE)) {
 +
 +					page_is_corrupt = TRUE;
 +				}
@@ -235,7 +329,8 @@
 +					/* it should be overwritten already */
 +					ut_a(!page_is_corrupt);
 +
-+				} else if (!((offset / UNIV_PAGE_SIZE) % UNIV_PAGE_SIZE)) {
++				} else if (!((offset / (zip_size ? zip_size : UNIV_PAGE_SIZE))
++					     % (zip_size ? zip_size : UNIV_PAGE_SIZE))) {
 +					/* descr page (not header) */
 +					if (page_is_corrupt) {
 +						file_is_corrupt = TRUE;
@@ -246,7 +341,7 @@
 +					}
 +
 +					/* store as descr page */
-+					memcpy(descr_page, page, UNIV_PAGE_SIZE);
++					memcpy(descr_page, page, (zip_size ? zip_size : UNIV_PAGE_SIZE));
 +
 +				} else if (descr_is_corrupt) {
 +					/* unknown state of the page */
@@ -274,9 +369,12 @@
 +					ulint	bit_index;
 +
 +					descr = descr_page + XDES_ARR_OFFSET
-+						+ XDES_SIZE * (ut_2pow_remainder((offset / UNIV_PAGE_SIZE), UNIV_PAGE_SIZE) / FSP_EXTENT_SIZE);
++						+ XDES_SIZE * (ut_2pow_remainder(
++							(offset / (zip_size ? zip_size : UNIV_PAGE_SIZE)),
++							(zip_size ? zip_size : UNIV_PAGE_SIZE)) / FSP_EXTENT_SIZE);
 +
-+					index = XDES_FREE_BIT + XDES_BITS_PER_PAGE * ((offset / UNIV_PAGE_SIZE) % FSP_EXTENT_SIZE);
++					index = XDES_FREE_BIT
++						+ XDES_BITS_PER_PAGE * ((offset / (zip_size ? zip_size : UNIV_PAGE_SIZE)) % FSP_EXTENT_SIZE);
 +					byte_index = index / 8;
 +					bit_index = index % 8;
 +
@@ -294,7 +392,7 @@
 +				}
 +
 +				if (page_is_corrupt) {
-+					fprintf(stderr, " [errp:%lld]", offset / UNIV_PAGE_SIZE);
++					fprintf(stderr, " [errp:%lld]", offset / (zip_size ? zip_size : UNIV_PAGE_SIZE));
 +
 +					/* cannot treat corrupt page */
 +					goto skip_write;
@@ -304,7 +402,13 @@
 +					mach_write_to_4(page + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID, id);
 +
 +					for (i = 0; i < n_index; i++) {
-+						if (offset / UNIV_PAGE_SIZE == root_page[i]) {
++						if (offset / (zip_size ? zip_size : UNIV_PAGE_SIZE) == root_page[i]) {
++							if (fil_page_get_type(page) != FIL_PAGE_INDEX) {
++								file_is_corrupt = TRUE;
++								fprintf(stderr, " [etyp:%lld]",
++									offset / (zip_size ? zip_size : UNIV_PAGE_SIZE));
++								goto skip_write;
++							}
 +							/* this is index root page */
 +							mach_write_to_4(page + FIL_PAGE_DATA + PAGE_BTR_SEG_LEAF
 +											+ FSEG_HDR_SPACE, id);
@@ -317,7 +421,14 @@
 +					if (fil_page_get_type(page) == FIL_PAGE_INDEX) {
 +						index_id_t tmp = mach_read_from_8(page + (PAGE_HEADER + PAGE_INDEX_ID));
 +
-+						if (mach_read_from_2(page + PAGE_HEADER + PAGE_LEVEL) == 0
++						for (i = 0; i < n_index; i++) {
++							if (old_id[i] == tmp) {
++								mach_write_to_8(page + (PAGE_HEADER + PAGE_INDEX_ID), new_id[i]);
++								break;
++							}
++						}
++
++						if (!zip_size && mach_read_from_2(page + PAGE_HEADER + PAGE_LEVEL) == 0
 +						    && old_id[0] == tmp) {
 +							/* leaf page of cluster index, reset trx_id of records */
 +							rec_t*	rec;
@@ -356,42 +467,34 @@
 +								rec = page_rec_get_next(rec);
 +								n_recs--;
 +							}
-+						}
-+
-+						for (i = 0; i < n_index; i++) {
-+							if (old_id[i] == tmp) {
-+								mach_write_to_8(page + (PAGE_HEADER + PAGE_INDEX_ID), new_id[i]);
-+								break;
-+							}
++						} else if (mach_read_from_2(page + PAGE_HEADER + PAGE_LEVEL) == 0
++							   && old_id[0] != tmp) {
++							mach_write_to_8(page + (PAGE_HEADER + PAGE_MAX_TRX_ID), 1);
 +						}
 +					}
 +
 +					if (mach_read_from_8(page + FIL_PAGE_LSN) > current_lsn) {
 +						mach_write_to_8(page + FIL_PAGE_LSN, current_lsn);
-+						mach_write_to_8(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
-+										current_lsn);
++						if (!zip_size) {
++							mach_write_to_8(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
++									current_lsn);
++						}
 +					}
 +
-+					mach_write_to_4(page + FIL_PAGE_SPACE_OR_CHKSUM,
-+							srv_use_checksums
-+							? buf_calc_page_new_checksum(page)
-+									: BUF_NO_CHECKSUM_MAGIC);
-+					mach_write_to_4(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
-+							srv_use_checksums
-+							? buf_calc_page_old_checksum(page)
-+									: BUF_NO_CHECKSUM_MAGIC);
++					fil_page_buf_page_store_checksum(page, zip_size);
 +
 +					success = os_file_write(filepath, file, page,
 +								(ulint)(offset & 0xFFFFFFFFUL),
-+								(ulint)(offset >> 32), UNIV_PAGE_SIZE);
++								(ulint)(offset >> 32),
++								zip_size ? zip_size : UNIV_PAGE_SIZE);
 +				}
 +
 +skip_write:
 +				if (free_limit_bytes
-+				    && ((ib_int64_t)((offset + UNIV_PAGE_SIZE) * 100) / free_limit_bytes)
++				    && ((ib_int64_t)((offset + (zip_size ? zip_size : UNIV_PAGE_SIZE)) * 100) / free_limit_bytes)
 +					!= ((offset * 100) / free_limit_bytes)) {
 +					fprintf(stderr, " %lu",
-+						(ulong)((ib_int64_t)((offset + UNIV_PAGE_SIZE) * 100) / free_limit_bytes));
++						(ulong)((ib_int64_t)((offset + (zip_size ? zip_size : UNIV_PAGE_SIZE)) * 100) / free_limit_bytes));
 +				}
 +			}
 +
@@ -447,13 +550,6 @@
 +			if (UNIV_LIKELY_NULL(heap)) {
 +				mem_heap_free(heap);
 +			}
-+		} else {
-+			/* zip page? */
-+			size = (ulint)
-+			(size_bytes
-+					/ dict_table_flags_to_zip_size(flags));
-+			fprintf(stderr, "InnoDB: Import: The table %s seems to be in a newer format."
-+					" It may not be possible to process it.\n", name);
 +		}
 +		/* .exp file should be removed */
 +		success = os_file_delete(info_file_path);
@@ -497,10 +593,282 @@
  	ut_free(buf2);
  
  	if (UNIV_UNLIKELY(space_id != id
+@@ -3166,6 +3691,271 @@
+ 	os_file_close(file);
+ 	mem_free(filepath);
+ 
++	if (srv_expand_import && dict_table_flags_to_zip_size(flags)) {
++		ulint		page_no;
++		ulint		zip_size;
++		ulint		height;
++		ulint		root_height = 0;
++		rec_t*		node_ptr;
++		dict_table_t*	table;
++		dict_index_t*	index;
++		buf_block_t*	block;
++		page_t*		page;
++		page_zip_des_t*	page_zip;
++		mtr_t		mtr;
++
++		mem_heap_t*	heap		= NULL;
++		ulint		offsets_[REC_OFFS_NORMAL_SIZE];
++		ulint*		offsets		= offsets_;
++
++		rec_offs_init(offsets_);
++
++		zip_size = dict_table_flags_to_zip_size(flags);
++
++		table = dict_table_get_low(name);
++		index = dict_table_get_first_index(table);
++		page_no = dict_index_get_page(index);
++		ut_a(page_no == 3);
++
++		fprintf(stderr, "InnoDB: It is compressed .ibd file. need to convert additionaly on buffer pool.\n");
++
++		/* down to leaf */
++		mtr_start(&mtr);
++		mtr_set_log_mode(&mtr, MTR_LOG_NONE);
++
++		height = ULINT_UNDEFINED;
++
++		for (;;) {
++			block = buf_page_get(space_id, zip_size, page_no,
++					     RW_NO_LATCH, &mtr);
++			page = buf_block_get_frame(block);
++
++			block->check_index_page_at_flush = TRUE;
++
++			if (height == ULINT_UNDEFINED) {
++				height = btr_page_get_level(page, &mtr);
++				root_height = height;
++			}
++
++			if (height == 0) {
++				break;
++			}
++
++			node_ptr = page_rec_get_next(page_get_infimum_rec(page));
++
++			height--;
++
++			offsets = rec_get_offsets(node_ptr, index, offsets, ULINT_UNDEFINED, &heap);
++			page_no = btr_node_ptr_get_child_page_no(node_ptr, offsets);
++		}
++
++		mtr_commit(&mtr);
++
++		fprintf(stderr, "InnoDB: pages needs split are ...");
++
++		/* scan reaf pages */
++		while (page_no != FIL_NULL) {
++			rec_t*	rec;
++			rec_t*	supremum;
++			ulint	n_recs;
++
++			mtr_start(&mtr);
++
++			block = buf_page_get(space_id, zip_size, page_no,
++					     RW_X_LATCH, &mtr);
++			page = buf_block_get_frame(block);
++			page_zip = buf_block_get_page_zip(block);
++
++			if (!page_zip) {
++				/*something wrong*/
++				fprintf(stderr, "InnoDB: Something wrong with reading page %lu.\n", page_no);
++convert_err_exit:
++				mtr_commit(&mtr);
++				mutex_enter(&fil_system->mutex);
++				fil_space_free(space_id, FALSE);
++				mutex_exit(&fil_system->mutex);
++				success = FALSE;
++				goto convert_exit;
++			}
++
++			supremum = page_get_supremum_rec(page);
++			rec = page_rec_get_next(page_get_infimum_rec(page));
++			n_recs = page_get_n_recs(page);
++
++			/* illegal operation as InnoDB online system. so not logged */
++			while (rec && rec != supremum && n_recs > 0) {
++				ulint	n_fields;
++				ulint	i;
++				ulint	offset = index->trx_id_offset;
++
++				offsets = rec_get_offsets(rec, index, offsets,
++						ULINT_UNDEFINED, &heap);
++				n_fields = rec_offs_n_fields(offsets);
++				if (!offset) {
++					offset = row_get_trx_id_offset(rec, index, offsets);
++				}
++				trx_write_trx_id(rec + offset, 1);
++
++				for (i = 0; i < n_fields; i++) {
++					if (rec_offs_nth_extern(offsets, i)) {
++						ulint	local_len;
++						byte*	data;
++
++						data = rec_get_nth_field(rec, offsets, i, &local_len);
++
++						local_len -= BTR_EXTERN_FIELD_REF_SIZE;
++
++						mach_write_to_4(data + local_len + BTR_EXTERN_SPACE_ID, id);
++					}
++				}
++
++				rec = page_rec_get_next(rec);
++				n_recs--;
++			}
++
++			/* dummy logged update for along with modified page path */
++			if (index->id != btr_page_get_index_id(page)) {
++				/* this should be adjusted already */
++				fprintf(stderr, "InnoDB: The page %lu seems to be converted wrong.\n", page_no);
++				goto convert_err_exit;
++			}
++			btr_page_set_index_id(page, page_zip, index->id, &mtr);
++
++			/* confirm whether fits to the page size or not */
++			if (!page_zip_compress(page_zip, page, index, &mtr)
++			    && !btr_page_reorganize(block, index, &mtr)) {
++				buf_block_t*	new_block;
++				page_t*		new_page;
++				page_zip_des_t*	new_page_zip;
++				rec_t*		split_rec;
++				ulint		n_uniq;
++
++				/* split page is needed */
++				fprintf(stderr, " %lu", page_no);
++
++				mtr_x_lock(dict_index_get_lock(index), &mtr);
++
++				n_uniq = dict_index_get_n_unique_in_tree(index);
++
++				if(page_get_n_recs(page) < 2) {
++					/* no way to make smaller */
++					fprintf(stderr, "InnoDB: The page %lu cannot be store to the page size.\n", page_no);
++					goto convert_err_exit;
++				}
++
++				if (UNIV_UNLIKELY(page_no == dict_index_get_page(index))) {
++					ulint		new_page_no;
++					dtuple_t*	node_ptr;
++					ulint		level;
++					rec_t*		node_ptr_rec;
++					page_cur_t	page_cursor;
++
++					/* it is root page, need to raise before split */
++
++					level = btr_page_get_level(page, &mtr);
++
++					new_block = btr_page_alloc(index, 0, FSP_NO_DIR, level, &mtr);
++					new_page = buf_block_get_frame(new_block);
++					new_page_zip = buf_block_get_page_zip(new_block);
++					btr_page_create(new_block, new_page_zip, index, level, &mtr);
++
++					btr_page_set_next(new_page, new_page_zip, FIL_NULL, &mtr);
++					btr_page_set_prev(new_page, new_page_zip, FIL_NULL, &mtr);
++
++					page_zip_copy_recs(new_page_zip, new_page,
++							   page_zip, page, index, &mtr);
++					btr_search_move_or_delete_hash_entries(new_block, block, index);
++
++					rec = page_rec_get_next(page_get_infimum_rec(new_page));
++					new_page_no = buf_block_get_page_no(new_block);
++
++					node_ptr = dict_index_build_node_ptr(index, rec, new_page_no, heap,
++									     level);
++					dtuple_set_info_bits(node_ptr,
++							     dtuple_get_info_bits(node_ptr)
++							     | REC_INFO_MIN_REC_FLAG);
++					btr_page_empty(block, page_zip, index, level + 1, &mtr);
++
++					btr_page_set_next(page, page_zip, FIL_NULL, &mtr);
++					btr_page_set_prev(page, page_zip, FIL_NULL, &mtr);
++
++					page_cur_set_before_first(block, &page_cursor);
++
++					node_ptr_rec = page_cur_tuple_insert(&page_cursor, node_ptr,
++									     index, 0, &mtr);
++					ut_a(node_ptr_rec);
++
++					if (!btr_page_reorganize(block, index, &mtr)) {
++						fprintf(stderr, "InnoDB: failed to store the page %lu.\n", page_no);
++						goto convert_err_exit;
++					}
++
++					/* move to the raised page */
++					page_no = new_page_no;
++					block = new_block;
++					page = new_page;
++					page_zip = new_page_zip;
++
++					fprintf(stderr, "(raise_to:%lu)", page_no);
++				}
++
++				split_rec = page_get_middle_rec(page);
++
++				new_block = btr_page_alloc(index, page_no + 1, FSP_UP,
++							   btr_page_get_level(page, &mtr), &mtr);
++				new_page = buf_block_get_frame(new_block);
++				new_page_zip = buf_block_get_page_zip(new_block);
++				btr_page_create(new_block, new_page_zip, index,
++						btr_page_get_level(page, &mtr), &mtr);
++
++				offsets = rec_get_offsets(split_rec, index, offsets, n_uniq, &heap);
++
++				btr_attach_half_pages(index, block,
++						      split_rec, new_block, FSP_UP, &mtr);
++
++				page_zip_copy_recs(new_page_zip, new_page,
++						   page_zip, page, index, &mtr);
++				page_delete_rec_list_start(split_rec - page + new_page,
++							   new_block, index, &mtr);
++				btr_search_move_or_delete_hash_entries(new_block, block, index);
++				page_delete_rec_list_end(split_rec, block, index,
++							 ULINT_UNDEFINED, ULINT_UNDEFINED, &mtr);
++
++				fprintf(stderr, "(new:%lu)", buf_block_get_page_no(new_block));
++
++				/* Are they needed? */
++				if (!btr_page_reorganize(block, index, &mtr)) {
++					fprintf(stderr, "InnoDB: failed to store the page %lu.\n", page_no);
++					goto convert_err_exit;
++				}
++				if (!btr_page_reorganize(new_block, index, &mtr)) {
++					fprintf(stderr, "InnoDB: failed to store the page %lu.\n", buf_block_get_page_no(new_block));
++					goto convert_err_exit;
++				}
++			}
++
++			page_no = btr_page_get_next(page, &mtr);
++
++			mtr_commit(&mtr);
++
++			if (heap) {
++				mem_heap_empty(heap);
++			}
++		}
++
++		fprintf(stderr, "...done.\nInnoDB: waiting the flush batch of the additional conversion.\n");
++
++		/* should wait for the not-logged changes are all flushed */
++		buf_flush_list(ULINT_MAX, mtr.end_lsn + 1);
++		buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST);
++
++		fprintf(stderr, "InnoDB: done.\n");
++convert_exit:
++		if (UNIV_LIKELY_NULL(heap)) {
++			mem_heap_free(heap);
++		}
++	}
++
+ 	return(success);
+ }
+ #endif /* !UNIV_HOTBACKUP */
 diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
 --- a/storage/innobase/handler/ha_innodb.cc	2010-12-03 15:49:59.195023983 +0900
 +++ b/storage/innobase/handler/ha_innodb.cc	2010-12-03 15:52:23.555957062 +0900
-@@ -7368,6 +7368,14 @@
+@@ -7377,6 +7377,14 @@
  		err = row_discard_tablespace_for_mysql(dict_table->name, trx);
  	} else {
  		err = row_import_tablespace_for_mysql(dict_table->name, trx);
@@ -515,7 +883,7 @@
  	}
  
  	err = convert_error_code_to_mysql(err, dict_table->flags, NULL);
-@@ -11642,6 +11650,11 @@
+@@ -11649,6 +11657,11 @@
    "Choose method of innodb_adaptive_flushing. (native, [estimate], keep_average)",
    NULL, innodb_adaptive_flushing_method_update, 1, &adaptive_flushing_method_typelib);
  
@@ -527,7 +895,7 @@
  static MYSQL_SYSVAR_ULONG(dict_size_limit, srv_dict_size_limit,
    PLUGIN_VAR_RQCMDARG,
    "Limit the allocated memory for dictionary cache. (0: unlimited)",
-@@ -11714,6 +11727,7 @@
+@@ -11721,6 +11734,7 @@
    MYSQL_SYSVAR(flush_neighbor_pages),
    MYSQL_SYSVAR(read_ahead),
    MYSQL_SYSVAR(adaptive_flushing_method),
@@ -535,10 +903,125 @@
    MYSQL_SYSVAR(dict_size_limit),
    MYSQL_SYSVAR(use_sys_malloc),
    MYSQL_SYSVAR(use_native_aio),
+diff -ruN a/storage/innobase/include/btr0btr.h b/storage/innobase/include/btr0btr.h
+--- a/storage/innobase/include/btr0btr.h	2011-04-11 19:44:03.000000000 +0900
++++ b/storage/innobase/include/btr0btr.h	2011-05-24 20:30:12.459853343 +0900
+@@ -219,6 +219,17 @@
+ @return the uncompressed page frame */
+ # define btr_page_get(space,zip_size,page_no,mode,mtr) \
+ 	buf_block_get_frame(btr_block_get(space,zip_size,page_no,mode,mtr))
++/**************************************************************//**
++Sets the index id field of a page. */
++UNIV_INLINE
++void
++btr_page_set_index_id(
++/*==================*/
++	page_t*		page,	/*!< in: page to be created */
++	page_zip_des_t*	page_zip,/*!< in: compressed page whose uncompressed
++				part will be updated, or NULL */
++	index_id_t	id,	/*!< in: index id */
++	mtr_t*		mtr);	/*!< in: mtr */
+ #endif /* !UNIV_HOTBACKUP */
+ /**************************************************************//**
+ Gets the index id field of a page.
+@@ -256,6 +267,17 @@
+ 	const page_t*	page,	/*!< in: index page */
+ 	mtr_t*		mtr);	/*!< in: mini-transaction handle */
+ /********************************************************//**
++Sets the next index page field. */
++UNIV_INLINE
++void
++btr_page_set_next(
++/*==============*/
++	page_t*		page,	/*!< in: index page */
++	page_zip_des_t*	page_zip,/*!< in: compressed page whose uncompressed
++				part will be updated, or NULL */
++	ulint		next,	/*!< in: next page number */
++	mtr_t*		mtr);	/*!< in: mini-transaction handle */
++/********************************************************//**
+ Gets the previous index page number.
+ @return	prev page number */
+ UNIV_INLINE
+@@ -264,6 +286,17 @@
+ /*==============*/
+ 	const page_t*	page,	/*!< in: index page */
+ 	mtr_t*		mtr);	/*!< in: mini-transaction handle */
++/********************************************************//**
++Sets the previous index page field. */
++UNIV_INLINE
++void
++btr_page_set_prev(
++/*==============*/
++	page_t*		page,	/*!< in: index page */
++	page_zip_des_t*	page_zip,/*!< in: compressed page whose uncompressed
++				part will be updated, or NULL */
++	ulint		prev,	/*!< in: previous page number */
++	mtr_t*		mtr);	/*!< in: mini-transaction handle */
+ /*************************************************************//**
+ Gets pointer to the previous user record in the tree. It is assumed
+ that the caller has appropriate latches on the page and its neighbor.
+@@ -309,6 +342,18 @@
+ /*===========================*/
+ 	const rec_t*	rec,	/*!< in: node pointer record */
+ 	const ulint*	offsets);/*!< in: array returned by rec_get_offsets() */
++/**************************************************************//**
++Creates a new index page (not the root, and also not
++used in page reorganization).  @see btr_page_empty(). */
++UNIV_INTERN
++void
++btr_page_create(
++/*============*/
++	buf_block_t*	block,	/*!< in/out: page to be created */
++	page_zip_des_t*	page_zip,/*!< in/out: compressed page, or NULL */
++	dict_index_t*	index,	/*!< in: index */
++	ulint		level,	/*!< in: the B-tree level of the page */
++	mtr_t*		mtr);	/*!< in: mtr */
+ /************************************************************//**
+ Creates the root node for a new index tree.
+ @return	page number of the created root, FIL_NULL if did not succeed */
+@@ -379,6 +424,17 @@
+ 	dict_index_t*	index,	/*!< in: record descriptor */
+ 	mtr_t*		mtr);	/*!< in: mtr */
+ /*************************************************************//**
++Empties an index page.  @see btr_page_create(). */
++UNIV_INTERN
++void
++btr_page_empty(
++/*===========*/
++	buf_block_t*	block,	/*!< in: page to be emptied */
++	page_zip_des_t*	page_zip,/*!< out: compressed page, or NULL */
++	dict_index_t*	index,	/*!< in: index of the page */
++	ulint		level,	/*!< in: the B-tree level of the page */
++	mtr_t*		mtr);	/*!< in: mtr */
++/*************************************************************//**
+ Decides if the page should be split at the convergence point of
+ inserts converging to left.
+ @return	TRUE if split recommended */
+@@ -437,6 +493,20 @@
+ # define btr_insert_on_non_leaf_level(i,l,t,m)				\
+ 	btr_insert_on_non_leaf_level_func(i,l,t,__FILE__,__LINE__,m)
+ #endif /* !UNIV_HOTBACKUP */
++/**************************************************************//**
++Attaches the halves of an index page on the appropriate level in an
++index tree. */
++UNIV_INTERN
++void
++btr_attach_half_pages(
++/*==================*/
++	dict_index_t*	index,		/*!< in: the index tree */
++	buf_block_t*	block,		/*!< in/out: page to be split */
++	rec_t*		split_rec,	/*!< in: first record on upper
++					half page */
++	buf_block_t*	new_block,	/*!< in/out: the new half page */
++	ulint		direction,	/*!< in: FSP_UP or FSP_DOWN */
++	mtr_t*		mtr);		/*!< in: mtr */
+ /****************************************************************//**
+ Sets a record as the predefined minimum record. */
+ UNIV_INTERN
 diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
 --- a/storage/innobase/include/srv0srv.h	2010-12-03 15:48:03.077954270 +0900
 +++ b/storage/innobase/include/srv0srv.h	2010-12-03 15:52:23.561986996 +0900
-@@ -232,6 +232,8 @@
+@@ -229,6 +229,8 @@
  extern ulint	srv_read_ahead;
  extern ulint	srv_adaptive_flushing_method;
  
@@ -547,10 +1030,37 @@
  extern ulint	srv_dict_size_limit;
  /*-------------------------------------------*/
  
+diff -ruN a/storage/innobase/row/row0mysql.c b/storage/innobase/row/row0mysql.c
+--- a/storage/innobase/row/row0mysql.c	2011-04-11 19:44:03.000000000 +0900
++++ b/storage/innobase/row/row0mysql.c	2011-06-06 11:53:18.395764565 +0900
+@@ -2568,6 +2568,11 @@
+ 
+ 	current_lsn = log_get_lsn();
+ 
++	/* Enlarge the fatal lock wait timeout during import. */
++	mutex_enter(&kernel_mutex);
++	srv_fatal_semaphore_wait_threshold += 7200; /* 2 hours */
++	mutex_exit(&kernel_mutex);
++
+ 	/* It is possible, though very improbable, that the lsn's in the
+ 	tablespace to be imported have risen above the current system lsn, if
+ 	a lengthy purge, ibuf merge, or rollback was performed on a backup
+@@ -2679,6 +2684,11 @@
+ 
+ 	trx->op_info = "";
+ 
++	/* Restore the fatal semaphore wait timeout */
++	mutex_enter(&kernel_mutex);
++	srv_fatal_semaphore_wait_threshold -= 7200; /* 2 hours */
++	mutex_exit(&kernel_mutex);
++
+ 	return((int) err);
+ }
+ 
 diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
 --- a/storage/innobase/srv/srv0srv.c	2010-12-03 15:49:59.230956118 +0900
 +++ b/storage/innobase/srv/srv0srv.c	2010-12-03 15:52:23.562954411 +0900
-@@ -422,6 +422,8 @@
+@@ -416,6 +416,8 @@
  UNIV_INTERN ulint	srv_read_ahead = 3; /* 1: random  2: linear  3: Both */
  UNIV_INTERN ulint	srv_adaptive_flushing_method = 0; /* 0: native  1: estimate  2: keep_average */
  

=== modified file 'innodb_extend_slow.patch'
--- innodb_extend_slow.patch	2011-05-10 11:57:42 +0000
+++ innodb_extend_slow.patch	2011-06-20 09:04:39 +0000
@@ -335,7 +335,7 @@
 diff -ruN a/storage/innobase/fil/fil0fil.c b/storage/innobase/fil/fil0fil.c
 --- a/storage/innobase/fil/fil0fil.c	2010-12-03 15:53:54.610037199 +0900
 +++ b/storage/innobase/fil/fil0fil.c	2010-12-03 17:42:42.079064198 +0900
-@@ -4423,7 +4423,7 @@
+@@ -4747,7 +4747,7 @@
  				 node->name, node->handle, buf,
  				 offset_low, offset_high,
  				 page_size * n_pages,
@@ -344,7 +344,7 @@
  #endif
  		if (success) {
  			node->size += n_pages;
-@@ -4750,7 +4750,7 @@
+@@ -5074,7 +5074,7 @@
  i/o on a tablespace which does not exist */
  UNIV_INTERN
  ulint
@@ -353,7 +353,7 @@
  /*===*/
  	ulint	type,		/*!< in: OS_FILE_READ or OS_FILE_WRITE,
  				ORed to OS_FILE_LOG, if a log i/o
-@@ -4775,8 +4775,9 @@
+@@ -5099,8 +5099,9 @@
  	void*	buf,		/*!< in/out: buffer where to store read data
  				or from where to write; in aio this must be
  				appropriately aligned */
@@ -364,7 +364,7 @@
  {
  	ulint		mode;
  	fil_space_t*	space;
-@@ -4944,7 +4945,7 @@
+@@ -5268,7 +5269,7 @@
  #else
  	/* Queue the aio request */
  	ret = os_aio(type, mode | wake_later, node->name, node->handle, buf,
@@ -376,7 +376,7 @@
 diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
 --- a/storage/innobase/handler/ha_innodb.cc	2010-12-03 17:36:44.293955189 +0900
 +++ b/storage/innobase/handler/ha_innodb.cc	2010-12-03 17:42:42.090024586 +0900
-@@ -1559,6 +1559,16 @@
+@@ -1573,6 +1573,16 @@
  	trx->check_unique_secondary = !thd_test_options(
  		thd, OPTION_RELAXED_UNIQUE_CHECKS);
  
@@ -393,7 +393,7 @@
  	DBUG_VOID_RETURN;
  }
  
-@@ -1613,6 +1623,32 @@
+@@ -1627,6 +1637,32 @@
  	return(trx);
  }
  
@@ -426,7 +426,7 @@
  /*********************************************************************//**
  Note that a transaction has been registered with MySQL.
  @return true if transaction is registered with MySQL 2PC coordinator */
-@@ -9296,6 +9332,25 @@
+@@ -9301,6 +9337,25 @@
  	statement has ended */
  
  	if (trx->n_mysql_tables_in_use == 0) {
@@ -648,13 +648,13 @@
 +/* prototypes for new functions added to ha_innodb.cc */
 +ibool	innobase_get_slow_log();
 +
- /* This is set to the MySQL server value for this variable. */
- extern uint	srv_lower_case_table_names;
- 
+ /* Mutex for locking srv_monitor_file */
+ extern mutex_t	srv_monitor_file_mutex;
+ /* Temporary file for innodb monitor output */
 diff -ruN a/storage/innobase/include/trx0trx.h b/storage/innobase/include/trx0trx.h
 --- a/storage/innobase/include/trx0trx.h	2010-12-03 15:41:52.049372966 +0900
 +++ b/storage/innobase/include/trx0trx.h	2010-12-03 17:42:42.107024532 +0900
-@@ -738,6 +738,17 @@
+@@ -743,6 +743,17 @@
  	/*------------------------------*/
  	char detailed_error[256];	/*!< detailed error message for last
  					error, or empty. */
@@ -843,8 +843,8 @@
  		}
  
  		ut_a(type == OS_FILE_WRITE);
-@@ -4099,6 +4131,11 @@
- 		ut_error;
+@@ -4101,6 +4133,11 @@
+ 		array = NULL; /* Eliminate compiler warning */
  	}
  
 +	if (trx && type == OS_FILE_READ)
@@ -865,10 +865,10 @@
 +/* prototypes for new functions added to ha_innodb.cc */
 +ibool	innobase_get_slow_log();
 +
- /* This is set to the MySQL server value for this variable.  It is only
- needed for FOREIGN KEY definition parsing since FOREIGN KEY names are not
- stored in the server metadata. The server stores and enforces it for
-@@ -1244,6 +1247,10 @@
+ /* The following counter is incremented whenever there is some user activity
+ in the server */
+ UNIV_INTERN ulint	srv_activity_count	= 0;
+@@ -1232,6 +1235,10 @@
  	ibool			has_slept = FALSE;
  	srv_conc_slot_t*	slot	  = NULL;
  	ulint			i;
@@ -877,9 +877,9 @@
 +	ulint                   sec;
 +	ulint                   ms;
  
- 	if (trx->mysql_thd != NULL
- 	    && thd_is_replication_slave_thread(trx->mysql_thd)) {
-@@ -1320,6 +1327,7 @@
+ #ifdef UNIV_SYNC_DEBUG
+ 	ut_ad(!sync_thread_levels_nonempty_trx(trx->has_search_latch));
+@@ -1312,6 +1319,7 @@
  		switches. */
  		if (SRV_THREAD_SLEEP_DELAY > 0) {
  			os_thread_sleep(SRV_THREAD_SLEEP_DELAY);
@@ -887,10 +887,11 @@
  		}
  
  		trx->op_info = "";
-@@ -1375,6 +1383,13 @@
- 	/* Go to wait for the event; when a thread leaves InnoDB it will
- 	release this thread */
- 
+@@ -1371,6 +1379,14 @@
+ #ifdef UNIV_SYNC_DEBUG
+ 	ut_ad(!sync_thread_levels_nonempty_trx(trx->has_search_latch));
+ #endif /* UNIV_SYNC_DEBUG */
++
 +	if (innobase_get_slow_log() && trx->take_stats) {
 +		ut_usectime(&sec, &ms);
 +		start_time = (ib_uint64_t)sec * 1000000 + ms;
@@ -901,7 +902,7 @@
  	trx->op_info = "waiting in InnoDB queue";
  
  	thd_wait_begin(trx->mysql_thd, THD_WAIT_ROW_TABLE_LOCK);
-@@ -1383,6 +1398,12 @@
+@@ -1379,6 +1395,12 @@
  
  	trx->op_info = "";
  
@@ -917,7 +918,7 @@
 diff -ruN a/storage/innobase/trx/trx0trx.c b/storage/innobase/trx/trx0trx.c
 --- a/storage/innobase/trx/trx0trx.c	2010-12-03 15:41:52.053955669 +0900
 +++ b/storage/innobase/trx/trx0trx.c	2010-12-03 17:42:42.127023410 +0900
-@@ -185,6 +185,15 @@
+@@ -188,6 +188,15 @@
  	trx->global_read_view = NULL;
  	trx->read_view = NULL;
  
@@ -933,9 +934,9 @@
  	/* Set X/Open XA transaction identification to NULL */
  	memset(&trx->xid, 0, sizeof(trx->xid));
  	trx->xid.formatID = -1;
-@@ -222,6 +231,11 @@
+@@ -221,6 +230,11 @@
  
- 	trx->mysql_process_no = os_proc_get_number();
+ 	mutex_exit(&kernel_mutex);
  
 +	if (innobase_get_slow_log() && trx->take_stats) {
 +		trx->distinct_page_access_hash = mem_alloc(DPAH_SIZE);
@@ -945,7 +946,7 @@
  	return(trx);
  }
  
-@@ -353,6 +367,12 @@
+@@ -406,6 +420,12 @@
  /*===============*/
  	trx_t*	trx)	/*!< in, own: trx object */
  {
@@ -958,7 +959,7 @@
  	mutex_enter(&kernel_mutex);
  
  	UT_LIST_REMOVE(mysql_trx_list, trx_sys->mysql_trx_list, trx);
-@@ -374,6 +394,12 @@
+@@ -427,6 +447,12 @@
  /*====================*/
  	trx_t*	trx)	/*!< in, own: trx object */
  {
@@ -971,7 +972,7 @@
  	mutex_enter(&kernel_mutex);
  
  	trx_free(trx);
-@@ -1152,6 +1178,9 @@
+@@ -1212,6 +1238,9 @@
  	trx_t*	trx)	/*!< in: transaction */
  {
  	que_thr_t*	thr;
@@ -981,7 +982,7 @@
  
  	ut_ad(mutex_own(&kernel_mutex));
  	ut_ad(trx->que_state == TRX_QUE_LOCK_WAIT);
-@@ -1166,6 +1195,11 @@
+@@ -1226,6 +1255,11 @@
  		thr = UT_LIST_GET_FIRST(trx->wait_thrs);
  	}
  
@@ -993,7 +994,7 @@
  	trx->que_state = TRX_QUE_RUNNING;
  }
  
-@@ -1179,6 +1213,9 @@
+@@ -1239,6 +1273,9 @@
  	trx_t*	trx)	/*!< in: transaction in the TRX_QUE_LOCK_WAIT state */
  {
  	que_thr_t*	thr;
@@ -1003,7 +1004,7 @@
  
  	ut_ad(mutex_own(&kernel_mutex));
  	ut_ad(trx->que_state == TRX_QUE_LOCK_WAIT);
-@@ -1193,6 +1230,11 @@
+@@ -1253,6 +1290,11 @@
  		thr = UT_LIST_GET_FIRST(trx->wait_thrs);
  	}
  

=== modified file 'innodb_extra_rseg.patch'
--- innodb_extra_rseg.patch	2011-05-23 03:13:18 +0000
+++ innodb_extra_rseg.patch	2011-06-20 09:04:39 +0000
@@ -8,7 +8,7 @@
 diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
 --- a/storage/innobase/handler/ha_innodb.cc	2010-12-03 15:18:48.879955903 +0900
 +++ b/storage/innobase/handler/ha_innodb.cc	2010-12-03 15:22:53.779955671 +0900
-@@ -11521,6 +11521,7 @@
+@@ -11528,6 +11528,7 @@
    innobase_system_variables, /* system variables */
    NULL /* reserved */
  },

=== added file 'innodb_fake_changes.patch'
--- innodb_fake_changes.patch	1970-01-01 00:00:00 +0000
+++ innodb_fake_changes.patch	2011-06-20 09:04:39 +0000
@@ -0,0 +1,614 @@
+# name       : innodb_fake_changes.patch
+# introduced : 5.5.12
+# maintainer : Yasufumi
+#
+#!!! notice !!!
+# Any small change to this file in the main branch
+# should be done or reviewed by the maintainer!
+diff -ruN a/storage/innobase/btr/btr0cur.c b/storage/innobase/btr/btr0cur.c
+--- a/storage/innobase/btr/btr0cur.c	2011-06-01 21:04:26.346416429 +0900
++++ b/storage/innobase/btr/btr0cur.c	2011-06-01 21:04:53.718415294 +0900
+@@ -1167,6 +1167,11 @@
+ 	rec_t*		rec;
+ 	roll_ptr_t	roll_ptr;
+ 
++	if (thr && thr_get_trx(thr)->fake_changes) {
++		/* skip LOCK, UNDO */
++		return(DB_SUCCESS);
++	}
++
+ 	/* Check if we have to wait for a lock: enqueue an explicit lock
+ 	request if yes */
+ 
+@@ -1298,7 +1303,7 @@
+ 	}
+ #endif /* UNIV_DEBUG */
+ 
+-	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
++	ut_ad((thr && thr_get_trx(thr)->fake_changes) || mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
+ 	max_size = page_get_max_insert_size_after_reorganize(page, 1);
+ 	leaf = page_is_leaf(page);
+ 
+@@ -1393,6 +1398,12 @@
+ 		goto fail_err;
+ 	}
+ 
++	if (thr && thr_get_trx(thr)->fake_changes) {
++		/* skip CHANGE, LOG */
++		*big_rec = big_rec_vec;
++		return(err); /* == DB_SUCCESS */
++	}
++
+ 	page_cursor = btr_cur_get_page_cur(cursor);
+ 
+ 	/* Now, try the insert */
+@@ -1535,10 +1546,10 @@
+ 
+ 	*big_rec = NULL;
+ 
+-	ut_ad(mtr_memo_contains(mtr,
++	ut_ad((thr && thr_get_trx(thr)->fake_changes) || mtr_memo_contains(mtr,
+ 				dict_index_get_lock(btr_cur_get_index(cursor)),
+ 				MTR_MEMO_X_LOCK));
+-	ut_ad(mtr_memo_contains(mtr, btr_cur_get_block(cursor),
++	ut_ad((thr && thr_get_trx(thr)->fake_changes) || mtr_memo_contains(mtr, btr_cur_get_block(cursor),
+ 				MTR_MEMO_PAGE_X_FIX));
+ 
+ 	/* Try first an optimistic insert; reset the cursor flag: we do not
+@@ -1604,6 +1615,16 @@
+ 		}
+ 	}
+ 
++	if (thr && thr_get_trx(thr)->fake_changes) {
++		/* skip CHANGE, LOG */
++		if (n_extents > 0) {
++			fil_space_release_free_extents(index->space,
++						       n_reserved);
++		}
++		*big_rec = big_rec_vec;
++		return(DB_SUCCESS);
++	}
++
+ 	if (dict_index_get_page(index)
+ 	    == buf_block_get_page_no(btr_cur_get_block(cursor))) {
+ 
+@@ -1660,6 +1681,11 @@
+ 
+ 	ut_ad(cursor && update && thr && roll_ptr);
+ 
++	if (thr && thr_get_trx(thr)->fake_changes) {
++		/* skip LOCK, UNDO */
++		return(DB_SUCCESS);
++	}
++
+ 	rec = btr_cur_get_rec(cursor);
+ 	index = cursor->index;
+ 
+@@ -1958,6 +1984,14 @@
+ 		return(err);
+ 	}
+ 
++	if (trx->fake_changes) {
++		/* skip CHANGE, LOG */
++		if (UNIV_LIKELY_NULL(heap)) {
++			mem_heap_free(heap);
++		}
++		return(err); /* == DB_SUCCESS */
++	}
++
+ 	if (block->is_hashed) {
+ 		/* The function row_upd_changes_ord_field_binary works only
+ 		if the update vector was built for a clustered index, we must
+@@ -2061,7 +2095,7 @@
+ 	rec = btr_cur_get_rec(cursor);
+ 	index = cursor->index;
+ 	ut_ad(!!page_rec_is_comp(rec) == dict_table_is_comp(index->table));
+-	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
++	ut_ad((thr && thr_get_trx(thr)->fake_changes) || mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
+ 	/* The insert buffer tree should never be updated in place. */
+ 	ut_ad(!dict_index_is_ibuf(index));
+ 
+@@ -2171,6 +2205,11 @@
+ 		goto err_exit;
+ 	}
+ 
++	if (thr && thr_get_trx(thr)->fake_changes) {
++		/* skip CHANGE, LOG */
++		goto err_exit; /* == DB_SUCCESS */
++	}
++
+ 	/* Ok, we may do the replacement. Store on the page infimum the
+ 	explicit locks on rec, before deleting rec (see the comment in
+ 	btr_cur_pessimistic_update). */
+@@ -2321,9 +2360,9 @@
+ 	rec = btr_cur_get_rec(cursor);
+ 	index = cursor->index;
+ 
+-	ut_ad(mtr_memo_contains(mtr, dict_index_get_lock(index),
++	ut_ad((thr && thr_get_trx(thr)->fake_changes) || mtr_memo_contains(mtr, dict_index_get_lock(index),
+ 				MTR_MEMO_X_LOCK));
+-	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
++	ut_ad((thr && thr_get_trx(thr)->fake_changes) || mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
+ #ifdef UNIV_ZIP_DEBUG
+ 	ut_a(!page_zip || page_zip_validate(page_zip, page));
+ #endif /* UNIV_ZIP_DEBUG */
+@@ -2411,6 +2450,9 @@
+ 
+ 		ut_ad(big_rec_vec == NULL);
+ 
++		/* fake_changes should not cause undo. so never reaches here */
++		ut_ad(!(trx->fake_changes));
++
+ 		btr_rec_free_updated_extern_fields(
+ 			index, rec, page_zip, offsets, update,
+ 			trx_is_recv(trx) ? RB_RECOVERY : RB_NORMAL, mtr);
+@@ -2445,6 +2487,12 @@
+ 		}
+ 	}
+ 
++	if (trx->fake_changes) {
++		/* skip CHANGE, LOG */
++		err = DB_SUCCESS;
++		goto return_after_reservations;
++	}
++
+ 	/* Store state of explicit locks on rec on the page infimum record,
+ 	before deleting rec. The page infimum acts as a dummy carrier of the
+ 	locks, taking care also of lock releases, before we can move the locks
+@@ -2746,6 +2794,11 @@
+ 	ut_ad(dict_index_is_clust(index));
+ 	ut_ad(!rec_get_deleted_flag(rec, rec_offs_comp(offsets)));
+ 
++	if (thr && thr_get_trx(thr)->fake_changes) {
++		/* skip LOCK, UNDO, CHANGE, LOG */
++		return(DB_SUCCESS);
++	}
++
+ 	err = lock_clust_rec_modify_check_and_lock(flags, block,
+ 						   rec, index, offsets, thr);
+ 
+@@ -2883,6 +2936,11 @@
+ 	rec_t*		rec;
+ 	ulint		err;
+ 
++	if (thr && thr_get_trx(thr)->fake_changes) {
++		/* skip LOCK, CHANGE, LOG */
++		return(DB_SUCCESS);
++	}
++
+ 	block = btr_cur_get_block(cursor);
+ 	rec = btr_cur_get_rec(cursor);
+ 
+diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
+--- a/storage/innobase/handler/ha_innodb.cc	2011-06-01 21:04:26.511385596 +0900
++++ b/storage/innobase/handler/ha_innodb.cc	2011-06-01 21:04:53.723390828 +0900
+@@ -484,6 +484,12 @@
+   " or 2 (write at commit, flush once per second).",
+   NULL, NULL, 1, 0, 2, 0);
+ 
++static MYSQL_THDVAR_BOOL(fake_changes, PLUGIN_VAR_OPCMDARG,
++  "In the transaction after enabled, UPDATE, INSERT and DELETE only move the cursor to the records "
++  "and do nothing other operations (no changes, no ibuf, no undo, no transaction log) in the transaction. "
++  "ATTENTION: the transaction started after enabled is affected.",
++  NULL, NULL, FALSE);
++
+ 
+ static handler *innobase_create_handler(handlerton *hton,
+                                         TABLE_SHARE *table,
+@@ -1675,6 +1681,8 @@
+ 	trx->check_unique_secondary = !thd_test_options(
+ 		thd, OPTION_RELAXED_UNIQUE_CHECKS);
+ 
++	trx->fake_changes = THDVAR(thd, fake_changes);
++
+ #ifdef EXTENDED_SLOWLOG
+ 	if (thd_log_slow_verbosity(thd) & SLOG_V_INNODB) {
+ 		trx->take_stats = TRUE;
+@@ -7486,12 +7494,20 @@
+ 
+ 	parent_trx = check_trx_exists(thd);
+ 
++
++	if (parent_trx->fake_changes
++	    && thd_sql_command(thd) != SQLCOM_CREATE_TABLE) {
++		sql_print_error("innodb_fake_changes cannot treat new table during other than CREATE TABLE. (%s)\n", name);
++		DBUG_RETURN(HA_ERR_WRONG_COMMAND);
++	}
++
+ 	/* In case MySQL calls this in the middle of a SELECT query, release
+ 	possible adaptive hash latch to avoid deadlocks of threads */
+ 
+ 	trx_search_latch_release_if_reserved(parent_trx);
+ 
+ 	trx = innobase_trx_allocate(thd);
++	trx->fake_changes = FALSE;
+ 
+ 	/* Latch the InnoDB data dictionary exclusively so that no deadlocks
+ 	or lock waits can happen in it during a table create operation.
+@@ -7701,6 +7717,7 @@
+ /*==============================*/
+ {
+ 	int		error;
++	ibool		fake_changes_reserved = FALSE;
+ 
+ 	DBUG_ENTER("ha_innobase::truncate");
+ 
+@@ -7713,10 +7730,21 @@
+ 		DBUG_RETURN(HA_ERR_CRASHED);
+ 	}
+ 
++	if (prebuilt->trx->fake_changes) {
++		/* disable temporally */
++		prebuilt->trx->fake_changes = FALSE;
++		fake_changes_reserved = TRUE;
++	}
++
+ 	/* Truncate the table in InnoDB */
+ 
+ 	error = row_truncate_table_for_mysql(prebuilt->table, prebuilt->trx);
+ 
++	if (fake_changes_reserved) {
++		prebuilt->trx->fake_changes = TRUE;
++		fake_changes_reserved = FALSE;
++	}
++
+ 	if (share->ib_table->is_corrupt) {
+ 		DBUG_RETURN(HA_ERR_CRASHED);
+ 	}
+@@ -7768,6 +7796,7 @@
+ 	trx_search_latch_release_if_reserved(parent_trx);
+ 
+ 	trx = innobase_trx_allocate(thd);
++	trx->fake_changes = FALSE;
+ 
+ 	name_len = strlen(name);
+ 
+@@ -7855,6 +7884,7 @@
+ 	trx->mysql_thd = NULL;
+ #else
+ 	trx = innobase_trx_allocate(thd);
++	trx->fake_changes = FALSE;
+ #endif
+ 	row_drop_database_for_mysql(namebuf, trx);
+ 	my_free(namebuf);
+@@ -7960,6 +7990,7 @@
+ 	trx_search_latch_release_if_reserved(parent_trx);
+ 
+ 	trx = innobase_trx_allocate(thd);
++	trx->fake_changes = FALSE;
+ 
+ 	error = innobase_rename_table(trx, from, to, TRUE);
+ 
+@@ -12228,6 +12259,7 @@
+   MYSQL_SYSVAR(rollback_segments),
+   MYSQL_SYSVAR(corrupt_table_action),
+   MYSQL_SYSVAR(lazy_drop_table),
++  MYSQL_SYSVAR(fake_changes),
+   NULL
+ };
+ 
+diff -ruN a/storage/innobase/handler/handler0alter.cc b/storage/innobase/handler/handler0alter.cc
+--- a/storage/innobase/handler/handler0alter.cc	2011-04-11 19:44:03.000000000 +0900
++++ b/storage/innobase/handler/handler0alter.cc	2011-06-01 21:04:53.728495636 +0900
+@@ -641,6 +641,7 @@
+ 	ibool		dict_locked	= FALSE;
+ 	ulint		new_primary;
+ 	int		error;
++	ulint		should_fake_changes	= FALSE;
+ 
+ 	DBUG_ENTER("ha_innobase::add_index");
+ 	ut_a(table);
+@@ -677,11 +678,17 @@
+ 	}
+ 
+ 	heap = mem_heap_create(1024);
++
++	if (prebuilt->trx->fake_changes) {
++		prebuilt->trx->fake_changes = FALSE;
++		should_fake_changes = TRUE;
++	}
+ 	trx_start_if_not_started(prebuilt->trx);
+ 
+ 	/* Create a background transaction for the operations on
+ 	the data dictionary tables. */
+ 	trx = innobase_trx_allocate(user_thd);
++	trx->fake_changes = FALSE;
+ 	trx_start_if_not_started(trx);
+ 
+ 	/* Create table containing all indexes to be built in this
+@@ -760,6 +767,9 @@
+ 			row_mysql_unlock_data_dictionary(trx);
+ 			trx_free_for_mysql(trx);
+ 			trx_commit_for_mysql(prebuilt->trx);
++			if (should_fake_changes) {
++				prebuilt->trx->fake_changes = TRUE;
++			}
+ 			DBUG_RETURN(error);
+ 		}
+ 
+@@ -925,6 +935,9 @@
+ 	trx_commit_for_mysql(trx);
+ 	if (prebuilt->trx) {
+ 		trx_commit_for_mysql(prebuilt->trx);
++		if (should_fake_changes) {
++			prebuilt->trx->fake_changes = TRUE;
++		}
+ 	}
+ 
+ 	if (dict_locked) {
+@@ -1172,6 +1185,7 @@
+ 	/* Create a background transaction for the operations on
+ 	the data dictionary tables. */
+ 	trx = innobase_trx_allocate(user_thd);
++	trx->fake_changes = FALSE;
+ 	trx_start_if_not_started(trx);
+ 
+ 	/* Flag this transaction as a dictionary operation, so that
+diff -ruN a/storage/innobase/ibuf/ibuf0ibuf.c b/storage/innobase/ibuf/ibuf0ibuf.c
+--- a/storage/innobase/ibuf/ibuf0ibuf.c	2011-06-01 21:04:26.529383815 +0900
++++ b/storage/innobase/ibuf/ibuf0ibuf.c	2011-06-01 21:04:53.732416483 +0900
+@@ -3496,6 +3496,8 @@
+ 
+ 	ut_a(trx_sys_multiple_tablespace_format);
+ 
++	ut_ad(!(thr_get_trx(thr)->fake_changes));
++
+ 	do_merge = FALSE;
+ 
+ 	/* Perform dirty reads of ibuf->size and ibuf->max_size, to
+diff -ruN a/storage/innobase/include/trx0trx.h b/storage/innobase/include/trx0trx.h
+--- a/storage/innobase/include/trx0trx.h	2011-06-01 21:04:25.762416618 +0900
++++ b/storage/innobase/include/trx0trx.h	2011-06-01 21:04:53.736387944 +0900
+@@ -512,6 +512,7 @@
+ 					FALSE, one can save CPU time and about
+ 					150 bytes in the undo log size as then
+ 					we skip XA steps */
++	ulint		fake_changes;
+ 	ulint		flush_log_later;/* In 2PC, we hold the
+ 					prepare_commit mutex across
+ 					both phases. In that case, we
+diff -ruN a/storage/innobase/lock/lock0lock.c b/storage/innobase/lock/lock0lock.c
+--- a/storage/innobase/lock/lock0lock.c	2011-06-01 21:04:26.543396960 +0900
++++ b/storage/innobase/lock/lock0lock.c	2011-06-01 21:04:53.739416526 +0900
+@@ -3909,6 +3909,10 @@
+ 
+ 	trx = thr_get_trx(thr);
+ 
++	if (trx->fake_changes && mode == LOCK_IX) {
++		mode = LOCK_IS;
++	}
++
+ 	lock_mutex_enter_kernel();
+ 
+ 	/* Look for stronger locks the same trx already has on the table */
+@@ -5107,6 +5111,11 @@
+ 	}
+ 
+ 	trx = thr_get_trx(thr);
++
++	if (trx->fake_changes) {
++		return(DB_SUCCESS);
++	}
++
+ 	next_rec = page_rec_get_next_const(rec);
+ 	next_rec_heap_no = page_rec_get_heap_no(next_rec);
+ 
+@@ -5275,6 +5284,10 @@
+ 		return(DB_SUCCESS);
+ 	}
+ 
++	if (thr && thr_get_trx(thr)->fake_changes) {
++		return(DB_SUCCESS);
++	}
++
+ 	heap_no = rec_offs_comp(offsets)
+ 		? rec_get_heap_no_new(rec)
+ 		: rec_get_heap_no_old(rec);
+@@ -5333,6 +5346,10 @@
+ 		return(DB_SUCCESS);
+ 	}
+ 
++	if (thr && thr_get_trx(thr)->fake_changes) {
++		return(DB_SUCCESS);
++	}
++
+ 	heap_no = page_rec_get_heap_no(rec);
+ 
+ 	/* Another transaction cannot have an implicit lock on the record,
+@@ -5420,6 +5437,10 @@
+ 		return(DB_SUCCESS);
+ 	}
+ 
++	if (thr && thr_get_trx(thr)->fake_changes && mode == LOCK_X) {
++		mode = LOCK_S;
++	}
++
+ 	heap_no = page_rec_get_heap_no(rec);
+ 
+ 	lock_mutex_enter_kernel();
+@@ -5496,6 +5517,10 @@
+ 		return(DB_SUCCESS);
+ 	}
+ 
++	if (thr && thr_get_trx(thr)->fake_changes && mode == LOCK_X) {
++		mode = LOCK_S;
++	}
++
+ 	heap_no = page_rec_get_heap_no(rec);
+ 
+ 	lock_mutex_enter_kernel();
+diff -ruN a/storage/innobase/que/que0que.c b/storage/innobase/que/que0que.c
+--- a/storage/innobase/que/que0que.c	2011-06-01 21:04:25.553416889 +0900
++++ b/storage/innobase/que/que0que.c	2011-06-01 21:04:53.743419001 +0900
+@@ -1417,6 +1417,12 @@
+ 
+ 	ut_a(trx->error_state == DB_SUCCESS);
+ 
++	if (trx->fake_changes) {
++		/* fake_changes should not access to system tables */
++		fprintf(stderr, "InnoDB: ERROR: innodb_fake_changes tried to access to system tables.\n");
++		return(DB_ERROR);
++	}
++
+ 	if (reserve_dict_mutex) {
+ 		mutex_enter(&dict_sys->mutex);
+ 	}
+diff -ruN a/storage/innobase/row/row0ins.c b/storage/innobase/row/row0ins.c
+--- a/storage/innobase/row/row0ins.c	2011-06-01 21:04:26.099449453 +0900
++++ b/storage/innobase/row/row0ins.c	2011-06-01 21:04:53.746383371 +0900
+@@ -1499,6 +1499,11 @@
+ 	if (UNIV_LIKELY_NULL(heap)) {
+ 		mem_heap_free(heap);
+ 	}
++
++	if (trx->fake_changes) {
++		err = DB_SUCCESS;
++	}
++
+ 	return(err);
+ }
+ 
+@@ -2004,7 +2009,7 @@
+ 	}
+ 
+ 	btr_cur_search_to_nth_level(index, 0, entry, PAGE_CUR_LE,
+-				    search_mode,
++				    thr_get_trx(thr)->fake_changes ? BTR_SEARCH_LEAF : search_mode,
+ 				    &cursor, 0, __FILE__, __LINE__, &mtr);
+ 
+ 	if (cursor.flag == BTR_CUR_INSERT_TO_IBUF) {
+@@ -2065,7 +2070,7 @@
+ 
+ 			btr_cur_search_to_nth_level(index, 0, entry,
+ 						    PAGE_CUR_LE,
+-						    mode | BTR_INSERT,
++						    thr_get_trx(thr)->fake_changes ? BTR_SEARCH_LEAF : (mode | BTR_INSERT),
+ 						    &cursor, 0,
+ 						    __FILE__, __LINE__, &mtr);
+ 		}
+@@ -2119,6 +2124,22 @@
+ 	if (UNIV_LIKELY_NULL(big_rec)) {
+ 		rec_t*	rec;
+ 		ulint*	offsets;
++
++		if (thr_get_trx(thr)->fake_changes) {
++			/* skip store extern */
++			if (modify) {
++				dtuple_big_rec_free(big_rec);
++			} else {
++				dtuple_convert_back_big_rec(index, entry, big_rec);
++			}
++
++			if (UNIV_LIKELY_NULL(heap)) {
++				mem_heap_free(heap);
++			}
++
++			return(err);
++		}
++
+ 		mtr_start(&mtr);
+ 
+ 		btr_cur_search_to_nth_level(index, 0, entry, PAGE_CUR_LE,
+diff -ruN a/storage/innobase/row/row0mysql.c b/storage/innobase/row/row0mysql.c
+--- a/storage/innobase/row/row0mysql.c	2011-06-01 21:04:26.287385626 +0900
++++ b/storage/innobase/row/row0mysql.c	2011-06-01 21:04:53.749372325 +0900
+@@ -1245,6 +1245,7 @@
+ 		prebuilt->table->stat_n_rows--;
+ 	}
+ 
++	if (!(trx->fake_changes))
+ 	row_update_statistics_if_needed(prebuilt->table);
+ 	trx->op_info = "";
+ 
+@@ -1504,6 +1505,7 @@
+ 	that changes indexed columns, UPDATEs that change only non-indexed
+ 	columns would not affect statistics. */
+ 	if (node->is_delete || !(node->cmpl_info & UPD_NODE_NO_ORD_CHANGE)) {
++		if (!(trx->fake_changes))
+ 		row_update_statistics_if_needed(prebuilt->table);
+ 	}
+ 
+@@ -1721,6 +1723,7 @@
+ 		srv_n_rows_updated++;
+ 	}
+ 
++	if (!(trx->fake_changes))
+ 	row_update_statistics_if_needed(table);
+ 
+ 	return(err);
+diff -ruN a/storage/innobase/row/row0upd.c b/storage/innobase/row/row0upd.c
+--- a/storage/innobase/row/row0upd.c	2011-06-01 21:04:25.588384975 +0900
++++ b/storage/innobase/row/row0upd.c	2011-06-01 21:04:53.753385366 +0900
+@@ -1603,7 +1603,8 @@
+ 		mode |= BTR_DELETE_MARK;
+ 	}
+ 
+-	search_result = row_search_index_entry(index, entry, mode,
++	search_result = row_search_index_entry(index, entry,
++					       trx->fake_changes ? BTR_SEARCH_LEAF : mode,
+ 					       &pcur, &mtr);
+ 
+ 	btr_cur = btr_pcur_get_btr_cur(&pcur);
+@@ -1850,9 +1851,11 @@
+ 		the previous invocation of this function. Mark the
+ 		off-page columns in the entry inherited. */
+ 
++		if (!(trx->fake_changes)) {
+ 		change_ownership = row_upd_clust_rec_by_insert_inherit(
+ 			NULL, NULL, entry, node->update);
+ 		ut_a(change_ownership);
++		}
+ 		/* fall through */
+ 	case UPD_NODE_INSERT_CLUSTERED:
+ 		/* A lock wait occurred in row_ins_index_entry() in
+@@ -1882,7 +1885,7 @@
+ 		delete-marked old record, mark them disowned by the
+ 		old record and owned by the new entry. */
+ 
+-		if (rec_offs_any_extern(offsets)) {
++		if (rec_offs_any_extern(offsets) && !(trx->fake_changes)) {
+ 			change_ownership = row_upd_clust_rec_by_insert_inherit(
+ 				rec, offsets, entry, node->update);
+ 
+@@ -2012,7 +2015,8 @@
+ 	the same transaction do not modify the record in the meantime.
+ 	Therefore we can assert that the restoration of the cursor succeeds. */
+ 
+-	ut_a(btr_pcur_restore_position(BTR_MODIFY_TREE, pcur, mtr));
++	ut_a(btr_pcur_restore_position(thr_get_trx(thr)->fake_changes ? BTR_SEARCH_LEAF : BTR_MODIFY_TREE,
++				       pcur, mtr));
+ 
+ 	ut_ad(!rec_get_deleted_flag(btr_pcur_get_rec(pcur),
+ 				    dict_table_is_comp(index->table)));
+@@ -2022,7 +2026,8 @@
+ 					 node->cmpl_info, thr, mtr);
+ 	mtr_commit(mtr);
+ 
+-	if (err == DB_SUCCESS && big_rec) {
++	/* skip store extern for fake_changes */
++	if (err == DB_SUCCESS && big_rec && !(thr_get_trx(thr)->fake_changes)) {
+ 		ulint		offsets_[REC_OFFS_NORMAL_SIZE];
+ 		rec_t*		rec;
+ 		rec_offs_init(offsets_);
+@@ -2146,7 +2151,8 @@
+ 
+ 	ut_a(pcur->rel_pos == BTR_PCUR_ON);
+ 
+-	success = btr_pcur_restore_position(BTR_MODIFY_LEAF, pcur, mtr);
++	success = btr_pcur_restore_position(thr_get_trx(thr)->fake_changes ? BTR_SEARCH_LEAF : BTR_MODIFY_LEAF,
++					    pcur, mtr);
+ 
+ 	if (!success) {
+ 		err = DB_RECORD_NOT_FOUND;
+diff -ruN a/storage/innobase/trx/trx0trx.c b/storage/innobase/trx/trx0trx.c
+--- a/storage/innobase/trx/trx0trx.c	2011-06-01 21:04:26.411537237 +0900
++++ b/storage/innobase/trx/trx0trx.c	2011-06-01 21:04:53.756415956 +0900
+@@ -121,6 +121,8 @@
+ 
+ 	trx->support_xa = TRUE;
+ 
++	trx->fake_changes = FALSE;
++
+ 	trx->check_foreigns = TRUE;
+ 	trx->check_unique_secondary = TRUE;
+ 

=== modified file 'innodb_fast_checksum.patch'
--- innodb_fast_checksum.patch	2011-05-10 11:57:42 +0000
+++ innodb_fast_checksum.patch	2011-06-20 09:04:39 +0000
@@ -109,8 +109,34 @@
 diff -ruN a/storage/innobase/fil/fil0fil.c b/storage/innobase/fil/fil0fil.c
 --- a/storage/innobase/fil/fil0fil.c	2010-12-04 15:52:23.406513743 +0900
 +++ b/storage/innobase/fil/fil0fil.c	2010-12-04 15:53:45.020513800 +0900
-@@ -3199,7 +3199,9 @@
- 			mach_write_to_8(page + FIL_PAGE_FILE_FLUSH_LSN, current_lsn);
+@@ -3094,13 +3094,24 @@
+ 		return(TRUE);
+ 	}
+ 
+-	if (checksum_field != 0
++	if (!srv_fast_checksum
++	    && checksum_field != 0
+ 	    && checksum_field != BUF_NO_CHECKSUM_MAGIC
+ 	    && checksum_field
+ 	    != buf_calc_page_new_checksum(page)) {
+ 		return(TRUE);
+ 	}
+ 
++	if (srv_fast_checksum
++	    && checksum_field != 0
++	    && checksum_field != BUF_NO_CHECKSUM_MAGIC
++	    && checksum_field
++	    != buf_calc_page_new_checksum_32(page)
++	    && checksum_field
++	    != buf_calc_page_new_checksum(page)) {
++		return(TRUE);
++	}
++
+ 	return(FALSE);
+ }
+ 
+@@ -3116,7 +3127,9 @@
+ 	if (!zip_size) {
  		mach_write_to_4(page + FIL_PAGE_SPACE_OR_CHKSUM,
  				srv_use_checksums
 -				? buf_calc_page_new_checksum(page)
@@ -120,45 +146,6 @@
  						: BUF_NO_CHECKSUM_MAGIC);
  		mach_write_to_4(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
  				srv_use_checksums
-@@ -3331,7 +3333,8 @@
- 					page_is_corrupt = TRUE;
- 				}
- 
--				if (checksum_field != 0
-+				if (!srv_fast_checksum
-+				    && checksum_field != 0
- 				    && checksum_field != BUF_NO_CHECKSUM_MAGIC
- 				    && checksum_field
- 				    != buf_calc_page_new_checksum(page)) {
-@@ -3339,6 +3342,17 @@
- 					page_is_corrupt = TRUE;
- 				}
- 
-+				if (srv_fast_checksum
-+				    && checksum_field != 0
-+				    && checksum_field != BUF_NO_CHECKSUM_MAGIC
-+				    && checksum_field
-+				    != buf_calc_page_new_checksum_32(page)
-+				    && checksum_field
-+				    != buf_calc_page_new_checksum(page)) {
-+
-+					page_is_corrupt = TRUE;
-+				}
-+
- 				/* if it is free page, inconsistency is acceptable */
- 				if (!offset) {
- 					/* header page*/
-@@ -3484,7 +3498,9 @@
- 
- 					mach_write_to_4(page + FIL_PAGE_SPACE_OR_CHKSUM,
- 							srv_use_checksums
--							? buf_calc_page_new_checksum(page)
-+							? (!srv_fast_checksum
-+							   ? buf_calc_page_new_checksum(page)
-+							   : buf_calc_page_new_checksum_32(page))
- 									: BUF_NO_CHECKSUM_MAGIC);
- 					mach_write_to_4(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
- 							srv_use_checksums
 diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
 --- a/storage/innobase/handler/ha_innodb.cc	2010-12-04 15:52:23.420480329 +0900
 +++ b/storage/innobase/handler/ha_innodb.cc	2010-12-04 15:53:45.029551892 +0900
@@ -170,7 +157,7 @@
  static my_bool	innobase_recovery_stats			= TRUE;
  static my_bool	innobase_locks_unsafe_for_binlog	= FALSE;
  static my_bool	innobase_overwrite_relay_log_info	= FALSE;
-@@ -2606,6 +2607,7 @@
+@@ -2620,6 +2621,7 @@
  
  	srv_use_doublewrite_buf = (ibool) innobase_use_doublewrite;
  	srv_use_checksums = (ibool) innobase_use_checksums;
@@ -178,7 +165,7 @@
  
  #ifdef HAVE_LARGE_PAGES
          if ((os_use_large_pages = (ibool) my_use_large_pages))
-@@ -11414,6 +11416,15 @@
+@@ -11421,6 +11423,15 @@
    "Disable with --skip-innodb-checksums.",
    NULL, NULL, TRUE);
  
@@ -194,7 +181,7 @@
  static MYSQL_SYSVAR_STR(data_home_dir, innobase_data_home_dir,
    PLUGIN_VAR_READONLY,
    "The common part for InnoDB table spaces.",
-@@ -11922,6 +11933,7 @@
+@@ -11930,6 +11941,7 @@
    MYSQL_SYSVAR(buffer_pool_size),
    MYSQL_SYSVAR(buffer_pool_instances),
    MYSQL_SYSVAR(checksums),
@@ -231,7 +218,7 @@
 diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
 --- a/storage/innobase/include/srv0srv.h	2010-12-04 15:52:23.474482590 +0900
 +++ b/storage/innobase/include/srv0srv.h	2010-12-04 15:53:45.048512100 +0900
-@@ -227,6 +227,7 @@
+@@ -224,6 +224,7 @@
  
  extern ibool	srv_use_doublewrite_buf;
  extern ibool	srv_use_checksums;
@@ -291,7 +278,7 @@
 diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
 --- a/storage/innobase/srv/srv0srv.c	2010-12-04 15:52:23.498513634 +0900
 +++ b/storage/innobase/srv/srv0srv.c	2010-12-04 15:53:45.053550283 +0900
-@@ -420,6 +420,7 @@
+@@ -414,6 +414,7 @@
  
  UNIV_INTERN ibool	srv_use_doublewrite_buf	= TRUE;
  UNIV_INTERN ibool	srv_use_checksums = TRUE;

=== modified file 'innodb_files_extend.patch'
--- innodb_files_extend.patch	2011-05-10 11:57:42 +0000
+++ innodb_files_extend.patch	2011-06-20 09:04:39 +0000
@@ -8,7 +8,7 @@
 diff -ruN a/storage/innobase/fil/fil0fil.c b/storage/innobase/fil/fil0fil.c
 --- a/storage/innobase/fil/fil0fil.c	2010-12-04 15:55:21.358513751 +0900
 +++ b/storage/innobase/fil/fil0fil.c	2010-12-04 15:55:58.243481131 +0900
-@@ -729,7 +729,7 @@
+@@ -731,7 +731,7 @@
  		ut_a(space->purpose != FIL_LOG);
  		ut_a(!trx_sys_sys_space(space->id));
  
@@ -17,16 +17,7 @@
  			fprintf(stderr,
  				"InnoDB: Error: the size of single-table"
  				" tablespace file %s\n"
-@@ -3216,7 +3216,7 @@
- 
- 		if (size_bytes < free_limit_bytes) {
- 			free_limit_bytes = size_bytes;
--			if (size_bytes >= FSP_EXTENT_SIZE * UNIV_PAGE_SIZE) {
-+			if (size_bytes >= (lint)FSP_EXTENT_SIZE * (lint)UNIV_PAGE_SIZE) {
- 				fprintf(stderr, "InnoDB: free limit of %s is larger than its real size.\n", filepath);
- 				file_is_corrupt = TRUE;
- 			}
-@@ -3830,7 +3830,7 @@
+@@ -4151,7 +4151,7 @@
  
  	size = (((ib_int64_t)size_high) << 32) + (ib_int64_t)size_low;
  #ifndef UNIV_HOTBACKUP
@@ -35,7 +26,7 @@
  		fprintf(stderr,
  			"InnoDB: Error: the size of single-table tablespace"
  			" file %s\n"
-@@ -3850,7 +3850,7 @@
+@@ -4171,7 +4171,7 @@
  	/* Align the memory for file i/o if we might have O_DIRECT set */
  	page = ut_align(buf2, UNIV_PAGE_SIZE);
  
@@ -44,7 +35,7 @@
  		success = os_file_read(file, page, 0, 0, UNIV_PAGE_SIZE);
  
  		/* We have to read the tablespace id from the file */
-@@ -4828,9 +4828,9 @@
+@@ -5149,9 +5149,9 @@
  	ut_ad(ut_is_2pow(zip_size));
  	ut_ad(buf);
  	ut_ad(len > 0);
@@ -121,7 +112,7 @@
  static my_bool innobase_thread_concurrency_timer_based;
  static long long innobase_buffer_pool_size, innobase_log_file_size;
  
-@@ -2302,6 +2305,65 @@
+@@ -2316,6 +2319,65 @@
  	}
  #endif /* DBUG_OFF */
  
@@ -187,7 +178,7 @@
  #ifndef MYSQL_SERVER
  	innodb_overwrite_relay_log_info = FALSE;
  #endif
-@@ -7253,9 +7315,9 @@
+@@ -7241,9 +7303,9 @@
  				| DICT_TF_COMPACT
  				| DICT_TF_FORMAT_ZIP
  				<< DICT_TF_FORMAT_SHIFT;
@@ -200,7 +191,7 @@
  		}
  	}
  
-@@ -11425,6 +11487,16 @@
+@@ -11432,6 +11494,16 @@
    "#### Attention: The checksum is not compatible for normal or disabled version! ####",
    NULL, NULL, FALSE);
  
@@ -217,7 +208,7 @@
  static MYSQL_SYSVAR_STR(data_home_dir, innobase_data_home_dir,
    PLUGIN_VAR_READONLY,
    "The common part for InnoDB table spaces.",
-@@ -11928,6 +12000,8 @@
+@@ -11936,6 +12008,8 @@
    NULL, NULL, 0, &corrupt_table_action_typelib);
  
  static struct st_mysql_sys_var* innobase_system_variables[]= {
@@ -229,7 +220,7 @@
 diff -ruN a/storage/innobase/include/buf0buf.h b/storage/innobase/include/buf0buf.h
 --- a/storage/innobase/include/buf0buf.h	2010-12-04 15:55:21.375482937 +0900
 +++ b/storage/innobase/include/buf0buf.h	2010-12-04 15:55:58.258469088 +0900
-@@ -1684,7 +1684,7 @@
+@@ -1683,7 +1683,7 @@
  	time_t		last_printout_time;
  					/*!< when buf_print_io was last time
  					called */
@@ -238,7 +229,7 @@
  					/*!< Statistics of buddy system,
  					indexed by block size */
  	buf_pool_stat_t	stat;		/*!< current statistics */
-@@ -1780,7 +1780,7 @@
+@@ -1779,7 +1779,7 @@
  	/* @{ */
  	UT_LIST_BASE_NODE_T(buf_page_t)	zip_clean;
  					/*!< unmodified compressed pages */
@@ -247,7 +238,7 @@
  					/*!< buddy free lists */
  
  	buf_page_t			watch[BUF_POOL_WATCH_SIZE];
-@@ -1788,9 +1788,9 @@
+@@ -1787,9 +1787,9 @@
  					pool watches. Protected by
  				       	buf_pool->mutex. */
  
@@ -379,7 +370,7 @@
 diff -ruN a/storage/innobase/include/univ.i b/storage/innobase/include/univ.i
 --- a/storage/innobase/include/univ.i	2010-11-03 07:01:13.000000000 +0900
 +++ b/storage/innobase/include/univ.i	2010-12-04 15:55:58.263549721 +0900
-@@ -298,9 +298,13 @@
+@@ -311,9 +311,13 @@
  */
  
  /* The 2-logarithm of UNIV_PAGE_SIZE: */
@@ -395,7 +386,7 @@
  
  /* Maximum number of parallel threads in a parallelized operation */
  #define UNIV_MAX_PARALLELISM	32
-@@ -419,7 +423,7 @@
+@@ -432,7 +436,7 @@
  stored part of the field in the tablespace. The length field then
  contains the sum of the following flag and the locally stored len. */
  
@@ -404,7 +395,7 @@
  
  /* Some macros to improve branch prediction and reduce cache misses */
  #if defined(__GNUC__) && (__GNUC__ > 2) && ! defined(__INTEL_COMPILER)
-@@ -522,4 +526,6 @@
+@@ -535,4 +539,6 @@
  	UNIV_MEM_ALLOC(addr, size);			\
  } while (0)
  
@@ -547,7 +538,7 @@
 diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
 --- a/storage/innobase/srv/srv0srv.c	2010-12-04 15:55:21.384486344 +0900
 +++ b/storage/innobase/srv/srv0srv.c	2010-12-04 15:55:58.282550845 +0900
-@@ -240,6 +240,13 @@
+@@ -234,6 +234,13 @@
  UNIV_INTERN ulint	srv_n_read_io_threads	= ULINT_MAX;
  UNIV_INTERN ulint	srv_n_write_io_threads	= ULINT_MAX;
  

=== modified file 'innodb_fix_misc.patch'
--- innodb_fix_misc.patch	2011-05-18 00:03:53 +0000
+++ innodb_fix_misc.patch	2011-06-20 09:04:39 +0000
@@ -13,7 +13,7 @@
 diff -ruN a/storage/innobase/buf/buf0buf.c b/storage/innobase/buf/buf0buf.c
 --- a/storage/innobase/buf/buf0buf.c	2011-02-23 19:00:48.178696354 +0900
 +++ b/storage/innobase/buf/buf0buf.c	2011-02-23 19:01:19.138826278 +0900
-@@ -4063,6 +4063,7 @@
+@@ -4061,6 +4061,7 @@
  		bpage->state	= BUF_BLOCK_ZIP_PAGE;
  		bpage->space	= space;
  		bpage->offset	= offset;
@@ -102,7 +102,7 @@
 diff -ruN a/storage/innobase/fil/fil0fil.c b/storage/innobase/fil/fil0fil.c
 --- a/storage/innobase/fil/fil0fil.c	2011-02-23 19:00:48.223696428 +0900
 +++ b/storage/innobase/fil/fil0fil.c	2011-02-23 19:01:19.147655510 +0900
-@@ -252,6 +252,7 @@
+@@ -254,6 +254,7 @@
  struct fil_system_struct {
  #ifndef UNIV_HOTBACKUP
  	mutex_t		mutex;		/*!< The mutex protecting the cache */
@@ -110,7 +110,7 @@
  #endif /* !UNIV_HOTBACKUP */
  	hash_table_t*	spaces;		/*!< The hash table of spaces in the
  					system; they are hashed on the space
-@@ -861,7 +862,7 @@
+@@ -863,7 +864,7 @@
  	ut_ad(node && system);
  	ut_ad(mutex_own(&(system->mutex)));
  	ut_a(node->open);
@@ -119,7 +119,7 @@
  	ut_a(node->n_pending_flushes == 0);
  	ut_a(node->modification_counter == node->flush_counter);
  
-@@ -874,7 +875,7 @@
+@@ -876,7 +877,7 @@
  	ut_a(system->n_open > 0);
  	system->n_open--;
  
@@ -128,7 +128,7 @@
  		ut_a(UT_LIST_GET_LEN(system->LRU) > 0);
  
  		/* The node is in the LRU list, remove it */
-@@ -1073,7 +1074,7 @@
+@@ -1075,7 +1076,7 @@
  	ut_ad(node && system && space);
  	ut_ad(mutex_own(&(system->mutex)));
  	ut_a(node->magic_n == FIL_NODE_MAGIC_N);
@@ -137,7 +137,7 @@
  
  	if (node->open) {
  		/* We fool the assertion in fil_node_close_file() to think
-@@ -1595,6 +1596,8 @@
+@@ -1597,6 +1598,8 @@
  
  	mutex_create(fil_system_mutex_key,
  		     &fil_system->mutex, SYNC_ANY_LATCH);
@@ -146,7 +146,7 @@
  
  	fil_system->spaces = hash_create(hash_size);
  	fil_system->name_hash = hash_create(hash_size);
-@@ -2341,7 +2344,11 @@
+@@ -2343,7 +2346,11 @@
  	completely and permanently. The flag is_being_deleted also prevents
  	fil_flush() from being applied to this tablespace. */
  
@@ -158,7 +158,7 @@
  #endif
  	/* printf("Deleting tablespace %s id %lu\n", space->name, id); */
  
-@@ -4400,6 +4407,10 @@
+@@ -4721,6 +4728,10 @@
  	ulint		page_size;
  	ibool		success		= TRUE;
  
@@ -169,7 +169,7 @@
  	fil_mutex_enter_and_prepare_for_io(space_id);
  
  	space = fil_space_get_by_id(space_id);
-@@ -4411,6 +4422,7 @@
+@@ -4732,6 +4743,7 @@
  		*actual_size = space->size;
  
  		mutex_exit(&fil_system->mutex);
@@ -177,7 +177,7 @@
  
  		return(TRUE);
  	}
-@@ -4443,6 +4455,8 @@
+@@ -4764,6 +4776,8 @@
  		offset_low  = ((start_page_no - file_start_page_no)
  			       % (4096 * ((1024 * 1024) / page_size)))
  			* page_size;
@@ -186,7 +186,7 @@
  #ifdef UNIV_HOTBACKUP
  		success = os_file_write(node->name, node->handle, buf,
  					offset_low, offset_high,
-@@ -4452,8 +4466,10 @@
+@@ -4773,8 +4787,10 @@
  				 node->name, node->handle, buf,
  				 offset_low, offset_high,
  				 page_size * n_pages,
@@ -198,7 +198,7 @@
  		if (success) {
  			node->size += n_pages;
  			space->size += n_pages;
-@@ -4499,6 +4515,7 @@
+@@ -4820,6 +4836,7 @@
  	printf("Extended %s to %lu, actual size %lu pages\n", space->name,
  	size_after_extend, *actual_size); */
  	mutex_exit(&fil_system->mutex);
@@ -206,7 +206,7 @@
  
  	fil_flush(space_id);
  
-@@ -4861,6 +4878,22 @@
+@@ -5182,6 +5199,22 @@
  		srv_data_written+= len;
  	}
  
@@ -216,7 +216,7 @@
 +	    && ((buf_page_t*)message)->space_was_being_deleted) {
 +
 +		if (mode == OS_AIO_NORMAL) {
-+			buf_page_io_complete(message, trx);
++			buf_page_io_complete(message);
 +			return(DB_SUCCESS); /*fake*/
 +		}
 +		if (type == OS_FILE_READ) {
@@ -229,7 +229,7 @@
  	/* Reserve the fil_system mutex and make sure that we can open at
  	least one file while holding it, if the file is not already open */
  
-@@ -4990,10 +5023,24 @@
+@@ -5323,10 +5356,24 @@
  #else
  	/* Queue the aio request */
  	ret = os_aio(type, mode | wake_later, node->name, node->handle, buf,
@@ -255,7 +255,7 @@
  	ut_a(ret);
  
  	if (mode == OS_AIO_SYNC) {
-@@ -5093,6 +5140,7 @@
+@@ -5426,6 +5473,7 @@
  	fil_node_t*	fil_node;
  	void*		message;
  	ulint		type;
@@ -263,7 +263,7 @@
  
  	ut_ad(fil_validate_skip());
  
-@@ -5100,10 +5148,10 @@
+@@ -5433,10 +5481,10 @@
  		srv_set_io_thread_op_info(segment, "native aio handle");
  #ifdef WIN_ASYNC_IO
  		ret = os_aio_windows_handle(segment, 0, &fil_node,
@@ -274,9 +274,9 @@
 -					  &message, &type);
 +					  &message, &type, &space_id);
  #else
+ 		ut_error;
  		ret = 0; /* Eliminate compiler warning */
- 		ut_error;
-@@ -5112,7 +5160,22 @@
+@@ -5445,7 +5493,22 @@
  		srv_set_io_thread_op_info(segment, "simulated aio handle");
  
  		ret = os_aio_simulated_handle(segment, &fil_node,
@@ -295,7 +295,7 @@
 +		     || buf_page_get_state(message) != BUF_BLOCK_FILE_PAGE);
 +
 +		srv_set_io_thread_op_info(segment, "complete io for buf page");
-+		buf_page_io_complete(message, NULL);
++		buf_page_io_complete(message);
 +		return;
  	}
  
@@ -303,7 +303,7 @@
 diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
 --- a/storage/innobase/handler/ha_innodb.cc	2010-12-04 15:57:13.035513990 +0900
 +++ b/storage/innobase/handler/ha_innodb.cc	2010-12-04 15:57:53.084513775 +0900
-@@ -11999,6 +11999,12 @@
+@@ -12007,6 +12007,12 @@
    "except for the deletion.",
    NULL, NULL, 0, &corrupt_table_action_typelib);
  
@@ -316,7 +316,7 @@
  static struct st_mysql_sys_var* innobase_system_variables[]= {
    MYSQL_SYSVAR(page_size),
    MYSQL_SYSVAR(log_block_size),
-@@ -12089,6 +12095,7 @@
+@@ -12097,6 +12103,7 @@
    MYSQL_SYSVAR(purge_batch_size),
    MYSQL_SYSVAR(rollback_segments),
    MYSQL_SYSVAR(corrupt_table_action),
@@ -324,7 +324,7 @@
    NULL
  };
  
-@@ -12098,7 +12105,7 @@
+@@ -12106,7 +12113,7 @@
    &innobase_storage_engine,
    innobase_hton_name,
    plugin_author,
@@ -336,7 +336,7 @@
 diff -ruN a/storage/innobase/include/buf0buf.h b/storage/innobase/include/buf0buf.h
 --- a/storage/innobase/include/buf0buf.h	2011-02-23 19:00:48.252696774 +0900
 +++ b/storage/innobase/include/buf0buf.h	2011-02-23 19:01:19.182655902 +0900
-@@ -1439,6 +1439,7 @@
+@@ -1438,6 +1438,7 @@
  					0 if the block was never accessed
  					in the buffer pool */
  	/* @} */
@@ -468,7 +468,7 @@
 diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
 --- a/storage/innobase/include/srv0srv.h	2011-02-23 19:00:48.212625715 +0900
 +++ b/storage/innobase/include/srv0srv.h	2011-02-23 19:01:19.193655990 +0900
-@@ -247,6 +247,8 @@
+@@ -244,6 +244,8 @@
  extern ulint	srv_pass_corrupt_table;
  
  extern ulint	srv_dict_size_limit;
@@ -480,7 +480,7 @@
 diff -ruN a/storage/innobase/include/sync0sync.h b/storage/innobase/include/sync0sync.h
 --- a/storage/innobase/include/sync0sync.h	2011-02-23 19:00:47.875625940 +0900
 +++ b/storage/innobase/include/sync0sync.h	2011-02-23 19:01:19.195703856 +0900
-@@ -682,6 +682,7 @@
+@@ -691,6 +691,7 @@
  #define	SYNC_BUF_POOL		150	/* Buffer pool mutex */
  #define	SYNC_BUF_FLUSH_LIST	145	/* Buffer flush list mutex */
  #define SYNC_DOUBLEWRITE	140
@@ -493,7 +493,7 @@
 +++ b/storage/innobase/include/univ.i	2010-12-04 15:57:53.091592933 +0900
 @@ -53,6 +53,11 @@
  #define INNODB_VERSION_MINOR	1
- #define INNODB_VERSION_BUGFIX	6
+ #define INNODB_VERSION_BUGFIX	7
  
 +#ifndef PERCONA_INNODB_VERSION
 +#define PERCONA_INNODB_VERSION 20.1
@@ -550,7 +550,7 @@
  	trx_t*		trx)
  {
  	os_aio_array_t*	array;
-@@ -4137,7 +4141,7 @@
+@@ -4139,7 +4143,7 @@
  		trx->io_read += n;
  	}
  	slot = os_aio_array_reserve_slot(type, array, message1, message2, file,
@@ -559,7 +559,7 @@
  	if (type == OS_FILE_READ) {
  		if (srv_use_native_aio) {
  			os_n_file_reads++;
-@@ -4256,7 +4260,8 @@
+@@ -4258,7 +4262,8 @@
  				parameters are valid and can be used to
  				restart the operation, for example */
  	void**	message2,
@@ -569,7 +569,7 @@
  {
  	ulint		orig_seg	= segment;
  	os_aio_array_t*	array;
-@@ -4329,6 +4334,7 @@
+@@ -4337,6 +4342,7 @@
  	*message2 = slot->message2;
  
  	*type = slot->type;
@@ -577,7 +577,7 @@
  
  	if (ret && len == slot->len) {
  		ret_val = TRUE;
-@@ -4569,7 +4575,8 @@
+@@ -4565,7 +4571,8 @@
  				aio operation failed, these output
  				parameters are valid and can be used to
  				restart the operation. */
@@ -587,7 +587,7 @@
  {
  	ulint		segment;
  	os_aio_array_t*	array;
-@@ -4627,6 +4634,7 @@
+@@ -4638,6 +4645,7 @@
  	*message2 = slot->message2;
  
  	*type = slot->type;
@@ -595,7 +595,7 @@
  
  	if ((slot->ret == 0) && (slot->n_bytes == (long)slot->len)) {
  		ret = TRUE;
-@@ -4680,7 +4688,8 @@
+@@ -4691,7 +4699,8 @@
  				parameters are valid and can be used to
  				restart the operation, for example */
  	void**	message2,
@@ -605,7 +605,7 @@
  {
  	os_aio_array_t*	array;
  	ulint		segment;
-@@ -4958,6 +4967,7 @@
+@@ -4987,6 +4996,7 @@
  	*message2 = slot->message2;
  
  	*type = slot->type;
@@ -624,7 +624,7 @@
  
  /** Provide optional 4.x backwards compatibility for 5.0 and above */
  UNIV_INTERN ibool	row_rollback_on_timeout	= FALSE;
-@@ -1194,6 +1195,13 @@
+@@ -1191,6 +1192,13 @@
  
  	thr = que_fork_get_first_thr(prebuilt->ins_graph);
  
@@ -649,7 +649,7 @@
  
  	rec_offs_init(offsets_);
  
-@@ -3732,6 +3733,17 @@
+@@ -3737,6 +3738,17 @@
  
  	/* Do some start-of-statement preparations */
  
@@ -667,7 +667,7 @@
  	if (!prebuilt->sql_stat_start) {
  		/* No need to set an intention lock or assign a read view */
  
-@@ -3742,6 +3754,18 @@
+@@ -3747,6 +3759,18 @@
  			      " perform a consistent read\n"
  			      "InnoDB: but the read view is not assigned!\n",
  			      stderr);
@@ -689,7 +689,7 @@
 diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
 --- a/storage/innobase/srv/srv0srv.c	2011-02-23 19:00:48.283695497 +0900
 +++ b/storage/innobase/srv/srv0srv.c	2011-02-23 19:01:19.204696643 +0900
-@@ -447,6 +447,8 @@
+@@ -441,6 +441,8 @@
  UNIV_INTERN ulint	srv_pass_corrupt_table = 0; /* 0:disable 1:enable */
  
  UNIV_INTERN ulint	srv_dict_size_limit = 0;
@@ -713,7 +713,7 @@
 diff -ruN a/storage/innobase/sync/sync0sync.c b/storage/innobase/sync/sync0sync.c
 --- a/storage/innobase/sync/sync0sync.c	2011-02-25 14:18:55.817202060 +0900
 +++ b/storage/innobase/sync/sync0sync.c	2011-02-25 14:19:44.596202017 +0900
-@@ -1175,6 +1175,7 @@
+@@ -1220,6 +1220,7 @@
  	case SYNC_LOG_FLUSH_ORDER:
  	case SYNC_THR_LOCAL:
  	case SYNC_ANY_LATCH:

=== modified file 'innodb_io_patches.patch'
--- innodb_io_patches.patch	2011-05-10 11:57:42 +0000
+++ innodb_io_patches.patch	2011-06-20 09:04:39 +0000
@@ -84,7 +84,7 @@
  /********************************************************************//**
  Obtain the InnoDB transaction of a MySQL thread.
  @return	reference to transaction pointer */
-@@ -2423,6 +2440,9 @@
+@@ -2437,6 +2454,9 @@
  	srv_n_read_io_threads = (ulint) innobase_read_io_threads;
  	srv_n_write_io_threads = (ulint) innobase_write_io_threads;
  
@@ -94,7 +94,7 @@
  	srv_force_recovery = (ulint) innobase_force_recovery;
  
  	srv_use_doublewrite_buf = (ibool) innobase_use_doublewrite;
-@@ -11018,7 +11038,7 @@
+@@ -11025,7 +11045,7 @@
    PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
    "Purge threads can be either 0 or 1.",
    NULL, NULL,
@@ -103,7 +103,7 @@
    0,			/* Minimum value */
    1, 0);		/* Maximum value */
  
-@@ -11060,12 +11080,18 @@
+@@ -11067,12 +11087,18 @@
    innodb_file_format_max_validate,
    innodb_file_format_max_update, "Antelope");
  
@@ -128,7 +128,7 @@
  
  static MYSQL_SYSVAR_STR(flush_method, innobase_file_flush_method,
    PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
-@@ -11160,7 +11186,7 @@
+@@ -11167,7 +11193,7 @@
  static MYSQL_SYSVAR_LONGLONG(buffer_pool_size, innobase_buffer_pool_size,
    PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
    "The size of the memory buffer InnoDB uses to cache data and indexes of its tables.",
@@ -137,7 +137,7 @@
  
  static MYSQL_SYSVAR_LONG(buffer_pool_instances, innobase_buffer_pool_instances,
    PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
-@@ -11312,6 +11338,95 @@
+@@ -11319,6 +11345,95 @@
    "trigger a readahead.",
    NULL, NULL, 56, 0, 64, 0);
  
@@ -233,7 +233,7 @@
  static struct st_mysql_sys_var* innobase_system_variables[]= {
    MYSQL_SYSVAR(additional_mem_pool_size),
    MYSQL_SYSVAR(autoextend_increment),
-@@ -11332,6 +11447,7 @@
+@@ -11339,6 +11454,7 @@
    MYSQL_SYSVAR(file_format_check),
    MYSQL_SYSVAR(file_format_max),
    MYSQL_SYSVAR(flush_log_at_trx_commit),
@@ -241,7 +241,7 @@
    MYSQL_SYSVAR(flush_method),
    MYSQL_SYSVAR(force_recovery),
    MYSQL_SYSVAR(locks_unsafe_for_binlog),
-@@ -11369,6 +11485,13 @@
+@@ -11376,6 +11492,13 @@
    MYSQL_SYSVAR(show_verbose_locks),
    MYSQL_SYSVAR(show_locks_held),
    MYSQL_SYSVAR(version),
@@ -271,7 +271,7 @@
  
  	mutex_create(ibuf_pessimistic_insert_mutex_key,
  		     &ibuf_pessimistic_insert_mutex,
-@@ -2764,9 +2766,11 @@
+@@ -2753,9 +2755,11 @@
  	size = ibuf->size;
  	max_size = ibuf->max_size;
  
@@ -299,7 +299,7 @@
 diff -ruN a/storage/innobase/include/ha_prototypes.h b/storage/innobase/include/ha_prototypes.h
 --- a/storage/innobase/include/ha_prototypes.h	2010-11-03 07:01:13.000000000 +0900
 +++ b/storage/innobase/include/ha_prototypes.h	2010-12-03 15:10:09.078026360 +0900
-@@ -284,5 +284,12 @@
+@@ -284,6 +284,13 @@
  /*===================*/
          void*   thd,	/*!< in: thread handle (THD*) */
          ulint   value);	/*!< in: time waited for the lock */
@@ -311,11 +311,12 @@
 +/*================================*/
 +	void*	thd);
  
- #endif
+ /**********************************************************************//**
+ Get the current setting of the lower_case_table_names global parameter from
 diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
 --- a/storage/innobase/include/srv0srv.h	2010-12-03 15:09:51.291955835 +0900
 +++ b/storage/innobase/include/srv0srv.h	2010-12-03 15:10:09.079029047 +0900
-@@ -141,7 +141,8 @@
+@@ -138,7 +138,8 @@
  extern ulint	srv_n_log_files;
  extern ulint	srv_log_file_size;
  extern ulint	srv_log_buffer_size;
@@ -325,7 +326,7 @@
  extern char	srv_adaptive_flushing;
  
  
-@@ -219,6 +220,16 @@
+@@ -216,6 +217,16 @@
  extern ulong	srv_max_purge_lag;
  
  extern ulong	srv_replication_delay;
@@ -342,7 +343,7 @@
  /*-------------------------------------------*/
  
  extern ulint	srv_n_rows_inserted;
-@@ -397,8 +408,9 @@
+@@ -394,8 +405,9 @@
  				when writing data files, but do flush
  				after writing to log files */
  	SRV_UNIX_NOSYNC,	/*!< do not flush after writing */
@@ -540,7 +541,7 @@
 diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
 --- a/storage/innobase/srv/srv0srv.c	2010-12-03 15:09:51.301987792 +0900
 +++ b/storage/innobase/srv/srv0srv.c	2010-12-03 15:13:29.369986988 +0900
-@@ -189,7 +189,8 @@
+@@ -183,7 +183,8 @@
  UNIV_INTERN ulint	srv_log_file_size	= ULINT_MAX;
  /* size in database pages */
  UNIV_INTERN ulint	srv_log_buffer_size	= ULINT_MAX;
@@ -550,7 +551,7 @@
  
  /* Try to flush dirty pages so as to avoid IO bursts at
  the checkpoints. */
-@@ -408,6 +409,17 @@
+@@ -402,6 +403,17 @@
  
  UNIV_INTERN ulong	srv_replication_delay		= 0;
  
@@ -568,7 +569,7 @@
  /*-------------------------------------------*/
  UNIV_INTERN ulong	srv_n_spin_wait_rounds	= 30;
  UNIV_INTERN ulong	srv_n_free_tickets_to_enter = 500;
-@@ -2733,6 +2745,7 @@
+@@ -2742,6 +2754,7 @@
  	ulint		n_pages_purged	= 0;
  	ulint		n_bytes_merged;
  	ulint		n_pages_flushed;
@@ -576,7 +577,7 @@
  	ulint		n_bytes_archived;
  	ulint		n_tables_to_drop;
  	ulint		n_ios;
-@@ -2740,7 +2753,20 @@
+@@ -2749,7 +2762,20 @@
  	ulint		n_ios_very_old;
  	ulint		n_pend_ios;
  	ulint		next_itr_time;
@@ -597,7 +598,7 @@
  
  #ifdef UNIV_DEBUG_THREAD_CREATION
  	fprintf(stderr, "Master thread starts, id %lu\n",
-@@ -2762,6 +2788,9 @@
+@@ -2771,6 +2797,9 @@
  
  	mutex_exit(&kernel_mutex);
  
@@ -607,7 +608,7 @@
  loop:
  	/*****************************************************************/
  	/* ---- When there is database activity by users, we cycle in this
-@@ -2792,9 +2821,13 @@
+@@ -2801,9 +2830,13 @@
  	/* Sleep for 1 second on entrying the for loop below the first time. */
  	next_itr_time = ut_time_ms() + 1000;
  
@@ -621,7 +622,7 @@
  		/* ALTER TABLE in MySQL requires on Unix that the table handler
  		can drop tables lazily after there no longer are SELECT
  		queries to them. */
-@@ -2818,6 +2851,7 @@
+@@ -2827,6 +2860,7 @@
  		srv_main_thread_op_info = "sleeping";
  		srv_main_1_second_loops++;
  
@@ -629,7 +630,7 @@
  		if (next_itr_time > cur_time
  		    && srv_shutdown_state == SRV_SHUTDOWN_NONE) {
  
-@@ -2828,10 +2862,26 @@
+@@ -2837,10 +2871,26 @@
  					(next_itr_time - cur_time)
  					 * 1000));
  			srv_main_sleeps++;
@@ -656,7 +657,7 @@
  
  		/* Flush logs if needed */
  		srv_sync_log_buffer_in_background();
-@@ -2851,7 +2901,7 @@
+@@ -2860,7 +2910,7 @@
  		if (n_pend_ios < SRV_PEND_IO_THRESHOLD
  		    && (n_ios - n_ios_old < SRV_RECENT_IO_ACTIVITY)) {
  			srv_main_thread_op_info = "doing insert buffer merge";
@@ -665,7 +666,7 @@
  
  			/* Flush logs if needed */
  			srv_sync_log_buffer_in_background();
-@@ -2868,7 +2918,11 @@
+@@ -2877,7 +2927,11 @@
  			n_pages_flushed = buf_flush_list(
  				PCT_IO(100), IB_ULONGLONG_MAX);
  
@@ -678,7 +679,7 @@
  
  			/* Try to keep the rate of flushing of dirty
  			pages such that redo log generation does not
-@@ -2884,6 +2938,224 @@
+@@ -2893,6 +2947,224 @@
  						n_flush,
  						IB_ULONGLONG_MAX);
  			}
@@ -903,7 +904,7 @@
  		}
  
  		if (srv_activity_count == old_activity_count) {
-@@ -2932,7 +3204,7 @@
+@@ -2941,7 +3213,7 @@
  	even if the server were active */
  
  	srv_main_thread_op_info = "doing insert buffer merge";
@@ -912,7 +913,7 @@
  
  	/* Flush logs if needed */
  	srv_sync_log_buffer_in_background();
-@@ -3040,7 +3312,7 @@
+@@ -3049,7 +3321,7 @@
  		buf_flush_list below. Otherwise, the system favors
  		clean pages over cleanup throughput. */
  		n_bytes_merged = ibuf_contract_for_n_pages(FALSE,
@@ -921,7 +922,7 @@
  	}
  
  	srv_main_thread_op_info = "reserving kernel mutex";
-@@ -3184,6 +3456,7 @@
+@@ -3189,6 +3461,7 @@
  	srv_slot_t*	slot;
  	ulint		retries = 0;
  	ulint		n_total_purged = ULINT_UNDEFINED;
@@ -929,7 +930,7 @@
  
  	ut_a(srv_n_purge_threads == 1);
  
-@@ -3204,9 +3477,12 @@
+@@ -3209,9 +3482,12 @@
  
  	mutex_exit(&kernel_mutex);
  
@@ -942,7 +943,7 @@
  
  		/* If there are very few records to purge or the last
  		purge didn't purge any records then wait for activity.
-@@ -3253,6 +3529,16 @@
+@@ -3258,6 +3534,16 @@
  		} while (n_pages_purged > 0 && !srv_fast_shutdown);
  
  		srv_sync_log_buffer_in_background();
@@ -991,7 +992,7 @@
 diff -ruN a/storage/innobase/trx/trx0trx.c b/storage/innobase/trx/trx0trx.c
 --- a/storage/innobase/trx/trx0trx.c	2010-11-03 07:01:13.000000000 +0900
 +++ b/storage/innobase/trx/trx0trx.c	2010-12-03 15:10:09.106023937 +0900
-@@ -924,6 +924,7 @@
+@@ -984,6 +984,7 @@
  	trx->read_view = NULL;
  
  	if (lsn) {
@@ -999,7 +1000,7 @@
  
  		mutex_exit(&kernel_mutex);
  
-@@ -932,6 +933,12 @@
+@@ -992,6 +993,12 @@
  			trx_undo_insert_cleanup(trx);
  		}
  
@@ -1012,7 +1013,7 @@
  		/* NOTE that we could possibly make a group commit more
  		efficient here: call os_thread_yield here to allow also other
  		trxs to come to commit! */
-@@ -963,9 +970,9 @@
+@@ -1023,9 +1030,9 @@
  		if (trx->flush_log_later) {
  			/* Do nothing yet */
  			trx->must_flush_log_later = TRUE;
@@ -1024,7 +1025,7 @@
  			if (srv_unix_file_flush_method == SRV_UNIX_NOSYNC) {
  				/* Write the log but do not flush it to disk */
  
-@@ -977,7 +984,7 @@
+@@ -1037,7 +1044,7 @@
  
  				log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE);
  			}
@@ -1033,7 +1034,7 @@
  
  			/* Write the log but do not flush it to disk */
  
-@@ -1641,16 +1648,23 @@
+@@ -1701,16 +1708,23 @@
  	trx_t*	trx)	/*!< in: trx handle */
  {
  	ib_uint64_t	lsn	= trx->commit_lsn;
@@ -1059,7 +1060,7 @@
  		if (srv_unix_file_flush_method == SRV_UNIX_NOSYNC) {
  			/* Write the log but do not flush it to disk */
  
-@@ -1661,7 +1675,7 @@
+@@ -1721,7 +1735,7 @@
  
  			log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE);
  		}
@@ -1068,7 +1069,7 @@
  
  		/* Write the log but do not flush it to disk */
  
-@@ -1914,6 +1928,8 @@
+@@ -1969,6 +1983,8 @@
  	/*--------------------------------------*/
  
  	if (lsn) {
@@ -1077,7 +1078,7 @@
  		/* Depending on the my.cnf options, we may now write the log
  		buffer to the log files, making the prepared state of the
  		transaction durable if the OS does not crash. We may also
-@@ -1933,9 +1949,15 @@
+@@ -1988,9 +2004,15 @@
  
  		mutex_exit(&kernel_mutex);
  
@@ -1095,7 +1096,7 @@
  			if (srv_unix_file_flush_method == SRV_UNIX_NOSYNC) {
  				/* Write the log but do not flush it to disk */
  
-@@ -1947,7 +1969,7 @@
+@@ -2002,7 +2024,7 @@
  
  				log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE);
  			}

=== modified file 'innodb_lru_dump_restore.patch'
--- innodb_lru_dump_restore.patch	2011-05-10 11:57:42 +0000
+++ innodb_lru_dump_restore.patch	2011-06-20 09:04:39 +0000
@@ -8,7 +8,7 @@
 diff -ruN a/storage/innobase/buf/buf0lru.c b/storage/innobase/buf/buf0lru.c
 --- a/storage/innobase/buf/buf0lru.c	2010-12-03 15:49:59.185023424 +0900
 +++ b/storage/innobase/buf/buf0lru.c	2010-12-04 15:33:37.626482350 +0900
-@@ -2245,6 +2245,284 @@
+@@ -2247,6 +2247,284 @@
  	memset(&buf_LRU_stat_cur, 0, sizeof buf_LRU_stat_cur);
  }
  
@@ -308,7 +308,7 @@
 diff -ruN a/storage/innobase/fil/fil0fil.c b/storage/innobase/fil/fil0fil.c
 --- a/storage/innobase/fil/fil0fil.c	2010-12-03 17:49:11.581025127 +0900
 +++ b/storage/innobase/fil/fil0fil.c	2010-12-04 15:33:37.632482885 +0900
-@@ -4965,6 +4965,70 @@
+@@ -5289,6 +5289,70 @@
  	return(DB_SUCCESS);
  }
  
@@ -382,7 +382,7 @@
 diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
 --- a/storage/innobase/handler/ha_innodb.cc	2010-12-03 17:49:11.589956135 +0900
 +++ b/storage/innobase/handler/ha_innodb.cc	2010-12-04 15:33:37.645555490 +0900
-@@ -11786,6 +11786,12 @@
+@@ -11793,6 +11793,12 @@
    "Limit the allocated memory for dictionary cache. (0: unlimited)",
    NULL, NULL, 0, 0, LONG_MAX, 0);
  
@@ -395,7 +395,7 @@
  static struct st_mysql_sys_var* innobase_system_variables[]= {
    MYSQL_SYSVAR(additional_mem_pool_size),
    MYSQL_SYSVAR(autoextend_increment),
-@@ -11867,6 +11873,7 @@
+@@ -11874,6 +11880,7 @@
  #endif /* UNIV_DEBUG || UNIV_IBUF_DEBUG */
    MYSQL_SYSVAR(read_ahead_threshold),
    MYSQL_SYSVAR(io_capacity),
@@ -535,7 +535,7 @@
 diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
 --- a/storage/innobase/include/srv0srv.h	2010-12-03 17:49:11.603969747 +0900
 +++ b/storage/innobase/include/srv0srv.h	2010-12-04 15:33:37.685550816 +0900
-@@ -359,6 +359,9 @@
+@@ -356,6 +356,9 @@
  reading of a disk page */
  extern ulint srv_buf_pool_reads;
  
@@ -545,7 +545,7 @@
  /** Status variables to be passed to MySQL */
  typedef struct export_var_struct export_struc;
  
-@@ -664,6 +667,16 @@
+@@ -661,6 +664,16 @@
  /*=====================*/
  	void*	arg);	/*!< in: a dummy parameter required by
  			os_thread_create */
@@ -565,7 +565,7 @@
 diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
 --- a/storage/innobase/srv/srv0srv.c	2010-12-03 17:49:11.620986661 +0900
 +++ b/storage/innobase/srv/srv0srv.c	2010-12-04 15:33:37.708550811 +0900
-@@ -336,6 +336,9 @@
+@@ -330,6 +330,9 @@
  reading of a disk page */
  UNIV_INTERN ulint srv_buf_pool_reads = 0;
  
@@ -575,7 +575,7 @@
  /* structure to pass status variables to MySQL */
  UNIV_INTERN export_struc export_vars;
  
-@@ -2691,6 +2694,56 @@
+@@ -2701,6 +2704,56 @@
  	/* We count the number of threads in os_thread_exit(). A created
  	thread should always use that to exit and not use return() to exit. */
  

=== modified file 'innodb_overwrite_relay_log_info.patch'
--- innodb_overwrite_relay_log_info.patch	2011-05-10 11:57:42 +0000
+++ innodb_overwrite_relay_log_info.patch	2011-06-20 09:04:39 +0000
@@ -56,7 +56,7 @@
  static my_bool	innobase_rollback_on_timeout		= FALSE;
  static my_bool	innobase_create_status_file		= FALSE;
  static my_bool	innobase_stats_on_metadata		= TRUE;
-@@ -2234,6 +2254,89 @@
+@@ -2248,6 +2268,89 @@
  	}
  #endif /* DBUG_OFF */
  
@@ -146,7 +146,7 @@
  	/* Check that values don't overflow on 32-bit systems. */
  	if (sizeof(ulint) == 4) {
  		if (innobase_buffer_pool_size > UINT_MAX32) {
-@@ -2532,6 +2635,76 @@
+@@ -2546,6 +2649,76 @@
  		goto mem_free_and_error;
  	}
  
@@ -223,7 +223,7 @@
  	innobase_old_blocks_pct = buf_LRU_old_ratio_update(
  		innobase_old_blocks_pct, TRUE);
  
-@@ -2644,6 +2817,25 @@
+@@ -2658,6 +2831,25 @@
  	trx_t*	trx)	/*!< in: transaction handle */
  {
  	if (trx_is_started(trx)) {
@@ -249,7 +249,7 @@
  
  		trx_commit_for_mysql(trx);
  	}
-@@ -11007,6 +11199,12 @@
+@@ -11014,6 +11206,12 @@
    "The common part for InnoDB table spaces.",
    NULL, NULL, NULL);
  
@@ -262,7 +262,7 @@
  static MYSQL_SYSVAR_BOOL(doublewrite, innobase_use_doublewrite,
    PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
    "Enable InnoDB doublewrite buffer (enabled by default). "
-@@ -11467,6 +11665,7 @@
+@@ -11474,6 +11672,7 @@
    MYSQL_SYSVAR(old_blocks_pct),
    MYSQL_SYSVAR(old_blocks_time),
    MYSQL_SYSVAR(open_files),
@@ -312,7 +312,7 @@
 diff -ruN a/storage/innobase/include/trx0trx.h b/storage/innobase/include/trx0trx.h
 --- a/storage/innobase/include/trx0trx.h	2010-12-03 15:18:48.894955550 +0900
 +++ b/storage/innobase/include/trx0trx.h	2010-12-03 15:38:20.323953416 +0900
-@@ -569,6 +569,21 @@
+@@ -580,6 +580,20 @@
  	ib_int64_t	mysql_log_offset;/* if MySQL binlog is used, this field
  					contains the end offset of the binlog
  					entry */
@@ -330,14 +330,13 @@
 +					replication has processed */
 +	const char*	mysql_relay_log_file_name;
 +	ib_int64_t	mysql_relay_log_pos;
-+
- 	os_thread_id_t	mysql_thread_id;/* id of the MySQL thread associated
- 					with this transaction object */
- 	ulint		mysql_process_no;/* since in Linux, 'top' reports
+ 	/*------------------------------*/
+ 	ulint		n_mysql_tables_in_use; /* number of Innobase tables
+ 					used in the processing of the current
 diff -ruN a/storage/innobase/trx/trx0sys.c b/storage/innobase/trx/trx0sys.c
 --- a/storage/innobase/trx/trx0sys.c	2010-11-03 07:01:13.000000000 +0900
 +++ b/storage/innobase/trx/trx0sys.c	2010-12-03 15:38:20.325956917 +0900
-@@ -75,13 +75,16 @@
+@@ -76,13 +76,16 @@
  file name and position here. */
  /* @{ */
  /** Master binlog file name */
@@ -355,7 +354,7 @@
  /** If this MySQL server uses binary logging, after InnoDB has been inited
  and if it has done a crash recovery, we store the binlog file name and position
  here. */
-@@ -683,23 +686,25 @@
+@@ -684,23 +687,25 @@
  void
  trx_sys_update_mysql_binlog_offset(
  /*===============================*/
@@ -387,7 +386,7 @@
  	if (mach_read_from_4(sys_header + field
  			     + TRX_SYS_MYSQL_LOG_MAGIC_N_FLD)
  	    != TRX_SYS_MYSQL_LOG_MAGIC_N) {
-@@ -821,13 +826,26 @@
+@@ -822,13 +827,26 @@
  					 + TRX_SYS_MYSQL_LOG_OFFSET_LOW),
  		sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
  		+ TRX_SYS_MYSQL_LOG_NAME);
@@ -415,7 +414,7 @@
  
  	trx_sys_mysql_master_log_pos
  		= (((ib_int64_t) mach_read_from_4(
-@@ -836,6 +854,19 @@
+@@ -837,6 +855,19 @@
  		+ ((ib_int64_t) mach_read_from_4(
  			   sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
  			   + TRX_SYS_MYSQL_LOG_OFFSET_LOW));
@@ -438,7 +437,7 @@
 diff -ruN a/storage/innobase/trx/trx0trx.c b/storage/innobase/trx/trx0trx.c
 --- a/storage/innobase/trx/trx0trx.c	2010-12-03 15:37:45.549028990 +0900
 +++ b/storage/innobase/trx/trx0trx.c	2010-12-03 15:38:20.328957217 +0900
-@@ -135,6 +135,10 @@
+@@ -138,6 +138,10 @@
  
  	trx->mysql_log_file_name = NULL;
  	trx->mysql_log_offset = 0;
@@ -449,7 +448,7 @@
  
  	mutex_create(trx_undo_mutex_key, &trx->undo_mutex, SYNC_TRX_UNDO);
  
-@@ -765,6 +769,7 @@
+@@ -820,6 +824,7 @@
  {
  	mtr_t		mtr;
  	trx_rseg_t*	rseg;
@@ -457,7 +456,7 @@
  
  	ut_ad(!mutex_own(&kernel_mutex));
  
-@@ -818,8 +823,12 @@
+@@ -873,8 +878,12 @@
  
  	if (trx->mysql_log_file_name
  	    && trx->mysql_log_file_name[0] != '\0') {
@@ -470,7 +469,7 @@
  			trx->mysql_log_file_name,
  			trx->mysql_log_offset,
  			TRX_SYS_MYSQL_LOG_INFO, &mtr);
-@@ -827,6 +836,27 @@
+@@ -882,6 +891,27 @@
  		trx->mysql_log_file_name = NULL;
  	}
  

=== modified file 'innodb_pass_corrupt_table.patch'
--- innodb_pass_corrupt_table.patch	2011-05-10 11:57:42 +0000
+++ innodb_pass_corrupt_table.patch	2011-06-20 09:04:39 +0000
@@ -343,37 +343,35 @@
  			if (!ready) {
  
  				return(block);
-@@ -2475,6 +2481,14 @@
+@@ -2475,6 +2481,13 @@
  		return(NULL);
  	}
  
-+	if (srv_pass_corrupt_table) {
++	if (srv_pass_corrupt_table <= 1) {
 +		if (bpage->is_corrupt) {
 +			rw_lock_s_unlock(&buf_pool->page_hash_latch);
 +			return(NULL);
 +		}
 +	}
-+	ut_a(!(bpage->is_corrupt));
 +
  	block_mutex = buf_page_get_mutex_enter(bpage);
  
  	rw_lock_s_unlock(&buf_pool->page_hash_latch);
-@@ -3036,6 +3050,14 @@
+@@ -3036,6 +3049,13 @@
  		return(NULL);
  	}
  
-+	if (srv_pass_corrupt_table) {
++	if (srv_pass_corrupt_table <= 1) {
 +		if (block->page.is_corrupt) {
 +			mutex_exit(block_mutex);
 +			return(NULL);
 +		}
 +	}
-+	ut_a(!(block->page.is_corrupt));
 +
  	switch (buf_block_get_state(block)) {
  		buf_page_t*	bpage;
  		ibool		success;
-@@ -3710,6 +3732,7 @@
+@@ -3710,6 +3730,7 @@
  	bpage->newest_modification = 0;
  	bpage->oldest_modification = 0;
  	HASH_INVALIDATE(bpage, hash);
@@ -381,17 +379,7 @@
  #if defined UNIV_DEBUG_FILE_ACCESSES || defined UNIV_DEBUG
  	bpage->file_page_was_freed = FALSE;
  #endif /* UNIV_DEBUG_FILE_ACCESSES || UNIV_DEBUG */
-@@ -4220,7 +4243,8 @@
- void
- buf_page_io_complete(
- /*=================*/
--	buf_page_t*	bpage)	/*!< in: pointer to the block in question */
-+	buf_page_t*	bpage,	/*!< in: pointer to the block in question */
-+	trx_t*		trx)
- {
- 	enum buf_io_fix	io_type;
- 	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
-@@ -4299,6 +4323,7 @@
+@@ -4299,6 +4320,7 @@
  				(ulong) bpage->offset);
  		}
  
@@ -399,27 +387,31 @@
  		/* From version 3.23.38 up we store the page checksum
  		to the 4 first bytes of the page end lsn field */
  
-@@ -4340,6 +4365,19 @@
+@@ -4340,6 +4362,23 @@
  			      REFMAN "forcing-innodb-recovery.html\n"
  			      "InnoDB: about forcing recovery.\n", stderr);
  
 +			if (srv_pass_corrupt_table && !trx_sys_sys_space(bpage->space)
 +			    && bpage->space < SRV_LOG_SPACE_FIRST_ID) {
++				trx_t*	trx;
++
 +				fprintf(stderr,
 +					"InnoDB: space %u will be treated as corrupt.\n",
 +					bpage->space);
 +				fil_space_set_corrupt(bpage->space);
-+				if (trx && trx->dict_operation_lock_mode == 0) {
++
++				trx = innobase_get_trx();
++				if (trx && trx->dict_operation_lock_mode == RW_X_LATCH) {
++					dict_table_set_corrupt_by_space(bpage->space, FALSE);
++				} else {
 +					dict_table_set_corrupt_by_space(bpage->space, TRUE);
-+				} else {
-+					dict_table_set_corrupt_by_space(bpage->space, FALSE);
 +				}
 +				bpage->is_corrupt = TRUE;
 +			} else
  			if (srv_force_recovery < SRV_FORCE_IGNORE_CORRUPT) {
  				fputs("InnoDB: Ending processing because of"
  				      " a corrupt database page.\n",
-@@ -4347,6 +4385,7 @@
+@@ -4347,6 +4386,7 @@
  				exit(1);
  			}
  		}
@@ -427,7 +419,7 @@
  
  		if (recv_recovery_is_on()) {
  			/* Pages must be uncompressed for crash recovery. */
-@@ -4356,8 +4395,11 @@
+@@ -4356,8 +4396,11 @@
  
  		if (uncompressed && !recv_no_ibuf_operations) {
  			ibuf_merge_or_delete_for_page(
@@ -442,7 +434,7 @@
 diff -ruN a/storage/innobase/buf/buf0rea.c b/storage/innobase/buf/buf0rea.c
 --- a/storage/innobase/buf/buf0rea.c	2010-12-04 15:37:50.557553380 +0900
 +++ b/storage/innobase/buf/buf0rea.c	2010-12-04 15:41:09.784467585 +0900
-@@ -193,12 +193,19 @@
+@@ -193,7 +193,14 @@
  			      ((buf_block_t*) bpage)->frame, bpage, trx);
  	}
  	thd_wait_end(NULL);
@@ -457,24 +449,18 @@
  
  	if (sync) {
  		/* The i/o is already completed when we arrive from
- 		fil_read */
--		buf_page_io_complete(bpage);
-+		buf_page_io_complete(bpage, trx);
- 	}
- 
- 	return(1);
 diff -ruN a/storage/innobase/dict/dict0dict.c b/storage/innobase/dict/dict0dict.c
 --- a/storage/innobase/dict/dict0dict.c	2010-12-03 17:30:16.248987063 +0900
 +++ b/storage/innobase/dict/dict0dict.c	2010-12-04 15:45:23.808513973 +0900
-@@ -55,6 +55,7 @@
- #include "srv0srv.h" /* srv_lower_case_table_names */
+@@ -54,6 +54,7 @@
+ #include "row0merge.h"
  #include "m_ctype.h" /* my_isspace() */
  #include "ha_prototypes.h" /* innobase_strcasecmp(), innobase_casedn_str()*/
 +#include "srv0start.h" /* SRV_LOG_SPACE_FIRST_ID */
  
  #include <ctype.h>
  
-@@ -751,7 +752,7 @@
+@@ -750,7 +751,7 @@
  
  	mutex_exit(&(dict_sys->mutex));
  
@@ -483,7 +469,7 @@
  		/* If table->ibd_file_missing == TRUE, this will
  		print an error message and return without doing
  		anything. */
-@@ -1294,7 +1295,7 @@
+@@ -1293,7 +1294,7 @@
  		    + dict_sys->size) > srv_dict_size_limit ) {
  		prev_table = UT_LIST_GET_PREV(table_LRU, table);
  
@@ -492,7 +478,7 @@
  			goto next_loop;
  
  		cached_foreign_tables = 0;
-@@ -4333,6 +4334,12 @@
+@@ -4332,6 +4333,12 @@
  	heap = mem_heap_create(1000);
  
  	while (index) {
@@ -505,7 +491,7 @@
  		size = btr_get_size(index, BTR_TOTAL_SIZE);
  
  		index->stat_index_size = size;
-@@ -4480,6 +4487,12 @@
+@@ -4479,6 +4486,12 @@
  	heap = mem_heap_create(1000);
  
  	while (index) {
@@ -518,20 +504,21 @@
  /*===========================================*/
  {
  	dict_table_t*	sys_stats;
-@@ -4666,6 +4679,12 @@
+@@ -4671,6 +4684,13 @@
  		     || (srv_force_recovery < SRV_FORCE_NO_LOG_REDO
  			 && dict_index_is_clust(index)))) {
  			ulint	size;
 +
 +			if (table->is_corrupt) {
 +				ut_a(srv_pass_corrupt_table);
++				dict_table_stats_unlock(table, RW_X_LATCH);
 +				return;
 +			}
 +
  			size = btr_get_size(index, BTR_TOTAL_SIZE);
  
  			index->stat_index_size = size;
-@@ -5462,4 +5481,42 @@
+@@ -5467,4 +5487,42 @@
  		rw_lock_free(&dict_table_stats_latches[i]);
  	}
  }
@@ -577,7 +564,7 @@
 diff -ruN a/storage/innobase/dict/dict0mem.c b/storage/innobase/dict/dict0mem.c
 --- a/storage/innobase/dict/dict0mem.c	2010-11-03 07:01:13.000000000 +0900
 +++ b/storage/innobase/dict/dict0mem.c	2010-12-04 15:38:18.126549463 +0900
-@@ -97,6 +97,8 @@
+@@ -96,6 +96,8 @@
  	/* The number of transactions that are either waiting on the
  	AUTOINC lock or have been granted the lock. */
  	table->n_waiting_or_granted_auto_inc_locks = 0;
@@ -589,7 +576,7 @@
 diff -ruN a/storage/innobase/fil/fil0fil.c b/storage/innobase/fil/fil0fil.c
 --- a/storage/innobase/fil/fil0fil.c	2010-12-04 15:37:50.564551587 +0900
 +++ b/storage/innobase/fil/fil0fil.c	2010-12-04 15:38:18.128549252 +0900
-@@ -233,6 +233,7 @@
+@@ -235,6 +235,7 @@
  				file we have written to */
  	ibool		is_in_unflushed_spaces; /*!< TRUE if this space is
  				currently in unflushed_spaces */
@@ -597,7 +584,7 @@
  	UT_LIST_NODE_T(fil_space_t) space_list;
  				/*!< list of all spaces */
  	ulint		magic_n;/*!< FIL_SPACE_MAGIC_N */
-@@ -1291,6 +1292,8 @@
+@@ -1293,6 +1294,8 @@
  		    ut_fold_string(name), space);
  	space->is_in_unflushed_spaces = FALSE;
  
@@ -606,18 +593,18 @@
  	UT_LIST_ADD_LAST(space_list, fil_system->space_list, space);
  
  	mutex_exit(&fil_system->mutex);
-@@ -4943,6 +4946,22 @@
+@@ -5267,6 +5270,34 @@
  	ut_a(byte_offset % OS_FILE_LOG_BLOCK_SIZE == 0);
  	ut_a((len % OS_FILE_LOG_BLOCK_SIZE) == 0);
  
-+	if (srv_pass_corrupt_table && space->is_corrupt) {
++	if (srv_pass_corrupt_table == 1 && space->is_corrupt) {
 +		/* should ignore i/o for the crashed space */
 +		mutex_enter(&fil_system->mutex);
 +		fil_node_complete_io(node, fil_system, type);
 +		mutex_exit(&fil_system->mutex);
 +		if (mode == OS_AIO_NORMAL) {
 +			ut_a(space->purpose == FIL_TABLESPACE);
-+			buf_page_io_complete(message, trx);
++			buf_page_io_complete(message);
 +		}
 +		if (type == OS_FILE_READ) {
 +			return(DB_TABLESPACE_DELETED);
@@ -625,11 +612,23 @@
 +			return(DB_SUCCESS);
 +		}
 +	} else {
-+		ut_a(!space->is_corrupt);
++		if (srv_pass_corrupt_table > 1 && space->is_corrupt) {
++			/* should ignore write i/o for the crashed space */
++			if (type == OS_FILE_WRITE) {
++				mutex_enter(&fil_system->mutex);
++				fil_node_complete_io(node, fil_system, type);
++				mutex_exit(&fil_system->mutex);
++				if (mode == OS_AIO_NORMAL) {
++					ut_a(space->purpose == FIL_TABLESPACE);
++					buf_page_io_complete(message);
++				}
++				return(DB_SUCCESS);
++			}
++		}
  #ifdef UNIV_HOTBACKUP
  	/* In ibbackup do normal i/o, not aio */
  	if (type == OS_FILE_READ) {
-@@ -4957,6 +4976,8 @@
+@@ -5281,6 +5312,8 @@
  	ret = os_aio(type, mode | wake_later, node->name, node->handle, buf,
  		     offset_low, offset_high, len, node, message, trx);
  #endif
@@ -638,16 +637,7 @@
  	ut_a(ret);
  
  	if (mode == OS_AIO_SYNC) {
-@@ -5098,7 +5119,7 @@
- 
- 	if (fil_node->space->purpose == FIL_TABLESPACE) {
- 		srv_set_io_thread_op_info(segment, "complete io for buf page");
--		buf_page_io_complete(message);
-+		buf_page_io_complete(message, NULL);
- 	} else {
- 		srv_set_io_thread_op_info(segment, "complete io for log");
- 		log_io_complete(message);
-@@ -5452,3 +5473,46 @@
+@@ -5780,3 +5813,46 @@
                 return 0;
         }
  }
@@ -808,11 +798,11 @@
 diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
 --- a/storage/innobase/handler/ha_innodb.cc	2010-12-04 15:37:50.578486593 +0900
 +++ b/storage/innobase/handler/ha_innodb.cc	2010-12-04 15:38:18.137549396 +0900
-@@ -3959,6 +3959,12 @@
+@@ -3972,6 +3972,12 @@
  		DBUG_RETURN(1);
  	}
  
-+	if (share->ib_table && share->ib_table->is_corrupt) {
++	if (srv_pass_corrupt_table <= 1 && share->ib_table && share->ib_table->is_corrupt) {
 +		free_share(share);
 +
 +		DBUG_RETURN(HA_ERR_CRASHED_ON_USAGE);
@@ -821,11 +811,11 @@
  	/* Create buffers for packing the fields of a record. Why
  	table->reclength did not work here? Obviously, because char
  	fields when packed actually became 1 byte longer, when we also
-@@ -3986,6 +3992,19 @@
+@@ -3999,6 +4005,19 @@
  	/* Get pointer to a table object in InnoDB dictionary cache */
  	ib_table = dict_table_get(norm_name, TRUE);
  	
-+	if (ib_table && ib_table->is_corrupt) {
++	if (srv_pass_corrupt_table <= 1 && ib_table && ib_table->is_corrupt) {
 +		free_share(share);
 +		my_free(upd_buff);
 +
@@ -841,7 +831,7 @@
  	if (NULL == ib_table) {
  		if (is_part && retries < 10) {
  			++retries;
-@@ -5150,6 +5169,10 @@
+@@ -5163,6 +5182,10 @@
  
  	ha_statistic_increment(&SSV::ha_write_count);
  
@@ -852,7 +842,7 @@
  	if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
  		table->timestamp_field->set_time();
  
-@@ -5367,6 +5390,10 @@
+@@ -5380,6 +5403,10 @@
  func_exit:
  	innobase_active_small();
  
@@ -863,7 +853,7 @@
  	DBUG_RETURN(error_result);
  }
  
-@@ -5543,6 +5570,10 @@
+@@ -5556,6 +5583,10 @@
  
  	ha_statistic_increment(&SSV::ha_update_count);
  
@@ -874,7 +864,7 @@
  	if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
  		table->timestamp_field->set_time();
  
-@@ -5632,6 +5663,10 @@
+@@ -5645,6 +5676,10 @@
  
  	innobase_active_small();
  
@@ -885,7 +875,7 @@
  	DBUG_RETURN(error);
  }
  
-@@ -5653,6 +5688,10 @@
+@@ -5666,6 +5701,10 @@
  
  	ha_statistic_increment(&SSV::ha_delete_count);
  
@@ -896,7 +886,7 @@
  	if (!prebuilt->upd_node) {
  		row_get_prebuilt_update_vector(prebuilt);
  	}
-@@ -5679,6 +5718,10 @@
+@@ -5692,6 +5731,10 @@
  
  	innobase_active_small();
  
@@ -907,62 +897,62 @@
  	DBUG_RETURN(error);
  }
  
-@@ -5918,6 +5961,10 @@
+@@ -5931,6 +5974,10 @@
  
  	ha_statistic_increment(&SSV::ha_read_key_count);
  
-+	if (share->ib_table->is_corrupt) {
++	if (srv_pass_corrupt_table <= 1 && share->ib_table->is_corrupt) {
 +		DBUG_RETURN(HA_ERR_CRASHED);
 +	}
 +
  	index = prebuilt->index;
  
  	if (UNIV_UNLIKELY(index == NULL)) {
-@@ -5983,6 +6030,10 @@
+@@ -5996,6 +6043,10 @@
  		ret = DB_UNSUPPORTED;
  	}
  
-+	if (share->ib_table->is_corrupt) {
++	if (srv_pass_corrupt_table <= 1 && share->ib_table->is_corrupt) {
 +		DBUG_RETURN(HA_ERR_CRASHED);
 +	}
 +
  	switch (ret) {
  	case DB_SUCCESS:
  		error = 0;
-@@ -6098,6 +6149,10 @@
+@@ -6111,6 +6162,10 @@
  {
  	DBUG_ENTER("change_active_index");
  
-+	if (share->ib_table->is_corrupt) {
++	if (srv_pass_corrupt_table <= 1 && share->ib_table->is_corrupt) {
 +		DBUG_RETURN(HA_ERR_CRASHED);
 +	}
 +
  	ut_ad(user_thd == ha_thd());
  	ut_a(prebuilt->trx == thd_to_trx(user_thd));
  
-@@ -6188,6 +6243,10 @@
+@@ -6201,6 +6256,10 @@
  
  	DBUG_ENTER("general_fetch");
  
-+	if (share->ib_table->is_corrupt) {
++	if (srv_pass_corrupt_table <= 1 && share->ib_table->is_corrupt) {
 +		DBUG_RETURN(HA_ERR_CRASHED);
 +	}
 +
  	ut_a(prebuilt->trx == thd_to_trx(user_thd));
  
  	innodb_srv_conc_enter_innodb(prebuilt->trx);
-@@ -6197,6 +6256,10 @@
+@@ -6210,6 +6269,10 @@
  
  	innodb_srv_conc_exit_innodb(prebuilt->trx);
  
-+	if (share->ib_table->is_corrupt) {
++	if (srv_pass_corrupt_table <= 1 && share->ib_table->is_corrupt) {
 +		DBUG_RETURN(HA_ERR_CRASHED);
 +	}
 +
  	switch (ret) {
  	case DB_SUCCESS:
  		error = 0;
-@@ -7467,10 +7530,18 @@
+@@ -7476,10 +7539,18 @@
  
  	update_thd(ha_thd());
  
@@ -981,7 +971,7 @@
  	error = convert_error_code_to_mysql(error, prebuilt->table->flags,
  					    NULL);
  
-@@ -7975,6 +8046,16 @@
+@@ -7980,6 +8051,16 @@
  	return(ranges + (double) rows / (double) total_rows * time_for_scan);
  }
  
@@ -998,7 +988,7 @@
  /*********************************************************************//**
  Calculates the key number used inside MySQL for an Innobase index. We will
  first check the "index translation table" for a match of the index to get
-@@ -8152,7 +8233,7 @@
+@@ -8157,7 +8238,7 @@
  	ib_table = prebuilt->table;
  
  	if (flag & HA_STATUS_TIME) {
@@ -1007,7 +997,7 @@
  			/* In sql_show we call with this flag: update
  			then statistics so that they are up-to-date */
  
-@@ -8445,10 +8526,18 @@
+@@ -8450,10 +8531,18 @@
  	THD*		thd,		/*!< in: connection thread handle */
  	HA_CHECK_OPT*	check_opt)	/*!< in: currently ignored */
  {
@@ -1026,7 +1016,7 @@
  	return(0);
  }
  
-@@ -8630,6 +8719,10 @@
+@@ -8635,6 +8724,10 @@
  		my_error(ER_QUERY_INTERRUPTED, MYF(0));
  	}
  
@@ -1037,7 +1027,7 @@
  	DBUG_RETURN(is_ok ? HA_ADMIN_OK : HA_ADMIN_CORRUPT);
  }
  
-@@ -9400,6 +9493,10 @@
+@@ -9405,6 +9498,10 @@
  
  	update_thd(thd);
  
@@ -1048,7 +1038,7 @@
  	if (prebuilt->table->ibd_file_missing && !thd_tablespace_op(thd)) {
  		ut_print_timestamp(stderr);
  		fprintf(stderr,
-@@ -11800,6 +11897,25 @@
+@@ -11807,6 +11904,26 @@
    "0 (the default) disables automatic dumps.",
    NULL, NULL, 0, 0, UINT_MAX32, 0);
  
@@ -1056,6 +1046,7 @@
 +{
 +  "assert", /* 0 */
 +  "warn", /* 1 */
++  "salvage", /* 2 */
 +  NullS
 +};
 +TYPELIB corrupt_table_action_typelib=
@@ -1074,7 +1065,7 @@
  static struct st_mysql_sys_var* innobase_system_variables[]= {
    MYSQL_SYSVAR(additional_mem_pool_size),
    MYSQL_SYSVAR(autoextend_increment),
-@@ -11886,6 +12002,7 @@
+@@ -11893,6 +12010,7 @@
    MYSQL_SYSVAR(purge_threads),
    MYSQL_SYSVAR(purge_batch_size),
    MYSQL_SYSVAR(rollback_segments),
@@ -1136,17 +1127,7 @@
  #endif /* UNIV_DEBUG */
  /*********************************************************************//**
  Gets the space id of a block.
-@@ -1118,7 +1118,8 @@
- void
- buf_page_io_complete(
- /*=================*/
--	buf_page_t*	bpage);	/*!< in: pointer to the block in question */
-+	buf_page_t*	bpage,	/*!< in: pointer to the block in question */
-+	trx_t*		trx);
- /********************************************************************//**
- Calculates a folded value of a file page address to use in the page hash
- table.
-@@ -1433,6 +1434,7 @@
+@@ -1433,6 +1433,7 @@
  					0 if the block was never accessed
  					in the buffer pool */
  	/* @} */
@@ -1201,7 +1182,7 @@
 diff -ruN a/storage/innobase/include/dict0mem.h b/storage/innobase/include/dict0mem.h
 --- a/storage/innobase/include/dict0mem.h	2010-11-03 07:01:13.000000000 +0900
 +++ b/storage/innobase/include/dict0mem.h	2010-12-04 15:38:18.171513956 +0900
-@@ -636,6 +636,7 @@
+@@ -640,6 +640,7 @@
  				the AUTOINC lock on this table. */
  				/* @} */
  	/*----------------------*/
@@ -1296,7 +1277,7 @@
 diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
 --- a/storage/innobase/include/srv0srv.h	2010-12-04 15:37:50.591516341 +0900
 +++ b/storage/innobase/include/srv0srv.h	2010-12-04 15:38:18.180563749 +0900
-@@ -243,6 +243,7 @@
+@@ -240,6 +240,7 @@
  extern ulint	srv_adaptive_flushing_method;
  
  extern ulint	srv_expand_import;
@@ -1354,7 +1335,7 @@
 diff -ruN a/storage/innobase/row/row0sel.c b/storage/innobase/row/row0sel.c
 --- a/storage/innobase/row/row0sel.c	2010-11-03 07:01:13.000000000 +0900
 +++ b/storage/innobase/row/row0sel.c	2010-12-04 15:38:18.205551115 +0900
-@@ -3848,6 +3848,13 @@
+@@ -3853,6 +3853,13 @@
  	/* PHASE 4: Look for matching records in a loop */
  
  	rec = btr_pcur_get_rec(pcur);
@@ -1368,10 +1349,35 @@
  	ut_ad(!!page_rec_is_comp(rec) == comp);
  #ifdef UNIV_SEARCH_DEBUG
  	/*
+@@ -3930,7 +3937,13 @@
+ 	if (UNIV_UNLIKELY(next_offs >= UNIV_PAGE_SIZE - PAGE_DIR)) {
+ 
+ wrong_offs:
+-		if (srv_force_recovery == 0 || moves_up == FALSE) {
++		if (srv_pass_corrupt_table && !trx_sys_sys_space(index->table->space)) {
++			index->table->is_corrupt = TRUE;
++			fil_space_set_corrupt(index->table->space);
++		}
++
++		if ((srv_force_recovery == 0 || moves_up == FALSE)
++		    && srv_pass_corrupt_table <= 1) {
+ 			ut_print_timestamp(stderr);
+ 			buf_page_print(page_align(rec), 0);
+ 			fprintf(stderr,
+@@ -3981,7 +3994,8 @@
+ 
+ 	offsets = rec_get_offsets(rec, index, offsets, ULINT_UNDEFINED, &heap);
+ 
+-	if (UNIV_UNLIKELY(srv_force_recovery > 0)) {
++	if (UNIV_UNLIKELY(srv_force_recovery > 0)
++	    || (srv_pass_corrupt_table == 2 && index->table->is_corrupt)) {
+ 		if (!rec_validate(rec, offsets)
+ 		    || !btr_index_rec_validate(rec, index, FALSE)) {
+ 			fprintf(stderr,
 diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
 --- a/storage/innobase/srv/srv0srv.c	2010-12-04 15:37:50.602481253 +0900
 +++ b/storage/innobase/srv/srv0srv.c	2010-12-04 15:38:18.209513823 +0900
-@@ -436,6 +436,7 @@
+@@ -430,6 +430,7 @@
  UNIV_INTERN ulint	srv_adaptive_flushing_method = 0; /* 0: native  1: estimate  2: keep_average */
  
  UNIV_INTERN ulint	srv_expand_import = 0; /* 0:disable 1:enable */

=== modified file 'innodb_recovery_patches.patch'
--- innodb_recovery_patches.patch	2011-05-10 11:57:42 +0000
+++ innodb_recovery_patches.patch	2011-06-20 09:04:39 +0000
@@ -117,7 +117,7 @@
  static my_bool	innobase_locks_unsafe_for_binlog	= FALSE;
  static my_bool	innobase_overwrite_relay_log_info	= FALSE;
  static my_bool	innobase_rollback_on_timeout		= FALSE;
-@@ -2562,6 +2563,8 @@
+@@ -2576,6 +2577,8 @@
  
  	srv_force_recovery = (ulint) innobase_force_recovery;
  
@@ -126,7 +126,7 @@
  	srv_use_doublewrite_buf = (ibool) innobase_use_doublewrite;
  	srv_use_checksums = (ibool) innobase_use_checksums;
  
-@@ -11267,6 +11270,11 @@
+@@ -11274,6 +11277,11 @@
    "The common part for InnoDB table spaces.",
    NULL, NULL, NULL);
  
@@ -138,7 +138,7 @@
  static MYSQL_SYSVAR_BOOL(recovery_update_relay_log, innobase_overwrite_relay_log_info,
    PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
    "During InnoDB crash recovery on slave overwrite relay-log.info "
-@@ -11740,6 +11748,7 @@
+@@ -11747,6 +11755,7 @@
    MYSQL_SYSVAR(data_file_path),
    MYSQL_SYSVAR(data_home_dir),
    MYSQL_SYSVAR(doublewrite),
@@ -192,7 +192,7 @@
 diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
 --- a/storage/innobase/include/srv0srv.h	2010-12-03 17:30:16.321953515 +0900
 +++ b/storage/innobase/include/srv0srv.h	2010-12-03 17:30:41.593985184 +0900
-@@ -129,6 +129,8 @@
+@@ -126,6 +126,8 @@
  extern ulint*	srv_data_file_sizes;
  extern ulint*	srv_data_file_is_raw_partition;
  
@@ -441,8 +441,8 @@
  #ifndef UNIV_HOTBACKUP
  # include "os0sync.h"
  # include "os0thread.h"
-@@ -4262,6 +4263,18 @@
- 		os_thread_exit(NULL);
+@@ -4260,6 +4261,18 @@
+ 					   INFINITE);
  	}
  
 +	if (srv_recovery_stats && recv_recovery_is_on() && n_consecutive) {
@@ -459,11 +459,11 @@
 +
  	os_mutex_enter(array->mutex);
  
- 	slot = os_aio_array_get_nth_slot(array, i + segment * n);
+ 	if (srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS
 diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
 --- a/storage/innobase/srv/srv0srv.c	2010-12-03 17:30:16.339955597 +0900
 +++ b/storage/innobase/srv/srv0srv.c	2010-12-03 17:30:41.604958138 +0900
-@@ -166,6 +166,8 @@
+@@ -160,6 +160,8 @@
  /* size in database pages */
  UNIV_INTERN ulint*	srv_data_file_sizes = NULL;
  
@@ -475,7 +475,7 @@
 diff -ruN a/storage/innobase/trx/trx0sys.c b/storage/innobase/trx/trx0sys.c
 --- a/storage/innobase/trx/trx0sys.c	2010-12-03 15:41:52.051986524 +0900
 +++ b/storage/innobase/trx/trx0sys.c	2010-12-03 17:30:41.607026818 +0900
-@@ -566,6 +566,12 @@
+@@ -567,6 +567,12 @@
  			       zip_size ? zip_size : UNIV_PAGE_SIZE,
  			       read_buf, NULL);
  
@@ -488,7 +488,7 @@
  			/* Check if the page is corrupt */
  
  			if (UNIV_UNLIKELY
-@@ -613,6 +619,13 @@
+@@ -614,6 +620,13 @@
  				       zip_size, page_no, 0,
  				       zip_size ? zip_size : UNIV_PAGE_SIZE,
  				       page, NULL);

=== modified file 'innodb_separate_doublewrite.patch'
--- innodb_separate_doublewrite.patch	2011-05-10 11:57:42 +0000
+++ innodb_separate_doublewrite.patch	2011-06-20 09:04:39 +0000
@@ -105,7 +105,7 @@
 diff -ruN a/storage/innobase/fil/fil0fil.c b/storage/innobase/fil/fil0fil.c
 --- a/storage/innobase/fil/fil0fil.c	2010-12-04 15:35:29.143813775 +0900
 +++ b/storage/innobase/fil/fil0fil.c	2010-12-04 15:35:58.628498870 +0900
-@@ -655,7 +655,7 @@
+@@ -657,7 +657,7 @@
  
  	UT_LIST_ADD_LAST(chain, space->chain, node);
  
@@ -114,7 +114,7 @@
  
  		fil_system->max_assigned_id = id;
  	}
-@@ -719,14 +719,14 @@
+@@ -721,14 +721,14 @@
  		size_bytes = (((ib_int64_t)size_high) << 32)
  			+ (ib_int64_t)size_low;
  #ifdef UNIV_HOTBACKUP
@@ -131,7 +131,7 @@
  
  		if (size_bytes < FIL_IBD_FILE_INITIAL_SIZE * UNIV_PAGE_SIZE) {
  			fprintf(stderr,
-@@ -772,7 +772,7 @@
+@@ -774,7 +774,7 @@
  		}
  
  		if (UNIV_UNLIKELY(space_id == ULINT_UNDEFINED
@@ -140,7 +140,7 @@
  			fprintf(stderr,
  				"InnoDB: Error: tablespace id %lu"
  				" in file %s is not sensible\n",
-@@ -840,7 +840,7 @@
+@@ -842,7 +842,7 @@
  
  	system->n_open++;
  
@@ -149,7 +149,7 @@
  		/* Put the node to the LRU list */
  		UT_LIST_ADD_FIRST(LRU, system->LRU, node);
  	}
-@@ -873,7 +873,7 @@
+@@ -875,7 +875,7 @@
  	ut_a(system->n_open > 0);
  	system->n_open--;
  
@@ -158,7 +158,7 @@
  		ut_a(UT_LIST_GET_LEN(system->LRU) > 0);
  
  		/* The node is in the LRU list, remove it */
-@@ -959,7 +959,7 @@
+@@ -961,7 +961,7 @@
  retry:
  	mutex_enter(&fil_system->mutex);
  
@@ -167,7 +167,7 @@
  		/* We keep log files and system tablespace files always open;
  		this is important in preventing deadlocks in this module, as
  		a page read completion often performs another read from the
-@@ -1190,7 +1190,7 @@
+@@ -1192,7 +1192,7 @@
  			" tablespace memory cache!\n",
  			(ulong) space->id);
  
@@ -176,7 +176,7 @@
  
  			mutex_exit(&fil_system->mutex);
  
-@@ -1252,6 +1252,7 @@
+@@ -1254,6 +1254,7 @@
  	space->mark = FALSE;
  
  	if (UNIV_LIKELY(purpose == FIL_TABLESPACE && !recv_recovery_on)
@@ -184,7 +184,7 @@
  	    && UNIV_UNLIKELY(id > fil_system->max_assigned_id)) {
  		if (!fil_system->space_id_reuse_warned) {
  			fil_system->space_id_reuse_warned = TRUE;
-@@ -1335,7 +1336,7 @@
+@@ -1337,7 +1338,7 @@
  			(ulong) SRV_LOG_SPACE_FIRST_ID);
  	}
  
@@ -193,7 +193,7 @@
  
  	if (success) {
  		*space_id = fil_system->max_assigned_id = id;
-@@ -1598,6 +1599,8 @@
+@@ -1600,6 +1601,8 @@
  	UT_LIST_INIT(fil_system->LRU);
  
  	fil_system->max_n_open = max_n_open;
@@ -202,7 +202,7 @@
  }
  
  /*******************************************************************//**
-@@ -1619,7 +1622,7 @@
+@@ -1621,7 +1624,7 @@
  	space = UT_LIST_GET_FIRST(fil_system->space_list);
  
  	while (space != NULL) {
@@ -211,7 +211,7 @@
  			node = UT_LIST_GET_FIRST(space->chain);
  
  			while (node != NULL) {
-@@ -1709,6 +1712,10 @@
+@@ -1711,6 +1714,10 @@
  		ut_error;
  	}
  
@@ -222,7 +222,7 @@
  	mutex_enter(&fil_system->mutex);
  
  	if (fil_system->max_assigned_id < max_id) {
-@@ -1727,6 +1734,7 @@
+@@ -1729,6 +1736,7 @@
  ulint
  fil_write_lsn_and_arch_no_to_file(
  /*==============================*/
@@ -230,7 +230,7 @@
  	ulint		sum_of_sizes,	/*!< in: combined size of previous files
  					in space, in database pages */
  	ib_uint64_t	lsn,		/*!< in: lsn to write */
-@@ -1736,14 +1744,16 @@
+@@ -1738,14 +1746,16 @@
  	byte*	buf1;
  	byte*	buf;
  
@@ -249,7 +249,7 @@
  
  	mem_free(buf1);
  
-@@ -1779,7 +1789,7 @@
+@@ -1781,7 +1791,7 @@
  		always open. */
  
  		if (space->purpose == FIL_TABLESPACE
@@ -258,7 +258,7 @@
  			sum_of_sizes = 0;
  
  			node = UT_LIST_GET_FIRST(space->chain);
-@@ -1787,7 +1797,7 @@
+@@ -1789,7 +1799,7 @@
  				mutex_exit(&fil_system->mutex);
  
  				err = fil_write_lsn_and_arch_no_to_file(
@@ -267,7 +267,7 @@
  				if (err != DB_SUCCESS) {
  
  					return(err);
-@@ -3834,7 +3844,7 @@
+@@ -4158,7 +4168,7 @@
  	}
  
  #ifndef UNIV_HOTBACKUP
@@ -276,7 +276,7 @@
  		fprintf(stderr,
  			"InnoDB: Error: tablespace id %lu in file %s"
  			" is not sensible\n",
-@@ -3843,7 +3853,7 @@
+@@ -4167,7 +4177,7 @@
  		goto func_exit;
  	}
  #else
@@ -285,7 +285,7 @@
  		char*	new_path;
  
  		fprintf(stderr,
-@@ -4664,7 +4674,7 @@
+@@ -4988,7 +4998,7 @@
  	}
  
  	if (node->n_pending == 0 && space->purpose == FIL_TABLESPACE
@@ -294,7 +294,7 @@
  		/* The node is in the LRU list, remove it */
  
  		ut_a(UT_LIST_GET_LEN(system->LRU) > 0);
-@@ -4710,7 +4720,7 @@
+@@ -5034,7 +5044,7 @@
  	}
  
  	if (node->n_pending == 0 && node->space->purpose == FIL_TABLESPACE
@@ -303,7 +303,7 @@
  		/* The node must be put back to the LRU list */
  		UT_LIST_ADD_FIRST(LRU, system->LRU, node);
  	}
-@@ -5316,7 +5326,7 @@
+@@ -5644,7 +5654,7 @@
  		ut_a(fil_node->n_pending == 0);
  		ut_a(fil_node->open);
  		ut_a(fil_node->space->purpose == FIL_TABLESPACE);
@@ -348,7 +348,7 @@
  
  /* The highest file format being used in the database. The value can be
  set by user, however, it will be adjusted to the newer file format if
-@@ -2458,6 +2459,8 @@
+@@ -2472,6 +2473,8 @@
  		goto error;
  	}
  
@@ -357,7 +357,7 @@
  	srv_use_sys_stats_table = (ibool) innobase_use_sys_stats_table;
  
  	/* -------------- Log files ---------------------------*/
-@@ -11634,6 +11637,11 @@
+@@ -11641,6 +11644,11 @@
    "Path to individual files and their sizes.",
    NULL, NULL, NULL);
  
@@ -369,7 +369,7 @@
  static MYSQL_SYSVAR_LONG(autoinc_lock_mode, innobase_autoinc_lock_mode,
    PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
    "The AUTOINC lock modes supported by InnoDB:               "
-@@ -11801,6 +11809,7 @@
+@@ -11808,6 +11816,7 @@
    MYSQL_SYSVAR(commit_concurrency),
    MYSQL_SYSVAR(concurrency_tickets),
    MYSQL_SYSVAR(data_file_path),
@@ -403,7 +403,7 @@
 diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
 --- a/storage/innobase/include/srv0srv.h	2010-12-04 15:35:29.177480351 +0900
 +++ b/storage/innobase/include/srv0srv.h	2010-12-04 15:35:58.646556250 +0900
-@@ -132,6 +132,8 @@
+@@ -129,6 +129,8 @@
  extern ulint*	srv_data_file_sizes;
  extern ulint*	srv_data_file_is_raw_partition;
  
@@ -519,7 +519,7 @@
 diff -ruN a/storage/innobase/row/row0mysql.c b/storage/innobase/row/row0mysql.c
 --- a/storage/innobase/row/row0mysql.c	2010-12-03 17:30:16.334989510 +0900
 +++ b/storage/innobase/row/row0mysql.c	2010-12-04 15:35:58.652496484 +0900
-@@ -3449,7 +3449,7 @@
+@@ -3447,7 +3447,7 @@
  		/* Do not drop possible .ibd tablespace if something went
  		wrong: we do not want to delete valuable data of the user */
  
@@ -531,7 +531,7 @@
 diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
 --- a/storage/innobase/srv/srv0srv.c	2010-12-04 15:35:29.180483212 +0900
 +++ b/storage/innobase/srv/srv0srv.c	2010-12-04 15:35:58.656550107 +0900
-@@ -169,6 +169,8 @@
+@@ -163,6 +163,8 @@
  /* size in database pages */
  UNIV_INTERN ulint*	srv_data_file_sizes = NULL;
  
@@ -768,7 +768,7 @@
 diff -ruN a/storage/innobase/trx/trx0sys.c b/storage/innobase/trx/trx0sys.c
 --- a/storage/innobase/trx/trx0sys.c	2010-12-03 17:32:15.651024019 +0900
 +++ b/storage/innobase/trx/trx0sys.c	2010-12-04 15:35:58.664550291 +0900
-@@ -414,6 +414,152 @@
+@@ -415,6 +415,152 @@
  
  		goto start_again;
  	}
@@ -921,7 +921,7 @@
  }
  
  /****************************************************************//**
-@@ -437,10 +583,19 @@
+@@ -438,10 +584,19 @@
  	ulint	source_page_no;
  	byte*	page;
  	byte*	doublewrite;
@@ -941,7 +941,7 @@
  	/* We do the file i/o past the buffer pool */
  
  	unaligned_read_buf = ut_malloc(2 * UNIV_PAGE_SIZE);
-@@ -449,7 +604,7 @@
+@@ -450,7 +605,7 @@
  	/* Read the trx sys header to check if we are using the doublewrite
  	buffer */
  
@@ -950,7 +950,7 @@
  	       UNIV_PAGE_SIZE, read_buf, NULL);
  	doublewrite = read_buf + TRX_SYS_DOUBLEWRITE;
  
-@@ -487,10 +642,10 @@
+@@ -488,10 +643,10 @@
  
  	/* Read the pages from the doublewrite buffer to memory */
  
@@ -963,7 +963,7 @@
  	       TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * UNIV_PAGE_SIZE,
  	       buf + TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * UNIV_PAGE_SIZE,
  	       NULL);
-@@ -546,7 +701,8 @@
+@@ -547,7 +702,8 @@
  				" doublewrite buf.\n",
  				(ulong) space_id, (ulong) page_no, (ulong) i);
  
@@ -973,7 +973,7 @@
  			   && ((page_no >= block1
  				&& page_no
  				< block1 + TRX_SYS_DOUBLEWRITE_BLOCK_SIZE)
-@@ -1015,6 +1171,83 @@
+@@ -1016,6 +1172,83 @@
  }
  
  /*****************************************************************//**
@@ -1057,7 +1057,7 @@
  Creates and initializes the central memory structures for the transaction
  system. This is called when the database is started. */
  UNIV_INTERN
-@@ -1386,6 +1619,26 @@
+@@ -1387,6 +1620,26 @@
  	/* Does nothing at the moment */
  }
  

=== modified file 'innodb_show_lock_name.patch'
--- innodb_show_lock_name.patch	2011-05-10 11:57:42 +0000
+++ innodb_show_lock_name.patch	2011-06-20 09:04:39 +0000
@@ -8,7 +8,7 @@
 diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
 --- a/storage/innobase/handler/ha_innodb.cc	2010-12-03 17:34:35.285040381 +0900
 +++ b/storage/innobase/handler/ha_innodb.cc	2010-12-03 17:35:12.974975252 +0900
-@@ -9588,9 +9588,8 @@
+@@ -9593,9 +9593,8 @@
  			rw_lock_wait_time += mutex->lspent_time;
  		}
  #else /* UNIV_DEBUG */
@@ -20,7 +20,7 @@
  		buf2len= (uint) my_snprintf(buf2, sizeof(buf2), "os_waits=%lu",
  				     (ulong) mutex->count_os_wait);
  
-@@ -9605,10 +9604,8 @@
+@@ -9610,10 +9609,8 @@
  
  	if (block_mutex) {
  		buf1len = (uint) my_snprintf(buf1, sizeof buf1,
@@ -33,7 +33,7 @@
  		buf2len = (uint) my_snprintf(buf2, sizeof buf2,
  					     "os_waits=%lu",
  					     (ulong) block_mutex_oswait_count);
-@@ -9637,9 +9634,8 @@
+@@ -9642,9 +9639,8 @@
  			continue;
  		}
  
@@ -45,7 +45,7 @@
  		buf2len = my_snprintf(buf2, sizeof buf2, "os_waits=%lu",
  				      (ulong) lock->count_os_wait);
  
-@@ -9653,10 +9649,8 @@
+@@ -9658,10 +9654,8 @@
  
  	if (block_lock) {
  		buf1len = (uint) my_snprintf(buf1, sizeof buf1,
@@ -248,7 +248,7 @@
  /******************************************************************//**
  NOTE! Please use the corresponding macro mutex_enter(), not directly
  this function!
-@@ -722,9 +722,9 @@
+@@ -731,9 +731,9 @@
  	ulint	line;		/*!< Line where the mutex was locked */
  	ulint	level;		/*!< Level in the global latching order */
  #endif /* UNIV_SYNC_DEBUG */
@@ -259,7 +259,7 @@
  	os_thread_id_t thread_id; /*!< The thread id of the thread
  				which locked the mutex. */
  	ulint		magic_n;	/*!< MUTEX_MAGIC_N */
-@@ -739,9 +739,9 @@
+@@ -748,9 +748,9 @@
  	ulong		count_os_yield;	/*!< count of os_wait */
  	ulonglong	lspent_time;	/*!< mutex os_wait timer msec */
  	ulonglong	lmax_spent_time;/*!< mutex os_wait timer msec */

=== modified file 'innodb_show_status.patch'
--- innodb_show_status.patch	2011-05-10 11:57:42 +0000
+++ innodb_show_status.patch	2011-06-20 09:04:39 +0000
@@ -62,7 +62,7 @@
 diff -ruN a/storage/innobase/fil/fil0fil.c b/storage/innobase/fil/fil0fil.c
 --- a/storage/innobase/fil/fil0fil.c	2010-11-03 07:01:13.000000000 +0900
 +++ b/storage/innobase/fil/fil0fil.c	2010-12-03 15:07:31.790357112 +0900
-@@ -4884,3 +4884,30 @@
+@@ -4888,3 +4888,30 @@
  
  	fil_system = NULL;
  }
@@ -105,7 +105,7 @@
    {"buffer_pool_pages_free",
    (char*) &export_vars.innodb_buffer_pool_pages_free,	  SHOW_LONG},
  #ifdef UNIV_DEBUG
-@@ -11074,6 +11076,16 @@
+@@ -11081,6 +11083,16 @@
    "Force InnoDB to not use next-key locking, to use only row-level locking.",
    NULL, NULL, FALSE);
  
@@ -122,7 +122,7 @@
  #ifdef UNIV_LOG_ARCHIVE
  static MYSQL_SYSVAR_STR(log_arch_dir, innobase_log_arch_dir,
    PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
-@@ -11261,7 +11273,7 @@
+@@ -11268,7 +11280,7 @@
  
  static MYSQL_SYSVAR_STR(version, innodb_version_str,
    PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_READONLY,
@@ -131,7 +131,7 @@
  
  static MYSQL_SYSVAR_BOOL(use_sys_malloc, srv_use_sys_malloc,
    PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
-@@ -11354,6 +11366,8 @@
+@@ -11361,6 +11373,8 @@
    MYSQL_SYSVAR(thread_concurrency),
    MYSQL_SYSVAR(thread_sleep_delay),
    MYSQL_SYSVAR(autoinc_lock_mode),
@@ -186,7 +186,7 @@
 diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
 --- a/storage/innobase/include/srv0srv.h	2010-11-03 07:01:13.000000000 +0900
 +++ b/storage/innobase/include/srv0srv.h	2010-12-03 15:07:31.813958103 +0900
-@@ -145,6 +145,9 @@
+@@ -142,6 +142,9 @@
  extern char	srv_adaptive_flushing;
  
  
@@ -196,7 +196,7 @@
  /* The sort order table of the MySQL latin1_swedish_ci character set
  collation */
  extern const byte*	srv_latin1_ordering;
-@@ -326,6 +329,8 @@
+@@ -323,6 +326,8 @@
  buffer pool to disk */
  extern ulint srv_buf_pool_flushed;
  
@@ -205,7 +205,7 @@
  /** Number of buffer pool reads that led to the
  reading of a disk page */
  extern ulint srv_buf_pool_reads;
-@@ -705,6 +710,7 @@
+@@ -702,6 +707,7 @@
  	ulint innodb_buffer_pool_reads;		/*!< srv_buf_pool_reads */
  	ulint innodb_buffer_pool_wait_free;	/*!< srv_buf_pool_wait_free */
  	ulint innodb_buffer_pool_pages_flushed;	/*!< srv_buf_pool_flushed */
@@ -309,7 +309,7 @@
  #include "mysql/plugin.h"
  #include "mysql/service_thd_wait.h"
  
-@@ -194,6 +195,9 @@
+@@ -188,6 +189,9 @@
  the checkpoints. */
  UNIV_INTERN char	srv_adaptive_flushing	= TRUE;
  
@@ -319,7 +319,7 @@
  /** Maximum number of times allowed to conditionally acquire
  mutex before switching to blocking wait on the mutex */
  #define MAX_MUTEX_NOWAIT	20
-@@ -320,6 +324,7 @@
+@@ -314,6 +318,7 @@
  /* variable to count the number of pages that were written from buffer
  pool to the disk */
  UNIV_INTERN ulint srv_buf_pool_flushed = 0;
@@ -327,7 +327,7 @@
  
  /** Number of buffer pool reads that led to the
  reading of a disk page */
-@@ -1814,6 +1819,13 @@
+@@ -1823,6 +1828,13 @@
  	ulint	n_reserved;
  	ibool	ret;
  
@@ -341,7 +341,7 @@
  	mutex_enter(&srv_innodb_monitor_mutex);
  
  	current_time = time(NULL);
-@@ -1862,31 +1874,6 @@
+@@ -1871,31 +1883,6 @@
  
  	mutex_exit(&dict_foreign_err_mutex);
  
@@ -373,7 +373,7 @@
  	fputs("--------\n"
  	      "FILE I/O\n"
  	      "--------\n", file);
-@@ -1917,10 +1904,78 @@
+@@ -1926,10 +1913,78 @@
  	      "BUFFER POOL AND MEMORY\n"
  	      "----------------------\n", file);
  	fprintf(file,
@@ -456,7 +456,7 @@
  	fprintf(file, "Dictionary memory allocated " ULINTPF "\n",
  		dict_sys->size);
  
-@@ -1936,6 +1991,16 @@
+@@ -1945,6 +2000,16 @@
  	fprintf(file, "%lu read views open inside InnoDB\n",
  		UT_LIST_GET_LEN(trx_sys->view_list));
  
@@ -473,7 +473,7 @@
  	n_reserved = fil_space_get_n_reserved_extents(0);
  	if (n_reserved > 0) {
  		fprintf(file,
-@@ -1979,6 +2044,31 @@
+@@ -1988,6 +2053,31 @@
  	srv_n_rows_deleted_old = srv_n_rows_deleted;
  	srv_n_rows_read_old = srv_n_rows_read;
  
@@ -505,7 +505,7 @@
  	fputs("----------------------------\n"
  	      "END OF INNODB MONITOR OUTPUT\n"
  	      "============================\n", file);
-@@ -2022,6 +2112,7 @@
+@@ -2031,6 +2121,7 @@
  		= srv_buf_pool_write_requests;
  	export_vars.innodb_buffer_pool_wait_free = srv_buf_pool_wait_free;
  	export_vars.innodb_buffer_pool_pages_flushed = srv_buf_pool_flushed;

=== modified file 'innodb_show_status_extend.patch'
--- innodb_show_status_extend.patch	2011-05-10 11:57:42 +0000
+++ innodb_show_status_extend.patch	2011-06-20 09:04:39 +0000
@@ -245,7 +245,7 @@
 diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
 --- a/storage/innobase/include/srv0srv.h	2011-01-21 19:53:42.380638228 +0900
 +++ b/storage/innobase/include/srv0srv.h	2011-01-21 19:54:44.662600032 +0900
-@@ -738,6 +738,11 @@
+@@ -735,6 +735,11 @@
  
  /** Status variables to be passed to MySQL */
  struct export_var_struct{
@@ -257,7 +257,7 @@
  	ulint innodb_data_pending_reads;	/*!< Pending reads */
  	ulint innodb_data_pending_writes;	/*!< Pending writes */
  	ulint innodb_data_pending_fsyncs;	/*!< Pending fsyncs */
-@@ -755,6 +760,9 @@
+@@ -752,6 +757,9 @@
  #ifdef UNIV_DEBUG
  	ulint innodb_buffer_pool_pages_latched;	/*!< Latched pages */
  #endif /* UNIV_DEBUG */
@@ -267,7 +267,7 @@
  	ulint innodb_buffer_pool_read_requests;	/*!< buf_pool->stat.n_page_gets */
  	ulint innodb_buffer_pool_reads;		/*!< srv_buf_pool_reads */
  	ulint innodb_buffer_pool_wait_free;	/*!< srv_buf_pool_wait_free */
-@@ -763,13 +771,43 @@
+@@ -760,13 +768,43 @@
  	ulint innodb_buffer_pool_write_requests;/*!< srv_buf_pool_write_requests */
  	ulint innodb_buffer_pool_read_ahead;	/*!< srv_read_ahead */
  	ulint innodb_buffer_pool_read_ahead_evicted;/*!< srv_read_ahead evicted*/
@@ -311,7 +311,7 @@
  	ulint innodb_os_log_written;		/*!< srv_os_log_written */
  	ulint innodb_os_log_fsyncs;		/*!< fil_n_log_flushes */
  	ulint innodb_os_log_pending_writes;	/*!< srv_os_log_pending_writes */
-@@ -778,6 +816,8 @@
+@@ -775,6 +813,8 @@
  	ulint innodb_pages_created;		/*!< buf_pool->stat.n_pages_created */
  	ulint innodb_pages_read;		/*!< buf_pool->stat.n_pages_read */
  	ulint innodb_pages_written;		/*!< buf_pool->stat.n_pages_written */
@@ -320,7 +320,7 @@
  	ulint innodb_row_lock_waits;		/*!< srv_n_lock_wait_count */
  	ulint innodb_row_lock_current_waits;	/*!< srv_n_lock_wait_current_count */
  	ib_int64_t innodb_row_lock_time;	/*!< srv_n_lock_wait_time
-@@ -787,11 +827,18 @@
+@@ -784,11 +824,18 @@
  						/ srv_n_lock_wait_count */
  	ulint innodb_row_lock_time_max;		/*!< srv_n_lock_max_wait_time
  						/ 1000 */
@@ -342,7 +342,7 @@
 diff -ruN a/storage/innobase/include/sync0sync.h b/storage/innobase/include/sync0sync.h
 --- a/storage/innobase/include/sync0sync.h	2011-01-21 19:48:45.982637372 +0900
 +++ b/storage/innobase/include/sync0sync.h	2011-01-21 19:54:44.664638235 +0900
-@@ -760,6 +760,10 @@
+@@ -769,6 +769,10 @@
  
  #define	SYNC_SPIN_ROUNDS	srv_n_spin_wait_rounds
  
@@ -391,7 +391,7 @@
 diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
 --- a/storage/innobase/srv/srv0srv.c	2011-01-21 19:53:42.390637840 +0900
 +++ b/storage/innobase/srv/srv0srv.c	2011-01-21 19:54:44.673637084 +0900
-@@ -2248,12 +2248,49 @@
+@@ -2258,12 +2258,49 @@
  	ulint		LRU_len;
  	ulint		free_len;
  	ulint		flush_list_len;
@@ -441,7 +441,7 @@
  	export_vars.innodb_data_pending_reads
  		= os_n_pending_reads;
  	export_vars.innodb_data_pending_writes
-@@ -2290,6 +2327,92 @@
+@@ -2300,6 +2337,92 @@
  
  	export_vars.innodb_buffer_pool_pages_misc
  	       	= buf_pool_get_n_pages() - LRU_len - free_len;

=== modified file 'innodb_show_sys_tables.patch'
--- innodb_show_sys_tables.patch	2011-05-23 03:13:18 +0000
+++ innodb_show_sys_tables.patch	2011-06-20 09:04:39 +0000
@@ -41,7 +41,7 @@
 diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
 --- a/storage/innobase/handler/ha_innodb.cc	2010-12-03 15:53:54.615040167 +0900
 +++ b/storage/innobase/handler/ha_innodb.cc	2010-12-03 16:07:26.851357007 +0900
-@@ -11765,7 +11765,14 @@
+@@ -11772,7 +11772,14 @@
  i_s_innodb_cmp,
  i_s_innodb_cmp_reset,
  i_s_innodb_cmpmem,

=== modified file 'innodb_split_buf_pool_mutex.patch'
--- innodb_split_buf_pool_mutex.patch	2011-05-10 11:57:42 +0000
+++ innodb_split_buf_pool_mutex.patch	2011-06-20 09:04:39 +0000
@@ -2282,7 +2282,7 @@
  	return(count);
  }
 @@ -1722,13 +1754,15 @@
- 	      || sync_thread_levels_empty_gen(TRUE));
+ 	      || sync_thread_levels_empty_except_dict());
  #endif /* UNIV_SYNC_DEBUG */
  
 -	buf_pool_mutex_enter(buf_pool);
@@ -3033,8 +3033,19 @@
  			b->state = b->oldest_modification
  				? BUF_BLOCK_ZIP_DIRTY
  				: BUF_BLOCK_ZIP_PAGE;
-@@ -1614,7 +1748,9 @@
+@@ -1597,6 +1731,7 @@
+ 				buf_LRU_add_block_low(b, buf_page_is_old(b));
+ 			}
+ 
++			mutex_enter(&buf_pool->zip_mutex);
+ 			if (b->state == BUF_BLOCK_ZIP_PAGE) {
+ 				buf_LRU_insert_zip_clean(b);
+ 			} else {
+@@ -1612,9 +1747,12 @@
+ 			buf_pool->mutex and block_mutex. */
+ 			b->buf_fix_count++;
  			b->io_fix = BUF_IO_READ;
++			mutex_exit(&buf_pool->zip_mutex);
  		}
  
 -		buf_pool_mutex_exit(buf_pool);
@@ -3044,7 +3055,7 @@
  		mutex_exit(block_mutex);
  
  		/* Remove possible adaptive hash index on the page.
-@@ -1646,7 +1782,9 @@
+@@ -1646,7 +1784,9 @@
  				: BUF_NO_CHECKSUM_MAGIC);
  		}
  
@@ -3055,7 +3066,7 @@
  		mutex_enter(block_mutex);
  
  		if (b) {
-@@ -1656,13 +1794,17 @@
+@@ -1656,13 +1796,17 @@
  			mutex_exit(&buf_pool->zip_mutex);
  		}
  
@@ -3074,7 +3085,7 @@
  	}
  
  	return(BUF_LRU_FREED);
-@@ -1674,13 +1816,14 @@
+@@ -1674,13 +1818,14 @@
  void
  buf_LRU_block_free_non_file_page(
  /*=============================*/
@@ -3091,7 +3102,7 @@
  	ut_ad(mutex_own(&block->mutex));
  
  	switch (buf_block_get_state(block)) {
-@@ -1714,18 +1857,21 @@
+@@ -1714,18 +1859,21 @@
  	if (data) {
  		block->page.zip.data = NULL;
  		mutex_exit(&block->mutex);
@@ -3117,7 +3128,7 @@
  
  	UNIV_MEM_ASSERT_AND_FREE(block->frame, UNIV_PAGE_SIZE);
  }
-@@ -1755,7 +1901,11 @@
+@@ -1755,7 +1903,11 @@
  	buf_pool_t*		buf_pool = buf_pool_from_bpage(bpage);
  
  	ut_ad(bpage);
@@ -3130,7 +3141,7 @@
  	ut_ad(mutex_own(buf_page_get_mutex(bpage)));
  
  	ut_a(buf_page_get_io_fix(bpage) == BUF_IO_NONE);
-@@ -1863,7 +2013,9 @@
+@@ -1863,7 +2015,9 @@
  
  #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
  		mutex_exit(buf_page_get_mutex(bpage));
@@ -3141,7 +3152,7 @@
  		buf_print();
  		buf_LRU_print();
  		buf_validate();
-@@ -1884,18 +2036,18 @@
+@@ -1884,18 +2038,18 @@
  		ut_a(bpage->zip.data);
  		ut_a(buf_page_get_zip_size(bpage));
  
@@ -3165,7 +3176,7 @@
  
  		UNIV_MEM_UNDESC(bpage);
  		return(BUF_BLOCK_ZIP_FREE);
-@@ -1918,13 +2070,13 @@
+@@ -1918,13 +2072,13 @@
  			ut_ad(!bpage->in_flush_list);
  			ut_ad(!bpage->in_LRU_list);
  			mutex_exit(&((buf_block_t*) bpage)->mutex);
@@ -3182,7 +3193,7 @@
  			mutex_enter(&((buf_block_t*) bpage)->mutex);
  			page_zip_set_size(&bpage->zip, 0);
  		}
-@@ -1950,18 +2102,19 @@
+@@ -1950,18 +2104,19 @@
  void
  buf_LRU_block_free_hashed_page(
  /*===========================*/
@@ -3206,7 +3217,7 @@
  }
  
  /**********************************************************************//**
-@@ -1988,7 +2141,8 @@
+@@ -1988,7 +2143,8 @@
  	}
  
  	if (adjust) {
@@ -3216,7 +3227,7 @@
  
  		if (ratio != buf_pool->LRU_old_ratio) {
  			buf_pool->LRU_old_ratio = ratio;
-@@ -2000,7 +2154,8 @@
+@@ -2000,7 +2156,8 @@
  			}
  		}
  
@@ -3226,7 +3237,7 @@
  	} else {
  		buf_pool->LRU_old_ratio = ratio;
  	}
-@@ -2105,7 +2260,8 @@
+@@ -2105,7 +2262,8 @@
  	ulint		new_len;
  
  	ut_ad(buf_pool);
@@ -3236,7 +3247,7 @@
  
  	if (UT_LIST_GET_LEN(buf_pool->LRU) >= BUF_LRU_OLD_MIN_LEN) {
  
-@@ -2166,16 +2322,22 @@
+@@ -2166,16 +2324,22 @@
  
  	ut_a(buf_pool->LRU_old_len == old_len);
  
@@ -3261,7 +3272,7 @@
  	UT_LIST_VALIDATE(unzip_LRU, buf_block_t, buf_pool->unzip_LRU,
  			 ut_ad(ut_list_node_313->in_unzip_LRU_list
  			       && ut_list_node_313->page.in_LRU_list));
-@@ -2189,7 +2351,8 @@
+@@ -2189,7 +2353,8 @@
  		ut_a(buf_page_belongs_to_unzip_LRU(&block->page));
  	}
  
@@ -3271,7 +3282,7 @@
  }
  
  /**********************************************************************//**
-@@ -2225,7 +2388,8 @@
+@@ -2225,7 +2390,8 @@
  	const buf_page_t*	bpage;
  
  	ut_ad(buf_pool);
@@ -3281,7 +3292,7 @@
  
  	bpage = UT_LIST_GET_FIRST(buf_pool->LRU);
  
-@@ -2282,7 +2446,8 @@
+@@ -2282,7 +2448,8 @@
  		bpage = UT_LIST_GET_NEXT(LRU, bpage);
  	}
  
@@ -3388,7 +3399,7 @@
 diff -ruN a/storage/innobase/ibuf/ibuf0ibuf.c b/storage/innobase/ibuf/ibuf0ibuf.c
 --- a/storage/innobase/ibuf/ibuf0ibuf.c	2010-12-03 15:48:03.068954202 +0900
 +++ b/storage/innobase/ibuf/ibuf0ibuf.c	2010-12-03 15:48:29.335988682 +0900
-@@ -3832,9 +3832,11 @@
+@@ -3821,9 +3821,11 @@
  		ulint		fold = buf_page_address_fold(space, page_no);
  		buf_pool_t*	buf_pool = buf_pool_get(space, page_no);
  
@@ -3897,7 +3908,7 @@
  extern mysql_pfs_key_t	cache_last_read_mutex_key;
  extern mysql_pfs_key_t	dict_foreign_err_mutex_key;
  extern mysql_pfs_key_t	dict_sys_mutex_key;
-@@ -659,7 +663,7 @@
+@@ -668,7 +672,7 @@
  #define SYNC_TRX_SYS_HEADER	290
  #define	SYNC_PURGE_QUEUE	200
  #define SYNC_LOG		170
@@ -3906,7 +3917,7 @@
  #define SYNC_RECV		168
  #define	SYNC_WORK_QUEUE		162
  #define	SYNC_SEARCH_SYS_CONF	161	/* for assigning btr_search_enabled */
-@@ -669,8 +673,13 @@
+@@ -678,8 +682,13 @@
  					SYNC_SEARCH_SYS, as memory allocation
  					can call routines there! Otherwise
  					the level is SYNC_MEM_HASH. */
@@ -3921,7 +3932,7 @@
  #define	SYNC_BUF_FLUSH_LIST	145	/* Buffer flush list mutex */
  #define SYNC_DOUBLEWRITE	140
  #define	SYNC_ANY_LATCH		135
-@@ -702,7 +711,7 @@
+@@ -711,7 +720,7 @@
  		os_fast_mutex;	/*!< We use this OS mutex in place of lock_word
  				when atomic operations are not enabled */
  #endif
@@ -3933,7 +3944,7 @@
 diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
 --- a/storage/innobase/srv/srv0srv.c	2010-12-03 15:48:03.080956216 +0900
 +++ b/storage/innobase/srv/srv0srv.c	2010-12-03 15:48:29.355023766 +0900
-@@ -3089,7 +3089,7 @@
+@@ -3098,7 +3098,7 @@
  								level += log_sys->max_checkpoint_age
  									 - (lsn - oldest_modification);
  							}
@@ -3942,7 +3953,7 @@
  							n_blocks++;
  						}
  
-@@ -3175,7 +3175,7 @@
+@@ -3184,7 +3184,7 @@
  							found = TRUE;
  							break;
  						}
@@ -3987,7 +3998,7 @@
  }
  
  /******************************************************************//**
-@@ -1189,7 +1199,12 @@
+@@ -1234,7 +1244,12 @@
  			ut_error;
  		}
  		break;
@@ -4000,7 +4011,7 @@
  	case SYNC_BUF_POOL:
  		/* We can have multiple mutexes of this type therefore we
  		can only check whether the greater than condition holds. */
-@@ -1207,7 +1222,8 @@
+@@ -1252,7 +1267,8 @@
  		buffer block (block->mutex or buf_pool->zip_mutex). */
  		if (!sync_thread_levels_g(array, level, FALSE)) {
  			ut_a(sync_thread_levels_g(array, level - 1, TRUE));

=== modified file 'innodb_stats.patch'
--- innodb_stats.patch	2011-05-23 03:13:18 +0000
+++ innodb_stats.patch	2011-06-20 09:04:39 +0000
@@ -350,7 +350,7 @@
 diff -ruN a/storage/innobase/dict/dict0dict.c b/storage/innobase/dict/dict0dict.c
 --- a/storage/innobase/dict/dict0dict.c	2010-12-03 15:48:03.040222428 +0900
 +++ b/storage/innobase/dict/dict0dict.c	2010-12-03 17:19:24.841947690 +0900
-@@ -756,7 +756,7 @@
+@@ -755,7 +755,7 @@
  		print an error message and return without doing
  		anything. */
  		dict_update_statistics(table, TRUE /* only update stats
@@ -359,7 +359,7 @@
  	}
  
  	return(table);
-@@ -4310,6 +4310,289 @@
+@@ -4309,6 +4309,295 @@
  }
  
  /*********************************************************************//**
@@ -592,6 +592,8 @@
 +			break;
 +		}
 +
++		btr_pcur_store_position(&pcur, &mtr);
++
 +		if (rec_get_deleted_flag(rec, 0)) {
 +			/* don't count */
 +			i--;
@@ -626,6 +628,10 @@
 +		rests--;
 +
 +next_rec:
++		mtr_commit(&mtr);
++		mtr_start(&mtr);
++		btr_pcur_restore_position(BTR_MODIFY_LEAF, &pcur, &mtr);
++
 +		btr_pcur_move_to_next_user_rec(&pcur, &mtr);
 +	}
 +	btr_pcur_close(&pcur);
@@ -649,7 +655,7 @@
  Calculates new estimates for table and index statistics. The statistics
  are used in query optimization. */