Merge lp:~percona-dev/percona-server/5.5.8 into lp:percona-server/release-5.1.54-12

[happytony65]

[Oleg Tsarev (tsarev)]

What is it?

[Oleg Tsarev (tsarev)]

lp:percona-server is Percona-Server 5.1
This is dangerous merge.

review: Disapprove

=== added file 'COPYING.innodb-deadlock-count-patch'
--- COPYING.innodb-deadlock-count-patch	1970-01-01 00:00:00 +0000
+++ COPYING.innodb-deadlock-count-patch	2011-01-10 13:15:57 +0000
@@ -0,0 +1,30 @@
+Portions of this software contain modifications contributed by Eric Bergen.
+These contributions are used with the following license:
+
+Copyright (c) 2010, Eric Bergen. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+      * Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+      * Redistributions in binary form must reproduce the above
+        copyright notice, this list of conditions and the following
+        disclaimer in the documentation and/or other materials
+        provided with the distribution.
+      * Neither the name of the Eric Bergen. nor the names of its
+        contributors may be used to endorse or promote products
+        derived from this software without specific prior written
+        permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

=== renamed file 'COPYING.innodb-deadlock-count-patch' => 'COPYING.innodb-deadlock-count-patch.moved'
=== added file 'COPYING.show_temp_51'
--- COPYING.show_temp_51	1970-01-01 00:00:00 +0000
+++ COPYING.show_temp_51	2011-01-10 13:15:57 +0000
@@ -0,0 +1,13 @@
+Portions of this software contain modifications contributed by Venu Anuganti.
+These contributions are used with the following license:
+
+Copyright (c) 2010, Venu Anuganti, http://venublog.com/
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+    * Neither the name of the <ORGANIZATION> nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

=== renamed file 'COPYING.show_temp_51' => 'COPYING.show_temp_51.moved'
=== added file 'Makefile'
--- Makefile	1970-01-01 00:00:00 +0000
+++ Makefile	2011-01-10 13:15:57 +0000
@@ -0,0 +1,68 @@
+FETCH_CMD=wget
+MASTER_SITE=http://www.percona.com/downloads/community
+MYSQL_VERSION=5.5.8
+PERCONA_SERVER ?=Percona-Server
+DEBUG_DIR ?= $(PERCONA_SERVER)-debug
+RELEASE_DIR ?= $(PERCONA_SERVER)-release
+SERIES ?=series
+CMAKE=CC=gcc CXX=gcc CFLAGS="-fPIC -Wall -O3 -g -static-libgcc -fno-omit-frame-pointer -fno-strict-aliasing -DDBUG_OFF" CXXFLAGS="-fno-exceptions  -fPIC -Wall -Wno-unused-parameter -fno-implicit-templates -fno-exceptions -fno-rtti -O3 -g -static-libgcc -fno-omit-frame-pointer -fno-strict-aliasing -DDBUG_OFF" cmake 
+CONFIGUR=CFLAGS="-O2 -g -fmessage-length=0 -D_FORTIFY_SOURCE=2" CXXFLAGS="-O2 -g -fmessage-length=0 -D_FORTIFY_SOURCE=2"  LIBS=-lrt ./configure --prefix=/usr/local/$(PERCONA_SERVER)-$(MYSQL_VERSION) --with-plugin-innobase --with-plugin-partition
+
+
+all: main install-lic tests misc
+	@echo ""
+	@echo "Percona Server source code is ready"
+	@echo "Now change directory to $(PERCONA_SERVER) define variables as show below"
+	@echo ""
+	export CFLAGS="-O2 -g -fmessage-length=0 -D_FORTIFY_SOURCE=2"
+	export CXXFLAGS="-O2 -g -fmessage-length=0 -D_FORTIFY_SOURCE=2"
+	export LIBS=-lrt
+	@echo ""
+	@echo "and run ./configure --prefix=/usr/local/$(PERCONA_SERVER)-$(MYSQL_VERSION) --with-plugin-innobase --with-plugin-partition && make all install"
+	@echo ""
+
+configure: all
+	(cd $(PERCONA_SERVER); bash BUILD/autorun.sh; $(CONFIGUR))
+
+cmake:
+	rm -rf $(DEBUG_DIR)
+	rm -rf $(RELEASE_DIR)
+	(mkdir -p $(DEBUG_DIR); cd $(DEBUG_DIR); $(CMAKE) -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Debug -DWITH_DEBUG=Full -DMYSQL_MAINTAINER_MODE=OFF ../$(PERCONA_SERVER))
+	(mkdir -p $(RELEASE_DIR); cd $(RELEASE_DIR); $(CMAKE) -G "Unix Makefiles" ../$(PERCONA_SERVER))
+
+binary:
+	(cd $(PERCONA_SERVER); ${CMAKE} . -DBUILD_CONFIG=mysql_release  \
+           -DCMAKE_BUILD_TYPE=RelWithDebInfo \
+	   -DCMAKE_INSTALL_PREFIX="/usr/local/$(PERCONA_SERVER)-$(MYSQL_VERSION)" \
+           -DFEATURE_SET="community" \
+	   -DWITH_EMBEDDED_SERVER=OFF \
+           -DCOMPILATION_COMMENT="Percona-Server" \
+           -DMYSQL_SERVER_SUFFIX="${MYSQL_VERSION}" )
+
+install-lic: 
+	@echo "Installing license files"
+	install -m 644 COPYING.* $(PERCONA_SERVER)
+
+main: mysql-$(MYSQL_VERSION).tar.gz
+	@echo "Prepare Percona Server sources"
+	rm -rf mysql-$(MYSQL_VERSION)
+	rm -rf $(PERCONA_SERVER);
+	tar zxf mysql-$(MYSQL_VERSION).tar.gz
+	mv mysql-$(MYSQL_VERSION) $(PERCONA_SERVER)
+	(cat `cat $(SERIES)`) | patch -p1 -d $(PERCONA_SERVER)
+	rm $(PERCONA_SERVER)/sql/sql_yacc.cc $(PERCONA_SERVER)/sql/sql_yacc.h
+
+mysql-$(MYSQL_VERSION).tar.gz:
+	@echo "Downloading MySQL sources from $(MASTER_SITE)"
+	$(FETCH_CMD) $(MASTER_SITE)/mysql-$(MYSQL_VERSION).tar.gz
+
+tests:
+	./install_tests.sh
+
+misc:
+	@echo "Installing other files"
+	install -m 644 lrusort.py $(PERCONA_SERVER)/scripts
+
+clean: env
+	rm -rf mysql-$(MYSQL_VERSION) $(PERCONA_SERVER)
+	rm -f mysql-$(MYSQL_VERSION).tar.gz

=== renamed file 'Makefile' => 'Makefile.moved'
=== added file 'bug580324.patch'
--- bug580324.patch	1970-01-01 00:00:00 +0000
+++ bug580324.patch	2011-01-10 13:15:57 +0000
@@ -0,0 +1,105 @@
+# name       : bug580324.patch
+# introduced : 11 or before
+# maintainer : Oleg
+#
+#!!! notice !!!
+# Any small change to this file in the main branch
+# should be done or reviewed by the maintainer!
+diff -ruN a/sql/sql_base.cc b/sql/sql_base.cc
+--- a/sql/sql_base.cc	2010-05-27 19:54:18.000000000 +0400
++++ b/sql/sql_base.cc	2010-05-27 19:55:20.000000000 +0400
+@@ -233,8 +233,12 @@
+ uint create_table_def_key(THD *thd, char *key, TABLE_LIST *table_list,
+                           bool tmp_table)
+ {
+-  uint key_length= (uint) (strmov(strmov(key, table_list->db)+1,
+-                                  table_list->table_name)-key)+1;
++  char *db_end= strnmov(key, table_list->db, MAX_DBKEY_LENGTH - 2);
++  *db_end++= '\0';
++  char *table_end= strnmov(db_end, table_list->table_name,
++                           key + MAX_DBKEY_LENGTH - 1 - db_end);
++  *table_end++= '\0';
++  uint key_length= (uint) (table_end-key);
+   if (tmp_table)
+   {
+     int4store(key + key_length, thd->server_id);
+diff -ruN a/sql/sql_parse.cc b/sql/sql_parse.cc
+--- a/sql/sql_parse.cc	2010-05-27 19:54:18.000000000 +0400
++++ b/sql/sql_parse.cc	2010-05-27 20:03:20.000000000 +0400
+@@ -1326,10 +1326,12 @@
+     break;
+ #else
+   {
+-    char *fields, *packet_end= packet + packet_length, *arg_end;
++    char *fields, *packet_end= packet + packet_length, *wildcard;
+     /* Locked closure of all tables */
+     TABLE_LIST table_list;
+-    LEX_STRING conv_name;
++    char db_buff[NAME_LEN+1];
++    uint32 db_length;
++    uint dummy_errors;
+ 
+     /* used as fields initializator */
+     lex_start(thd);
+@@ -1341,26 +1343,22 @@
+     /*
+       We have name + wildcard in packet, separated by endzero
+     */
+-    arg_end= strend(packet);
+-    uint arg_length= arg_end - packet;
+-    
+-    /* Check given table name length. */
+-    if (arg_length >= packet_length || arg_length > NAME_LEN)
++    wildcard= strend(packet);
++    db_length= wildcard - packet;
++    wildcard++;
++    uint query_length= (uint) (packet_end - wildcard); // Don't count end \0
++    if (db_length > NAME_LEN || query_length > NAME_LEN)
+     {
+       my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
+       break;
+     }
+-    thd->convert_string(&conv_name, system_charset_info,
+-			packet, arg_length, thd->charset());
+-    if (check_table_name(conv_name.str, conv_name.length, FALSE))
+-    {
+-      /* this is OK due to convert_string() null-terminating the string */
+-      my_error(ER_WRONG_TABLE_NAME, MYF(0), conv_name.str);
++    db_length= copy_and_convert(db_buff, sizeof(db_buff)-1,
++                                system_charset_info, packet, db_length,
++                                thd->charset(), &dummy_errors);
++    db_buff[db_length]= '\0';
++    table_list.alias= table_list.table_name= db_buff;
++    if (!(fields= (char *) thd->memdup(wildcard, query_length + 1)))
+       break;
+-    }
+-
+-    table_list.alias= table_list.table_name= conv_name.str;
+-    packet= arg_end + 1;
+ 
+     if (is_schema_db(table_list.db, table_list.db_length))
+     {
+@@ -1369,9 +1367,6 @@
+         table_list.schema_table= schema_table;
+     }
+ 
+-    uint query_length= (uint) (packet_end - packet); // Don't count end \0
+-    if (!(fields= (char *) thd->memdup(packet, query_length + 1)))
+-      break;
+     thd->set_query(fields, query_length);
+     general_log_print(thd, command, "%s %s", table_list.table_name, fields);
+     if (lower_case_table_names)
+diff -ruN a/strings/ctype-utf8.c b/strings/ctype-utf8.c
+--- a/strings/ctype-utf8.c	2010-05-06 19:28:05.000000000 +0400
++++ b/strings/ctype-utf8.c	2010-05-27 20:04:20.000000000 +0400
+@@ -4116,6 +4116,10 @@
+ {
+   int code;
+   char hex[]= "0123456789abcdef";
++
++  if (s >= e)
++    return MY_CS_TOOSMALL;
++
+   if (wc < 128 && filename_safe_char[wc])
+   {
+     *s= (uchar) wc;

=== renamed file 'bug580324.patch' => 'bug580324.patch.moved'
=== added file 'control_online_alter_index.patch'
--- control_online_alter_index.patch	1970-01-01 00:00:00 +0000
+++ control_online_alter_index.patch	2011-01-10 13:15:57 +0000
@@ -0,0 +1,90 @@
+# name       : control_online_alter_index.patch
+# introduced : 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/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
+@@ -194,6 +194,19 @@
+ #define HA_ONLINE_DROP_UNIQUE_INDEX             (1L << 9) /*drop uniq. online*/
+ #define HA_ONLINE_ADD_PK_INDEX                  (1L << 10)/*add prim. online*/
+ #define HA_ONLINE_DROP_PK_INDEX                 (1L << 11)/*drop prim. online*/
++
++#define HA_ONLINE_ALTER_INDEX_MASK	(HA_ONLINE_ADD_INDEX_NO_WRITES \
++						| HA_ONLINE_DROP_INDEX_NO_WRITES \
++						| HA_ONLINE_ADD_UNIQUE_INDEX_NO_WRITES \
++						| HA_ONLINE_DROP_UNIQUE_INDEX_NO_WRITES \
++						| HA_ONLINE_ADD_PK_INDEX_NO_WRITES \
++						| HA_ONLINE_DROP_PK_INDEX_NO_WRITES \
++						| HA_ONLINE_ADD_INDEX \
++						| HA_ONLINE_DROP_INDEX \
++						| HA_ONLINE_ADD_UNIQUE_INDEX \
++						| HA_ONLINE_DROP_UNIQUE_INDEX \
++						| HA_ONLINE_ADD_PK_INDEX \
++						| HA_ONLINE_DROP_PK_INDEX)
+ /*
+   HA_PARTITION_FUNCTION_SUPPORTED indicates that the function is
+   supported at all.
+diff -ruN a/sql/sql_class.h b/sql/sql_class.h
+--- a/sql/sql_class.h	2010-12-02 20:31:56.200956501 +0900
++++ b/sql/sql_class.h	2010-12-03 13:51:04.744953174 +0900
+@@ -481,6 +481,8 @@
+   my_bool engine_condition_pushdown;
+   my_bool keep_files_on_create;
+ 
++  my_bool online_alter_index;
++
+   my_bool old_alter_table;
+   my_bool old_passwords;
+   my_bool big_tables;
+diff -ruN a/sql/sql_partition.cc b/sql/sql_partition.cc
+--- a/sql/sql_partition.cc	2010-11-03 07:01:14.000000000 +0900
++++ b/sql/sql_partition.cc	2010-12-03 13:59:56.444039002 +0900
+@@ -4635,7 +4635,12 @@
+         alter_info->num_parts= curr_part_no - new_part_no;
+       }
+     }
+-    if (!(flags= new_table->file->alter_table_flags(alter_info->flags)))
++    flags= new_table->file->alter_table_flags(alter_info->flags);
++    if (!thd->variables.online_alter_index)
++    {
++      flags&= ~((uint)HA_ONLINE_ALTER_INDEX_MASK);
++    }
++    if (!flags)
+     {
+       my_error(ER_PARTITION_FUNCTION_FAILURE, MYF(0));
+       goto err;
+diff -ruN a/sql/sql_table.cc b/sql/sql_table.cc
+--- a/sql/sql_table.cc	2010-11-03 07:01:14.000000000 +0900
++++ b/sql/sql_table.cc	2010-12-03 13:51:04.768955495 +0900
+@@ -6107,6 +6107,10 @@
+     uint  *idx_end_p;
+ 
+     alter_flags= table->file->alter_table_flags(alter_info->flags);
++    if (!thd->variables.online_alter_index)
++    {
++      alter_flags&= ~((ulong)HA_ONLINE_ALTER_INDEX_MASK);
++    }
+     DBUG_PRINT("info", ("alter_flags: %lu", alter_flags));
+     /* Check dropped indexes. */
+     for (idx_p= index_drop_buffer, idx_end_p= idx_p + index_drop_count;
+diff -ruN a/sql/sys_vars.cc b/sql/sys_vars.cc
+--- a/sql/sys_vars.cc	2010-12-02 21:23:05.569356468 +0900
++++ b/sql/sys_vars.cc	2010-12-03 14:05:28.857356603 +0900
+@@ -2124,6 +2124,13 @@
+        GLOBAL_VAR(opt_optimizer_fix),
+        NO_CMD_LINE, DEFAULT(TRUE));
+ 
++static Sys_var_mybool Sys_fast_index_creation(
++       "fast_index_creation",
++       "If disabled, suppresses online operations for indexes of ALTER TABLE "
++       "(e.g. fast index creation of InnoDB Plugin) for the session.",
++       SESSION_VAR(online_alter_index), NO_CMD_LINE,
++       DEFAULT(TRUE));
++
+ /** propagates changes to the relevant flag of @@optimizer_switch */
+ static bool fix_engine_condition_pushdown(sys_var *self, THD *thd,
+                                           enum_var_type type)

=== renamed file 'control_online_alter_index.patch' => 'control_online_alter_index.patch.moved'
=== added file 'error_pad.patch'
--- error_pad.patch	1970-01-01 00:00:00 +0000
+++ error_pad.patch	2011-01-10 13:15:57 +0000
@@ -0,0 +1,267 @@
+# name       : error_pad.patch
+# introduced : 12
+# maintainer : Oleg
+#
+#!!! notice !!!
+# Any small change to this file in the main branch
+# should be done or reviewed by the maintainer!
+diff -ruN a/extra/comp_err.c b/extra/comp_err.c
+--- a/extra/comp_err.c	2010-08-03 17:24:24.000000000 +0000
++++ b/extra/comp_err.c	2010-09-14 16:49:28.000000000 +0000
+@@ -30,11 +30,12 @@
+ #include <assert.h>
+ #include <my_dir.h>
+ 
+-#define MAX_ROWS  1000
++#define MAX_ROWS  5000
+ #define HEADER_LENGTH 32                /* Length of header in errmsg.sys */
+ #define DEFAULT_CHARSET_DIR "../sql/share/charsets"
+ #define ER_PREFIX "ER_"
+ #define WARN_PREFIX "WARN_"
++#define PADD_PREFIX "PADD_"
+ static char *OUTFILE= (char*) "errmsg.sys";
+ static char *HEADERFILE= (char*) "mysqld_error.h";
+ static char *NAMEFILE= (char*) "mysqld_ername.h";
+@@ -89,6 +90,7 @@
+   const char *sql_code1;		/* sql state */
+   const char *sql_code2;		/* ODBC state */
+   struct errors *next_error;            /* Pointer to next error */
++  my_bool is_padding;                   /* If true - padd this er_name while er_code != d_code*/
+   DYNAMIC_ARRAY msg;                    /* All language texts for this error */
+ };
+ 
+@@ -127,6 +129,7 @@
+ 
+ 
+ static struct languages *parse_charset_string(char *str);
++static struct errors *parse_padd_string(char *ptr, int er_count);
+ static struct errors *parse_error_string(char *ptr, int er_count);
+ static struct message *parse_message_string(struct message *new_message,
+ 					    char *str);
+@@ -252,6 +255,11 @@
+ 
+   for (tmp_error= error_head; tmp_error; tmp_error= tmp_error->next_error)
+   {
++    if (tmp_error->is_padding)
++    {
++      er_last= tmp_error->d_code;
++      continue;
++    }
+     /*
+        generating mysqld_error.h
+        fprintf() will automatically add \r on windows
+@@ -344,12 +352,29 @@
+ 		"language\n", tmp_error->er_name, tmp_lang->lang_short_name);
+ 	goto err;
+       }
+-      if (copy_rows(to, tmp->text, row_nr, start_pos))
++      if (tmp_error->is_padding)
+       {
+-	fprintf(stderr, "Failed to copy rows to %s\n", outfile);
+-	goto err;
++        uint padd_to= tmp_error->d_code;
++        char* padd_message= tmp->text;
++        while ((row_nr+er_offset) < padd_to)
++        {
++          if (copy_rows(to, padd_message,row_nr,start_pos))
++          {
++            fprintf(stderr, "Failed to copy rows to %s\n", outfile);
++            goto err;
++          }
++          row_nr++;
++        }
++      }
++      else
++      {
++        if (copy_rows(to, tmp->text, row_nr, start_pos))
++        {
++          fprintf(stderr, "Failed to copy rows to %s\n", outfile);
++          goto err;
++        }
++        row_nr++;
+       }
+-      row_nr++;
+     }
+ 
+     /* continue with header of the errmsg.sys file */
+@@ -500,14 +525,26 @@
+ 	DBUG_RETURN(0);
+       continue;
+     }
+-    if (is_prefix(str, ER_PREFIX) || is_prefix(str, WARN_PREFIX))
++    if (is_prefix(str, ER_PREFIX) || is_prefix(str, WARN_PREFIX) || is_prefix(str, PADD_PREFIX))
+     {
+-      if (!(current_error= parse_error_string(str, rcount)))
++      if (is_prefix(str, PADD_PREFIX))
+       {
+-	fprintf(stderr, "Failed to parse the error name string\n");
+-	DBUG_RETURN(0);
++        if (!(current_error= parse_padd_string(str, rcount)))
++        {
++          fprintf(stderr, "Failed to parse the error padd string\n");
++          DBUG_RETURN(0);
++        }
++        rcount= current_error->d_code - er_offset;  /* Count number of unique errors */
++      }
++      else
++      {
++        if (!(current_error= parse_error_string(str, rcount)))
++        {
++          fprintf(stderr, "Failed to parse the error name string\n");
++          DBUG_RETURN(0);
++        }
++        rcount++;                         /* Count number of unique errors */
+       }
+-      rcount++;                         /* Count number of unique errors */
+ 
+       /* add error to the list */
+       *tail_error= current_error;
+@@ -848,78 +885,122 @@
+   DBUG_RETURN(new_message);
+ }
+ 
++static struct errors* create_new_error(my_bool is_padding, char *er_name, int d_code, const char *sql_code1, const char *sql_code2)
++{
++  struct errors *new_error;
++  DBUG_ENTER("create_new_error");
++  /* create a new element */
++  new_error= (struct errors *) my_malloc(sizeof(*new_error), MYF(MY_WME));
++  if (my_init_dynamic_array(&new_error->msg, sizeof(struct message), 0, 0))
++    DBUG_RETURN(0);				/* OOM: Fatal error */
++  new_error->is_padding= is_padding;
++  DBUG_PRINT("info", ("is_padding: %s", (is_padding ? "true" : "false")));
++  new_error->er_name= er_name;
++  DBUG_PRINT("info", ("er_name: %s", er_name));
++  new_error->d_code= d_code;
++  DBUG_PRINT("info", ("d_code: %d", d_code));
++  new_error->sql_code1= sql_code1;
++  DBUG_PRINT("info", ("sql_code1: %s", sql_code1));
++  new_error->sql_code2= sql_code2;
++  DBUG_PRINT("info", ("sql_code2: %s", sql_code2));
++  DBUG_RETURN(new_error);
++}
+ 
+ /*
+-  Parsing the string with error name and codes; returns the pointer to
++  Parsing the string with padd syntax (name + error to pad); returns the pointer to
+   the errors struct
+ */
+ 
+-static struct errors *parse_error_string(char *str, int er_count)
++static struct errors *parse_padd_string(char* str, int er_count)
+ {
+-  struct errors *new_error;
++  char *er_name;
++  uint d_code;
++  char *start;
+   DBUG_ENTER("parse_error_string");
+   DBUG_PRINT("enter", ("str: %s", str));
+ 
+-  /* create a new element */
+-  new_error= (struct errors *) my_malloc(sizeof(*new_error), MYF(MY_WME));
++  start= str;
++  str= skip_delimiters(str);
+ 
+-  if (my_init_dynamic_array(&new_error->msg, sizeof(struct message), 0, 0))
++  /* getting the error name */
++
++  if (!(er_name= get_word(&str)))
+     DBUG_RETURN(0);				/* OOM: Fatal error */
+ 
+-  /* getting the error name */
+   str= skip_delimiters(str);
+ 
+-  if (!(new_error->er_name= get_word(&str)))
++  if (!(d_code= parse_error_offset(start)))
++  {
++    fprintf(stderr, "Failed to parse the error padd string '%s' '%s' (d_code doesn't parse)!\n",er_name,str);
++    DBUG_RETURN(0);
++  }
++  if (d_code < (uint)(er_offset + er_count))
++  {
++    fprintf(stderr, "Error to padding less current error number!\n");
++    DBUG_RETURN(0);
++  }
++  DBUG_RETURN(create_new_error(TRUE,er_name,d_code,empty_string,empty_string));
++}
++
++/*
++  Parsing the string with error name and codes; returns the pointer to
++  the errors struct
++*/
++
++static struct errors *parse_error_string(char *str, int er_count)
++{
++  char *er_name;
++  int d_code;
++  const char *sql_code1= empty_string;
++  const char *sql_code2= empty_string;
++  DBUG_ENTER("parse_error_string");
++  DBUG_PRINT("enter", ("str: %s", str));
++
++  str= skip_delimiters(str);
++
++  /* getting the error name */
++
++  if (!(er_name= get_word(&str)))
+     DBUG_RETURN(0);				/* OOM: Fatal error */
+-  DBUG_PRINT("info", ("er_name: %s", new_error->er_name));
+ 
+   str= skip_delimiters(str);
+ 
+   /* getting the code1 */
+-
+-  new_error->d_code= er_offset + er_count;
+-  DBUG_PRINT("info", ("d_code: %d", new_error->d_code));
++  d_code= er_offset + er_count;
+ 
+   str= skip_delimiters(str);
+ 
+   /* if we reached EOL => no more codes, but this can happen */
+   if (!*str)
+   {
+-    new_error->sql_code1= empty_string;
+-    new_error->sql_code2= empty_string;
+     DBUG_PRINT("info", ("str: %s", str));
+-    DBUG_RETURN(new_error);
++    goto complete_create;
+   }
+-
+   /* getting the sql_code 1 */
+-
+-  if (!(new_error->sql_code1= get_word(&str)))
++  if (!(sql_code1= get_word(&str)))
+     DBUG_RETURN(0);				/* OOM: Fatal error */
+-  DBUG_PRINT("info", ("sql_code1: %s", new_error->sql_code1));
+ 
+   str= skip_delimiters(str);
+ 
+   /* if we reached EOL => no more codes, but this can happen */
+   if (!*str)
+   {
+-    new_error->sql_code2= empty_string;
+     DBUG_PRINT("info", ("str: %s", str));
+-    DBUG_RETURN(new_error);
++    goto complete_create;
+   }
+-
+   /* getting the sql_code 2 */
+-  if (!(new_error->sql_code2= get_word(&str)))
++  if (!(sql_code2= get_word(&str)))
+     DBUG_RETURN(0);				/* OOM: Fatal error */
+-  DBUG_PRINT("info", ("sql_code2: %s", new_error->sql_code2));
+ 
+   str= skip_delimiters(str);
++
+   if (*str)
+   {
+     fprintf(stderr, "The error line did not end with sql/odbc code!");
+     DBUG_RETURN(0);
+   }
+-
+-  DBUG_RETURN(new_error);
++complete_create:
++  DBUG_RETURN(create_new_error(FALSE,er_name,d_code,sql_code1,sql_code2));
+ }
+ 
+ 

=== renamed file 'error_pad.patch' => 'error_pad.patch.moved'
=== added file 'innodb_adaptive_hash_index_partitions.patch'
--- innodb_adaptive_hash_index_partitions.patch	1970-01-01 00:00:00 +0000
+++ innodb_adaptive_hash_index_partitions.patch	2011-01-10 13:15:57 +0000
@@ -0,0 +1,1508 @@
+# name       : innodb_adaptive_hash_index_num.patch
+# introduced : XtraDB on 5.5 (-13?)
+# 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/btr0btr.c b/storage/innobase/btr/btr0btr.c
+--- a/storage/innobase/btr/btr0btr.c	2010-12-04 15:52:23.355483176 +0900
++++ b/storage/innobase/btr/btr0btr.c	2010-12-04 16:12:48.639514256 +0900
+@@ -954,7 +954,7 @@
+ 	}
+ 	ut_a(block);
+ 
+-	btr_search_drop_page_hash_index(block);
++	btr_search_drop_page_hash_index(block, NULL);
+ 
+ 	header = buf_block_get_frame(block) + PAGE_HEADER + PAGE_BTR_SEG_TOP;
+ #ifdef UNIV_BTR_DEBUG
+@@ -1023,7 +1023,7 @@
+ 
+ #ifndef UNIV_HOTBACKUP
+ 	if (UNIV_LIKELY(!recovery)) {
+-		btr_search_drop_page_hash_index(block);
++		btr_search_drop_page_hash_index(block, index);
+ 	}
+ 
+ 	block->check_index_page_at_flush = TRUE;
+@@ -1188,7 +1188,7 @@
+ 	ut_a(!page_zip || page_zip_validate(page_zip, page));
+ #endif /* UNIV_ZIP_DEBUG */
+ 
+-	btr_search_drop_page_hash_index(block);
++	btr_search_drop_page_hash_index(block, index);
+ 
+ 	/* Recreate the page: note that global data on page (possible
+ 	segment headers, next page-field, etc.) is preserved intact */
+@@ -2497,7 +2497,7 @@
+ 		mem_heap_free(heap);
+ 	}
+ 
+-	btr_search_drop_page_hash_index(block);
++	btr_search_drop_page_hash_index(block, index);
+ 
+ 	/* Make the father empty */
+ 	btr_page_empty(father_block, father_page_zip, index, page_level, mtr);
+@@ -2720,7 +2720,7 @@
+ 			goto err_exit;
+ 		}
+ 
+-		btr_search_drop_page_hash_index(block);
++		btr_search_drop_page_hash_index(block, index);
+ 
+ 		/* Remove the page from the level list */
+ 		btr_level_list_remove(space, zip_size, page, mtr);
+@@ -2761,7 +2761,7 @@
+ 			goto err_exit;
+ 		}
+ 
+-		btr_search_drop_page_hash_index(block);
++		btr_search_drop_page_hash_index(block, index);
+ 
+ #ifdef UNIV_BTR_DEBUG
+ 		if (UNIV_LIKELY_NULL(merge_page_zip)) {
+@@ -2875,7 +2875,7 @@
+ 		ut_a(btr_page_get_next(page, mtr) == FIL_NULL);
+ 
+ 		ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
+-		btr_search_drop_page_hash_index(block);
++		btr_search_drop_page_hash_index(block, index);
+ 
+ 		btr_page_get_father(index, block, mtr, &cursor);
+ 		father = btr_cur_get_block(&cursor);
+@@ -2980,7 +2980,7 @@
+ 
+ 	page = buf_block_get_frame(block);
+ 	ut_a(page_is_comp(merge_page) == page_is_comp(page));
+-	btr_search_drop_page_hash_index(block);
++	btr_search_drop_page_hash_index(block, index);
+ 
+ 	if (left_page_no == FIL_NULL && !page_is_leaf(page)) {
+ 
+diff -ruN a/storage/innobase/btr/btr0cur.c b/storage/innobase/btr/btr0cur.c
+--- a/storage/innobase/btr/btr0cur.c	2010-12-04 15:52:23.359513820 +0900
++++ b/storage/innobase/btr/btr0cur.c	2010-12-04 16:12:48.643551837 +0900
+@@ -486,7 +486,7 @@
+ #ifdef UNIV_SEARCH_PERF_STAT
+ 	info->n_searches++;
+ #endif
+-	if (rw_lock_get_writer(&btr_search_latch) == RW_LOCK_NOT_LOCKED
++	if (rw_lock_get_writer(btr_search_get_latch(cursor->index->id)) == RW_LOCK_NOT_LOCKED
+ 	    && latch_mode <= BTR_MODIFY_LEAF
+ 	    && info->last_hash_succ
+ 	    && !estimate
+@@ -522,7 +522,7 @@
+ 
+ 	if (has_search_latch) {
+ 		/* Release possible search latch to obey latching order */
+-		rw_lock_s_unlock(&btr_search_latch);
++		rw_lock_s_unlock(btr_search_get_latch(cursor->index->id));
+ 	}
+ 
+ 	/* Store the position of the tree latch we push to mtr so that we
+@@ -844,7 +844,7 @@
+ 
+ 	if (has_search_latch) {
+ 
+-		rw_lock_s_lock(&btr_search_latch);
++		rw_lock_s_lock(btr_search_get_latch(cursor->index->id));
+ 	}
+ }
+ 
+@@ -2059,7 +2059,7 @@
+ 			btr_search_update_hash_on_delete(cursor);
+ 		}
+ 
+-		rw_lock_x_lock(&btr_search_latch);
++		rw_lock_x_lock(btr_search_get_latch(cursor->index->id));
+ 	}
+ 
+ 	if (!(flags & BTR_KEEP_SYS_FLAG)) {
+@@ -2073,7 +2073,7 @@
+ 	row_upd_rec_in_place(rec, index, offsets, update, page_zip);
+ 
+ 	if (block->is_hashed) {
+-		rw_lock_x_unlock(&btr_search_latch);
++		rw_lock_x_unlock(btr_search_get_latch(cursor->index->id));
+ 	}
+ 
+ 	if (page_zip && !dict_index_is_clust(index)
+@@ -2857,7 +2857,7 @@
+ 	block = btr_cur_get_block(cursor);
+ 
+ 	if (block->is_hashed) {
+-		rw_lock_x_lock(&btr_search_latch);
++		rw_lock_x_lock(btr_search_get_latch(index->id));
+ 	}
+ 
+ 	page_zip = buf_block_get_page_zip(block);
+@@ -2872,7 +2872,7 @@
+ 	}
+ 
+ 	if (block->is_hashed) {
+-		rw_lock_x_unlock(&btr_search_latch);
++		rw_lock_x_unlock(btr_search_get_latch(index->id));
+ 	}
+ 
+ 	btr_cur_del_mark_set_clust_rec_log(flags, rec, index, val, trx,
+@@ -3003,13 +3003,13 @@
+ 	      == dict_table_is_comp(cursor->index->table));
+ 
+ 	if (block->is_hashed) {
+-		rw_lock_x_lock(&btr_search_latch);
++		rw_lock_x_lock(btr_search_get_latch(cursor->index->id));
+ 	}
+ 
+ 	btr_rec_set_deleted_flag(rec, buf_block_get_page_zip(block), val);
+ 
+ 	if (block->is_hashed) {
+-		rw_lock_x_unlock(&btr_search_latch);
++		rw_lock_x_unlock(btr_search_get_latch(cursor->index->id));
+ 	}
+ 
+ 	btr_cur_del_mark_set_sec_rec_log(rec, val, mtr);
+diff -ruN a/storage/innobase/btr/btr0sea.c b/storage/innobase/btr/btr0sea.c
+--- a/storage/innobase/btr/btr0sea.c	2010-12-04 15:52:23.387513429 +0900
++++ b/storage/innobase/btr/btr0sea.c	2010-12-04 16:14:51.721884049 +0900
+@@ -48,6 +48,8 @@
+ UNIV_INTERN char		btr_search_enabled	= TRUE;
+ UNIV_INTERN ibool		btr_search_fully_disabled = FALSE;
+ 
++UNIV_INTERN ulint		btr_search_index_num	= 1;
++
+ /** Mutex protecting btr_search_enabled */
+ static mutex_t			btr_search_enabled_mutex;
+ 
+@@ -79,7 +81,9 @@
+ 
+ /* We will allocate the latch from dynamic memory to get it to the
+ same DRAM page as other hotspot semaphores */
+-UNIV_INTERN rw_lock_t*		btr_search_latch_temp;
++//UNIV_INTERN rw_lock_t*		btr_search_latch_temp;
++
++UNIV_INTERN rw_lock_t**		btr_search_latch_part;
+ 
+ /** padding to prevent other memory update hotspots from residing on
+ the same memory cache line */
+@@ -131,18 +135,19 @@
+ will not guarantee success. */
+ static
+ void
+-btr_search_check_free_space_in_heap(void)
++btr_search_check_free_space_in_heap(
+ /*=====================================*/
++	index_id_t	key)
+ {
+ 	hash_table_t*	table;
+ 	mem_heap_t*	heap;
+ 
+ #ifdef UNIV_SYNC_DEBUG
+-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
+-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
++	ut_ad(!rw_lock_own(btr_search_get_latch(key), RW_LOCK_SHARED));
++	ut_ad(!rw_lock_own(btr_search_get_latch(key), RW_LOCK_EX));
+ #endif /* UNIV_SYNC_DEBUG */
+ 
+-	table = btr_search_sys->hash_index;
++	table = btr_search_get_hash_index(key);
+ 
+ 	heap = table->heap;
+ 
+@@ -153,7 +158,7 @@
+ 	if (heap->free_block == NULL) {
+ 		buf_block_t*	block = buf_block_alloc(NULL, 0);
+ 
+-		rw_lock_x_lock(&btr_search_latch);
++		rw_lock_x_lock(btr_search_get_latch(key));
+ 
+ 		if (heap->free_block == NULL) {
+ 			heap->free_block = block;
+@@ -161,7 +166,7 @@
+ 			buf_block_free(block);
+ 		}
+ 
+-		rw_lock_x_unlock(&btr_search_latch);
++		rw_lock_x_unlock(btr_search_get_latch(key));
+ 	}
+ }
+ 
+@@ -173,19 +178,30 @@
+ /*==================*/
+ 	ulint	hash_size)	/*!< in: hash index hash table size */
+ {
++	ulint i;
+ 	/* We allocate the search latch from dynamic memory:
+ 	see above at the global variable definition */
+ 
+-	btr_search_latch_temp = mem_alloc(sizeof(rw_lock_t));
++	//btr_search_latch_temp = mem_alloc(sizeof(rw_lock_t));
+ 
+-	rw_lock_create(btr_search_latch_key, &btr_search_latch,
+-		       SYNC_SEARCH_SYS);
++	//rw_lock_create(btr_search_latch_key, &btr_search_latch,
++	//	       SYNC_SEARCH_SYS);
+ 	mutex_create(btr_search_enabled_mutex_key,
+ 		     &btr_search_enabled_mutex, SYNC_SEARCH_SYS_CONF);
+ 
+ 	btr_search_sys = mem_alloc(sizeof(btr_search_sys_t));
+ 
+-	btr_search_sys->hash_index = ha_create(hash_size, 0, 0);
++	/* btr_search_index_num should be <= 32. (bits of trx->has_search_latch) */
++	btr_search_latch_part = mem_alloc(sizeof(rw_lock_t*) * btr_search_index_num);
++	btr_search_sys->hash_index = mem_alloc(sizeof(hash_table_t*) * btr_search_index_num);
++	for (i = 0; i < btr_search_index_num; i++) {
++		btr_search_latch_part[i] = mem_alloc(sizeof(rw_lock_t));
++
++		rw_lock_create(btr_search_latch_key,
++				btr_search_latch_part[i], SYNC_SEARCH_SYS);
++
++		btr_search_sys->hash_index[i] = ha_create(hash_size, 0, 0);
++	}
+ }
+ 
+ /*****************************************************************//**
+@@ -195,11 +211,20 @@
+ btr_search_sys_free(void)
+ /*=====================*/
+ {
+-	rw_lock_free(&btr_search_latch);
+-	mem_free(btr_search_latch_temp);
+-	btr_search_latch_temp = NULL;
+-	mem_heap_free(btr_search_sys->hash_index->heap);
+-	hash_table_free(btr_search_sys->hash_index);
++	ulint i;
++
++	for (i = 0; i < btr_search_index_num; i++) {
++		mem_heap_free(btr_search_sys->hash_index[i]->heap);
++		hash_table_free(btr_search_sys->hash_index[i]);
++
++		rw_lock_free(btr_search_latch_part[i]);
++
++		mem_free(btr_search_latch_part[i]);
++	}
++
++	//rw_lock_free(&btr_search_latch);
++	//mem_free(btr_search_latch_temp);
++	//btr_search_latch_temp = NULL;
+ 	mem_free(btr_search_sys);
+ 	btr_search_sys = NULL;
+ }
+@@ -212,7 +237,7 @@
+ /*====================*/
+ {
+ 	mutex_enter(&btr_search_enabled_mutex);
+-	rw_lock_x_lock(&btr_search_latch);
++	btr_search_x_lock_all();
+ 
+ 	/* Disable access to hash index, also tell ha_insert_for_fold()
+ 	stop adding new nodes to hash index, but still allow updating
+@@ -230,7 +255,7 @@
+ 	/* btr_search_enabled_mutex should guarantee this. */
+ 	ut_ad(!btr_search_enabled);
+ 
+-	rw_lock_x_unlock(&btr_search_latch);
++	btr_search_x_unlock_all();
+ 	mutex_exit(&btr_search_enabled_mutex);
+ }
+ 
+@@ -242,12 +267,12 @@
+ /*====================*/
+ {
+ 	mutex_enter(&btr_search_enabled_mutex);
+-	rw_lock_x_lock(&btr_search_latch);
++	btr_search_x_lock_all();
+ 
+ 	btr_search_enabled = TRUE;
+ 	btr_search_fully_disabled = FALSE;
+ 
+-	rw_lock_x_unlock(&btr_search_latch);
++	btr_search_x_unlock_all();
+ 	mutex_exit(&btr_search_enabled_mutex);
+ }
+ 
+@@ -300,20 +325,21 @@
+ ulint
+ btr_search_info_get_ref_count(
+ /*==========================*/
+-	btr_search_t*   info)	/*!< in: search info. */
++	btr_search_t*   info,	/*!< in: search info. */
++	index_id_t	key)
+ {
+ 	ulint ret;
+ 
+ 	ut_ad(info);
+ 
+ #ifdef UNIV_SYNC_DEBUG
+-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
+-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
++	ut_ad(!rw_lock_own(btr_search_get_latch(key), RW_LOCK_SHARED));
++	ut_ad(!rw_lock_own(btr_search_get_latch(key), RW_LOCK_EX));
+ #endif /* UNIV_SYNC_DEBUG */
+ 
+-	rw_lock_s_lock(&btr_search_latch);
++	rw_lock_s_lock(btr_search_get_latch(key));
+ 	ret = info->ref_count;
+-	rw_lock_s_unlock(&btr_search_latch);
++	rw_lock_s_unlock(btr_search_get_latch(key));
+ 
+ 	return(ret);
+ }
+@@ -334,8 +360,8 @@
+ 	int		cmp;
+ 
+ #ifdef UNIV_SYNC_DEBUG
+-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
+-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
++	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index->id), RW_LOCK_SHARED));
++	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index->id), RW_LOCK_EX));
+ #endif /* UNIV_SYNC_DEBUG */
+ 
+ 	index = cursor->index;
+@@ -453,8 +479,8 @@
+ 				/*!< in: cursor */
+ {
+ #ifdef UNIV_SYNC_DEBUG
+-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
+-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
++	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index->id), RW_LOCK_SHARED));
++	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index->id), RW_LOCK_EX));
+ 	ut_ad(rw_lock_own(&block->lock, RW_LOCK_SHARED)
+ 	      || rw_lock_own(&block->lock, RW_LOCK_EX));
+ #endif /* UNIV_SYNC_DEBUG */
+@@ -538,7 +564,7 @@
+ 
+ 	ut_ad(cursor->flag == BTR_CUR_HASH_FAIL);
+ #ifdef UNIV_SYNC_DEBUG
+-	ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_EX));
++	ut_ad(rw_lock_own(btr_search_get_latch(cursor->index->id), RW_LOCK_EX));
+ 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED)
+ 	      || rw_lock_own(&(block->lock), RW_LOCK_EX));
+ #endif /* UNIV_SYNC_DEBUG */
+@@ -578,10 +604,10 @@
+ 			mem_heap_free(heap);
+ 		}
+ #ifdef UNIV_SYNC_DEBUG
+-		ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_EX));
++		ut_ad(rw_lock_own(btr_search_get_latch(cursor->index->id), RW_LOCK_EX));
+ #endif /* UNIV_SYNC_DEBUG */
+ 
+-		ha_insert_for_fold(btr_search_sys->hash_index, fold,
++		ha_insert_for_fold(btr_search_get_hash_index(cursor->index->id), fold,
+ 				   block, rec);
+ 	}
+ }
+@@ -601,8 +627,8 @@
+ 	ulint*		params2;
+ 
+ #ifdef UNIV_SYNC_DEBUG
+-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
+-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
++	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index->id), RW_LOCK_SHARED));
++	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index->id), RW_LOCK_EX));
+ #endif /* UNIV_SYNC_DEBUG */
+ 
+ 	block = btr_cur_get_block(cursor);
+@@ -623,7 +649,7 @@
+ 
+ 	if (build_index || (cursor->flag == BTR_CUR_HASH_FAIL)) {
+ 
+-		btr_search_check_free_space_in_heap();
++		btr_search_check_free_space_in_heap(cursor->index->id);
+ 	}
+ 
+ 	if (cursor->flag == BTR_CUR_HASH_FAIL) {
+@@ -633,11 +659,11 @@
+ 		btr_search_n_hash_fail++;
+ #endif /* UNIV_SEARCH_PERF_STAT */
+ 
+-		rw_lock_x_lock(&btr_search_latch);
++		rw_lock_x_lock(btr_search_get_latch(cursor->index->id));
+ 
+ 		btr_search_update_hash_ref(info, block, cursor);
+ 
+-		rw_lock_x_unlock(&btr_search_latch);
++		rw_lock_x_unlock(btr_search_get_latch(cursor->index->id));
+ 	}
+ 
+ 	if (build_index) {
+@@ -881,17 +907,17 @@
+ 	cursor->flag = BTR_CUR_HASH;
+ 
+ 	if (UNIV_LIKELY(!has_search_latch)) {
+-		rw_lock_s_lock(&btr_search_latch);
++		rw_lock_s_lock(btr_search_get_latch(index_id));
+ 
+ 		if (UNIV_UNLIKELY(!btr_search_enabled)) {
+ 			goto failure_unlock;
+ 		}
+ 	}
+ 
+-	ut_ad(rw_lock_get_writer(&btr_search_latch) != RW_LOCK_EX);
+-	ut_ad(rw_lock_get_reader_count(&btr_search_latch) > 0);
++	ut_ad(rw_lock_get_writer(btr_search_get_latch(index_id)) != RW_LOCK_EX);
++	ut_ad(rw_lock_get_reader_count(btr_search_get_latch(index_id)) > 0);
+ 
+-	rec = ha_search_and_get_data(btr_search_sys->hash_index, fold);
++	rec = ha_search_and_get_data(btr_search_get_hash_index(index_id), fold);
+ 
+ 	if (UNIV_UNLIKELY(!rec)) {
+ 		goto failure_unlock;
+@@ -909,7 +935,7 @@
+ 			goto failure_unlock;
+ 		}
+ 
+-		rw_lock_s_unlock(&btr_search_latch);
++		rw_lock_s_unlock(btr_search_get_latch(index_id));
+ 
+ 		buf_block_dbg_add_level(block, SYNC_TREE_NODE_FROM_HASH);
+ 	}
+@@ -1006,7 +1032,7 @@
+ 	/*-------------------------------------------*/
+ failure_unlock:
+ 	if (UNIV_LIKELY(!has_search_latch)) {
+-		rw_lock_s_unlock(&btr_search_latch);
++		rw_lock_s_unlock(btr_search_get_latch(index_id));
+ 	}
+ failure:
+ 	cursor->flag = BTR_CUR_HASH_FAIL;
+@@ -1029,10 +1055,11 @@
+ void
+ btr_search_drop_page_hash_index(
+ /*============================*/
+-	buf_block_t*	block)	/*!< in: block containing index page,
++	buf_block_t*	block,	/*!< in: block containing index page,
+ 				s- or x-latched, or an index page
+ 				for which we know that
+ 				block->buf_fix_count == 0 */
++	dict_index_t*	index_in)
+ {
+ 	hash_table_t*		table;
+ 	ulint			n_fields;
+@@ -1051,22 +1078,60 @@
+ 	ulint*			offsets;
+ 
+ #ifdef UNIV_SYNC_DEBUG
+-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
+-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
++	if (index_in) {
++		ut_ad(!rw_lock_own(btr_search_get_latch(index_in->id), RW_LOCK_SHARED));
++		ut_ad(!rw_lock_own(btr_search_get_latch(index_in->id), RW_LOCK_EX));
++	}
+ #endif /* UNIV_SYNC_DEBUG */
+ 
+ retry:
+-	rw_lock_s_lock(&btr_search_latch);
++	if (index_in) {
++		index = index_in;
++		rw_lock_s_lock(btr_search_get_latch(index->id));
++	} else if (btr_search_index_num > 1) {
++		rw_lock_t*	btr_search_latch;
++
++		/* FIXME: This may be optimistic implementation still. */
++		btr_search_latch = (rw_lock_t*)(block->btr_search_latch);
++		if (UNIV_LIKELY(!btr_search_latch)) {
++			if (block->is_hashed) {
++				goto retry;
++			}
++			return;
++		}
++		rw_lock_s_lock(btr_search_latch);
++		if (UNIV_LIKELY(btr_search_latch != block->btr_search_latch)) {
++			rw_lock_s_unlock(btr_search_latch);
++			goto retry;
++		}
++		if (UNIV_LIKELY(!block->is_hashed)) {
++			rw_lock_s_unlock(btr_search_latch);
++			return;
++		}
++		index = block->index;
++		ut_a(btr_search_latch == btr_search_get_latch(index->id));
++	} else {
++		/* btr_search_index_num == 1 */
++		/* btr_search_latch is only one and able to obtain
++		   before evaluating block->is_hashed. */
++		rw_lock_s_lock(btr_search_latch_part[0]);
++		if (UNIV_LIKELY(!block->is_hashed)) {
++			rw_lock_s_unlock(btr_search_latch_part[0]);
++			return;
++		}
++		index = block->index;
++	}
++
+ 	page = block->frame;
+ 
+ 	if (UNIV_LIKELY(!block->is_hashed)) {
+ 
+-		rw_lock_s_unlock(&btr_search_latch);
++		rw_lock_s_unlock(btr_search_get_latch(index->id));
+ 
+ 		return;
+ 	}
+ 
+-	table = btr_search_sys->hash_index;
++	table = btr_search_get_hash_index(index->id);
+ 
+ #ifdef UNIV_SYNC_DEBUG
+ 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED)
+@@ -1076,14 +1141,14 @@
+ 
+ 	n_fields = block->curr_n_fields;
+ 	n_bytes = block->curr_n_bytes;
+-	index = block->index;
++	ut_a(index == block->index);
+ 	ut_a(!dict_index_is_ibuf(index));
+ 
+ 	/* NOTE: The fields of block must not be accessed after
+ 	releasing btr_search_latch, as the index page might only
+ 	be s-latched! */
+ 
+-	rw_lock_s_unlock(&btr_search_latch);
++	rw_lock_s_unlock(btr_search_get_latch(index->id));
+ 
+ 	ut_a(n_fields + n_bytes > 0);
+ 
+@@ -1133,7 +1198,7 @@
+ 		mem_heap_free(heap);
+ 	}
+ 
+-	rw_lock_x_lock(&btr_search_latch);
++	rw_lock_x_lock(btr_search_get_latch(index->id));
+ 
+ 	if (UNIV_UNLIKELY(!block->is_hashed)) {
+ 		/* Someone else has meanwhile dropped the hash index */
+@@ -1149,7 +1214,7 @@
+ 		/* Someone else has meanwhile built a new hash index on the
+ 		page, with different parameters */
+ 
+-		rw_lock_x_unlock(&btr_search_latch);
++		rw_lock_x_unlock(btr_search_get_latch(index->id));
+ 
+ 		mem_free(folds);
+ 		goto retry;
+@@ -1165,6 +1230,7 @@
+ 
+ 	block->is_hashed = FALSE;
+ 	block->index = NULL;
++	block->btr_search_latch = NULL;
+ 	
+ cleanup:
+ #if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
+@@ -1177,14 +1243,14 @@
+ 			"InnoDB: the hash index to a page of %s,"
+ 			" still %lu hash nodes remain.\n",
+ 			index->name, (ulong) block->n_pointers);
+-		rw_lock_x_unlock(&btr_search_latch);
++		rw_lock_x_unlock(btr_search_get_latch(index->id));
+ 
+ 		btr_search_validate();
+ 	} else {
+-		rw_lock_x_unlock(&btr_search_latch);
++		rw_lock_x_unlock(btr_search_get_latch(index->id));
+ 	}
+ #else /* UNIV_AHI_DEBUG || UNIV_DEBUG */
+-	rw_lock_x_unlock(&btr_search_latch);
++	rw_lock_x_unlock(btr_search_get_latch(index->id));
+ #endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
+ 
+ 	mem_free(folds);
+@@ -1215,10 +1281,10 @@
+ 	mem_heap_t*	heap	= NULL;
+ 	ulint*		offsets;
+ 
+-	rw_lock_x_lock(&btr_search_latch);
++	rw_lock_x_lock(btr_search_get_latch(index->id));
+ 	//buf_pool_mutex_enter_all();
+ 
+-	table = btr_search_sys->hash_index;
++	table = btr_search_get_hash_index(index->id);
+ 
+ 	for (j = 0; j < srv_buf_pool_instances; j++) {
+ 		buf_pool_t*	buf_pool;
+@@ -1291,6 +1357,7 @@
+ 
+ 				block->is_hashed = FALSE;
+ 				block->index = NULL;
++				block->btr_search_latch = NULL;
+ 	
+ #if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
+ 				if (UNIV_UNLIKELY(block->n_pointers)) {
+@@ -1313,7 +1380,7 @@
+ 	}
+ 
+ 	//buf_pool_mutex_exit_all();
+-	rw_lock_x_unlock(&btr_search_latch);
++	rw_lock_x_unlock(btr_search_get_latch(index->id));
+ 
+ 	if (UNIV_LIKELY_NULL(heap)) {
+ 		mem_heap_free(heap);
+@@ -1360,7 +1427,7 @@
+ 
+ 		buf_block_dbg_add_level(block, SYNC_TREE_NODE_FROM_HASH);
+ 
+-		btr_search_drop_page_hash_index(block);
++		btr_search_drop_page_hash_index(block, NULL);
+ 	}
+ 
+ 	mtr_commit(&mtr);
+@@ -1402,26 +1469,26 @@
+ 	ut_ad(index);
+ 	ut_a(!dict_index_is_ibuf(index));
+ 
+-	table = btr_search_sys->hash_index;
++	table = btr_search_get_hash_index(index->id);
+ 	page = buf_block_get_frame(block);
+ 
+ #ifdef UNIV_SYNC_DEBUG
+-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
++	ut_ad(!rw_lock_own(btr_search_get_latch(index->id), RW_LOCK_EX));
+ 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED)
+ 	      || rw_lock_own(&(block->lock), RW_LOCK_EX));
+ #endif /* UNIV_SYNC_DEBUG */
+ 
+-	rw_lock_s_lock(&btr_search_latch);
++	rw_lock_s_lock(btr_search_get_latch(index->id));
+ 
+ 	if (block->is_hashed && ((block->curr_n_fields != n_fields)
+ 				 || (block->curr_n_bytes != n_bytes)
+ 				 || (block->curr_left_side != left_side))) {
+ 
+-		rw_lock_s_unlock(&btr_search_latch);
++		rw_lock_s_unlock(btr_search_get_latch(index->id));
+ 
+-		btr_search_drop_page_hash_index(block);
++		btr_search_drop_page_hash_index(block, index);
+ 	} else {
+-		rw_lock_s_unlock(&btr_search_latch);
++		rw_lock_s_unlock(btr_search_get_latch(index->id));
+ 	}
+ 
+ 	n_recs = page_get_n_recs(page);
+@@ -1515,9 +1582,9 @@
+ 		fold = next_fold;
+ 	}
+ 
+-	btr_search_check_free_space_in_heap();
++	btr_search_check_free_space_in_heap(index->id);
+ 
+-	rw_lock_x_lock(&btr_search_latch);
++	rw_lock_x_lock(btr_search_get_latch(index->id));
+ 
+ 	if (UNIV_UNLIKELY(btr_search_fully_disabled)) {
+ 		goto exit_func;
+@@ -1545,6 +1612,7 @@
+ 	block->curr_n_bytes = n_bytes;
+ 	block->curr_left_side = left_side;
+ 	block->index = index;
++	block->btr_search_latch = btr_search_get_latch(index->id);
+ 
+ 	for (i = 0; i < n_cached; i++) {
+ 
+@@ -1552,7 +1620,7 @@
+ 	}
+ 
+ exit_func:
+-	rw_lock_x_unlock(&btr_search_latch);
++	rw_lock_x_unlock(btr_search_get_latch(index->id));
+ 
+ 	mem_free(folds);
+ 	mem_free(recs);
+@@ -1591,13 +1659,13 @@
+ 	ut_a(!(new_block->is_hashed || block->is_hashed)
+ 	     || !dict_index_is_ibuf(index));
+ 
+-	rw_lock_s_lock(&btr_search_latch);
++	rw_lock_s_lock(btr_search_get_latch(index->id));
+ 
+ 	if (new_block->is_hashed) {
+ 
+-		rw_lock_s_unlock(&btr_search_latch);
++		rw_lock_s_unlock(btr_search_get_latch(index->id));
+ 
+-		btr_search_drop_page_hash_index(block);
++		btr_search_drop_page_hash_index(block, index);
+ 
+ 		return;
+ 	}
+@@ -1612,7 +1680,7 @@
+ 		new_block->n_bytes = block->curr_n_bytes;
+ 		new_block->left_side = left_side;
+ 
+-		rw_lock_s_unlock(&btr_search_latch);
++		rw_lock_s_unlock(btr_search_get_latch(index->id));
+ 
+ 		ut_a(n_fields + n_bytes > 0);
+ 
+@@ -1624,7 +1692,7 @@
+ 		return;
+ 	}
+ 
+-	rw_lock_s_unlock(&btr_search_latch);
++	rw_lock_s_unlock(btr_search_get_latch(index->id));
+ }
+ 
+ /********************************************************************//**
+@@ -1663,7 +1731,7 @@
+ 	ut_a(block->curr_n_fields + block->curr_n_bytes > 0);
+ 	ut_a(!dict_index_is_ibuf(cursor->index));
+ 
+-	table = btr_search_sys->hash_index;
++	table = btr_search_get_hash_index(cursor->index->id);
+ 
+ 	index_id = cursor->index->id;
+ 	fold = rec_fold(rec, rec_get_offsets(rec, cursor->index, offsets_,
+@@ -1672,11 +1740,11 @@
+ 	if (UNIV_LIKELY_NULL(heap)) {
+ 		mem_heap_free(heap);
+ 	}
+-	rw_lock_x_lock(&btr_search_latch);
++	rw_lock_x_lock(btr_search_get_latch(cursor->index->id));
+ 
+ 	ha_search_and_delete_if_found(table, fold, rec);
+ 
+-	rw_lock_x_unlock(&btr_search_latch);
++	rw_lock_x_unlock(btr_search_get_latch(cursor->index->id));
+ }
+ 
+ /********************************************************************//**
+@@ -1710,21 +1778,21 @@
+ 	ut_a(block->index == cursor->index);
+ 	ut_a(!dict_index_is_ibuf(cursor->index));
+ 
+-	rw_lock_x_lock(&btr_search_latch);
++	rw_lock_x_lock(btr_search_get_latch(cursor->index->id));
+ 
+ 	if ((cursor->flag == BTR_CUR_HASH)
+ 	    && (cursor->n_fields == block->curr_n_fields)
+ 	    && (cursor->n_bytes == block->curr_n_bytes)
+ 	    && !block->curr_left_side) {
+ 
+-		table = btr_search_sys->hash_index;
++		table = btr_search_get_hash_index(cursor->index->id);
+ 
+ 		ha_search_and_update_if_found(table, cursor->fold, rec,
+ 					      block, page_rec_get_next(rec));
+ 
+-		rw_lock_x_unlock(&btr_search_latch);
++		rw_lock_x_unlock(btr_search_get_latch(cursor->index->id));
+ 	} else {
+-		rw_lock_x_unlock(&btr_search_latch);
++		rw_lock_x_unlock(btr_search_get_latch(cursor->index->id));
+ 
+ 		btr_search_update_hash_on_insert(cursor);
+ 	}
+@@ -1759,9 +1827,9 @@
+ 	ulint*		offsets		= offsets_;
+ 	rec_offs_init(offsets_);
+ 
+-	table = btr_search_sys->hash_index;
++	table = btr_search_get_hash_index(cursor->index->id);
+ 
+-	btr_search_check_free_space_in_heap();
++	btr_search_check_free_space_in_heap(cursor->index->id);
+ 
+ 	rec = btr_cur_get_rec(cursor);
+ 
+@@ -1806,7 +1874,7 @@
+ 	} else {
+ 		if (left_side) {
+ 
+-			rw_lock_x_lock(&btr_search_latch);
++			rw_lock_x_lock(btr_search_get_latch(index_id));
+ 
+ 			locked = TRUE;
+ 
+@@ -1820,7 +1888,7 @@
+ 
+ 		if (!locked) {
+ 
+-			rw_lock_x_lock(&btr_search_latch);
++			rw_lock_x_lock(btr_search_get_latch(index_id));
+ 
+ 			locked = TRUE;
+ 		}
+@@ -1838,7 +1906,7 @@
+ 		if (!left_side) {
+ 
+ 			if (!locked) {
+-				rw_lock_x_lock(&btr_search_latch);
++				rw_lock_x_lock(btr_search_get_latch(index_id));
+ 
+ 				locked = TRUE;
+ 			}
+@@ -1853,7 +1921,7 @@
+ 
+ 		if (!locked) {
+ 
+-			rw_lock_x_lock(&btr_search_latch);
++			rw_lock_x_lock(btr_search_get_latch(index_id));
+ 
+ 			locked = TRUE;
+ 		}
+@@ -1876,7 +1944,7 @@
+ 		mem_heap_free(heap);
+ 	}
+ 	if (locked) {
+-		rw_lock_x_unlock(&btr_search_latch);
++		rw_lock_x_unlock(btr_search_get_latch(index_id));
+ 	}
+ }
+ 
+@@ -1892,7 +1960,7 @@
+ 	ha_node_t*	node;
+ 	ulint		n_page_dumps	= 0;
+ 	ibool		ok		= TRUE;
+-	ulint		i;
++	ulint		i,j;
+ 	ulint		cell_count;
+ 	mem_heap_t*	heap		= NULL;
+ 	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
+@@ -1904,23 +1972,25 @@
+ 
+ 	rec_offs_init(offsets_);
+ 
+-	rw_lock_x_lock(&btr_search_latch);
++	btr_search_x_lock_all();
+ 	buf_pool_page_hash_x_lock_all();
+ 
+-	cell_count = hash_get_n_cells(btr_search_sys->hash_index);
++	for (j = 0; j < btr_search_index_num; j++) {
++
++	cell_count = hash_get_n_cells(btr_search_sys->hash_index[j]);
+ 
+ 	for (i = 0; i < cell_count; i++) {
+ 		/* We release btr_search_latch every once in a while to
+ 		give other queries a chance to run. */
+ 		if ((i != 0) && ((i % chunk_size) == 0)) {
+ 			buf_pool_page_hash_x_unlock_all();
+-			rw_lock_x_unlock(&btr_search_latch);
++			btr_search_x_unlock_all();
+ 			os_thread_yield();
+-			rw_lock_x_lock(&btr_search_latch);
++			btr_search_x_lock_all();
+ 			buf_pool_page_hash_x_lock_all();
+ 		}
+ 
+-		node = hash_get_nth_cell(btr_search_sys->hash_index, i)->node;
++		node = hash_get_nth_cell(btr_search_sys->hash_index[j], i)->node;
+ 
+ 		for (; node != NULL; node = node->next) {
+ 			const buf_block_t*	block
+@@ -2029,19 +2099,21 @@
+ 		give other queries a chance to run. */
+ 		if (i != 0) {
+ 			buf_pool_page_hash_x_unlock_all();
+-			rw_lock_x_unlock(&btr_search_latch);
++			btr_search_x_unlock_all();
+ 			os_thread_yield();
+-			rw_lock_x_lock(&btr_search_latch);
++			btr_search_x_lock_all();
+ 			buf_pool_page_hash_x_lock_all();
+ 		}
+ 
+-		if (!ha_validate(btr_search_sys->hash_index, i, end_index)) {
++		if (!ha_validate(btr_search_sys->hash_index[j], i, end_index)) {
+ 			ok = FALSE;
+ 		}
+ 	}
+ 
++	} /*for (j = 0; j < btr_search_index_num; j++)*/
++
+ 	buf_pool_page_hash_x_unlock_all();
+-	rw_lock_x_unlock(&btr_search_latch);
++	btr_search_x_unlock_all();
+ 	if (UNIV_LIKELY_NULL(heap)) {
+ 		mem_heap_free(heap);
+ 	}
+diff -ruN a/storage/innobase/buf/buf0buf.c b/storage/innobase/buf/buf0buf.c
+--- a/storage/innobase/buf/buf0buf.c	2010-12-04 15:55:21.351597052 +0900
++++ b/storage/innobase/buf/buf0buf.c	2010-12-04 16:12:48.654550708 +0900
+@@ -949,6 +949,7 @@
+ 
+ 	block->check_index_page_at_flush = FALSE;
+ 	block->index = NULL;
++	block->btr_search_latch = NULL;
+ 
+ 	block->is_hashed = FALSE;
+ 
+@@ -1477,7 +1478,7 @@
+ 			/* To follow the latching order, we
+ 			have to release btr_search_latch
+ 			before acquiring block->latch. */
+-			rw_lock_x_unlock(&btr_search_latch);
++			btr_search_x_unlock_all();
+ 			/* When we release the search latch,
+ 			we must rescan all blocks, because
+ 			some may become hashed again. */
+@@ -1508,11 +1509,11 @@
+ 			anything.  block->is_hashed can only
+ 			be set on uncompressed file pages. */
+ 			
+-			btr_search_drop_page_hash_index(block);
++			btr_search_drop_page_hash_index(block, NULL);
+ 			
+ 			rw_lock_x_unlock(&block->lock);
+ 			
+-			rw_lock_x_lock(&btr_search_latch);
++			btr_search_x_lock_all();
+ 			
+ 			ut_ad(!btr_search_enabled);
+ 		}
+@@ -1531,7 +1532,11 @@
+ 	ibool		released_search_latch;
+ 
+ #ifdef UNIV_SYNC_DEBUG
+-	ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_EX));
++	ulint	j;
++
++	for (j = 0; j < btr_search_index_num; j++) {
++		ut_ad(rw_lock_own(btr_search_latch_part[j], RW_LOCK_EX));
++	}
+ #endif /* UNIV_SYNC_DEBUG */
+ 	ut_ad(!btr_search_enabled);
+ 
+@@ -2635,6 +2640,7 @@
+ {
+ 	block->check_index_page_at_flush = FALSE;
+ 	block->index		= NULL;
++	block->btr_search_latch	= NULL;
+ 
+ 	block->n_hash_helps	= 0;
+ 	block->is_hashed	= FALSE;
+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
+@@ -1775,7 +1775,7 @@
+ 
+ 		UNIV_MEM_VALID(((buf_block_t*) bpage)->frame,
+ 			       UNIV_PAGE_SIZE);
+-		btr_search_drop_page_hash_index((buf_block_t*) bpage);
++		btr_search_drop_page_hash_index((buf_block_t*) bpage, NULL);
+ 		UNIV_MEM_INVALID(((buf_block_t*) bpage)->frame,
+ 				 UNIV_PAGE_SIZE);
+ 
+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
+@@ -1802,7 +1802,7 @@
+ 	zero. */
+ 
+ 	for (;;) {
+-		ulint ref_count = btr_search_info_get_ref_count(info);
++		ulint ref_count = btr_search_info_get_ref_count(info, index->id);
+ 		if (ref_count == 0) {
+ 			break;
+ 		}
+diff -ruN a/storage/innobase/ha/ha0ha.c b/storage/innobase/ha/ha0ha.c
+--- a/storage/innobase/ha/ha0ha.c	2010-11-03 07:01:13.000000000 +0900
++++ b/storage/innobase/ha/ha0ha.c	2010-12-04 16:12:48.665593752 +0900
+@@ -102,7 +102,8 @@
+ 	ut_ad(table);
+ 	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
+ #ifdef UNIV_SYNC_DEBUG
+-	ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_EXCLUSIVE));
++	/* cannot identificate which btr_search_latch[i] for now */
++	//ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_EXCLUSIVE));
+ #endif /* UNIV_SYNC_DEBUG */
+ 
+ #ifndef 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-04 16:12:20.185850734 +0900
++++ b/storage/innobase/handler/ha_innodb.cc	2010-12-04 16:12:48.674552412 +0900
+@@ -11603,6 +11603,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);
++
+ static MYSQL_SYSVAR_ULONG(replication_delay, srv_replication_delay,
+   PLUGIN_VAR_RQCMDARG,
+   "Replication thread delay (ms) on the slave server if "
+@@ -11956,6 +11961,7 @@
+   MYSQL_SYSVAR(use_sys_stats_table),
+   MYSQL_SYSVAR(stats_sample_pages),
+   MYSQL_SYSVAR(adaptive_hash_index),
++  MYSQL_SYSVAR(adaptive_hash_index_partitions),
+   MYSQL_SYSVAR(replication_delay),
+   MYSQL_SYSVAR(status_file),
+   MYSQL_SYSVAR(strict_mode),
+diff -ruN a/storage/innobase/include/btr0sea.h b/storage/innobase/include/btr0sea.h
+--- a/storage/innobase/include/btr0sea.h	2010-12-03 15:48:03.070987226 +0900
++++ b/storage/innobase/include/btr0sea.h	2010-12-04 16:12:48.707551382 +0900
+@@ -85,7 +85,8 @@
+ ulint
+ btr_search_info_get_ref_count(
+ /*==========================*/
+-	btr_search_t*   info);	/*!< in: search info. */
++	btr_search_t*   info,	/*!< in: search info. */
++	index_id_t	key);
+ /*********************************************************************//**
+ Updates the search info. */
+ UNIV_INLINE
+@@ -136,10 +137,11 @@
+ void
+ btr_search_drop_page_hash_index(
+ /*============================*/
+-	buf_block_t*	block);	/*!< in: block containing index page,
++	buf_block_t*	block,	/*!< in: block containing index page,
+ 				s- or x-latched, or an index page
+ 				for which we know that
+ 				block->buf_fix_count == 0 */
++	dict_index_t*	index_in);
+ /************************************************************************
+ Drops a page hash index based on index */
+ UNIV_INTERN
+@@ -199,10 +201,47 @@
+ # define btr_search_validate()	TRUE
+ #endif /* defined UNIV_AHI_DEBUG || defined UNIV_DEBUG */
+ 
++/********************************************************************//**
++New functions to control split btr_search_index */
++UNIV_INLINE
++hash_table_t*
++btr_search_get_hash_index(
++/*======================*/
++	index_id_t	key);
++
++UNIV_INLINE
++rw_lock_t*
++btr_search_get_latch(
++/*=================*/
++	index_id_t	key);
++
++UNIV_INLINE
++void
++btr_search_x_lock_all(void);
++/*========================*/
++
++UNIV_INLINE
++void
++btr_search_x_unlock_all(void);
++/*==========================*/
++
++UNIV_INLINE
++void
++btr_search_s_lock_all(void);
++/*========================*/
++
++UNIV_INLINE
++void
++btr_search_s_unlock_all(void);
++/*==========================*/
++
++
+ /** Flag: has the search system been enabled?
+ Protected by btr_search_latch and btr_search_enabled_mutex. */
+ extern char	btr_search_enabled;
+ 
++extern ulint	btr_search_index_num;
++
+ /** Flag: whether the search system has completed its disabling process,
+ It is set to TRUE right after buf_pool_drop_hash_index() in
+ btr_search_disable(), indicating hash index entries are cleaned up.
+@@ -269,7 +308,7 @@
+ 
+ /** The hash index system */
+ struct btr_search_sys_struct{
+-	hash_table_t*	hash_index;	/*!< the adaptive hash index,
++	hash_table_t**	hash_index;	/*!< the adaptive hash index,
+ 					mapping dtuple_fold values
+ 					to rec_t pointers on index pages */
+ };
+@@ -290,10 +329,12 @@
+ 
+ Bear in mind (3) and (4) when using the hash index.
+ */
+-extern rw_lock_t*	btr_search_latch_temp;
++//extern rw_lock_t*	btr_search_latch_temp;
++
++extern rw_lock_t**	btr_search_latch_part;
+ 
+ /** The latch protecting the adaptive search system */
+-#define btr_search_latch	(*btr_search_latch_temp)
++//#define btr_search_latch	(*btr_search_latch_temp)
+ 
+ #ifdef UNIV_SEARCH_PERF_STAT
+ /** Number of successful adaptive hash index lookups */
+diff -ruN a/storage/innobase/include/btr0sea.ic b/storage/innobase/include/btr0sea.ic
+--- a/storage/innobase/include/btr0sea.ic	2010-11-03 07:01:13.000000000 +0900
++++ b/storage/innobase/include/btr0sea.ic	2010-12-04 16:12:48.709511202 +0900
+@@ -62,8 +62,8 @@
+ 	btr_search_t*	info;
+ 
+ #ifdef UNIV_SYNC_DEBUG
+-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
+-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
++	ut_ad(!rw_lock_own(btr_search_get_latch(index->id), RW_LOCK_SHARED));
++	ut_ad(!rw_lock_own(btr_search_get_latch(index->id), RW_LOCK_EX));
+ #endif /* UNIV_SYNC_DEBUG */
+ 
+ 	info = btr_search_get_info(index);
+@@ -82,3 +82,72 @@
+ 
+ 	btr_search_info_update_slow(info, cursor);
+ }
++
++/*********************************************************************//**
++New functions to control split btr_search_index */
++UNIV_INLINE
++hash_table_t*
++btr_search_get_hash_index(
++/*======================*/
++	index_id_t	key)
++{
++	return(btr_search_sys->hash_index[key % btr_search_index_num]);
++}
++
++UNIV_INLINE
++rw_lock_t*
++btr_search_get_latch(
++/*=================*/
++	index_id_t	key)
++{
++	return(btr_search_latch_part[key % btr_search_index_num]);
++}
++
++UNIV_INLINE
++void
++btr_search_x_lock_all(void)
++/*=======================*/
++{
++	ulint	i;
++
++	for (i = 0; i < btr_search_index_num; i++) {
++		rw_lock_x_lock(btr_search_latch_part[i]);
++	}
++}
++
++UNIV_INLINE
++void
++btr_search_x_unlock_all(void)
++/*==========================*/
++{
++	ulint	i;
++
++	for (i = 0; i < btr_search_index_num; i++) {
++		rw_lock_x_unlock(btr_search_latch_part[i]);
++	}
++}
++
++UNIV_INLINE
++void
++btr_search_s_lock_all(void)
++/*=======================*/
++{
++	ulint	i;
++
++	for (i = 0; i < btr_search_index_num; i++) {
++		rw_lock_s_lock(btr_search_latch_part[i]);
++	}
++}
++
++UNIV_INLINE
++void
++btr_search_s_unlock_all(void)
++/*=========================*/
++{
++	ulint	i;
++
++	for (i = 0; i < btr_search_index_num; i++) {
++		rw_lock_s_unlock(btr_search_latch_part[i]);
++	}
++}
++
+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
+@@ -1473,7 +1473,7 @@
+ 					pointers in the adaptive hash index
+ 					pointing to this frame */
+ #endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
+-	unsigned	is_hashed:1;	/*!< TRUE if hash index has
++	volatile unsigned	is_hashed:1;	/*!< TRUE if hash index has
+ 					already been built on this
+ 					page; note that it does not
+ 					guarantee that the index is
+@@ -1487,6 +1487,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. */
++	volatile rw_lock_t*	btr_search_latch;
+ 	/* @} */
+ # ifdef UNIV_SYNC_DEBUG
+ 	/** @name Debug fields */
+diff -ruN a/storage/innobase/include/row0upd.ic b/storage/innobase/include/row0upd.ic
+--- a/storage/innobase/include/row0upd.ic	2010-11-03 07:01:13.000000000 +0900
++++ b/storage/innobase/include/row0upd.ic	2010-12-04 16:12:48.710551113 +0900
+@@ -158,7 +158,7 @@
+ 	ut_ad(dict_index_is_clust(index));
+ 	ut_ad(rec_offs_validate(rec, index, offsets));
+ #ifdef UNIV_SYNC_DEBUG
+-	if (!rw_lock_own(&btr_search_latch, RW_LOCK_EX)) {
++	if (!rw_lock_own(btr_search_get_latch(index->id), RW_LOCK_EX)) {
+ 		ut_ad(!buf_block_align(rec)->is_hashed);
+ 	}
+ #endif /* UNIV_SYNC_DEBUG */
+diff -ruN a/storage/innobase/page/page0page.c b/storage/innobase/page/page0page.c
+--- a/storage/innobase/page/page0page.c	2010-11-03 07:01:13.000000000 +0900
++++ b/storage/innobase/page/page0page.c	2010-12-04 16:12:48.712550963 +0900
+@@ -218,7 +218,7 @@
+ 	const ibool	is_hashed	= block->is_hashed;
+ 
+ 	if (is_hashed) {
+-		rw_lock_x_lock(&btr_search_latch);
++		rw_lock_x_lock(btr_search_get_latch(block->index->id));
+ 	}
+ 
+ 	ut_ad(!mtr || mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
+@@ -244,7 +244,7 @@
+ 
+ #ifndef UNIV_HOTBACKUP
+ 	if (is_hashed) {
+-		rw_lock_x_unlock(&btr_search_latch);
++		rw_lock_x_unlock(btr_search_get_latch(block->index->id));
+ 	}
+ #endif /* !UNIV_HOTBACKUP */
+ }
+diff -ruN a/storage/innobase/page/page0zip.c b/storage/innobase/page/page0zip.c
+--- a/storage/innobase/page/page0zip.c	2010-12-04 15:57:13.061494433 +0900
++++ b/storage/innobase/page/page0zip.c	2010-12-04 16:12:48.716470334 +0900
+@@ -4445,7 +4445,7 @@
+ 
+ #ifndef UNIV_HOTBACKUP
+ 	temp_block = buf_block_alloc(buf_pool, 0);
+-	btr_search_drop_page_hash_index(block);
++	btr_search_drop_page_hash_index(block, index);
+ 	block->check_index_page_at_flush = TRUE;
+ #else /* !UNIV_HOTBACKUP */
+ 	ut_ad(block == back_block1);
+diff -ruN a/storage/innobase/row/row0sel.c b/storage/innobase/row/row0sel.c
+--- a/storage/innobase/row/row0sel.c	2010-12-04 16:09:53.204513572 +0900
++++ b/storage/innobase/row/row0sel.c	2010-12-04 16:12:48.722551273 +0900
+@@ -1210,7 +1210,7 @@
+ 	ut_ad(plan->unique_search);
+ 	ut_ad(!plan->must_get_clust);
+ #ifdef UNIV_SYNC_DEBUG
+-	ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
++	ut_ad(rw_lock_own(btr_search_get_latch(index->id), RW_LOCK_SHARED));
+ #endif /* UNIV_SYNC_DEBUG */
+ 
+ 	row_sel_open_pcur(plan, TRUE, mtr);
+@@ -1381,10 +1381,10 @@
+ 	    && !plan->must_get_clust
+ 	    && !plan->table->big_rows) {
+ 		if (!search_latch_locked) {
+-			rw_lock_s_lock(&btr_search_latch);
++			rw_lock_s_lock(btr_search_get_latch(index->id));
+ 
+ 			search_latch_locked = TRUE;
+-		} else if (rw_lock_get_writer(&btr_search_latch) == RW_LOCK_WAIT_EX) {
++		} else if (rw_lock_get_writer(btr_search_get_latch(index->id)) == RW_LOCK_WAIT_EX) {
+ 
+ 			/* There is an x-latch request waiting: release the
+ 			s-latch for a moment; as an s-latch here is often
+@@ -1393,8 +1393,8 @@
+ 			from acquiring an s-latch for a long time, lowering
+ 			performance significantly in multiprocessors. */
+ 
+-			rw_lock_s_unlock(&btr_search_latch);
+-			rw_lock_s_lock(&btr_search_latch);
++			rw_lock_s_unlock(btr_search_get_latch(index->id));
++			rw_lock_s_lock(btr_search_get_latch(index->id));
+ 		}
+ 
+ 		found_flag = row_sel_try_search_shortcut(node, plan, &mtr);
+@@ -1417,7 +1417,7 @@
+ 	}
+ 
+ 	if (search_latch_locked) {
+-		rw_lock_s_unlock(&btr_search_latch);
++		rw_lock_s_unlock(btr_search_get_latch(index->id));
+ 
+ 		search_latch_locked = FALSE;
+ 	}
+@@ -1993,7 +1993,7 @@
+ 
+ func_exit:
+ 	if (search_latch_locked) {
+-		rw_lock_s_unlock(&btr_search_latch);
++		rw_lock_s_unlock(btr_search_get_latch(index->id));
+ 	}
+ 	if (UNIV_LIKELY_NULL(heap)) {
+ 		mem_heap_free(heap);
+@@ -3356,6 +3356,8 @@
+ 	/* if the returned record was locked and we did a semi-consistent
+ 	read (fetch the newest committed version), then this is set to
+ 	TRUE */
++	ulint		i;
++	ulint		should_release;
+ #ifdef UNIV_SEARCH_DEBUG
+ 	ulint		cnt				= 0;
+ #endif /* UNIV_SEARCH_DEBUG */
+@@ -3441,18 +3443,32 @@
+ 	/* PHASE 0: Release a possible s-latch we are holding on the
+ 	adaptive hash index latch if there is someone waiting behind */
+ 
+-	if (UNIV_UNLIKELY(rw_lock_get_writer(&btr_search_latch) != RW_LOCK_NOT_LOCKED)
+-	    && 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) {
++			should_release |= ((ulint)1 << i);
++		}
++	}
++
++	if (should_release) {
+ 
+ 		/* There is an x-latch request on the adaptive hash index:
+ 		release the s-latch to reduce starvation and wait for
+ 		BTR_SEA_TIMEOUT rounds before trying to keep it again over
+ 		calls from MySQL */
+ 
+-		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)) {
++				rw_lock_s_unlock(btr_search_latch_part[i]);
++				trx->has_search_latch &= ~((ulint)1 << i);
++			}
++		}
+ 
++		if (!trx->has_search_latch) {
+ 		trx->search_latch_timeout = BTR_SEA_TIMEOUT;
++		}
+ 	}
+ 
+ 	/* Reset the new record lock info if srv_locks_unsafe_for_binlog
+@@ -3603,9 +3619,11 @@
+ 			hash index semaphore! */
+ 
+ #ifndef UNIV_SEARCH_DEBUG
+-			if (!trx->has_search_latch) {
+-				rw_lock_s_lock(&btr_search_latch);
+-				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);
+ 			}
+ #endif
+ 			switch (row_sel_try_search_shortcut_for_mysql(
+@@ -3666,7 +3684,11 @@
+ 
+ 					trx->search_latch_timeout--;
+ 
+-					rw_lock_s_unlock(&btr_search_latch);
++					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 = FALSE;
+ 				}
+ 
+@@ -3690,7 +3712,12 @@
+ 	/* PHASE 3: Open or restore index cursor position */
+ 
+ 	if (trx->has_search_latch) {
+-		rw_lock_s_unlock(&btr_search_latch);
++
++		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 = FALSE;
+ 	}
+ 
+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
+@@ -2005,7 +2005,9 @@
+ 	      "-------------------------------------\n", file);
+ 	ibuf_print(file);
+ 
+-	ha_print_info(file, btr_search_sys->hash_index);
++	for (i = 0; i < btr_search_index_num; i++) {
++		ha_print_info(file, btr_search_get_hash_index((index_id_t)i));
++	}
+ 
+ 	fprintf(file,
+ 		"%.2f hash searches/s, %.2f non-hash searches/s\n",
+@@ -2030,14 +2032,15 @@
+ 			ut_total_allocated_memory,
+ 			mem_pool_get_reserved(mem_comm_pool));
+ 	/* Calcurate reserved memories */
+-	if (btr_search_sys && btr_search_sys->hash_index->heap) {
+-		btr_search_sys_subtotal = mem_heap_get_size(btr_search_sys->hash_index->heap);
++	if (btr_search_sys && btr_search_sys->hash_index[0]->heap) {
++		btr_search_sys_subtotal = mem_heap_get_size(btr_search_sys->hash_index[0]->heap);
+ 	} else {
+ 		btr_search_sys_subtotal = 0;
+-		for (i=0; i < btr_search_sys->hash_index->n_mutexes; i++) {
+-			btr_search_sys_subtotal += mem_heap_get_size(btr_search_sys->hash_index->heaps[i]);
++		for (i=0; i < btr_search_sys->hash_index[0]->n_mutexes; i++) {
++			btr_search_sys_subtotal += mem_heap_get_size(btr_search_sys->hash_index[0]->heaps[i]);
+ 		}
+ 	}
++	btr_search_sys_subtotal *= btr_search_index_num;
+ 
+ 	lock_sys_subtotal = 0;
+ 	if (trx_sys) {
+@@ -2064,10 +2067,10 @@
+ 			"    Threads             %lu \t(%lu + %lu)\n",
+ 
+ 			(ulong) (btr_search_sys
+-				? (btr_search_sys->hash_index->n_cells * sizeof(hash_cell_t)) : 0)
++				? (btr_search_sys->hash_index[0]->n_cells * btr_search_index_num * sizeof(hash_cell_t)) : 0)
+ 			+ btr_search_sys_subtotal,
+ 			(ulong) (btr_search_sys
+-				? (btr_search_sys->hash_index->n_cells * sizeof(hash_cell_t)) : 0),
++				? (btr_search_sys->hash_index[0]->n_cells * btr_search_index_num * sizeof(hash_cell_t)) : 0),
+ 			(ulong) btr_search_sys_subtotal,
+ 
+ 			(ulong) (buf_pool_from_array(0)->page_hash->n_cells * sizeof(hash_cell_t)),
+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
+@@ -1183,7 +1183,6 @@
+ 	case SYNC_ANY_LATCH:
+ 	case SYNC_FILE_FORMAT_TAG:
+ 	case SYNC_DOUBLEWRITE:
+-	case SYNC_SEARCH_SYS:
+ 	case SYNC_SEARCH_SYS_CONF:
+ 	case SYNC_TRX_LOCK_HEAP:
+ 	case SYNC_KERNEL:
+@@ -1204,6 +1203,7 @@
+ 			ut_error;
+ 		}
+ 		break;
++	case SYNC_SEARCH_SYS:
+ 	case SYNC_BUF_LRU_LIST:
+ 	case SYNC_BUF_FLUSH_LIST:
+ 	case SYNC_BUF_PAGE_HASH:
+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
+@@ -268,8 +268,14 @@
+ /*=================================*/
+ 	trx_t*	   trx) /*!< in: transaction */
+ {
++	ulint	i;
++
+ 	if (trx->has_search_latch) {
+-		rw_lock_s_unlock(&btr_search_latch);
++		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 = FALSE;
+ 	}

=== added file 'innodb_admin_command_base.patch'
--- innodb_admin_command_base.patch	1970-01-01 00:00:00 +0000
+++ innodb_admin_command_base.patch	2011-01-10 13:15:57 +0000
@@ -0,0 +1,173 @@
+# name       : innodb_admin_command_base.patch
+# introduced : 11 or before
+# 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/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
+@@ -11769,7 +11769,8 @@
+ i_s_innodb_sys_foreign_cols,
+ i_s_innodb_sys_stats,
+ i_s_innodb_table_stats,
+-i_s_innodb_index_stats
++i_s_innodb_index_stats,
++i_s_innodb_admin_command
+ mysql_declare_plugin_end;
+ 
+ /** @brief Initialize the default value of innodb_commit_concurrency.
+diff -ruN a/storage/innobase/handler/i_s.cc b/storage/innobase/handler/i_s.cc
+--- a/storage/innobase/handler/i_s.cc	2010-12-03 17:30:16.299955549 +0900
++++ b/storage/innobase/handler/i_s.cc	2010-12-03 17:32:35.425989972 +0900
+@@ -4162,3 +4162,139 @@
+ 	STRUCT_FLD(system_vars, NULL),
+ 	STRUCT_FLD(__reserved1, NULL)
+ };
++
++/***********************************************************************
++*/
++static ST_FIELD_INFO	i_s_innodb_admin_command_info[] =
++{
++	{STRUCT_FLD(field_name,		"result_message"),
++	 STRUCT_FLD(field_length,	1024),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_STRING),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	0),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	END_OF_ST_FIELD_INFO
++};
++
++#ifndef INNODB_COMPATIBILITY_HOOKS
++#error InnoDB needs MySQL to be built with #define INNODB_COMPATIBILITY_HOOKS
++#endif
++
++extern "C" {
++char **thd_query(MYSQL_THD thd);
++}
++
++static
++int
++i_s_innodb_admin_command_fill(
++/*==========================*/
++	THD*		thd,
++	TABLE_LIST*	tables,
++	COND*		cond)
++{
++	TABLE*	i_s_table	= (TABLE *) tables->table;
++	char**	query_str;
++	char*	ptr;
++	char	quote	= '\0';
++	const char*	command_head = "XTRA_";
++
++	DBUG_ENTER("i_s_innodb_admin_command_fill");
++
++	/* deny access to non-superusers */
++	if (check_global_access(thd, PROCESS_ACL)) {
++		DBUG_RETURN(0);
++	}
++
++	if(thd_sql_command(thd) != SQLCOM_SELECT) {
++		field_store_string(i_s_table->field[0],
++			"SELECT command is only accepted.");
++		goto end_func;
++	}
++
++	query_str = thd_query(thd);
++	ptr = *query_str;
++	
++	for (; *ptr; ptr++) {
++		if (*ptr == quote) {
++			quote = '\0';
++		} else if (quote) {
++		} else if (*ptr == '`' || *ptr == '"') {
++			quote = *ptr;
++		} else {
++			long	i;
++			for (i = 0; command_head[i]; i++) {
++				if (toupper((int)(unsigned char)(ptr[i]))
++				    != toupper((int)(unsigned char)
++				      (command_head[i]))) {
++					goto nomatch;
++				}
++			}
++			break;
++nomatch:
++			;
++		}
++	}
++
++	if (!*ptr) {
++		field_store_string(i_s_table->field[0],
++			"No XTRA_* command in the SQL statement."
++			" Please add /*!XTRA_xxxx*/ to the SQL.");
++		goto end_func;
++	}
++
++	if (!strncasecmp("XTRA_HELLO", ptr, 10)) {
++		/* This is example command XTRA_HELLO */
++
++		ut_print_timestamp(stderr);
++		fprintf(stderr, " InnoDB: administration command test for XtraDB"
++				" 'XTRA_HELLO' was detected.\n");
++
++		field_store_string(i_s_table->field[0],
++			"Hello!");
++		goto end_func;
++	}
++
++	field_store_string(i_s_table->field[0],
++		"Undefined XTRA_* command.");
++	goto end_func;
++
++end_func:
++	if (schema_table_store_record(thd, i_s_table)) {
++		DBUG_RETURN(1);
++	} else {
++		DBUG_RETURN(0);
++	}
++}
++
++static
++int
++i_s_innodb_admin_command_init(
++/*==========================*/
++	void*	p)
++{
++	DBUG_ENTER("i_s_innodb_admin_command_init");
++	ST_SCHEMA_TABLE* schema = (ST_SCHEMA_TABLE*) p;
++
++	schema->fields_info = i_s_innodb_admin_command_info;
++	schema->fill_table = i_s_innodb_admin_command_fill;
++
++	DBUG_RETURN(0);
++}
++
++UNIV_INTERN struct st_mysql_plugin	i_s_innodb_admin_command =
++{
++	STRUCT_FLD(type, MYSQL_INFORMATION_SCHEMA_PLUGIN),
++	STRUCT_FLD(info, &i_s_info),
++	STRUCT_FLD(name, "XTRADB_ADMIN_COMMAND"),
++	STRUCT_FLD(author, plugin_author),
++	STRUCT_FLD(descr, "XtraDB specific command acceptor"),
++	STRUCT_FLD(license, PLUGIN_LICENSE_GPL),
++	STRUCT_FLD(init, i_s_innodb_admin_command_init),
++	STRUCT_FLD(deinit, i_s_common_deinit),
++	STRUCT_FLD(version, 0x0100 /* 1.0 */),
++	STRUCT_FLD(status_vars, NULL),
++	STRUCT_FLD(system_vars, NULL),
++	STRUCT_FLD(__reserved1, NULL)
++};
+diff -ruN a/storage/innobase/handler/i_s.h b/storage/innobase/handler/i_s.h
+--- a/storage/innobase/handler/i_s.h	2010-12-03 17:30:16.301987692 +0900
++++ b/storage/innobase/handler/i_s.h	2010-12-03 17:32:35.426954555 +0900
+@@ -44,5 +44,6 @@
+ extern struct st_mysql_plugin	i_s_innodb_sys_stats;
+ extern struct st_mysql_plugin	i_s_innodb_table_stats;
+ extern struct st_mysql_plugin	i_s_innodb_index_stats;
++extern struct st_mysql_plugin	i_s_innodb_admin_command;
+ 
+ #endif /* i_s_h */

=== renamed file 'innodb_admin_command_base.patch' => 'innodb_admin_command_base.patch.moved'
=== added file 'innodb_buffer_pool_pages_i_s.patch'
--- innodb_buffer_pool_pages_i_s.patch	1970-01-01 00:00:00 +0000
+++ innodb_buffer_pool_pages_i_s.patch	2011-01-10 13:15:57 +0000
@@ -0,0 +1,803 @@
+# name       : innodb_buffer_pool_pages_i_s.patch
+# introduced : 11 or before
+# 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/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
+@@ -4514,6 +4514,36 @@
+ 	mutex_exit(block_mutex);
+ }
+ 
++/********************************************************************//**
++*/
++UNIV_INTERN
++buf_block_t*
++buf_page_from_array(
++/*================*/
++	buf_pool_t*	buf_pool,
++	ulint		n_block)
++{
++	ulint		n_chunks, offset;
++	buf_chunk_t*	chunk;
++
++	ut_a(n_block < buf_pool->curr_size);
++
++	chunk = buf_pool->chunks;
++	offset = n_block;
++
++	for (n_chunks = buf_pool->n_chunks; n_chunks--; chunk++) {
++		if (offset < chunk->size) {
++			return(&chunk->blocks[offset]);
++		}
++
++		offset -= chunk->size;
++	}
++
++	ut_error;
++
++	return(NULL);
++}
++
+ /*********************************************************************//**
+ Asserts that all file pages in the buffer are in a replaceable state.
+ @return	TRUE */
+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
+@@ -12036,6 +12036,9 @@
+ i_s_innodb_sys_stats,
+ i_s_innodb_table_stats,
+ i_s_innodb_index_stats,
++i_s_innodb_buffer_pool_pages,
++i_s_innodb_buffer_pool_pages_index,
++i_s_innodb_buffer_pool_pages_blob,
+ i_s_innodb_admin_command
+ mysql_declare_plugin_end;
+ 
+diff -ruN a/storage/innobase/handler/i_s.cc b/storage/innobase/handler/i_s.cc
+--- a/storage/innobase/handler/i_s.cc	2010-12-04 19:46:39.786513783 +0900
++++ b/storage/innobase/handler/i_s.cc	2010-12-06 19:28:52.270226921 +0900
+@@ -51,6 +51,7 @@
+ #include "trx0sys.h" /* for trx_sys */
+ #include "dict0dict.h" /* for dict_sys */
+ #include "buf0lru.h" /* for XTRA_LRU_[DUMP/RESTORE] */
++#include "btr0btr.h" /* for btr_page_get_index_id */
+ }
+ 
+ static const char plugin_author[] = "Innobase Oy";
+@@ -4329,3 +4330,701 @@
+ 	STRUCT_FLD(system_vars, NULL),
+ 	STRUCT_FLD(__reserved1, NULL)
+ };
++
++/***********************************************************************
++*/
++static ST_FIELD_INFO	i_s_innodb_buffer_pool_pages_fields_info[] =
++{
++	{STRUCT_FLD(field_name,		"page_type"),
++	 STRUCT_FLD(field_length,	64),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_STRING),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_MAYBE_NULL),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"space_id"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"page_no"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"lru_position"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"fix_count"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"flush_type"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	END_OF_ST_FIELD_INFO
++};
++
++static ST_FIELD_INFO	i_s_innodb_buffer_pool_pages_index_fields_info[] =
++{
++	{STRUCT_FLD(field_name,		"index_id"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"space_id"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"page_no"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"n_recs"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"data_size"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"hashed"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"access_time"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"modified"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"dirty"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"old"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"lru_position"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"fix_count"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"flush_type"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	END_OF_ST_FIELD_INFO
++};
++
++static ST_FIELD_INFO	i_s_innodb_buffer_pool_pages_blob_fields_info[] =
++{
++	{STRUCT_FLD(field_name,		"space_id"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"page_no"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"compressed"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"part_len"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"next_page_no"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"lru_position"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"fix_count"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	{STRUCT_FLD(field_name,		"flush_type"),
++	 STRUCT_FLD(field_length,	MY_INT64_NUM_DECIMAL_DIGITS),
++	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONGLONG),
++	 STRUCT_FLD(value,		0),
++	 STRUCT_FLD(field_flags,	MY_I_S_UNSIGNED),
++	 STRUCT_FLD(old_name,		""),
++	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
++
++	END_OF_ST_FIELD_INFO
++};
++
++/***********************************************************************
++Fill the dynamic table information_schema.innodb_buffer_pool_pages. */
++static
++int
++i_s_innodb_buffer_pool_pages_fill(
++/*================*/
++				/* out: 0 on success, 1 on failure */
++	THD*		thd,	/* in: thread */
++	TABLE_LIST*	tables,	/* in/out: tables to fill */
++	COND*		cond)	/* in: condition (ignored) */
++{
++	TABLE*	table	= (TABLE *) tables->table;
++	int	status	= 0;
++	ulint	i;
++
++	DBUG_ENTER("i_s_innodb_buffer_pool_pages_fill");
++
++	/* deny access to non-superusers */
++	if (check_global_access(thd, PROCESS_ACL)) {
++
++		DBUG_RETURN(0);
++	}
++
++	RETURN_IF_INNODB_NOT_STARTED(tables->schema_table_name);
++
++	for (i = 0; i < srv_buf_pool_instances; i++) {
++		ulint		n_block;
++		buf_pool_t*	buf_pool;
++
++		buf_pool = buf_pool_from_array(i);
++
++		buf_pool_mutex_enter(buf_pool);
++
++		for (n_block = 0; n_block < buf_pool->curr_size; n_block++) {
++			buf_block_t*	block = buf_page_from_array(buf_pool, n_block);
++			const buf_frame_t*	frame = block->frame;
++
++			char page_type[64];
++
++			switch(fil_page_get_type(frame))
++			{
++				case FIL_PAGE_INDEX:
++					strcpy(page_type, "index");
++					break;
++				case FIL_PAGE_UNDO_LOG:
++					strcpy(page_type, "undo_log");
++					break;
++				case FIL_PAGE_INODE:
++					strcpy(page_type, "inode");
++					break;
++				case FIL_PAGE_IBUF_FREE_LIST:
++					strcpy(page_type, "ibuf_free_list");
++					break;
++				case FIL_PAGE_TYPE_ALLOCATED:
++					strcpy(page_type, "allocated");
++					break;
++				case FIL_PAGE_IBUF_BITMAP:
++					strcpy(page_type, "bitmap");
++					break;
++				case FIL_PAGE_TYPE_SYS:
++					strcpy(page_type, "sys");
++					break;
++				case FIL_PAGE_TYPE_TRX_SYS:
++					strcpy(page_type, "trx_sys");
++					break;
++				case FIL_PAGE_TYPE_FSP_HDR:
++					strcpy(page_type, "fsp_hdr");
++					break;
++				case FIL_PAGE_TYPE_XDES:
++					strcpy(page_type, "xdes");
++					break;
++				case FIL_PAGE_TYPE_BLOB:
++					strcpy(page_type, "blob");
++					break;
++				case FIL_PAGE_TYPE_ZBLOB:
++					strcpy(page_type, "zblob");
++					break;
++				case FIL_PAGE_TYPE_ZBLOB2:
++					strcpy(page_type, "zblob2");
++					break;
++				default:
++					sprintf(page_type, "unknown (type=%li)", fil_page_get_type(frame));
++			}
++
++			field_store_string(table->field[0], page_type);
++			table->field[1]->store(block->page.space);
++			table->field[2]->store(block->page.offset);
++			table->field[3]->store(0);
++			table->field[4]->store(block->page.buf_fix_count);
++			table->field[5]->store(block->page.flush_type);
++
++			if (schema_table_store_record(thd, table)) {
++				status = 1;
++				break;
++			}
++
++		}      
++
++		buf_pool_mutex_exit(buf_pool);
++	}
++
++	DBUG_RETURN(status);
++}
++
++/***********************************************************************
++Fill the dynamic table information_schema.innodb_buffer_pool_pages_index. */
++static
++int
++i_s_innodb_buffer_pool_pages_index_fill(
++/*================*/
++				/* out: 0 on success, 1 on failure */
++	THD*		thd,	/* in: thread */
++	TABLE_LIST*	tables,	/* in/out: tables to fill */
++	COND*		cond)	/* in: condition (ignored) */
++{
++	TABLE*	table	= (TABLE *) tables->table;
++	int	status	= 0;
++	ulint	i;
++	index_id_t	index_id;
++
++	DBUG_ENTER("i_s_innodb_buffer_pool_pages_index_fill");
++
++	/* deny access to non-superusers */
++	if (check_global_access(thd, PROCESS_ACL)) {
++
++		DBUG_RETURN(0);
++	}
++
++	RETURN_IF_INNODB_NOT_STARTED(tables->schema_table_name);
++
++	for (i = 0; i < srv_buf_pool_instances; i++) {
++		ulint		n_block;
++		buf_pool_t*	buf_pool;
++
++		buf_pool = buf_pool_from_array(i);
++
++		buf_pool_mutex_enter(buf_pool);
++	
++		for (n_block = 0; n_block < buf_pool->curr_size; n_block++) {
++			buf_block_t*	block = buf_page_from_array(buf_pool, n_block);
++			const buf_frame_t* frame = block->frame;
++
++			if (fil_page_get_type(frame) == FIL_PAGE_INDEX) {
++				index_id = btr_page_get_index_id(frame);
++				table->field[0]->store(index_id);
++				table->field[1]->store(block->page.space);
++				table->field[2]->store(block->page.offset);
++				table->field[3]->store(page_get_n_recs(frame));
++				table->field[4]->store(page_get_data_size(frame));
++				table->field[5]->store(block->is_hashed);
++				table->field[6]->store(block->page.access_time);
++				table->field[7]->store(block->page.newest_modification != 0);
++				table->field[8]->store(block->page.oldest_modification != 0);
++				table->field[9]->store(block->page.old);
++				table->field[10]->store(0);
++				table->field[11]->store(block->page.buf_fix_count);
++				table->field[12]->store(block->page.flush_type);
++
++				if (schema_table_store_record(thd, table)) {
++					status = 1;
++					break;
++				}
++			}      
++		}
++
++		buf_pool_mutex_exit(buf_pool);
++	}
++
++	DBUG_RETURN(status);
++}
++
++/***********************************************************************
++Fill the dynamic table information_schema.innodb_buffer_pool_pages_index. */
++static
++int
++i_s_innodb_buffer_pool_pages_blob_fill(
++/*================*/
++				/* out: 0 on success, 1 on failure */
++	THD*		thd,	/* in: thread */
++	TABLE_LIST*	tables,	/* in/out: tables to fill */
++	COND*		cond)	/* in: condition (ignored) */
++{
++	TABLE*	table	= (TABLE *) tables->table;
++	int	status	= 0;
++	ulint	i;
++
++	ulint		part_len;
++	ulint		next_page_no;
++
++	DBUG_ENTER("i_s_innodb_buffer_pool_pages_blob_fill");
++
++	/* deny access to non-superusers */
++	if (check_global_access(thd, PROCESS_ACL)) {
++
++		DBUG_RETURN(0);
++	}
++
++	RETURN_IF_INNODB_NOT_STARTED(tables->schema_table_name);
++
++	for (i = 0; i < srv_buf_pool_instances; i++) {
++		ulint		n_block;
++		buf_pool_t*	buf_pool;
++
++		buf_pool = buf_pool_from_array(i);
++
++		buf_pool_mutex_enter(buf_pool);
++	
++		for (n_block = 0; n_block < buf_pool->curr_size; n_block++) {
++			buf_block_t*	block = buf_page_from_array(buf_pool, n_block);
++			page_zip_des_t*	block_page_zip = buf_block_get_page_zip(block);
++			const buf_frame_t* frame = block->frame;
++
++			if (fil_page_get_type(frame) == FIL_PAGE_TYPE_BLOB) {
++
++				if (UNIV_LIKELY_NULL(block_page_zip)) {
++					part_len = 0; /* hmm, can't figure it out */
++
++					next_page_no = mach_read_from_4(
++							buf_block_get_frame(block)
++							+ FIL_PAGE_NEXT);        
++				} else {
++					part_len = mach_read_from_4(
++							buf_block_get_frame(block)
++							+ FIL_PAGE_DATA
++							+ 0 /*BTR_BLOB_HDR_PART_LEN*/);
++
++					next_page_no = mach_read_from_4(
++							buf_block_get_frame(block)
++							+ FIL_PAGE_DATA
++							+ 4 /*BTR_BLOB_HDR_NEXT_PAGE_NO*/);
++				}
++
++				table->field[0]->store(block->page.space);
++				table->field[1]->store(block->page.offset);
++				table->field[2]->store(block_page_zip != NULL);
++				table->field[3]->store(part_len);
++
++				if(next_page_no == FIL_NULL)
++				{
++					table->field[4]->store(0);
++				} else {
++					table->field[4]->store(block->page.offset);
++				}
++
++				table->field[5]->store(0);
++				table->field[6]->store(block->page.buf_fix_count);
++				table->field[7]->store(block->page.flush_type);
++
++				if (schema_table_store_record(thd, table)) {
++					status = 1;
++					break;
++				}
++
++			}
++		}      
++
++		buf_pool_mutex_exit(buf_pool);
++	}
++
++	DBUG_RETURN(status);
++}
++
++/***********************************************************************
++Bind the dynamic table information_schema.innodb_buffer_pool_pages. */
++static
++int
++i_s_innodb_buffer_pool_pages_init(
++/*=========*/
++			/* out: 0 on success */
++	void*	p)	/* in/out: table schema object */
++{
++	DBUG_ENTER("i_s_innodb_buffer_pool_pages_init");
++	ST_SCHEMA_TABLE* schema = (ST_SCHEMA_TABLE*) p;
++
++	schema->fields_info = i_s_innodb_buffer_pool_pages_fields_info;
++	schema->fill_table = i_s_innodb_buffer_pool_pages_fill;
++
++	DBUG_RETURN(0);
++}
++
++/***********************************************************************
++Bind the dynamic table information_schema.innodb_buffer_pool_pages. */
++static
++int
++i_s_innodb_buffer_pool_pages_index_init(
++/*=========*/
++			/* out: 0 on success */
++	void*	p)	/* in/out: table schema object */
++{
++	DBUG_ENTER("i_s_innodb_buffer_pool_pages_index_init");
++	ST_SCHEMA_TABLE* schema = (ST_SCHEMA_TABLE*) p;
++
++	schema->fields_info = i_s_innodb_buffer_pool_pages_index_fields_info;
++	schema->fill_table = i_s_innodb_buffer_pool_pages_index_fill;
++
++	DBUG_RETURN(0);
++}
++
++/***********************************************************************
++Bind the dynamic table information_schema.innodb_buffer_pool_pages. */
++static
++int
++i_s_innodb_buffer_pool_pages_blob_init(
++/*=========*/
++			/* out: 0 on success */
++	void*	p)	/* in/out: table schema object */
++{
++	DBUG_ENTER("i_s_innodb_buffer_pool_pages_blob_init");
++	ST_SCHEMA_TABLE* schema = (ST_SCHEMA_TABLE*) p;
++
++	schema->fields_info = i_s_innodb_buffer_pool_pages_blob_fields_info;
++	schema->fill_table = i_s_innodb_buffer_pool_pages_blob_fill;
++
++	DBUG_RETURN(0);
++}
++
++
++UNIV_INTERN struct st_mysql_plugin	i_s_innodb_buffer_pool_pages =
++{
++	/* the plugin type (a MYSQL_XXX_PLUGIN value) */
++	/* int */
++	STRUCT_FLD(type, MYSQL_INFORMATION_SCHEMA_PLUGIN),
++
++	/* pointer to type-specific plugin descriptor */
++	/* void* */
++	STRUCT_FLD(info, &i_s_info),
++
++	/* plugin name */
++	/* const char* */
++	STRUCT_FLD(name, "INNODB_BUFFER_POOL_PAGES"),
++
++	/* plugin author (for SHOW PLUGINS) */
++	/* const char* */
++	STRUCT_FLD(author, plugin_author),
++
++	/* general descriptive text (for SHOW PLUGINS) */
++	/* const char* */
++	STRUCT_FLD(descr, "InnoDB buffer pool pages"),
++
++	/* the plugin license (PLUGIN_LICENSE_XXX) */
++	/* int */
++	STRUCT_FLD(license, PLUGIN_LICENSE_GPL),
++
++	/* the function to invoke when plugin is loaded */
++	/* int (*)(void*); */
++	STRUCT_FLD(init, i_s_innodb_buffer_pool_pages_init),
++
++	/* the function to invoke when plugin is unloaded */
++	/* int (*)(void*); */
++	STRUCT_FLD(deinit, i_s_common_deinit),
++
++	/* plugin version (for SHOW PLUGINS) */
++	/* unsigned int */
++	STRUCT_FLD(version, 0x0100 /* 1.0 */),
++
++	/* struct st_mysql_show_var* */
++	STRUCT_FLD(status_vars, NULL),
++
++	/* struct st_mysql_sys_var** */
++	STRUCT_FLD(system_vars, NULL),
++
++	/* reserved for dependency checking */
++	/* void* */
++	STRUCT_FLD(__reserved1, NULL)
++};
++
++UNIV_INTERN struct st_mysql_plugin	i_s_innodb_buffer_pool_pages_index =
++{
++	/* the plugin type (a MYSQL_XXX_PLUGIN value) */
++	/* int */
++	STRUCT_FLD(type, MYSQL_INFORMATION_SCHEMA_PLUGIN),
++
++	/* pointer to type-specific plugin descriptor */
++	/* void* */
++	STRUCT_FLD(info, &i_s_info),
++
++	/* plugin name */
++	/* const char* */
++	STRUCT_FLD(name, "INNODB_BUFFER_POOL_PAGES_INDEX"),
++
++	/* plugin author (for SHOW PLUGINS) */
++	/* const char* */
++	STRUCT_FLD(author, plugin_author),
++
++	/* general descriptive text (for SHOW PLUGINS) */
++	/* const char* */
++	STRUCT_FLD(descr, "InnoDB buffer pool index pages"),
++
++	/* the plugin license (PLUGIN_LICENSE_XXX) */
++	/* int */
++	STRUCT_FLD(license, PLUGIN_LICENSE_GPL),
++
++	/* the function to invoke when plugin is loaded */
++	/* int (*)(void*); */
++	STRUCT_FLD(init, i_s_innodb_buffer_pool_pages_index_init),
++
++	/* the function to invoke when plugin is unloaded */
++	/* int (*)(void*); */
++	STRUCT_FLD(deinit, i_s_common_deinit),
++
++	/* plugin version (for SHOW PLUGINS) */
++	/* unsigned int */
++	STRUCT_FLD(version, 0x0100 /* 1.0 */),
++
++	/* struct st_mysql_show_var* */
++	STRUCT_FLD(status_vars, NULL),
++
++	/* struct st_mysql_sys_var** */
++	STRUCT_FLD(system_vars, NULL),
++
++	/* reserved for dependency checking */
++	/* void* */
++	STRUCT_FLD(__reserved1, NULL)
++};
++
++UNIV_INTERN struct st_mysql_plugin	i_s_innodb_buffer_pool_pages_blob =
++{
++	/* the plugin type (a MYSQL_XXX_PLUGIN value) */
++	/* int */
++	STRUCT_FLD(type, MYSQL_INFORMATION_SCHEMA_PLUGIN),
++
++	/* pointer to type-specific plugin descriptor */
++	/* void* */
++	STRUCT_FLD(info, &i_s_info),
++
++	/* plugin name */
++	/* const char* */
++	STRUCT_FLD(name, "INNODB_BUFFER_POOL_PAGES_BLOB"),
++
++	/* plugin author (for SHOW PLUGINS) */
++	/* const char* */
++	STRUCT_FLD(author, plugin_author),
++
++	/* general descriptive text (for SHOW PLUGINS) */
++	/* const char* */
++	STRUCT_FLD(descr, "InnoDB buffer pool blob pages"),
++
++	/* the plugin license (PLUGIN_LICENSE_XXX) */
++	/* int */
++	STRUCT_FLD(license, PLUGIN_LICENSE_GPL),
++
++	/* the function to invoke when plugin is loaded */
++	/* int (*)(void*); */
++	STRUCT_FLD(init, i_s_innodb_buffer_pool_pages_blob_init),
++
++	/* the function to invoke when plugin is unloaded */
++	/* int (*)(void*); */
++	STRUCT_FLD(deinit, i_s_common_deinit),
++
++	/* plugin version (for SHOW PLUGINS) */
++	/* unsigned int */
++	STRUCT_FLD(version, 0x0100 /* 1.0 */),
++
++	/* struct st_mysql_show_var* */
++	STRUCT_FLD(status_vars, NULL),
++
++	/* struct st_mysql_sys_var** */
++	STRUCT_FLD(system_vars, NULL),
++
++	/* reserved for dependency checking */
++	/* void* */
++	STRUCT_FLD(__reserved1, NULL)
++};
++
+diff -ruN a/storage/innobase/handler/i_s.h b/storage/innobase/handler/i_s.h
+--- a/storage/innobase/handler/i_s.h	2010-12-04 19:46:39.657513849 +0900
++++ b/storage/innobase/handler/i_s.h	2010-12-06 19:23:47.635192988 +0900
+@@ -45,5 +45,8 @@
+ extern struct st_mysql_plugin	i_s_innodb_table_stats;
+ extern struct st_mysql_plugin	i_s_innodb_index_stats;
+ extern struct st_mysql_plugin	i_s_innodb_admin_command;
++extern struct st_mysql_plugin	i_s_innodb_buffer_pool_pages;
++extern struct st_mysql_plugin	i_s_innodb_buffer_pool_pages_index;
++extern struct st_mysql_plugin	i_s_innodb_buffer_pool_pages_blob;
+ 
+ #endif /* i_s_h */
+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
+@@ -1072,6 +1072,14 @@
+ /*===========*/
+ 	const buf_pool_t*	buf_pool)	/*!< in: buffer pool */
+ 	__attribute__((nonnull, const));
++/********************************************************************//**
++*/
++UNIV_INTERN
++buf_block_t*
++buf_page_from_array(
++/*================*/
++	buf_pool_t*	buf_pool,
++	ulint		n_block);
+ /******************************************************************//**
+ Returns the buffer pool instance given a page instance
+ @return buf_pool */

=== added file 'innodb_buffer_pool_shm.patch'
--- innodb_buffer_pool_shm.patch	1970-01-01 00:00:00 +0000
+++ innodb_buffer_pool_shm.patch	2011-01-10 13:15:57 +0000
@@ -0,0 +1,1224 @@
+# name       : innodb_buffer_pool_shm.patch
+# introduced : 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/buf/buf0buddy.c b/storage/innobase/buf/buf0buddy.c
+--- a/storage/innobase/buf/buf0buddy.c	2010-12-04 19:46:39.372513543 +0900
++++ b/storage/innobase/buf/buf0buddy.c	2010-12-07 17:56:28.302087851 +0900
+@@ -183,7 +183,7 @@
+ 	void*		buf,		/*!< in: buffer frame to deallocate */
+ 	ibool		have_page_hash_mutex)
+ {
+-	const ulint	fold	= BUF_POOL_ZIP_FOLD_PTR(buf);
++	const ulint	fold	= BUF_POOL_ZIP_FOLD_PTR(buf_pool, buf);
+ 	buf_page_t*	bpage;
+ 	buf_block_t*	block;
+ 
+@@ -227,7 +227,7 @@
+ 	buf_block_t*	block)	/*!< in: buffer frame to allocate */
+ {
+ 	buf_pool_t*	buf_pool = buf_pool_from_block(block);
+-	const ulint	fold = BUF_POOL_ZIP_FOLD(block);
++	const ulint	fold = BUF_POOL_ZIP_FOLD(buf_pool, block);
+ 	//ut_ad(buf_pool_mutex_own(buf_pool));
+ 	ut_ad(!mutex_own(&buf_pool->zip_mutex));
+ 	ut_ad(buf_block_get_state(block) == BUF_BLOCK_READY_FOR_USE);
+diff -ruN a/storage/innobase/buf/buf0buf.c b/storage/innobase/buf/buf0buf.c
+--- a/storage/innobase/buf/buf0buf.c	2010-12-06 20:16:21.726195340 +0900
++++ b/storage/innobase/buf/buf0buf.c	2010-12-07 20:40:30.824749814 +0900
+@@ -53,6 +53,10 @@
+ #include "page0zip.h"
+ #include "trx0trx.h"
+ #include "srv0start.h"
++#include "que0que.h"
++#include "read0read.h"
++#include "row0row.h"
++#include "ha_prototypes.h"
+ 
+ /* prototypes for new functions added to ha_innodb.cc */
+ trx_t* innobase_get_trx();
+@@ -342,6 +346,31 @@
+ 					was allocated for the frames */
+ 	buf_block_t*	blocks;		/*!< array of buffer control blocks */
+ };
++
++/* Buffer pool shared memory segment information */
++typedef	struct buf_shm_info_struct	buf_shm_info_t;
++
++struct buf_shm_info_struct {
++	char	head_str[8];
++	ulint	binary_id;
++	ibool	is_new;		/* during initializing */
++	ibool	clean;		/* clean shutdowned and free */
++	ibool	reusable;	/* reusable */
++	ulint	buf_pool_size;	/* backup value */
++	ulint	page_size;	/* backup value */
++	ulint	frame_offset;	/* offset of the first frame based on chunk->mem */
++	ulint	zip_hash_offset;
++	ulint	zip_hash_n;
++
++	ulint	checksum;
++
++	buf_pool_t	buf_pool_backup;
++	buf_chunk_t	chunk_backup;
++
++	ib_uint64_t	dummy;
++};
++
++#define BUF_SHM_INFO_HEAD "XTRA_SHM"
+ #endif /* !UNIV_HOTBACKUP */
+ 
+ /********************************************************************//**
+@@ -988,6 +1017,58 @@
+ #endif /* UNIV_SYNC_DEBUG */
+ }
+ 
++static
++void
++buf_block_reuse(
++/*============*/
++	buf_block_t*	block,
++	ptrdiff_t	frame_offset)
++{
++	/* block_init */
++	block->frame += frame_offset;
++
++	UNIV_MEM_DESC(block->frame, UNIV_PAGE_SIZE, block);
++
++	block->index = NULL;
++	block->btr_search_latch = NULL;
++
++#ifdef UNIV_DEBUG
++	/* recreate later */
++	block->page.in_page_hash = FALSE;
++	block->page.in_zip_hash = FALSE;
++#endif /* UNIV_DEBUG */
++
++#if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
++	block->n_pointers = 0;
++#endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
++
++	if (block->page.zip.data)
++		block->page.zip.data += frame_offset;
++
++	block->is_hashed = FALSE;
++
++#if defined PFS_SKIP_BUFFER_MUTEX_RWLOCK || defined PFS_GROUP_BUFFER_SYNC
++	/* If PFS_SKIP_BUFFER_MUTEX_RWLOCK is defined, skip registration
++	of buffer block mutex/rwlock with performance schema. If
++	PFS_GROUP_BUFFER_SYNC is defined, skip the registration
++	since buffer block mutex/rwlock will be registered later in
++	pfs_register_buffer_block() */
++
++	mutex_create(PFS_NOT_INSTRUMENTED, &block->mutex, SYNC_BUF_BLOCK);
++	rw_lock_create(PFS_NOT_INSTRUMENTED, &block->lock, SYNC_LEVEL_VARYING);
++#else /* PFS_SKIP_BUFFER_MUTEX_RWLOCK || PFS_GROUP_BUFFER_SYNC */
++	mutex_create(buffer_block_mutex_key, &block->mutex, SYNC_BUF_BLOCK);
++	rw_lock_create(buf_block_lock_key, &block->lock, SYNC_LEVEL_VARYING);
++#endif /* PFS_SKIP_BUFFER_MUTEX_RWLOCK || PFS_GROUP_BUFFER_SYNC */
++
++	ut_ad(rw_lock_validate(&(block->lock)));
++
++#ifdef UNIV_SYNC_DEBUG
++	rw_lock_create(buf_block_debug_latch_key,
++		       &block->debug_latch, SYNC_NO_ORDER_CHECK);
++#endif /* UNIV_SYNC_DEBUG */
++}
++
+ /********************************************************************//**
+ Allocates a chunk of buffer frames.
+ @return	chunk, or NULL on failure */
+@@ -1001,26 +1082,188 @@
+ {
+ 	buf_block_t*	block;
+ 	byte*		frame;
++	ulint		zip_hash_n = 0;
++	ulint		zip_hash_mem_size = 0;
++	hash_table_t*	zip_hash_tmp = NULL;
+ 	ulint		i;
++	buf_shm_info_t*	shm_info = NULL;
+ 
+ 	/* Round down to a multiple of page size,
+ 	although it already should be. */
+ 	mem_size = ut_2pow_round(mem_size, UNIV_PAGE_SIZE);
++
++	srv_buffer_pool_shm_is_reused = FALSE;
++
++	if (srv_buffer_pool_shm_key) {
++		/* zip_hash size */
++		zip_hash_n = (mem_size / UNIV_PAGE_SIZE) * 2;
++		zip_hash_mem_size = ut_2pow_round(hash_create_needed(zip_hash_n)
++						  + (UNIV_PAGE_SIZE - 1), UNIV_PAGE_SIZE);
++	}
++
+ 	/* Reserve space for the block descriptors. */
+ 	mem_size += ut_2pow_round((mem_size / UNIV_PAGE_SIZE) * (sizeof *block)
+ 				  + (UNIV_PAGE_SIZE - 1), UNIV_PAGE_SIZE);
++	if (srv_buffer_pool_shm_key) {
++		 mem_size += ut_2pow_round(sizeof(buf_shm_info_t)
++					   + (UNIV_PAGE_SIZE - 1), UNIV_PAGE_SIZE);
++		 mem_size += zip_hash_mem_size;
++	}
+ 
+ 	chunk->mem_size = mem_size;
++
++	if (srv_buffer_pool_shm_key) {
++		ulint	binary_id;
++		ibool	is_new;
++
++		ut_a(buf_pool->n_chunks == 1);
++
++		fprintf(stderr,
++		"InnoDB: Warning: The innodb_buffer_pool_shm_key option has been specified.\n"
++		"InnoDB: Do not change the following between restarts of the server while this option is being used:\n"
++		"InnoDB:   * the mysqld executable between restarts of the server.\n"
++		"InnoDB:   * the value of innodb_buffer_pool_size.\n"
++		"InnoDB:   * the value of innodb_page_size.\n"
++		"InnoDB:   * datafiles created by InnoDB during this session.\n"
++		"InnoDB: Otherwise, data corruption in datafiles may result.\n");
++
++		/* FIXME: This is vague id still */
++		binary_id = (ulint) ((byte*)mtr_commit - (byte*)btr_root_get)
++			  + (ulint) ((byte*)os_get_os_version - (byte*)buf_calc_page_new_checksum)
++			  + (ulint) ((byte*)page_dir_find_owner_slot - (byte*)dfield_data_is_binary_equal)
++			  + (ulint) ((byte*)que_graph_publish - (byte*)dict_casedn_str)
++			  + (ulint) ((byte*)read_view_oldest_copy_or_open_new - (byte*)fil_space_get_version)
++			  + (ulint) ((byte*)rec_get_n_extern_new - (byte*)fsp_get_size_low)
++			  + (ulint) ((byte*)row_get_trx_id_offset - (byte*)ha_create_func)
++			  + (ulint) ((byte*)srv_set_io_thread_op_info - (byte*)thd_is_replication_slave_thread)
++			  + (ulint) ((byte*)mutex_create_func - (byte*)ibuf_inside)
++			  + (ulint) ((byte*)trx_set_detailed_error - (byte*)lock_check_trx_id_sanity)
++			  + (ulint) ((byte*)ut_time - (byte*)mem_heap_strdup);
++
++		chunk->mem = os_shm_alloc(&chunk->mem_size, srv_buffer_pool_shm_key, &is_new);
++
++		if (UNIV_UNLIKELY(chunk->mem == NULL)) {
++			return(NULL);
++		}
++init_again:
++#ifdef UNIV_SET_MEM_TO_ZERO
++		if (is_new) {
++			memset(chunk->mem, '\0', chunk->mem_size);
++		}
++#endif
++		/* for ut_fold_binary_32(), these values should be 32-bit aligned */
++		ut_a(sizeof(buf_shm_info_t) % 4 == 0);
++		ut_a((ulint)chunk->mem % 4 == 0);
++		ut_a(chunk->mem_size % 4 == 0);
++
++		shm_info = chunk->mem;
++
++		zip_hash_tmp = (hash_table_t*)((byte*)chunk->mem + chunk->mem_size - zip_hash_mem_size);
++
++		if (is_new) {
++			strncpy(shm_info->head_str, BUF_SHM_INFO_HEAD, 8);
++			shm_info->binary_id = binary_id;
++			shm_info->is_new = TRUE;	/* changed to FALSE when the initialization is finished */
++			shm_info->clean = FALSE;	/* changed to TRUE when free the segment. */
++			shm_info->reusable = FALSE;	/* changed to TRUE when validation is finished. */
++			shm_info->buf_pool_size = srv_buf_pool_size;
++			shm_info->page_size = srv_page_size;
++			shm_info->zip_hash_offset = chunk->mem_size - zip_hash_mem_size;
++			shm_info->zip_hash_n = zip_hash_n;
++		} else {
++			ulint	checksum;
++
++			if (strncmp(shm_info->head_str, BUF_SHM_INFO_HEAD, 8)) {
++				fprintf(stderr,
++				"InnoDB: Error: The shared memory segment seems not to be for buffer pool.\n");
++				return(NULL);
++			}
++			if (shm_info->binary_id != binary_id) {
++				fprintf(stderr,
++				"InnoDB: Error: The shared memory segment seems not to be for this binary.\n");
++				return(NULL);
++			}
++			if (shm_info->is_new) {
++				fprintf(stderr,
++				"InnoDB: Error: The shared memory was not initialized yet.\n");
++				return(NULL);
++			}
++			if (shm_info->buf_pool_size != srv_buf_pool_size) {
++				fprintf(stderr,
++				"InnoDB: Error: srv_buf_pool_size is different (shm=%lu current=%lu).\n",
++				shm_info->buf_pool_size, srv_buf_pool_size);
++				return(NULL);
++			}
++			if (shm_info->page_size != srv_page_size) {
++				fprintf(stderr,
++				"InnoDB: Error: srv_page_size is different (shm=%lu current=%lu).\n",
++				shm_info->page_size, srv_page_size);
++				return(NULL);
++			}
++			if (!shm_info->reusable) {
++				fprintf(stderr,
++				"InnoDB: Warning: The shared memory has unrecoverable contents.\n"
++				"InnoDB: The shared memory segment is initialized.\n");
++				is_new = TRUE;
++				goto init_again;
++			}
++			if (!shm_info->clean) {
++				fprintf(stderr,
++				"InnoDB: Warning: The shared memory was not shut down cleanly.\n"
++				"InnoDB: The shared memory segment is initialized.\n");
++				is_new = TRUE;
++				goto init_again;
++			}
++
++			ut_a(shm_info->zip_hash_offset == chunk->mem_size - zip_hash_mem_size);
++			ut_a(shm_info->zip_hash_n == zip_hash_n);
++
++			/* check checksum */
++			if (srv_buffer_pool_shm_checksum) {
++				checksum = ut_fold_binary_32((byte*)chunk->mem + sizeof(buf_shm_info_t),
++							     chunk->mem_size - sizeof(buf_shm_info_t));
++			} else {
++				checksum = BUF_NO_CHECKSUM_MAGIC;
++			}
++
++			if (shm_info->checksum != BUF_NO_CHECKSUM_MAGIC
++			    && shm_info->checksum != checksum) {
++				fprintf(stderr,
++				"InnoDB: Error: checksum of the shared memory is not match. "
++				"(stored=%lu calculated=%lu)\n",
++				shm_info->checksum, checksum);
++				return(NULL);
++			}
++
++			/* flag to use the segment. */
++			shm_info->clean = FALSE;	/* changed to TRUE when free the segment. */
++		}
++
++		/* init zip_hash contents */
++		if (is_new) {
++			hash_create_init(zip_hash_tmp, zip_hash_n);
++		} else {
++			/* adjust offset is done later */
++			hash_create_reuse(zip_hash_tmp);
++
++			srv_buffer_pool_shm_is_reused = TRUE;
++		}
++	} else {
+ 	chunk->mem = os_mem_alloc_large(&chunk->mem_size);
+ 
+ 	if (UNIV_UNLIKELY(chunk->mem == NULL)) {
+ 
+ 		return(NULL);
+ 	}
++	}
+ 
+ 	/* Allocate the block descriptors from
+ 	the start of the memory block. */
++	if (srv_buffer_pool_shm_key) {
++		chunk->blocks = (buf_block_t*)((byte*)chunk->mem + sizeof(buf_shm_info_t));
++	} else {
+ 	chunk->blocks = chunk->mem;
++	}
+ 
+ 	/* Align a pointer to the first frame.  Note that when
+ 	os_large_page_size is smaller than UNIV_PAGE_SIZE,
+@@ -1028,8 +1271,13 @@
+ 	it is bigger, we may allocate more blocks than requested. */
+ 
+ 	frame = ut_align(chunk->mem, UNIV_PAGE_SIZE);
++	if (srv_buffer_pool_shm_key) {
++		/* reserve zip_hash space and always -1 for reproductibity */
++		chunk->size = (chunk->mem_size - zip_hash_mem_size) / UNIV_PAGE_SIZE - 1;
++	} else {
+ 	chunk->size = chunk->mem_size / UNIV_PAGE_SIZE
+ 		- (frame != chunk->mem);
++	}
+ 
+ 	/* Subtract the space needed for block descriptors. */
+ 	{
+@@ -1043,6 +1291,98 @@
+ 		chunk->size = size;
+ 	}
+ 
++	if (shm_info && !(shm_info->is_new)) {
++		/* convert the shared memory segment for reuse */
++		ptrdiff_t	phys_offset;
++		ptrdiff_t	logi_offset;
++		ptrdiff_t	blocks_offset;
++		void*		previous_frame_address;
++
++		if (chunk->size < shm_info->chunk_backup.size) {
++			fprintf(stderr,
++			"InnoDB: Error: The buffer pool became smaller because of allocated address.\n"
++			"InnoDB: Retrying may avoid this situation.\n");
++			shm_info->clean = TRUE; /* release the flag for retrying */
++			return(NULL);
++		}
++
++		chunk->size = shm_info->chunk_backup.size;
++		phys_offset = frame - ((byte*)chunk->mem + shm_info->frame_offset);
++		logi_offset = frame - chunk->blocks[0].frame;
++		previous_frame_address = chunk->blocks[0].frame;
++		blocks_offset = (byte*)chunk->blocks - (byte*)shm_info->chunk_backup.blocks;
++
++		if (phys_offset || logi_offset || blocks_offset) {
++			fprintf(stderr,
++			"InnoDB: Buffer pool in the shared memory segment should be converted.\n"
++			"InnoDB: Previous frames in address      : %p\n"
++			"InnoDB: Previous frames were located    : %p\n"
++			"InnoDB: Current frames should be located: %p\n"
++			"InnoDB: Pysical offset                  : %ld (%#lx)\n"
++			"InnoDB: Logical offset (frames)         : %ld (%#lx)\n"
++			"InnoDB: Logical offset (blocks)         : %ld (%#lx)\n",
++				(byte*)chunk->mem + shm_info->frame_offset,
++				chunk->blocks[0].frame, frame,
++				phys_offset, phys_offset, logi_offset, logi_offset,
++				blocks_offset, blocks_offset);
++		} else {
++			fprintf(stderr,
++			"InnoDB: Buffer pool in the shared memory segment can be used as it is.\n");
++		}
++
++		if (phys_offset) {
++			fprintf(stderr,
++			"InnoDB: Aligning physical offset...");
++
++			memmove(frame, (byte*)chunk->mem + shm_info->frame_offset,
++				chunk->size * UNIV_PAGE_SIZE);
++
++			fprintf(stderr,
++			" Done.\n");
++		}
++
++		/* buf_block_t */
++		block = chunk->blocks;
++		for (i = chunk->size; i--; ) {
++			buf_block_reuse(block, logi_offset);
++			block++;
++		}
++
++		if (logi_offset || blocks_offset) {
++			fprintf(stderr,
++			"InnoDB: Aligning logical offset...");
++
++
++			/* buf_pool_t buf_pool_backup */
++			UT_LIST_OFFSET(flush_list, buf_page_t, shm_info->buf_pool_backup.flush_list,
++					previous_frame_address, logi_offset, blocks_offset);
++			UT_LIST_OFFSET(free, buf_page_t, shm_info->buf_pool_backup.free,
++					previous_frame_address, logi_offset, blocks_offset);
++			UT_LIST_OFFSET(LRU, buf_page_t, shm_info->buf_pool_backup.LRU,
++					previous_frame_address, logi_offset, blocks_offset);
++			if (shm_info->buf_pool_backup.LRU_old)
++				shm_info->buf_pool_backup.LRU_old =
++					(buf_page_t*)((byte*)(shm_info->buf_pool_backup.LRU_old)
++						+ (((void*)shm_info->buf_pool_backup.LRU_old > previous_frame_address)
++						  ? logi_offset : blocks_offset));
++
++			UT_LIST_OFFSET(unzip_LRU, buf_block_t, shm_info->buf_pool_backup.unzip_LRU,
++					previous_frame_address, logi_offset, blocks_offset);
++
++			UT_LIST_OFFSET(zip_list, buf_page_t, shm_info->buf_pool_backup.zip_clean,
++					previous_frame_address, logi_offset, blocks_offset);
++			for (i = 0; i < BUF_BUDDY_SIZES_MAX; i++) {
++				UT_LIST_OFFSET(zip_list, buf_page_t, shm_info->buf_pool_backup.zip_free[i],
++					previous_frame_address, logi_offset, blocks_offset);
++			}
++
++			HASH_OFFSET(zip_hash_tmp, buf_page_t, hash,
++					previous_frame_address, logi_offset, blocks_offset);
++
++			fprintf(stderr,
++			" Done.\n");
++		}
++	} else {
+ 	/* Init block structs and assign frames for them. Then we
+ 	assign the frames to the first blocks (we already mapped the
+ 	memory above). */
+@@ -1068,6 +1408,11 @@
+ 		block++;
+ 		frame += UNIV_PAGE_SIZE;
+ 	}
++	}
++
++	if (shm_info) {
++		shm_info->frame_offset = chunk->blocks[0].frame - (byte*)chunk->mem;
++	}
+ 
+ #ifdef PFS_GROUP_BUFFER_SYNC
+ 	pfs_register_buffer_block(chunk);
+@@ -1249,6 +1594,8 @@
+ 		UNIV_MEM_UNDESC(block);
+ 	}
+ 
++	ut_a(!srv_buffer_pool_shm_key);
++
+ 	os_mem_free_large(chunk->mem, chunk->mem_size);
+ }
+ 
+@@ -1289,7 +1636,7 @@
+ 	ulint		instance_no)	/*!< in: id of the instance */
+ {
+ 	ulint		i;
+-	buf_chunk_t*	chunk;
++	buf_chunk_t*	chunk = NULL;
+ 
+ 	/* 1. Initialize general fields
+ 	------------------------------- */
+@@ -1335,7 +1682,10 @@
+ 		buf_pool->curr_pool_size = buf_pool->curr_size * UNIV_PAGE_SIZE;
+ 
+ 		buf_pool->page_hash = hash_create(2 * buf_pool->curr_size);
++		/* zip_hash is allocated to shm when srv_buffer_pool_shm_key is enabled */
++		if (!srv_buffer_pool_shm_key) {
+ 		buf_pool->zip_hash = hash_create(2 * buf_pool->curr_size);
++		}
+ 		
+ 		buf_pool->last_printout_time = ut_time();
+ 	}
+@@ -1354,6 +1704,86 @@
+ 
+ 	/* All fields are initialized by mem_zalloc(). */
+ 
++	if (chunk && srv_buffer_pool_shm_key) {
++		buf_shm_info_t*	shm_info;
++
++		ut_a((byte*)chunk->blocks == (byte*)chunk->mem + sizeof(buf_shm_info_t));
++		shm_info = chunk->mem;
++
++		buf_pool->zip_hash = (hash_table_t*)((byte*)chunk->mem + shm_info->zip_hash_offset);
++
++		if(shm_info->is_new) {
++			shm_info->is_new = FALSE; /* initialization was finished */
++		} else {
++			buf_block_t*	block = chunk->blocks;
++			buf_page_t*	b;
++
++			/* shm_info->buf_pool_backup should be converted */
++			/* at buf_chunk_init(). So copy simply. */
++			buf_pool->flush_list 		= shm_info->buf_pool_backup.flush_list;
++			buf_pool->freed_page_clock 	= shm_info->buf_pool_backup.freed_page_clock;
++			buf_pool->free			= shm_info->buf_pool_backup.free;
++			buf_pool->LRU			= shm_info->buf_pool_backup.LRU;
++			buf_pool->LRU_old		= shm_info->buf_pool_backup.LRU_old;
++			buf_pool->LRU_old_len		= shm_info->buf_pool_backup.LRU_old_len;
++			buf_pool->unzip_LRU		= shm_info->buf_pool_backup.unzip_LRU;
++			buf_pool->zip_clean		= shm_info->buf_pool_backup.zip_clean;
++			for (i = 0; i < BUF_BUDDY_SIZES_MAX; i++) {
++				buf_pool->zip_free[i]	= shm_info->buf_pool_backup.zip_free[i];
++			}
++
++			for (i = 0; i < chunk->size; i++, block++) {
++				if (buf_block_get_state(block)
++				    == BUF_BLOCK_FILE_PAGE) {
++					ut_d(block->page.in_page_hash = TRUE);
++					HASH_INSERT(buf_page_t, hash, buf_pool->page_hash,
++						    buf_page_address_fold(
++							    block->page.space,
++							    block->page.offset),
++						    &block->page);
++				}
++			}
++
++			for (b = UT_LIST_GET_FIRST(buf_pool->zip_clean); b;
++			     b = UT_LIST_GET_NEXT(zip_list, b)) {
++				ut_ad(!b->in_flush_list);
++				ut_ad(b->in_LRU_list);
++
++				ut_d(b->in_page_hash = TRUE);
++				HASH_INSERT(buf_page_t, hash, buf_pool->page_hash,
++					    buf_page_address_fold(b->space, b->offset), b);
++			}
++
++			for (b = UT_LIST_GET_FIRST(buf_pool->flush_list); b;
++			     b = UT_LIST_GET_NEXT(flush_list, b)) {
++				ut_ad(b->in_flush_list);
++				ut_ad(b->in_LRU_list);
++
++				switch (buf_page_get_state(b)) {
++				case BUF_BLOCK_ZIP_DIRTY:
++					ut_d(b->in_page_hash = TRUE);
++					HASH_INSERT(buf_page_t, hash, buf_pool->page_hash,
++						    buf_page_address_fold(b->space,
++							    		  b->offset), b);
++					break;
++				case BUF_BLOCK_FILE_PAGE:
++					/* uncompressed page */
++					break;
++				case BUF_BLOCK_ZIP_FREE:
++				case BUF_BLOCK_ZIP_PAGE:
++				case BUF_BLOCK_NOT_USED:
++				case BUF_BLOCK_READY_FOR_USE:
++				case BUF_BLOCK_MEMORY:
++				case BUF_BLOCK_REMOVE_HASH:
++					ut_error;
++					break;
++				}
++			}
++
++
++		}
++	}
++
+ 	mutex_exit(&buf_pool->LRU_list_mutex);
+ 	rw_lock_x_unlock(&buf_pool->page_hash_latch);
+ 	buf_pool_mutex_exit(buf_pool);
+@@ -1373,6 +1803,42 @@
+ 	buf_chunk_t*	chunk;
+ 	buf_chunk_t*	chunks;
+ 
++	if (srv_buffer_pool_shm_key) {
++		buf_shm_info_t*	shm_info;
++
++		ut_a(buf_pool->n_chunks == 1);
++
++		chunk = buf_pool->chunks;
++		shm_info = chunk->mem;
++		ut_a((byte*)chunk->blocks == (byte*)chunk->mem + sizeof(buf_shm_info_t));
++
++		/* if opened, close shm. */
++		if (!shm_info->clean) {
++			/* validation the shared memory segment doesn't have unrecoverable contents. */
++			/* Currently, validation became not needed */
++			shm_info->reusable = TRUE;
++
++			memcpy(&(shm_info->buf_pool_backup), buf_pool, sizeof(buf_pool_t));
++			memcpy(&(shm_info->chunk_backup), chunk, sizeof(buf_chunk_t));
++
++			if (srv_fast_shutdown < 2) {
++				if (srv_buffer_pool_shm_checksum) {
++					shm_info->checksum =
++						ut_fold_binary_32(
++							(byte*)chunk->mem + sizeof(buf_shm_info_t),
++							chunk->mem_size - sizeof(buf_shm_info_t));
++				} else {
++					shm_info->checksum = BUF_NO_CHECKSUM_MAGIC;
++				}
++				shm_info->clean = TRUE;
++			}
++
++			fprintf(stderr,
++				"InnoDB: The shared memory was closed.\n");
++		}
++
++		os_shm_free(chunk->mem, chunk->mem_size);
++	} else {
+ 	chunks = buf_pool->chunks;
+ 	chunk = chunks + buf_pool->n_chunks;
+ 
+@@ -1381,10 +1847,13 @@
+ 		would fail at shutdown. */
+ 		os_mem_free_large(chunk->mem, chunk->mem_size);
+ 	}
++	}
+ 
+ 	mem_free(buf_pool->chunks);
+ 	hash_table_free(buf_pool->page_hash);
++	if (!srv_buffer_pool_shm_key) {
+ 	hash_table_free(buf_pool->zip_hash);
++	}
+ }
+ 
+ /********************************************************************//**
+@@ -1668,6 +2137,11 @@
+ 	//buf_pool_mutex_enter(buf_pool);
+ 	mutex_enter(&buf_pool->LRU_list_mutex);
+ 
++	if (srv_buffer_pool_shm_key) {
++		/* Cannot support shrink */
++		goto func_done;
++	}
++
+ shrink_again:
+ 	if (buf_pool->n_chunks <= 1) {
+ 
+@@ -1848,7 +2322,7 @@
+ 	zip_hash = hash_create(2 * buf_pool->curr_size);
+ 
+ 	HASH_MIGRATE(buf_pool->zip_hash, zip_hash, buf_page_t, hash,
+-		     BUF_POOL_ZIP_FOLD_BPAGE);
++		     buf_pool, BUF_POOL_ZIP_FOLD_BPAGE);
+ 
+ 	hash_table_free(buf_pool->zip_hash);
+ 	buf_pool->zip_hash = zip_hash;
+@@ -2130,6 +2604,11 @@
+ 	ulint	change_size;
+ 	ulint	min_change_size = 1048576 * srv_buf_pool_instances;
+ 
++	if (srv_buffer_pool_shm_key) {
++		/* Cannot support resize */
++		return;
++	}
++
+ 	buf_pool_mutex_enter_all();
+   
+   	if (srv_buf_pool_old_size == srv_buf_pool_size) {
+diff -ruN a/storage/innobase/ha/hash0hash.c b/storage/innobase/ha/hash0hash.c
+--- a/storage/innobase/ha/hash0hash.c	2010-11-03 07:01:13.000000000 +0900
++++ b/storage/innobase/ha/hash0hash.c	2010-12-07 16:10:14.937749140 +0900
+@@ -133,6 +133,70 @@
+ }
+ 
+ /*************************************************************//**
++*/
++UNIV_INTERN
++ulint
++hash_create_needed(
++/*===============*/
++	ulint	n)
++{
++	ulint	prime;
++	ulint	offset;
++
++	prime = ut_find_prime(n);
++
++	offset = (sizeof(hash_table_t) + 7) / 8;
++	offset *= 8;
++
++	return(offset + sizeof(hash_cell_t) * prime);
++}
++
++UNIV_INTERN
++void
++hash_create_init(
++/*=============*/
++	hash_table_t*	table,
++	ulint		n)
++{
++	ulint	prime;
++	ulint	offset;
++
++	prime = ut_find_prime(n);
++
++	offset = (sizeof(hash_table_t) + 7) / 8;
++	offset *= 8;
++
++	table->array = (hash_cell_t*)(((byte*)table) + offset);
++	table->n_cells = prime;
++# if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
++	table->adaptive = FALSE;
++# endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
++	table->n_mutexes = 0;
++	table->mutexes = NULL;
++	table->heaps = NULL;
++	table->heap = NULL;
++	ut_d(table->magic_n = HASH_TABLE_MAGIC_N);
++
++	/* Initialize the cell array */
++	hash_table_clear(table);
++}
++
++UNIV_INTERN
++void
++hash_create_reuse(
++/*==============*/
++	hash_table_t*	table)
++{
++	ulint	offset;
++
++	offset = (sizeof(hash_table_t) + 7) / 8;
++	offset *= 8;
++
++	table->array = (hash_cell_t*)(((byte*)table) + offset);
++	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
++}
++
++/*************************************************************//**
+ Frees a hash table. */
+ UNIV_INTERN
+ void
+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-06 20:16:21.733263627 +0900
++++ b/storage/innobase/handler/ha_innodb.cc	2010-12-07 17:56:28.316139830 +0900
+@@ -194,6 +194,7 @@
+ static my_bool	innobase_create_status_file		= FALSE;
+ static my_bool	innobase_stats_on_metadata		= TRUE;
+ static my_bool	innobase_use_sys_stats_table		= FALSE;
++static my_bool	innobase_buffer_pool_shm_checksum	= TRUE;
+ 
+ 
+ static char*	internal_innobase_data_file_path	= NULL;
+@@ -2618,6 +2619,14 @@
+ 	srv_buf_pool_size = (ulint) innobase_buffer_pool_size;
+ 	srv_buf_pool_instances = (ulint) innobase_buffer_pool_instances;
+ 
++	if (srv_buffer_pool_shm_key && srv_buf_pool_instances > 1) {
++		fprintf(stderr,
++			"InnoDB: Warning: innodb_buffer_pool_shm_key cannot be used with several innodb_buffer_pool_instances.\n"
++			"InnoDB:          innodb_buffer_pool_instances was set to 1.\n");
++		srv_buf_pool_instances = 1;
++		innobase_buffer_pool_instances = 1;
++	}
++
+ 	srv_mem_pool_size = (ulint) innobase_additional_mem_pool_size;
+ 
+ 	srv_n_file_io_threads = (ulint) innobase_file_io_threads;
+@@ -2634,6 +2643,7 @@
+ 	srv_use_doublewrite_buf = (ibool) innobase_use_doublewrite;
+ 	srv_use_checksums = (ibool) innobase_use_checksums;
+ 	srv_fast_checksum = (ibool) innobase_fast_checksum;
++	srv_buffer_pool_shm_checksum = (ibool) innobase_buffer_pool_shm_checksum;
+ 
+ #ifdef HAVE_LARGE_PAGES
+         if ((os_use_large_pages = (ibool) my_use_large_pages))
+@@ -11634,6 +11644,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);
+ 
++static MYSQL_SYSVAR_UINT(buffer_pool_shm_key, srv_buffer_pool_shm_key,
++  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
++  "[experimental] The key value of shared memory segment for the buffer pool. 0 (default) disables the feature.",
++  NULL, NULL, 0, 0, INT_MAX32, 0);
++
++static MYSQL_SYSVAR_BOOL(buffer_pool_shm_checksum, innobase_buffer_pool_shm_checksum,
++  PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
++  "Enable buffer_pool_shm checksum validation (enabled by default).",
++  NULL, NULL, TRUE);
++
+ static MYSQL_SYSVAR_ULONG(commit_concurrency, innobase_commit_concurrency,
+   PLUGIN_VAR_RQCMDARG,
+   "Helps in performance tuning in heavily concurrent environments.",
+@@ -11915,6 +11935,8 @@
+   MYSQL_SYSVAR(autoextend_increment),
+   MYSQL_SYSVAR(buffer_pool_size),
+   MYSQL_SYSVAR(buffer_pool_instances),
++  MYSQL_SYSVAR(buffer_pool_shm_key),
++  MYSQL_SYSVAR(buffer_pool_shm_checksum),
+   MYSQL_SYSVAR(checksums),
+   MYSQL_SYSVAR(fast_checksum),
+   MYSQL_SYSVAR(commit_concurrency),
+diff -ruN a/storage/innobase/include/buf0buf.h b/storage/innobase/include/buf0buf.h
+--- a/storage/innobase/include/buf0buf.h	2010-12-06 20:16:21.778264552 +0900
++++ b/storage/innobase/include/buf0buf.h	2010-12-07 17:56:28.322749380 +0900
+@@ -36,6 +36,7 @@
+ #ifndef UNIV_HOTBACKUP
+ #include "ut0rbt.h"
+ #include "os0proc.h"
++#include "srv0srv.h"
+ 
+ /** @name Modes for buf_page_get_gen */
+ /* @{ */
+@@ -1520,9 +1521,12 @@
+ /**********************************************************************//**
+ Compute the hash fold value for blocks in buf_pool->zip_hash. */
+ /* @{ */
+-#define BUF_POOL_ZIP_FOLD_PTR(ptr) ((ulint) (ptr) / UNIV_PAGE_SIZE)
+-#define BUF_POOL_ZIP_FOLD(b) BUF_POOL_ZIP_FOLD_PTR((b)->frame)
+-#define BUF_POOL_ZIP_FOLD_BPAGE(b) BUF_POOL_ZIP_FOLD((buf_block_t*) (b))
++/* the fold should be relative when srv_buffer_pool_shm_key is enabled */
++#define BUF_POOL_ZIP_FOLD_PTR(bpool, ptr) (!srv_buffer_pool_shm_key\
++					?((ulint) (ptr) / UNIV_PAGE_SIZE)\
++					:((ulint) ((byte*)ptr - (byte*)(buf_page_from_array(bpool, 0)->frame)) / UNIV_PAGE_SIZE))
++#define BUF_POOL_ZIP_FOLD(bpool, b) BUF_POOL_ZIP_FOLD_PTR(bpool, (b)->frame)
++#define BUF_POOL_ZIP_FOLD_BPAGE(bpool, b) BUF_POOL_ZIP_FOLD(bpool, (buf_block_t*) (b))
+ /* @} */
+ 
+ /** @brief The buffer pool statistics structure. */
+diff -ruN a/storage/innobase/include/hash0hash.h b/storage/innobase/include/hash0hash.h
+--- a/storage/innobase/include/hash0hash.h	2010-11-03 07:01:13.000000000 +0900
++++ b/storage/innobase/include/hash0hash.h	2010-12-07 17:56:28.324726446 +0900
+@@ -49,6 +49,28 @@
+ hash_create(
+ /*========*/
+ 	ulint	n);	/*!< in: number of array cells */
++
++/*************************************************************//**
++*/
++UNIV_INTERN
++ulint
++hash_create_needed(
++/*===============*/
++	ulint	n);
++
++UNIV_INTERN
++void
++hash_create_init(
++/*=============*/
++	hash_table_t*	table,
++	ulint		n);
++
++UNIV_INTERN
++void
++hash_create_reuse(
++/*==============*/
++	hash_table_t*	table);
++
+ #ifndef UNIV_HOTBACKUP
+ /*************************************************************//**
+ Creates a mutex array to protect a hash table. */
+@@ -306,7 +328,7 @@
+ /****************************************************************//**
+ Move all hash table entries from OLD_TABLE to NEW_TABLE. */
+ 
+-#define HASH_MIGRATE(OLD_TABLE, NEW_TABLE, NODE_TYPE, PTR_NAME, FOLD_FUNC) \
++#define HASH_MIGRATE(OLD_TABLE, NEW_TABLE, NODE_TYPE, PTR_NAME, BPOOL, FOLD_FUNC) \
+ do {\
+ 	ulint		i2222;\
+ 	ulint		cell_count2222;\
+@@ -318,7 +340,7 @@
+ \
+ 		while (node2222) {\
+ 			NODE_TYPE*	next2222 = node2222->PTR_NAME;\
+-			ulint		fold2222 = FOLD_FUNC(node2222);\
++			ulint		fold2222 = FOLD_FUNC(BPOOL, node2222);\
+ \
+ 			HASH_INSERT(NODE_TYPE, PTR_NAME, (NEW_TABLE),\
+ 				fold2222, node2222);\
+@@ -327,6 +349,33 @@
+ 		}\
+ 	}\
+ } while (0)
++
++/********************************************************************//**
++Align nodes with moving location.*/
++#define HASH_OFFSET(TABLE, NODE_TYPE, PTR_NAME, FADDR, FOFFSET, BOFFSET) \
++do {\
++	ulint		i2222;\
++	ulint		cell_count2222;\
++\
++	cell_count2222 = hash_get_n_cells(TABLE);\
++\
++	for (i2222 = 0; i2222 < cell_count2222; i2222++) {\
++		NODE_TYPE*	node2222;\
++\
++		if ((TABLE)->array[i2222].node) \
++			(TABLE)->array[i2222].node = (void*)((byte*)(TABLE)->array[i2222].node \
++			+ (((TABLE)->array[i2222].node > (void*)FADDR)?FOFFSET:BOFFSET));\
++		node2222 = HASH_GET_FIRST((TABLE), i2222);\
++\
++		while (node2222) {\
++			if (node2222->PTR_NAME) \
++				node2222->PTR_NAME = (void*)((byte*)(node2222->PTR_NAME) \
++				+ ((((void*)node2222->PTR_NAME) > (void*)FADDR)?FOFFSET:BOFFSET));\
++\
++			node2222 = node2222->PTR_NAME;\
++		}\
++	}\
++} while (0)
+ 
+ /************************************************************//**
+ Gets the mutex index for a fold value in a hash table.
+diff -ruN a/storage/innobase/include/os0proc.h b/storage/innobase/include/os0proc.h
+--- a/storage/innobase/include/os0proc.h	2010-11-03 07:01:13.000000000 +0900
++++ b/storage/innobase/include/os0proc.h	2010-12-07 16:10:14.955718750 +0900
+@@ -32,6 +32,11 @@
+ #ifdef UNIV_LINUX
+ #include <sys/ipc.h>
+ #include <sys/shm.h>
++#else
++# if defined HAVE_SYS_IPC_H && HAVE_SYS_SHM_H
++#include <sys/ipc.h>
++#include <sys/shm.h>
++# endif
+ #endif
+ 
+ typedef void*			os_process_t;
+@@ -70,6 +75,29 @@
+ 	ulint	size);			/*!< in: size returned by
+ 					os_mem_alloc_large() */
+ 
++
++/****************************************************************//**
++Allocates or attaches and reuses shared memory segment.
++The content is not cleared automatically.
++@return	allocated memory */
++UNIV_INTERN
++void*
++os_shm_alloc(
++/*=========*/
++	ulint*	n,			/*!< in/out: number of bytes */
++	uint	key,
++	ibool*	is_new);
++
++/****************************************************************//**
++Detach shared memory segment. */
++UNIV_INTERN
++void
++os_shm_free(
++/*========*/
++	void	*ptr,			/*!< in: pointer returned by
++					os_shm_alloc() */
++	ulint	size);			/*!< in: size returned by
++					os_shm_alloc() */
+ #ifndef UNIV_NONINL
+ #include "os0proc.ic"
+ #endif
+diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
+--- a/storage/innobase/include/srv0srv.h	2010-12-04 20:20:28.016566697 +0900
++++ b/storage/innobase/include/srv0srv.h	2010-12-07 16:10:14.956717659 +0900
+@@ -170,6 +170,10 @@
+ extern ulint	srv_mem_pool_size;
+ extern ulint	srv_lock_table_size;
+ 
++extern uint	srv_buffer_pool_shm_key;
++extern ibool	srv_buffer_pool_shm_is_reused;
++extern ibool	srv_buffer_pool_shm_checksum;
++
+ extern ibool	srv_thread_concurrency_timer_based;
+ 
+ extern ulint	srv_n_file_io_threads;
+diff -ruN a/storage/innobase/include/ut0lst.h b/storage/innobase/include/ut0lst.h
+--- a/storage/innobase/include/ut0lst.h	2010-11-03 07:01:13.000000000 +0900
++++ b/storage/innobase/include/ut0lst.h	2010-12-07 16:10:14.957785525 +0900
+@@ -257,5 +257,48 @@
+ 	ut_a(ut_list_node_313 == NULL);					\
+ } while (0)
+ 
++/********************************************************************//**
++Align nodes with moving location.
++@param NAME		the name of the list
++@param TYPE		node type
++@param BASE		base node (not a pointer to it)
++@param OFFSET		offset moved */
++#define UT_LIST_OFFSET(NAME, TYPE, BASE, FADDR, FOFFSET, BOFFSET)	\
++do {									\
++	ulint	ut_list_i_313;						\
++	TYPE*	ut_list_node_313;					\
++									\
++	if ((BASE).start)						\
++		(BASE).start = (void*)((byte*)((BASE).start)			\
++			+ (((void*)((BASE).start) > (void*)FADDR)?FOFFSET:BOFFSET));\
++	if ((BASE).end)							\
++		(BASE).end   = (void*)((byte*)((BASE).end)			\
++			+ (((void*)((BASE).end) > (void*)FADDR)?FOFFSET:BOFFSET));\
++									\
++	ut_list_node_313 = (BASE).start;				\
++									\
++	for (ut_list_i_313 = (BASE).count; ut_list_i_313--; ) {		\
++		ut_a(ut_list_node_313);					\
++		if ((ut_list_node_313->NAME).prev)			\
++			(ut_list_node_313->NAME).prev = (void*)((byte*)((ut_list_node_313->NAME).prev)\
++				+ (((void*)((ut_list_node_313->NAME).prev) > (void*)FADDR)?FOFFSET:BOFFSET));\
++		if ((ut_list_node_313->NAME).next)			\
++			(ut_list_node_313->NAME).next =	(void*)((byte*)((ut_list_node_313->NAME).next)\
++				+ (((void*)((ut_list_node_313->NAME).next)> (void*)FADDR)?FOFFSET:BOFFSET));\
++		ut_list_node_313 = (ut_list_node_313->NAME).next;	\
++	}								\
++									\
++	ut_a(ut_list_node_313 == NULL);					\
++									\
++	ut_list_node_313 = (BASE).end;					\
++									\
++	for (ut_list_i_313 = (BASE).count; ut_list_i_313--; ) {		\
++		ut_a(ut_list_node_313);					\
++		ut_list_node_313 = (ut_list_node_313->NAME).prev;	\
++	}								\
++									\
++	ut_a(ut_list_node_313 == NULL);					\
++} while (0)
++
+ #endif
+ 
+diff -ruN a/storage/innobase/log/log0recv.c b/storage/innobase/log/log0recv.c
+--- a/storage/innobase/log/log0recv.c	2010-12-04 19:46:40.212513377 +0900
++++ b/storage/innobase/log/log0recv.c	2010-12-07 16:10:14.959785817 +0900
+@@ -2912,6 +2912,7 @@
+ /*==========================*/
+ {
+ 	ut_a(!recv_needed_recovery);
++	ut_a(!srv_buffer_pool_shm_is_reused);
+ 
+ 	recv_needed_recovery = TRUE;
+ 
+diff -ruN a/storage/innobase/os/os0proc.c b/storage/innobase/os/os0proc.c
+--- a/storage/innobase/os/os0proc.c	2010-11-03 07:01:13.000000000 +0900
++++ b/storage/innobase/os/os0proc.c	2010-12-07 16:10:14.960800123 +0900
+@@ -229,3 +229,173 @@
+ 	}
+ #endif
+ }
++
++/****************************************************************//**
++Allocates or attaches and reuses shared memory segment.
++The content is not cleared automatically.
++@return	allocated memory */
++UNIV_INTERN
++void*
++os_shm_alloc(
++/*=========*/
++	ulint*	n,			/*!< in/out: number of bytes */
++	uint	key,
++	ibool*	is_new)
++{
++	void*	ptr;
++#if defined HAVE_SYS_IPC_H && HAVE_SYS_SHM_H
++	ulint	size;
++	int	shmid;
++
++	*is_new = FALSE;
++	fprintf(stderr,
++		"InnoDB: The shared memory segment containing the buffer pool is: key  %#x (%d).\n",
++		key, key);
++# if defined HAVE_LARGE_PAGES && defined UNIV_LINUX
++	if (!os_use_large_pages || !os_large_page_size) {
++		goto skip;
++	}
++
++	/* Align block size to os_large_page_size */
++	ut_ad(ut_is_2pow(os_large_page_size));
++	size = ut_2pow_round(*n + (os_large_page_size - 1),
++			     os_large_page_size);
++
++	shmid = shmget((key_t)key, (size_t)size,
++			IPC_CREAT | IPC_EXCL | SHM_HUGETLB | SHM_R | SHM_W);
++	if (shmid < 0) {
++		if (errno == EEXIST) {
++			fprintf(stderr,
++				"InnoDB: HugeTLB: The shared memory segment exists.\n");
++			shmid = shmget((key_t)key, (size_t)size,
++					SHM_HUGETLB | SHM_R | SHM_W);
++			if (shmid < 0) {
++				fprintf(stderr,
++					"InnoDB: HugeTLB: Warning: Failed to allocate %lu bytes. (reuse) errno %d\n",
++					size, errno);
++				goto skip;
++			} else {
++				fprintf(stderr,
++					"InnoDB: HugeTLB: The existent shared memory segment is used.\n");
++			}
++		} else {
++			fprintf(stderr,
++				"InnoDB: HugeTLB: Warning: Failed to allocate %lu bytes. (new) errno %d\n",
++				size, errno);
++			goto skip;
++		}
++	} else {
++		*is_new = TRUE;
++		fprintf(stderr,
++			"InnoDB: HugeTLB: A new shared memory segment has been created .\n");
++	}
++
++	ptr = shmat(shmid, NULL, 0);
++	if (ptr == (void *)-1) {
++		fprintf(stderr,
++			"InnoDB: HugeTLB: Warning: Failed to attach shared memory segment, errno %d\n",
++			errno);
++		ptr = NULL;
++	}
++
++	if (ptr) {
++		*n = size;
++		os_fast_mutex_lock(&ut_list_mutex);
++		ut_total_allocated_memory += size;
++		os_fast_mutex_unlock(&ut_list_mutex);
++		UNIV_MEM_ALLOC(ptr, size);
++		return(ptr);
++	}
++skip:
++	*is_new = FALSE;
++# endif /* HAVE_LARGE_PAGES && defined UNIV_LINUX */
++# ifdef HAVE_GETPAGESIZE
++	size = getpagesize();
++# else
++	size = UNIV_PAGE_SIZE;
++# endif
++	/* Align block size to system page size */
++	ut_ad(ut_is_2pow(size));
++	size = *n = ut_2pow_round(*n + (size - 1), size);
++
++	shmid = shmget((key_t)key, (size_t)size,
++			IPC_CREAT | IPC_EXCL | SHM_R | SHM_W);
++	if (shmid < 0) {
++		if (errno == EEXIST) {
++			fprintf(stderr,
++				"InnoDB: A shared memory segment containing the buffer pool seems to already exist.\n");
++			shmid = shmget((key_t)key, (size_t)size,
++					SHM_R | SHM_W);
++			if (shmid < 0) {
++				fprintf(stderr,
++					"InnoDB: Warning: Failed to allocate %lu bytes. (reuse) errno %d\n",
++					size, errno);
++				ptr = NULL;
++				goto end;
++			} else {
++				fprintf(stderr,
++					"InnoDB: The existent shared memory segment is used.\n");
++			}
++		} else {
++			fprintf(stderr,
++				"InnoDB: Warning: Failed to allocate %lu bytes. (new) errno %d\n",
++				size, errno);
++			ptr = NULL;
++			goto end;
++		}
++	} else {
++		*is_new = TRUE;
++		fprintf(stderr,
++			"InnoDB: A new shared memory segment has been created.\n");
++	}
++
++	ptr = shmat(shmid, NULL, 0);
++	if (ptr == (void *)-1) {
++		fprintf(stderr,
++			"InnoDB: Warning: Failed to attach shared memory segment, errno %d\n",
++			errno);
++		ptr = NULL;
++	}
++
++	if (ptr) {
++		*n = size;
++		os_fast_mutex_lock(&ut_list_mutex);
++		ut_total_allocated_memory += size;
++		os_fast_mutex_unlock(&ut_list_mutex);
++		UNIV_MEM_ALLOC(ptr, size);
++	}
++end:
++#else /* HAVE_SYS_IPC_H && HAVE_SYS_SHM_H */
++	fprintf(stderr, "InnoDB: shared memory segment is not supported.\n");
++	ptr = NULL;
++#endif /* HAVE_SYS_IPC_H && HAVE_SYS_SHM_H */
++	return(ptr);
++}
++
++/****************************************************************//**
++Detach shared memory segment. */
++UNIV_INTERN
++void
++os_shm_free(
++/*========*/
++	void	*ptr,			/*!< in: pointer returned by
++					os_shm_alloc() */
++	ulint	size)			/*!< in: size returned by
++					os_shm_alloc() */
++{
++	os_fast_mutex_lock(&ut_list_mutex);
++	ut_a(ut_total_allocated_memory >= size);
++	os_fast_mutex_unlock(&ut_list_mutex);
++
++#if defined HAVE_SYS_IPC_H && HAVE_SYS_SHM_H
++	if (!shmdt(ptr)) {
++		os_fast_mutex_lock(&ut_list_mutex);
++		ut_a(ut_total_allocated_memory >= size);
++		ut_total_allocated_memory -= size;
++		os_fast_mutex_unlock(&ut_list_mutex);
++		UNIV_MEM_FREE(ptr, size);
++	}
++#else /* HAVE_SYS_IPC_H && HAVE_SYS_SHM_H */
++	fprintf(stderr, "InnoDB: shared memory segment is not supported.\n");
++#endif /* HAVE_SYS_IPC_H && HAVE_SYS_SHM_H */
++}
+diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
+--- a/storage/innobase/srv/srv0srv.c	2010-12-04 20:20:44.687550693 +0900
++++ b/storage/innobase/srv/srv0srv.c	2010-12-07 16:10:14.962785720 +0900
+@@ -231,6 +231,11 @@
+ UNIV_INTERN ulint	srv_mem_pool_size	= ULINT_MAX;
+ UNIV_INTERN ulint	srv_lock_table_size	= ULINT_MAX;
+ 
++/* key value for shm */
++UNIV_INTERN uint	srv_buffer_pool_shm_key	= 0;
++UNIV_INTERN ibool	srv_buffer_pool_shm_is_reused = FALSE;
++UNIV_INTERN ibool	srv_buffer_pool_shm_checksum = TRUE;
++
+ /* This parameter is deprecated. Use srv_n_io_[read|write]_threads
+ instead. */
+ UNIV_INTERN ulint	srv_n_file_io_threads	= ULINT_MAX;
+diff -ruN a/storage/innobase/srv/srv0start.c b/storage/innobase/srv/srv0start.c
+--- a/storage/innobase/srv/srv0start.c	2010-12-04 20:19:29.806482628 +0900
++++ b/storage/innobase/srv/srv0start.c	2010-12-07 16:10:14.964785346 +0900
+@@ -1759,6 +1759,8 @@
+ 		Note that this is not as heavy weight as it seems. At
+ 		this point there will be only ONE page in the buf_LRU
+ 		and there must be no page in the buf_flush list. */
++		/* buffer_pool_shm should not be reused when recovery was needed. */
++		if (!srv_buffer_pool_shm_is_reused)
+ 		buf_pool_invalidate();
+ 
+ 		/* We always try to do a recovery, even if the database had

=== renamed file 'innodb_buffer_pool_shm.patch' => 'innodb_buffer_pool_shm.patch.moved'
=== added file 'innodb_deadlock_count.patch'
--- innodb_deadlock_count.patch	1970-01-01 00:00:00 +0000
+++ innodb_deadlock_count.patch	2011-01-10 13:15:57 +0000
@@ -0,0 +1,71 @@
+# name       : innodb_deadlock_count.patch
+# introduced : 11 or before
+# 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/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
+--- a/storage/innobase/handler/ha_innodb.cc	2010-12-04 16:09:53.145500265 +0900
++++ b/storage/innobase/handler/ha_innodb.cc	2010-12-04 16:10:24.605515894 +0900
+@@ -665,6 +665,8 @@
+   (char*) &export_vars.innodb_dblwr_pages_written,	  SHOW_LONG},
+   {"dblwr_writes",
+   (char*) &export_vars.innodb_dblwr_writes,		  SHOW_LONG},
++  {"deadlocks",
++  (char*) &export_vars.innodb_deadlocks,		  SHOW_LONG},
+   {"dict_tables",
+   (char*) &export_vars.innodb_dict_tables,		  SHOW_LONG},
+   {"have_atomic_builtins",
+diff -ruN a/storage/innobase/include/lock0lock.h b/storage/innobase/include/lock0lock.h
+--- a/storage/innobase/include/lock0lock.h	2010-11-03 07:01:13.000000000 +0900
++++ b/storage/innobase/include/lock0lock.h	2010-12-04 16:10:24.605515894 +0900
+@@ -43,6 +43,7 @@
+ #endif /* UNIV_DEBUG */
+ /* Buffer for storing information about the most recent deadlock error */
+ extern FILE*	lock_latest_err_file;
++extern ulint	srv_n_lock_deadlock_count;
+ 
+ /*********************************************************************//**
+ Gets the size of a lock struct.
+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
+@@ -746,6 +746,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 */
++	ulint innodb_deadlocks;
+ 	ibool innodb_have_atomic_builtins;	/*!< HAVE_ATOMIC_BUILTINS */
+ 	ulint innodb_log_waits;			/*!< srv_log_waits */
+ 	ulint innodb_log_write_requests;	/*!< srv_log_write_requests */
+diff -ruN a/storage/innobase/lock/lock0lock.c b/storage/innobase/lock/lock0lock.c
+--- a/storage/innobase/lock/lock0lock.c	2010-12-03 17:49:11.609953956 +0900
++++ b/storage/innobase/lock/lock0lock.c	2010-12-04 16:10:24.608513889 +0900
+@@ -3328,6 +3328,7 @@
+ 		break;
+ 
+ 	case LOCK_VICTIM_IS_START:
++		srv_n_lock_deadlock_count++;
+ 		fputs("*** WE ROLL BACK TRANSACTION (2)\n",
+ 		      lock_latest_err_file);
+ 		break;
+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
+@@ -462,6 +462,7 @@
+ static ulint	srv_n_rows_deleted_old		= 0;
+ static ulint	srv_n_rows_read_old		= 0;
+ 
++UNIV_INTERN ulint		srv_n_lock_deadlock_count	= 0;
+ 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;
+@@ -2237,6 +2238,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;
++	export_vars.innodb_deadlocks = srv_n_lock_deadlock_count;
+ #ifdef UNIV_DEBUG
+ 	export_vars.innodb_buffer_pool_pages_latched
+ 		= buf_get_latched_pages_number();

=== renamed file 'innodb_deadlock_count.patch' => 'innodb_deadlock_count.patch.moved'
=== added file 'innodb_dict_size_limit.patch'
--- innodb_dict_size_limit.patch	1970-01-01 00:00:00 +0000
+++ innodb_dict_size_limit.patch	2011-01-10 13:15:57 +0000
@@ -0,0 +1,446 @@
+# name       : innodb_dict_size_limit.patch
+# introduced : 11 or before
+# 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/btr0sea.c b/storage/innobase/btr/btr0sea.c
+--- a/storage/innobase/btr/btr0sea.c	2010-11-03 07:01:13.000000000 +0900
++++ b/storage/innobase/btr/btr0sea.c	2010-12-03 15:45:47.503988924 +0900
+@@ -1185,6 +1185,132 @@
+ 	mem_free(folds);
+ }
+ 
++/************************************************************************
++Drops a page hash index based on index */
++UNIV_INTERN
++void
++btr_search_drop_page_hash_index_on_index(
++/*=====================================*/
++	dict_index_t*	index)		/* in: record descriptor */
++{
++	buf_page_t*	bpage;
++	hash_table_t*	table;
++	buf_block_t*	block;
++	ulint		n_fields;
++	ulint		n_bytes;
++	const page_t*		page;
++	const rec_t*		rec;
++	ulint		fold;
++	ulint		prev_fold;
++	index_id_t	index_id;
++	ulint		n_cached;
++	ulint		n_recs;
++	ulint*		folds;
++	ulint		i, j;
++	mem_heap_t*	heap	= NULL;
++	ulint*		offsets;
++
++	rw_lock_x_lock(&btr_search_latch);
++	buf_pool_mutex_enter_all();
++
++	table = btr_search_sys->hash_index;
++
++	for (j = 0; j < srv_buf_pool_instances; j++) {
++		buf_pool_t*	buf_pool;
++
++		buf_pool = buf_pool_from_array(j);
++
++		bpage = UT_LIST_GET_LAST(buf_pool->LRU);
++
++		while (bpage != NULL) {
++			block = (buf_block_t*) bpage;
++			if (block->index == index && block->is_hashed) {
++				page = block->frame;
++
++				/* from btr_search_drop_page_hash_index() */
++				n_fields = block->curr_n_fields;
++				n_bytes = block->curr_n_bytes;
++
++				ut_a(n_fields + n_bytes > 0);
++
++				n_recs = page_get_n_recs(page);
++
++				/* Calculate and cache fold values into an array for fast deletion
++				from the hash index */
++
++				folds = mem_alloc(n_recs * sizeof(ulint));
++
++				n_cached = 0;
++
++				rec = page_get_infimum_rec(page);
++				rec = page_rec_get_next_low(rec, page_is_comp(page));
++
++				index_id = btr_page_get_index_id(page);
++	
++				ut_a(index_id == index->id);
++
++				prev_fold = 0;
++
++				offsets = NULL;
++
++				while (!page_rec_is_supremum(rec)) {
++					offsets = rec_get_offsets(rec, index, offsets,
++								n_fields + (n_bytes > 0), &heap);
++					ut_a(rec_offs_n_fields(offsets) == n_fields + (n_bytes > 0));
++					fold = rec_fold(rec, offsets, n_fields, n_bytes, index_id);
++
++					if (fold == prev_fold && prev_fold != 0) {
++
++						goto next_rec;
++					}
++
++					/* Remove all hash nodes pointing to this page from the
++					hash chain */
++
++					folds[n_cached] = fold;
++					n_cached++;
++next_rec:
++					rec = page_rec_get_next_low(rec, page_rec_is_comp(rec));
++					prev_fold = fold;
++				}
++
++				for (i = 0; i < n_cached; i++) {
++
++					ha_remove_all_nodes_to_page(table, folds[i], page);
++				}
++
++				ut_a(index->search_info->ref_count > 0);
++				index->search_info->ref_count--;
++
++				block->is_hashed = FALSE;
++				block->index = NULL;
++	
++#if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
++				if (UNIV_UNLIKELY(block->n_pointers)) {
++					/* Corruption */
++					ut_print_timestamp(stderr);
++					fprintf(stderr,
++"  InnoDB: Corruption of adaptive hash index. After dropping\n"
++"InnoDB: the hash index to a page of %s, still %lu hash nodes remain.\n",
++						index->name, (ulong) block->n_pointers);
++				}
++#endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
++
++				mem_free(folds);
++			}
++
++			bpage = UT_LIST_GET_PREV(LRU, bpage);
++		}
++	}
++
++	buf_pool_mutex_exit_all();
++	rw_lock_x_unlock(&btr_search_latch);
++
++	if (UNIV_LIKELY_NULL(heap)) {
++		mem_heap_free(heap);
++	}
++}
++
+ /********************************************************************//**
+ Drops a page hash index when a page is freed from a fseg to the file system.
+ Drops possible hash index if the page happens to be in the buffer pool. */
+diff -ruN a/storage/innobase/dict/dict0boot.c b/storage/innobase/dict/dict0boot.c
+--- a/storage/innobase/dict/dict0boot.c	2010-11-03 07:01:13.000000000 +0900
++++ b/storage/innobase/dict/dict0boot.c	2010-12-03 15:45:47.503988924 +0900
+@@ -284,6 +284,7 @@
+ 	system tables */
+ 	/*-------------------------*/
+ 	table = dict_mem_table_create("SYS_TABLES", DICT_HDR_SPACE, 8, 0);
++	table->n_mysql_handles_opened = 1; /* for pin */
+ 
+ 	dict_mem_table_add_col(table, heap, "NAME", DATA_BINARY, 0, 0);
+ 	dict_mem_table_add_col(table, heap, "ID", DATA_BINARY, 0, 0);
+@@ -336,6 +337,7 @@
+ 
+ 	/*-------------------------*/
+ 	table = dict_mem_table_create("SYS_COLUMNS", DICT_HDR_SPACE, 7, 0);
++	table->n_mysql_handles_opened = 1; /* for pin */
+ 
+ 	dict_mem_table_add_col(table, heap, "TABLE_ID", DATA_BINARY, 0, 0);
+ 	dict_mem_table_add_col(table, heap, "POS", DATA_INT, 0, 4);
+@@ -368,6 +370,7 @@
+ 
+ 	/*-------------------------*/
+ 	table = dict_mem_table_create("SYS_INDEXES", DICT_HDR_SPACE, 7, 0);
++	table->n_mysql_handles_opened = 1; /* for pin */
+ 
+ 	dict_mem_table_add_col(table, heap, "TABLE_ID", DATA_BINARY, 0, 0);
+ 	dict_mem_table_add_col(table, heap, "ID", DATA_BINARY, 0, 0);
+@@ -413,6 +416,7 @@
+ 
+ 	/*-------------------------*/
+ 	table = dict_mem_table_create("SYS_FIELDS", DICT_HDR_SPACE, 3, 0);
++	table->n_mysql_handles_opened = 1; /* for pin */
+ 
+ 	dict_mem_table_add_col(table, heap, "INDEX_ID", DATA_BINARY, 0, 0);
+ 	dict_mem_table_add_col(table, heap, "POS", DATA_INT, 0, 4);
+diff -ruN a/storage/innobase/dict/dict0crea.c b/storage/innobase/dict/dict0crea.c
+--- a/storage/innobase/dict/dict0crea.c	2010-11-03 07:01:13.000000000 +0900
++++ b/storage/innobase/dict/dict0crea.c	2010-12-03 15:45:47.521955810 +0900
+@@ -1210,6 +1210,9 @@
+ 		/* Foreign constraint system tables have already been
+ 		created, and they are ok */
+ 
++		table1->n_mysql_handles_opened = 1; /* for pin */
++		table2->n_mysql_handles_opened = 1; /* for pin */
++
+ 		mutex_exit(&(dict_sys->mutex));
+ 
+ 		return(DB_SUCCESS);
+@@ -1291,6 +1294,11 @@
+ 
+ 	trx_commit_for_mysql(trx);
+ 
++	table1 = dict_table_get_low("SYS_FOREIGN");
++	table2 = dict_table_get_low("SYS_FOREIGN_COLS");
++	table1->n_mysql_handles_opened = 1; /* for pin */
++	table2->n_mysql_handles_opened = 1; /* for pin */
++
+ 	row_mysql_unlock_data_dictionary(trx);
+ 
+ 	trx_free_for_mysql(trx);
+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
+@@ -625,6 +625,8 @@
+ 
+ 	table = dict_table_get_on_id_low(table_id);
+ 
++	dict_table_LRU_trim(table);
++
+ 	mutex_exit(&(dict_sys->mutex));
+ 
+ 	return(table);
+@@ -743,6 +745,8 @@
+ 		table->n_mysql_handles_opened++;
+ 	}
+ 
++	dict_table_LRU_trim(table);
++
+ 	mutex_exit(&(dict_sys->mutex));
+ 
+ 	if (table != NULL) {
+@@ -1256,6 +1260,64 @@
+ 	dict_mem_table_free(table);
+ }
+ 
++/**************************************************************************
++Frees tables from the end of table_LRU if the dictionary cache occupies
++too much space. */
++UNIV_INTERN
++void
++dict_table_LRU_trim(
++/*================*/
++	dict_table_t*	self)
++{
++	dict_table_t*	table;
++	dict_table_t*	prev_table;
++	dict_foreign_t*	foreign;
++	ulint		n_removed;
++	ulint		n_have_parent;
++	ulint		cached_foreign_tables;
++
++#ifdef UNIV_SYNC_DEBUG
++	ut_ad(mutex_own(&(dict_sys->mutex)));
++#endif /* UNIV_SYNC_DEBUG */
++
++retry:
++	n_removed = n_have_parent = 0;
++	table = UT_LIST_GET_LAST(dict_sys->table_LRU);
++
++	while ( srv_dict_size_limit && table
++		&& ((dict_sys->table_hash->n_cells
++		     + dict_sys->table_id_hash->n_cells) * sizeof(hash_cell_t)
++		    + dict_sys->size) > srv_dict_size_limit ) {
++		prev_table = UT_LIST_GET_PREV(table_LRU, table);
++
++		if (table == self || table->n_mysql_handles_opened)
++			goto next_loop;
++
++		cached_foreign_tables = 0;
++		foreign = UT_LIST_GET_FIRST(table->foreign_list);
++		while (foreign != NULL) {
++			if (foreign->referenced_table)
++				cached_foreign_tables++;
++			foreign = UT_LIST_GET_NEXT(foreign_list, foreign);
++		}
++
++		if (cached_foreign_tables == 0) {
++			dict_table_remove_from_cache(table);
++			n_removed++;
++		} else {
++			n_have_parent++;
++		}
++next_loop:
++		table = prev_table;
++	}
++
++	if ( srv_dict_size_limit && n_have_parent && n_removed
++		&& ((dict_sys->table_hash->n_cells
++		     + dict_sys->table_id_hash->n_cells) * sizeof(hash_cell_t)
++		    + dict_sys->size) > srv_dict_size_limit )
++		goto retry;
++}
++
+ /****************************************************************//**
+ If the given column name is reserved for InnoDB system columns, return
+ TRUE.
+@@ -1719,6 +1781,11 @@
+ 	ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
+ 	ut_ad(mutex_own(&(dict_sys->mutex)));
+ 
++	/* remove all entry of the index from adaptive hash index,
++	because removing from adaptive hash index needs dict_index */
++	if (btr_search_enabled && srv_dict_size_limit)
++		btr_search_drop_page_hash_index_on_index(index);
++
+ 	/* We always create search info whether or not adaptive
+ 	hash index is enabled or not. */
+ 	info = index->search_info;
+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:43:57.294986852 +0900
++++ b/storage/innobase/handler/ha_innodb.cc	2010-12-03 15:45:47.534959966 +0900
+@@ -653,6 +653,8 @@
+   (char*) &export_vars.innodb_dblwr_pages_written,	  SHOW_LONG},
+   {"dblwr_writes",
+   (char*) &export_vars.innodb_dblwr_writes,		  SHOW_LONG},
++  {"dict_tables",
++  (char*) &export_vars.innodb_dict_tables,		  SHOW_LONG},
+   {"have_atomic_builtins",
+   (char*) &export_vars.innodb_have_atomic_builtins,	  SHOW_BOOL},
+   {"log_waits",
+@@ -11537,6 +11539,11 @@
+   "Number of extra user rollback segments which are used in a round-robin fashion.",
+   NULL, NULL, 127, 0, 127, 0);
+ 
++static MYSQL_SYSVAR_ULONG(dict_size_limit, srv_dict_size_limit,
++  PLUGIN_VAR_RQCMDARG,
++  "Limit the allocated memory for dictionary cache. (0: unlimited)",
++  NULL, NULL, 0, 0, LONG_MAX, 0);
++
+ static struct st_mysql_sys_var* innobase_system_variables[]= {
+   MYSQL_SYSVAR(additional_mem_pool_size),
+   MYSQL_SYSVAR(autoextend_increment),
+@@ -11605,6 +11612,7 @@
+   MYSQL_SYSVAR(flush_log_at_trx_commit_session),
+   MYSQL_SYSVAR(enable_unsafe_group_commit),
+   MYSQL_SYSVAR(extra_rsegments),
++  MYSQL_SYSVAR(dict_size_limit),
+   MYSQL_SYSVAR(use_sys_malloc),
+   MYSQL_SYSVAR(use_native_aio),
+   MYSQL_SYSVAR(change_buffering),
+diff -ruN a/storage/innobase/ibuf/ibuf0ibuf.c b/storage/innobase/ibuf/ibuf0ibuf.c
+--- a/storage/innobase/ibuf/ibuf0ibuf.c	2010-12-03 15:18:48.889024455 +0900
++++ b/storage/innobase/ibuf/ibuf0ibuf.c	2010-12-03 15:45:47.553025057 +0900
+@@ -578,6 +578,7 @@
+ 
+ 	/* Use old-style record format for the insert buffer. */
+ 	table = dict_mem_table_create(IBUF_TABLE_NAME, IBUF_SPACE_ID, 1, 0);
++	table->n_mysql_handles_opened = 1; /* for pin */
+ 
+ 	dict_mem_table_add_col(table, heap, "DUMMY_COLUMN", DATA_BINARY, 0, 0);
+ 
+diff -ruN a/storage/innobase/include/btr0sea.h b/storage/innobase/include/btr0sea.h
+--- a/storage/innobase/include/btr0sea.h	2010-11-03 07:01:13.000000000 +0900
++++ b/storage/innobase/include/btr0sea.h	2010-12-03 15:45:47.555024229 +0900
+@@ -140,6 +140,13 @@
+ 				s- or x-latched, or an index page
+ 				for which we know that
+ 				block->buf_fix_count == 0 */
++/************************************************************************
++Drops a page hash index based on index */
++UNIV_INTERN
++void
++btr_search_drop_page_hash_index_on_index(
++/*=====================================*/
++	dict_index_t*	index);		/* in: record descriptor */
+ /********************************************************************//**
+ Drops a page hash index when a page is freed from a fseg to the file system.
+ Drops possible hash index if the page happens to be in the buffer pool. */
+diff -ruN a/storage/innobase/include/dict0dict.h b/storage/innobase/include/dict0dict.h
+--- a/storage/innobase/include/dict0dict.h	2010-11-03 07:01:13.000000000 +0900
++++ b/storage/innobase/include/dict0dict.h	2010-12-03 15:45:47.558024515 +0900
+@@ -1158,6 +1158,12 @@
+ /*====================================*/
+ 	dict_table_t*	table,	/*!< in: table */
+ 	const char*	name);	/*!< in: name of the index to find */
++
++UNIV_INTERN
++void
++dict_table_LRU_trim(
++/*================*/
++	dict_table_t*	self);
+ /* Buffers for storing detailed information about the latest foreign key
+ and unique key errors */
+ extern FILE*	dict_foreign_err_file;
+diff -ruN a/storage/innobase/include/dict0dict.ic b/storage/innobase/include/dict0dict.ic
+--- a/storage/innobase/include/dict0dict.ic	2010-11-03 07:01:13.000000000 +0900
++++ b/storage/innobase/include/dict0dict.ic	2010-12-03 15:45:47.560024398 +0900
+@@ -824,6 +824,13 @@
+ 	HASH_SEARCH(name_hash, dict_sys->table_hash, table_fold,
+ 		    dict_table_t*, table, ut_ad(table->cached),
+ 		    !strcmp(table->name, table_name));
++
++	/* make young in table_LRU */
++	if (table) {
++		UT_LIST_REMOVE(table_LRU, dict_sys->table_LRU, table);
++		UT_LIST_ADD_FIRST(table_LRU, dict_sys->table_LRU, table);
++	}
++
+ 	return(table);
+ }
+ 
+@@ -877,6 +884,12 @@
+ 		table = dict_load_table_on_id(table_id);
+ 	}
+ 
++	/* make young in table_LRU */
++	if (table) {
++		UT_LIST_REMOVE(table_LRU, dict_sys->table_LRU, table);
++		UT_LIST_ADD_FIRST(table_LRU, dict_sys->table_LRU, table);
++	}
++
+ 	ut_ad(!table || table->cached);
+ 
+ 	/* TODO: should get the type information from MySQL */
+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
+@@ -227,7 +227,7 @@
+ extern ulint	srv_adaptive_checkpoint;
+ 
+ extern ulint	srv_extra_rsegments;
+-
++extern ulint	srv_dict_size_limit;
+ /*-------------------------------------------*/
+ 
+ extern ulint	srv_n_rows_inserted;
+@@ -697,6 +697,7 @@
+ 	ulint innodb_data_writes;		/*!< I/O write requests */
+ 	ulint innodb_data_written;		/*!< Data bytes written */
+ 	ulint innodb_data_reads;		/*!< I/O read requests */
++	ulint innodb_dict_tables;
+ 	ulint innodb_buffer_pool_pages_total;	/*!< Buffer pool size */
+ 	ulint innodb_buffer_pool_pages_data;	/*!< Data pages */
+ 	ulint innodb_buffer_pool_pages_dirty;	/*!< Dirty data pages */
+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
+@@ -411,6 +411,7 @@
+ UNIV_INTERN ulint	srv_adaptive_checkpoint = 0; /* 0: none  1: reflex  2: estimate */
+ 
+ UNIV_INTERN ulint	srv_extra_rsegments = 127; /* extra rseg for users */
++UNIV_INTERN ulint	srv_dict_size_limit = 0;
+ /*-------------------------------------------*/
+ UNIV_INTERN ulong	srv_n_spin_wait_rounds	= 30;
+ UNIV_INTERN ulong	srv_n_free_tickets_to_enter = 500;
+@@ -2179,6 +2180,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;
++	export_vars.innodb_dict_tables= (dict_sys ? UT_LIST_GET_LEN(dict_sys->table_LRU) : 0);
+ 	export_vars.innodb_buffer_pool_read_requests = stat.n_page_gets;
+ 	export_vars.innodb_buffer_pool_write_requests
+ 		= srv_buf_pool_write_requests;

=== renamed file 'innodb_dict_size_limit.patch' => 'innodb_dict_size_limit.patch.moved'
=== added file 'innodb_expand_import.patch'
--- innodb_expand_import.patch	1970-01-01 00:00:00 +0000
+++ innodb_expand_import.patch	2011-01-10 13:15:57 +0000
@@ -0,0 +1,561 @@
+# name       : innodb_expand_import.patch
+# introduced : 11 or before
+# 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/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 @@
+ #include "dict0dict.h"
+ #include "page0page.h"
+ #include "page0zip.h"
++#include "trx0trx.h"
++#include "trx0sys.h"
++#include "pars0pars.h"
++#include "row0mysql.h"
++#include "row0row.h"
++#include "que0que.h"
+ #ifndef UNIV_HOTBACKUP
+ # include "buf0lru.h"
+ # include "ibuf0ibuf.h"
+@@ -3050,7 +3056,7 @@
+ 
+ 	file = os_file_create_simple_no_error_handling(
+ 		innodb_file_data_key, filepath, OS_FILE_OPEN,
+-		OS_FILE_READ_ONLY, &success);
++		OS_FILE_READ_WRITE, &success);
+ 	if (!success) {
+ 		/* The following call prints an error message */
+ 		os_file_get_last_error(TRUE);
+@@ -3097,6 +3103,466 @@
+ 	space_id = fsp_header_get_space_id(page);
+ 	space_flags = fsp_header_get_flags(page);
+ 
++	if (srv_expand_import
++	    && (space_id != id || space_flags != (flags & ~(~0 << DICT_TF_BITS)))) {
++		ibool		file_is_corrupt = FALSE;
++		byte*		buf3;
++		byte*		descr_page;
++		ibool		descr_is_corrupt = FALSE;
++		index_id_t	old_id[31];
++		index_id_t	new_id[31];
++		ulint		root_page[31];
++		ulint		n_index;
++		os_file_t	info_file = -1;
++		char*		info_file_path;
++		ulint	i;
++		int		len;
++		ib_uint64_t	current_lsn;
++		ulint		size_low, size_high, size, free_limit;
++		ib_int64_t	size_bytes, free_limit_bytes;
++		dict_table_t*	table;
++		dict_index_t*	index;
++		fil_system_t*	system;
++		fil_node_t*	node = NULL;
++		fil_space_t*	space;
++
++		buf3 = ut_malloc(2 * UNIV_PAGE_SIZE);
++		descr_page = ut_align(buf3, UNIV_PAGE_SIZE);
++
++		current_lsn = log_get_lsn();
++
++		/* check the header page's consistency */
++		if (buf_page_is_corrupted(page,
++					  dict_table_flags_to_zip_size(space_flags))) {
++			fprintf(stderr, "InnoDB: page 0 of %s seems corrupt.\n", filepath);
++			file_is_corrupt = TRUE;
++			descr_is_corrupt = TRUE;
++		}
++
++		/* store as first descr page */
++		memcpy(descr_page, page, UNIV_PAGE_SIZE);
++
++		/* 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;
++
++		/* overwrite fsp header */
++		fsp_header_init_fields(page, id, flags);
++		mach_write_to_4(page + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID, id);
++		space_id = id;
++		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);
++		success = os_file_write(filepath, file, page, 0, 0, UNIV_PAGE_SIZE);
++
++		/* get file size */
++		os_file_get_size(file, &size_low, &size_high);
++		size_bytes = (((ib_int64_t)size_high) << 32)
++				+ (ib_int64_t)size_low;
++
++		if (size_bytes < free_limit_bytes) {
++			free_limit_bytes = size_bytes;
++			if (size_bytes >= FSP_EXTENT_SIZE * UNIV_PAGE_SIZE) {
++				fprintf(stderr, "InnoDB: free limit of %s is larger than its real size.\n", filepath);
++				file_is_corrupt = TRUE;
++			}
++		}
++
++		/* get cruster index information */
++		table = dict_table_get_low(name);
++		index = dict_table_get_first_index(table);
++		ut_a(index->page==3);
++
++		/* read metadata from .exp file */
++		n_index = 0;
++		memset(old_id, 0, sizeof(old_id));
++		memset(new_id, 0, sizeof(new_id));
++		memset(root_page, 0, sizeof(root_page));
++
++		info_file_path = fil_make_ibd_name(name, FALSE);
++		len = strlen(info_file_path);
++		info_file_path[len - 3] = 'e';
++		info_file_path[len - 2] = 'x';
++		info_file_path[len - 1] = 'p';