[packages/percona-server.git] / innodb_expand_import.patch

# 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"
@@ -3078,7 +3084,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);
@@ -3125,6 +3131,466 @@
 	space_id = fsp_header_get_space_id(page);
 	space_flags = fsp_header_get_flags(page);
 
+	if (srv_expand_import) {
+
+		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';
+
+		info_file = os_file_create_simple_no_error_handling(innodb_file_data_key,
+				info_file_path, OS_FILE_OPEN, OS_FILE_READ_ONLY, &success);
+		if (!success) {
+			fprintf(stderr, "InnoDB: Cannot open the file: %s\n", info_file_path);
+			file_is_corrupt = TRUE;
+			goto skip_info;
+		}
+		success = os_file_read(info_file, page, 0, 0, UNIV_PAGE_SIZE);
+		if (!success) {
+			fprintf(stderr, "InnoDB: Cannot read the file: %s\n", info_file_path);
+			file_is_corrupt = TRUE;
+			goto skip_info;
+		}
+		if (mach_read_from_4(page) != 0x78706f72UL
+		    || mach_read_from_4(page + 4) != 0x74696e66UL) {
+			fprintf(stderr, "InnoDB: %s seems to be an incorrect .exp file.\n", info_file_path);
+			file_is_corrupt = TRUE;
+			goto skip_info;
+		}
+
+		fprintf(stderr, "InnoDB: Import: The extended import of %s is being started.\n", name);
+
+		n_index = mach_read_from_4(page + 8);
+		fprintf(stderr, "InnoDB: Import: %lu indexes have been detected.\n", (ulong)n_index);
+		for (i = 0; i < n_index; i++) {
+			new_id[i] =
+				dict_table_get_index_on_name(table,
+						(char*)(page + (i + 1) * 512 + 12))->id;
+			old_id[i] = mach_read_from_8(page + (i + 1) * 512);
+			root_page[i] = mach_read_from_4(page + (i + 1) * 512 + 8);
+		}
+
+skip_info:
+		if (info_file != -1)
+			os_file_close(info_file);
+
+		/*
+		if (size_bytes >= 1024 * 1024) {
+			size_bytes = ut_2pow_round(size_bytes, 1024 * 1024);
+		}
+		*/
+		if (!(flags & DICT_TF_ZSSIZE_MASK)) {
+			mem_heap_t*	heap = NULL;
+			ulint		offsets_[REC_OFFS_NORMAL_SIZE];
+			ulint*		offsets = offsets_;
+			ib_int64_t	offset;
+
+			size = (ulint) (size_bytes / UNIV_PAGE_SIZE);
+			/* over write space id of all pages */
+			rec_offs_init(offsets_);
+
+			fprintf(stderr, "InnoDB: Progress in %%:");
+
+			for (offset = 0; offset < free_limit_bytes; offset += UNIV_PAGE_SIZE) {
+				ulint		checksum_field;
+				ulint		old_checksum_field;
+				ibool		page_is_corrupt;
+
+				success = os_file_read(file, page,
+							(ulint)(offset & 0xFFFFFFFFUL),
+							(ulint)(offset >> 32), UNIV_PAGE_SIZE);
+
+				page_is_corrupt = FALSE;
+
+				/* check consistency */
+				if (memcmp(page + FIL_PAGE_LSN + 4,
+					   page + UNIV_PAGE_SIZE
+					   - FIL_PAGE_END_LSN_OLD_CHKSUM + 4, 4)) {
+
+					page_is_corrupt = TRUE;
+				}
+
+				if (mach_read_from_4(page + FIL_PAGE_OFFSET)
+				    != offset / UNIV_PAGE_SIZE) {
+
+					page_is_corrupt = TRUE;
+				}
+
+				checksum_field = mach_read_from_4(page
+								  + FIL_PAGE_SPACE_OR_CHKSUM);
+
+				old_checksum_field = mach_read_from_4(
+					page + UNIV_PAGE_SIZE
+					- FIL_PAGE_END_LSN_OLD_CHKSUM);
+
+				if (old_checksum_field != mach_read_from_4(page
+									   + FIL_PAGE_LSN)
+				    && old_checksum_field != BUF_NO_CHECKSUM_MAGIC
+				    && old_checksum_field
+				    != buf_calc_page_old_checksum(page)) {
+
+					page_is_corrupt = TRUE;
+				}
+
+				if (checksum_field != 0
+				    && checksum_field != BUF_NO_CHECKSUM_MAGIC
+				    && checksum_field
+				    != buf_calc_page_new_checksum(page)) {
+
+					page_is_corrupt = TRUE;
+				}
+
+				/* if it is free page, inconsistency is acceptable */
+				if (!offset) {
+					/* header page*/
+					/* it should be overwritten already */
+					ut_a(!page_is_corrupt);
+
+				} else if (!((offset / UNIV_PAGE_SIZE) % UNIV_PAGE_SIZE)) {
+					/* descr page (not header) */
+					if (page_is_corrupt) {
+						file_is_corrupt = TRUE;
+						descr_is_corrupt = TRUE;
+					} else {
+						ut_ad(fil_page_get_type(page) == FIL_PAGE_TYPE_XDES);
+						descr_is_corrupt = FALSE;
+					}
+
+					/* store as descr page */
+					memcpy(descr_page, page, UNIV_PAGE_SIZE);
+
+				} else if (descr_is_corrupt) {
+					/* unknown state of the page */
+					if (page_is_corrupt) {
+						file_is_corrupt = TRUE;
+					}
+
+				} else {
+					/* check free page or not */
+					/* These definitions should be same to fsp0fsp.c */
+#define	FSP_HEADER_SIZE		(32 + 5 * FLST_BASE_NODE_SIZE)
+
+#define	XDES_BITMAP		(FLST_NODE_SIZE + 12)
+#define	XDES_BITS_PER_PAGE	2
+#define	XDES_FREE_BIT		0
+#define	XDES_SIZE							\
+	(XDES_BITMAP + UT_BITS_IN_BYTES(FSP_EXTENT_SIZE * XDES_BITS_PER_PAGE))
+#define	XDES_ARR_OFFSET		(FSP_HEADER_OFFSET + FSP_HEADER_SIZE)
+
+					/*descr = descr_page + XDES_ARR_OFFSET + XDES_SIZE * xdes_calc_descriptor_index(zip_size, offset)*/
+					/*xdes_get_bit(descr, XDES_FREE_BIT, page % FSP_EXTENT_SIZE, mtr)*/
+					byte*	descr;
+					ulint	index;
+					ulint	byte_index;
+					ulint	bit_index;
+
+					descr = descr_page + XDES_ARR_OFFSET
+						+ XDES_SIZE * (ut_2pow_remainder((offset / UNIV_PAGE_SIZE), UNIV_PAGE_SIZE) / FSP_EXTENT_SIZE);
+
+					index = XDES_FREE_BIT + XDES_BITS_PER_PAGE * ((offset / UNIV_PAGE_SIZE) % FSP_EXTENT_SIZE);
+					byte_index = index / 8;
+					bit_index = index % 8;
+
+					if (ut_bit_get_nth(mach_read_from_1(descr + XDES_BITMAP + byte_index), bit_index)) {
+						/* free page */
+						if (page_is_corrupt) {
+							goto skip_write;
+						}
+					} else {
+						/* not free */
+						if (page_is_corrupt) {
+							file_is_corrupt = TRUE;
+						}
+					}
+				}
+
+				if (page_is_corrupt) {
+					fprintf(stderr, " [errp:%lld]", offset / UNIV_PAGE_SIZE);
+
+					/* cannot treat corrupt page */
+					goto skip_write;
+				}
+
+				if (mach_read_from_4(page + FIL_PAGE_OFFSET) || !offset) {
+					mach_write_to_4(page + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID, id);
+
+					for (i = 0; i < n_index; i++) {
+						if (offset / UNIV_PAGE_SIZE == root_page[i]) {
+							/* this is index root page */
+							mach_write_to_4(page + FIL_PAGE_DATA + PAGE_BTR_SEG_LEAF
+											+ FSEG_HDR_SPACE, id);
+							mach_write_to_4(page + FIL_PAGE_DATA + PAGE_BTR_SEG_TOP
+											+ FSEG_HDR_SPACE, id);
+							break;
+						}
+					}
+
+					if (fil_page_get_type(page) == FIL_PAGE_INDEX) {
+						index_id_t tmp = mach_read_from_8(page + (PAGE_HEADER + PAGE_INDEX_ID));
+
+						if (mach_read_from_2(page + PAGE_HEADER + PAGE_LEVEL) == 0
+						    && old_id[0] == tmp) {
+							/* leaf page of cluster index, reset trx_id of records */
+							rec_t*	rec;
+							rec_t*	supremum;
+							ulint	n_recs;
+
+							supremum = page_get_supremum_rec(page);
+							rec = page_rec_get_next(page_get_infimum_rec(page));
+							n_recs = page_get_n_recs(page);
+
+							while (rec && rec != supremum && n_recs > 0) {
+								ulint	n_fields;
+								ulint	i;
+								ulint	offset = index->trx_id_offset;
+								offsets = rec_get_offsets(rec, index, offsets,
+										ULINT_UNDEFINED, &heap);
+								n_fields = rec_offs_n_fields(offsets);
+								if (!offset) {
+									offset = row_get_trx_id_offset(rec, index, offsets);
+								}
+								trx_write_trx_id(rec + offset, 1);
+
+								for (i = 0; i < n_fields; i++) {
+									if (rec_offs_nth_extern(offsets, i)) {
+										ulint	local_len;
+										byte*	data;
+
+										data = rec_get_nth_field(rec, offsets, i, &local_len);
+
+										local_len -= BTR_EXTERN_FIELD_REF_SIZE;
+
+										mach_write_to_4(data + local_len + BTR_EXTERN_SPACE_ID, id);
+									}
+								}
+
+								rec = page_rec_get_next(rec);
+								n_recs--;
+							}
+						}
+
+						for (i = 0; i < n_index; i++) {
+							if (old_id[i] == tmp) {
+								mach_write_to_8(page + (PAGE_HEADER + PAGE_INDEX_ID), new_id[i]);
+								break;
+							}
+						}
+					}
+
+					if (mach_read_from_8(page + FIL_PAGE_LSN) > current_lsn) {
+						mach_write_to_8(page + FIL_PAGE_LSN, current_lsn);
+						mach_write_to_8(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
+										current_lsn);
+					}
+
+					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,
+								(ulint)(offset & 0xFFFFFFFFUL),
+								(ulint)(offset >> 32), UNIV_PAGE_SIZE);
+				}
+
+skip_write:
+				if (free_limit_bytes
+				    && ((ib_int64_t)((offset + UNIV_PAGE_SIZE) * 100) / free_limit_bytes)
+					!= ((offset * 100) / free_limit_bytes)) {
+					fprintf(stderr, " %lu",
+						(ulong)((ib_int64_t)((offset + UNIV_PAGE_SIZE) * 100) / free_limit_bytes));
+				}
+			}
+
+			fprintf(stderr, " done.\n");
+
+			/* update SYS_INDEXES set root page */
+			index = dict_table_get_first_index(table);
+			while (index) {
+				for (i = 0; i < n_index; i++) {
+					if (new_id[i] == index->id) {
+						break;
+					}
+				}
+
+				if (i != n_index
+				    && root_page[i] != index->page) {
+					/* must update */
+					ulint	error;
+					trx_t*	trx;
+					pars_info_t*	info = NULL;
+
+					trx = trx_allocate_for_mysql();
+					trx->op_info = "extended import";
+
+					info = pars_info_create();
+
+					pars_info_add_ull_literal(info, "indexid", new_id[i]);
+					pars_info_add_int4_literal(info, "new_page", (lint) root_page[i]);
+
+					error = que_eval_sql(info,
+						"PROCEDURE UPDATE_INDEX_PAGE () IS\n"
+						"BEGIN\n"
+						"UPDATE SYS_INDEXES"
+						" SET PAGE_NO = :new_page"
+						" WHERE ID = :indexid;\n"
+						"COMMIT WORK;\n"
+						"END;\n",
+						FALSE, trx);
+
+					if (error != DB_SUCCESS) {
+						fprintf(stderr, "InnoDB: failed to update SYS_INDEXES\n");
+					}
+
+					trx_commit_for_mysql(trx);
+
+					trx_free_for_mysql(trx);
+
+					index->page = root_page[i];
+				}
+
+				index = dict_table_get_next_index(index);
+			}
+			if (UNIV_LIKELY_NULL(heap)) {
+				mem_heap_free(heap);
+			}
+		} else {
+			/* zip page? */
+			size = (ulint)
+			(size_bytes
+					/ dict_table_flags_to_zip_size(flags));
+			fprintf(stderr, "InnoDB: Import: The table %s seems to be in a newer format."
+					" It may not be possible to process it.\n", name);
+		}
+		/* .exp file should be removed */
+		success = os_file_delete(info_file_path);
+		if (!success) {
+			success = os_file_delete_if_exists(info_file_path);
+		}
+		mem_free(info_file_path);
+
+		system	= fil_system;
+		mutex_enter(&(system->mutex));
+		space = fil_space_get_by_id(id);
+		if (space)
+			node = UT_LIST_GET_FIRST(space->chain);
+		if (node && node->size < size) {
+			space->size += (size - node->size);
+			node->size = size;
+		}
+		mutex_exit(&(system->mutex));
+
+		ut_free(buf3);
+
+		if (file_is_corrupt) {
+			ut_print_timestamp(stderr);
+			fputs("  InnoDB: Error: file ",
+			      stderr);
+			ut_print_filename(stderr, filepath);
+			fprintf(stderr, " seems to be corrupt.\n"
+				"InnoDB: An attempt to convert and salvage all corrupt pages was not made.\n"
+				"InnoDB: ##### CAUTION #####\n"
+				"InnoDB: ## The .ibd file may cause InnoDB to crash, even though its re-import seems to have succeeded.\n"
+				"InnoDB: ## If you don't know how to salvage data from a .ibd, you should not use the file.\n"
+				"InnoDB: ###################\n");
+			success = FALSE;
+
+			ut_free(buf2);
+
+			goto func_exit;
+		}
+	}
+
 	ut_free(buf2);
 
 	if (UNIV_UNLIKELY(space_id != id
diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
--- a/storage/innobase/handler/ha_innodb.cc	2010-12-03 15:49:59.195023983 +0900
+++ b/storage/innobase/handler/ha_innodb.cc	2010-12-03 15:52:23.555957062 +0900
@@ -7337,6 +7337,14 @@
 		err = row_discard_tablespace_for_mysql(dict_table->name, trx);
 	} else {
 		err = row_import_tablespace_for_mysql(dict_table->name, trx);
+
+		/* in expanded import mode re-initialize auto_increment again */
+		if ((err == DB_SUCCESS) && srv_expand_import &&
+		    (table->found_next_number_field != NULL)) {
+			dict_table_autoinc_lock(dict_table);
+			innobase_initialize_autoinc();
+			dict_table_autoinc_unlock(dict_table);
+		}
 	}
 
 	err = convert_error_code_to_mysql(err, dict_table->flags, NULL);
@@ -11538,6 +11546,11 @@
   "Choose method of innodb_adaptive_flushing. (native, [estimate], keep_average)",
   NULL, innodb_adaptive_flushing_method_update, 1, &adaptive_flushing_method_typelib);
 
+static MYSQL_SYSVAR_ULONG(import_table_from_xtrabackup, srv_expand_import,
+  PLUGIN_VAR_RQCMDARG,
+  "Enable/Disable converting automatically *.ibd files when import tablespace.",
+  NULL, NULL, 0, 0, 1, 0);
+
 static MYSQL_SYSVAR_ULONG(extra_rsegments, srv_extra_rsegments,
   PLUGIN_VAR_RQCMDARG,
   "Number of extra user rollback segments which are used in a round-robin fashion.",
@@ -11614,6 +11627,7 @@
   MYSQL_SYSVAR(flush_neighbor_pages),
   MYSQL_SYSVAR(read_ahead),
   MYSQL_SYSVAR(adaptive_flushing_method),
+  MYSQL_SYSVAR(import_table_from_xtrabackup),
   MYSQL_SYSVAR(extra_rsegments),
   MYSQL_SYSVAR(dict_size_limit),
   MYSQL_SYSVAR(use_sys_malloc),
diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
--- a/storage/innobase/include/srv0srv.h	2010-12-03 15:48:03.077954270 +0900
+++ b/storage/innobase/include/srv0srv.h	2010-12-03 15:52:23.561986996 +0900
@@ -227,6 +227,8 @@
 extern ulint	srv_read_ahead;
 extern ulint	srv_adaptive_flushing_method;
 
+extern ulint	srv_expand_import;
+
 extern ulint	srv_extra_rsegments;
 extern ulint	srv_dict_size_limit;
 /*-------------------------------------------*/
diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
--- a/storage/innobase/srv/srv0srv.c	2010-12-03 15:49:59.230956118 +0900
+++ b/storage/innobase/srv/srv0srv.c	2010-12-03 15:52:23.562954411 +0900
@@ -415,6 +415,8 @@
 UNIV_INTERN ulint	srv_read_ahead = 3; /* 1: random  2: linear  3: Both */
 UNIV_INTERN ulint	srv_adaptive_flushing_method = 0; /* 0: native  1: estimate  2: keep_average */
 
+UNIV_INTERN ulint	srv_expand_import = 0; /* 0:disable 1:enable */
+
 UNIV_INTERN ulint	srv_extra_rsegments = 127; /* extra rseg for users */
 UNIV_INTERN ulint	srv_dict_size_limit = 0;
 /*-------------------------------------------*/
Commit	Line	Data
b4e1fa2c AM	1	# name : innodb_expand_import.patch
	2	# introduced : 11 or before
	3	# maintainer : Yasufumi
	4	#
	5	#!!! notice !!!
	6	# Any small change to this file in the main branch
	7	# should be done or reviewed by the maintainer!
	8	diff -ruN a/storage/innobase/fil/fil0fil.c b/storage/innobase/fil/fil0fil.c
	9	--- a/storage/innobase/fil/fil0fil.c 2010-12-03 15:09:51.274957577 +0900
	10	+++ b/storage/innobase/fil/fil0fil.c 2010-12-03 15:52:23.553986552 +0900
	11	@@ -40,6 +40,12 @@
	12	#include "dict0dict.h"
	13	#include "page0page.h"
	14	#include "page0zip.h"
	15	+#include "trx0trx.h"
	16	+#include "trx0sys.h"
	17	+#include "pars0pars.h"
	18	+#include "row0mysql.h"
	19	+#include "row0row.h"
	20	+#include "que0que.h"
	21	#ifndef UNIV_HOTBACKUP
	22	# include "buf0lru.h"
	23	# include "ibuf0ibuf.h"
d8778560	24	@@ -3078,7 +3084,7 @@
b4e1fa2c AM	25
	26	file = os_file_create_simple_no_error_handling(
	27	innodb_file_data_key, filepath, OS_FILE_OPEN,
	28	- OS_FILE_READ_ONLY, &success);
	29	+ OS_FILE_READ_WRITE, &success);
	30	if (!success) {
	31	/* The following call prints an error message */
	32	os_file_get_last_error(TRUE);
d8778560	33	@@ -3125,6 +3131,466 @@
b4e1fa2c AM	34	space_id = fsp_header_get_space_id(page);
	35	space_flags = fsp_header_get_flags(page);
	36
d8778560 AM	37	+ if (srv_expand_import) {
d8778560 AM	38	+
b4e1fa2c AM	39	+ ibool file_is_corrupt = FALSE;
	40	+ byte* buf3;
	41	+ byte* descr_page;
	42	+ ibool descr_is_corrupt = FALSE;
	43	+ index_id_t old_id[31];
	44	+ index_id_t new_id[31];
	45	+ ulint root_page[31];
	46	+ ulint n_index;
	47	+ os_file_t info_file = -1;
	48	+ char* info_file_path;
	49	+ ulint i;
	50	+ int len;
	51	+ ib_uint64_t current_lsn;
	52	+ ulint size_low, size_high, size, free_limit;
	53	+ ib_int64_t size_bytes, free_limit_bytes;
	54	+ dict_table_t* table;
	55	+ dict_index_t* index;
	56	+ fil_system_t* system;
	57	+ fil_node_t* node = NULL;
	58	+ fil_space_t* space;
	59	+
	60	+ buf3 = ut_malloc(2 * UNIV_PAGE_SIZE);
	61	+ descr_page = ut_align(buf3, UNIV_PAGE_SIZE);
	62	+
	63	+ current_lsn = log_get_lsn();
	64	+
	65	+ /* check the header page's consistency */
	66	+ if (buf_page_is_corrupted(page,
	67	+ dict_table_flags_to_zip_size(space_flags))) {
	68	+ fprintf(stderr, "InnoDB: page 0 of %s seems corrupt.\n", filepath);
	69	+ file_is_corrupt = TRUE;
	70	+ descr_is_corrupt = TRUE;
	71	+ }
	72	+
	73	+ /* store as first descr page */
	74	+ memcpy(descr_page, page, UNIV_PAGE_SIZE);
	75	+
	76	+ /* get free limit (page number) of the table space */
	77	+/* these should be same to the definition in fsp0fsp.c */
	78	+#define FSP_HEADER_OFFSET FIL_PAGE_DATA
	79	+#define FSP_FREE_LIMIT 12
	80	+ free_limit = mach_read_from_4(FSP_HEADER_OFFSET + FSP_FREE_LIMIT + page);
	81	+ free_limit_bytes = (ib_int64_t)free_limit * (ib_int64_t)UNIV_PAGE_SIZE;
	82	+
	83	+ /* overwrite fsp header */
	84	+ fsp_header_init_fields(page, id, flags);
	85	+ mach_write_to_4(page + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID, id);
	86	+ space_id = id;
	87	+ space_flags = flags;
	88	+ if (mach_read_from_8(page + FIL_PAGE_FILE_FLUSH_LSN) > current_lsn)
	89	+ mach_write_to_8(page + FIL_PAGE_FILE_FLUSH_LSN, current_lsn);
	90	+ mach_write_to_4(page + FIL_PAGE_SPACE_OR_CHKSUM,
	91	+ srv_use_checksums
	92	+ ? buf_calc_page_new_checksum(page)
	93	+ : BUF_NO_CHECKSUM_MAGIC);
	94	+ mach_write_to_4(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
	95	+ srv_use_checksums
	96	+ ? buf_calc_page_old_checksum(page)
	97	+ : BUF_NO_CHECKSUM_MAGIC);
	98	+ success = os_file_write(filepath, file, page, 0, 0, UNIV_PAGE_SIZE);
	99	+
	100	+ /* get file size */
	101	+ os_file_get_size(file, &size_low, &size_high);
	102	+ size_bytes = (((ib_int64_t)size_high) << 32)
103	+ + (ib_int64_t)size_low;
104	+
105	+ if (size_bytes < free_limit_bytes) {
106	+ free_limit_bytes = size_bytes;
107	+ if (size_bytes >= FSP_EXTENT_SIZE * UNIV_PAGE_SIZE) {
108	+ fprintf(stderr, "InnoDB: free limit of %s is larger than its real size.\n", filepath);
109	+ file_is_corrupt = TRUE;
110	+ }
111	+ }
112	+
113	+ /* get cruster index information */
114	+ table = dict_table_get_low(name);
115	+ index = dict_table_get_first_index(table);
116	+ ut_a(index->page==3);
117	+
118	+ /* read metadata from .exp file */
119	+ n_index = 0;
120	+ memset(old_id, 0, sizeof(old_id));
121	+ memset(new_id, 0, sizeof(new_id));
122	+ memset(root_page, 0, sizeof(root_page));
123	+
124	+ info_file_path = fil_make_ibd_name(name, FALSE);
125	+ len = strlen(info_file_path);
126	+ info_file_path[len - 3] = 'e';
127	+ info_file_path[len - 2] = 'x';
128	+ info_file_path[len - 1] = 'p';
129	+
130	+ info_file = os_file_create_simple_no_error_handling(innodb_file_data_key,
131	+ info_file_path, OS_FILE_OPEN, OS_FILE_READ_ONLY, &success);
132	+ if (!success) {
d8778560	133	+ fprintf(stderr, "InnoDB: Cannot open the file: %s\n", info_file_path);
b4e1fa2c AM	134	+ file_is_corrupt = TRUE;
	135	+ goto skip_info;
	136	+ }
	137	+ success = os_file_read(info_file, page, 0, 0, UNIV_PAGE_SIZE);
	138	+ if (!success) {
d8778560	139	+ fprintf(stderr, "InnoDB: Cannot read the file: %s\n", info_file_path);
b4e1fa2c AM	140	+ file_is_corrupt = TRUE;
	141	+ goto skip_info;
	142	+ }
	143	+ if (mach_read_from_4(page) != 0x78706f72UL
	144	+ \|\| mach_read_from_4(page + 4) != 0x74696e66UL) {
d8778560	145	+ fprintf(stderr, "InnoDB: %s seems to be an incorrect .exp file.\n", info_file_path);
b4e1fa2c AM	146	+ file_is_corrupt = TRUE;
	147	+ goto skip_info;
	148	+ }
	149	+
d8778560	150	+ fprintf(stderr, "InnoDB: Import: The extended import of %s is being started.\n", name);
b4e1fa2c AM	151	+
b4e1fa2c AM	152	+ n_index = mach_read_from_4(page + 8);
d8778560	153	+ fprintf(stderr, "InnoDB: Import: %lu indexes have been detected.\n", (ulong)n_index);
b4e1fa2c AM	154	+ for (i = 0; i < n_index; i++) {
	155	+ new_id[i] =
	156	+ dict_table_get_index_on_name(table,
	157	+ (char)(page + (i + 1) 512 + 12))->id;
	158	+ old_id[i] = mach_read_from_8(page + (i + 1) * 512);
	159	+ root_page[i] = mach_read_from_4(page + (i + 1) * 512 + 8);
	160	+ }
	161	+
	162	+skip_info:
	163	+ if (info_file != -1)
	164	+ os_file_close(info_file);
	165	+
	166	+ /*
	167	+ if (size_bytes >= 1024 * 1024) {
	168	+ size_bytes = ut_2pow_round(size_bytes, 1024 * 1024);
	169	+ }
	170	+ */
	171	+ if (!(flags & DICT_TF_ZSSIZE_MASK)) {
	172	+ mem_heap_t* heap = NULL;
	173	+ ulint offsets_[REC_OFFS_NORMAL_SIZE];
	174	+ ulint* offsets = offsets_;
	175	+ ib_int64_t offset;
	176	+
	177	+ size = (ulint) (size_bytes / UNIV_PAGE_SIZE);
	178	+ /* over write space id of all pages */
	179	+ rec_offs_init(offsets_);
	180	+
	181	+ fprintf(stderr, "InnoDB: Progress in %%:");
	182	+
	183	+ for (offset = 0; offset < free_limit_bytes; offset += UNIV_PAGE_SIZE) {
	184	+ ulint checksum_field;
	185	+ ulint old_checksum_field;
	186	+ ibool page_is_corrupt;
	187	+
	188	+ success = os_file_read(file, page,
	189	+ (ulint)(offset & 0xFFFFFFFFUL),
	190	+ (ulint)(offset >> 32), UNIV_PAGE_SIZE);
	191	+
	192	+ page_is_corrupt = FALSE;
	193	+
	194	+ /* check consistency */
	195	+ if (memcmp(page + FIL_PAGE_LSN + 4,
	196	+ page + UNIV_PAGE_SIZE
	197	+ - FIL_PAGE_END_LSN_OLD_CHKSUM + 4, 4)) {
	198	+
	199	+ page_is_corrupt = TRUE;
	200	+ }
	201	+
	202	+ if (mach_read_from_4(page + FIL_PAGE_OFFSET)
	203	+ != offset / UNIV_PAGE_SIZE) {
	204	+
	205	+ page_is_corrupt = TRUE;
	206	+ }
	207	+
	208	+ checksum_field = mach_read_from_4(page
	209	+ + FIL_PAGE_SPACE_OR_CHKSUM);
	210	+
	211	+ old_checksum_field = mach_read_from_4(
	212	+ page + UNIV_PAGE_SIZE
	213	+ - FIL_PAGE_END_LSN_OLD_CHKSUM);
	214	+
	215	+ if (old_checksum_field != mach_read_from_4(page
	216	+ + FIL_PAGE_LSN)
	217	+ && old_checksum_field != BUF_NO_CHECKSUM_MAGIC
218	+ && old_checksum_field
219	+ != buf_calc_page_old_checksum(page)) {
220	+
221	+ page_is_corrupt = TRUE;
222	+ }
223	+
224	+ if (checksum_field != 0
225	+ && checksum_field != BUF_NO_CHECKSUM_MAGIC
226	+ && checksum_field
227	+ != buf_calc_page_new_checksum(page)) {
228	+
229	+ page_is_corrupt = TRUE;
230	+ }
231	+
232	+ /* if it is free page, inconsistency is acceptable */
233	+ if (!offset) {
234	+ /* header page*/
235	+ /* it should be overwritten already */
236	+ ut_a(!page_is_corrupt);
237	+
238	+ } else if (!((offset / UNIV_PAGE_SIZE) % UNIV_PAGE_SIZE)) {
239	+ /* descr page (not header) */
240	+ if (page_is_corrupt) {
241	+ file_is_corrupt = TRUE;
242	+ descr_is_corrupt = TRUE;
243	+ } else {
a9ee80b9	244	+ ut_ad(fil_page_get_type(page) == FIL_PAGE_TYPE_XDES);
b4e1fa2c AM	245	+ descr_is_corrupt = FALSE;
	246	+ }
	247	+
	248	+ /* store as descr page */
	249	+ memcpy(descr_page, page, UNIV_PAGE_SIZE);
	250	+
	251	+ } else if (descr_is_corrupt) {
	252	+ /* unknown state of the page */
	253	+ if (page_is_corrupt) {
	254	+ file_is_corrupt = TRUE;
	255	+ }
	256	+
	257	+ } else {
	258	+ /* check free page or not */
	259	+ /* These definitions should be same to fsp0fsp.c */
	260	+#define FSP_HEADER_SIZE (32 + 5 * FLST_BASE_NODE_SIZE)
	261	+
	262	+#define XDES_BITMAP (FLST_NODE_SIZE + 12)
	263	+#define XDES_BITS_PER_PAGE 2
	264	+#define XDES_FREE_BIT 0
	265	+#define XDES_SIZE \
	266	+ (XDES_BITMAP + UT_BITS_IN_BYTES(FSP_EXTENT_SIZE * XDES_BITS_PER_PAGE))
	267	+#define XDES_ARR_OFFSET (FSP_HEADER_OFFSET + FSP_HEADER_SIZE)
	268	+
	269	+ /descr = descr_page + XDES_ARR_OFFSET + XDES_SIZE xdes_calc_descriptor_index(zip_size, offset)*/
	270	+ /xdes_get_bit(descr, XDES_FREE_BIT, page % FSP_EXTENT_SIZE, mtr)/
	271	+ byte* descr;
	272	+ ulint index;
	273	+ ulint byte_index;
	274	+ ulint bit_index;
	275	+
	276	+ descr = descr_page + XDES_ARR_OFFSET
	277	+ + XDES_SIZE * (ut_2pow_remainder((offset / UNIV_PAGE_SIZE), UNIV_PAGE_SIZE) / FSP_EXTENT_SIZE);
	278	+
	279	+ index = XDES_FREE_BIT + XDES_BITS_PER_PAGE * ((offset / UNIV_PAGE_SIZE) % FSP_EXTENT_SIZE);
	280	+ byte_index = index / 8;
	281	+ bit_index = index % 8;
	282	+
	283	+ if (ut_bit_get_nth(mach_read_from_1(descr + XDES_BITMAP + byte_index), bit_index)) {
	284	+ /* free page */
	285	+ if (page_is_corrupt) {
	286	+ goto skip_write;
	287	+ }
	288	+ } else {
	289	+ /* not free */
	290	+ if (page_is_corrupt) {
	291	+ file_is_corrupt = TRUE;
	292	+ }
	293	+ }
	294	+ }
	295	+
	296	+ if (page_is_corrupt) {
	297	+ fprintf(stderr, " [errp:%lld]", offset / UNIV_PAGE_SIZE);
	298	+
	299	+ /* cannot treat corrupt page */
	300	+ goto skip_write;
	301	+ }
	302	+
	303	+ if (mach_read_from_4(page + FIL_PAGE_OFFSET) \|\| !offset) {
	304	+ mach_write_to_4(page + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID, id);
	305	+
	306	+ for (i = 0; i < n_index; i++) {
	307	+ if (offset / UNIV_PAGE_SIZE == root_page[i]) {
	308	+ /* this is index root page */
309	+ mach_write_to_4(page + FIL_PAGE_DATA + PAGE_BTR_SEG_LEAF
310	+ + FSEG_HDR_SPACE, id);
311	+ mach_write_to_4(page + FIL_PAGE_DATA + PAGE_BTR_SEG_TOP
312	+ + FSEG_HDR_SPACE, id);
313	+ break;
314	+ }
315	+ }
316	+
317	+ if (fil_page_get_type(page) == FIL_PAGE_INDEX) {
318	+ index_id_t tmp = mach_read_from_8(page + (PAGE_HEADER + PAGE_INDEX_ID));
319	+
320	+ if (mach_read_from_2(page + PAGE_HEADER + PAGE_LEVEL) == 0
321	+ && old_id[0] == tmp) {
322	+ /* leaf page of cluster index, reset trx_id of records */
323	+ rec_t* rec;
324	+ rec_t* supremum;
325	+ ulint n_recs;
326	+
327	+ supremum = page_get_supremum_rec(page);
328	+ rec = page_rec_get_next(page_get_infimum_rec(page));
329	+ n_recs = page_get_n_recs(page);
330	+
331	+ while (rec && rec != supremum && n_recs > 0) {
332	+ ulint n_fields;
333	+ ulint i;
334	+ ulint offset = index->trx_id_offset;
335	+ offsets = rec_get_offsets(rec, index, offsets,
336	+ ULINT_UNDEFINED, &heap);
337	+ n_fields = rec_offs_n_fields(offsets);
338	+ if (!offset) {
339	+ offset = row_get_trx_id_offset(rec, index, offsets);
340	+ }
341	+ trx_write_trx_id(rec + offset, 1);
342	+
343	+ for (i = 0; i < n_fields; i++) {
344	+ if (rec_offs_nth_extern(offsets, i)) {
345	+ ulint local_len;
346	+ byte* data;
347	+
348	+ data = rec_get_nth_field(rec, offsets, i, &local_len);
349	+
350	+ local_len -= BTR_EXTERN_FIELD_REF_SIZE;
351	+
352	+ mach_write_to_4(data + local_len + BTR_EXTERN_SPACE_ID, id);
353	+ }
354	+ }
355	+
356	+ rec = page_rec_get_next(rec);
357	+ n_recs--;
358	+ }
359	+ }
360	+
361	+ for (i = 0; i < n_index; i++) {
362	+ if (old_id[i] == tmp) {
363	+ mach_write_to_8(page + (PAGE_HEADER + PAGE_INDEX_ID), new_id[i]);
364	+ break;
365	+ }
366	+ }
367	+ }
368	+
369	+ if (mach_read_from_8(page + FIL_PAGE_LSN) > current_lsn) {
370	+ mach_write_to_8(page + FIL_PAGE_LSN, current_lsn);
371	+ mach_write_to_8(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
372	+ current_lsn);
373	+ }
374	+
375	+ mach_write_to_4(page + FIL_PAGE_SPACE_OR_CHKSUM,
376	+ srv_use_checksums
377	+ ? buf_calc_page_new_checksum(page)
378	+ : BUF_NO_CHECKSUM_MAGIC);
379	+ mach_write_to_4(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
380	+ srv_use_checksums
381	+ ? buf_calc_page_old_checksum(page)
382	+ : BUF_NO_CHECKSUM_MAGIC);
383	+
384	+ success = os_file_write(filepath, file, page,
385	+ (ulint)(offset & 0xFFFFFFFFUL),
386	+ (ulint)(offset >> 32), UNIV_PAGE_SIZE);
387	+ }
388	+
389	+skip_write:
390	+ if (free_limit_bytes
391	+ && ((ib_int64_t)((offset + UNIV_PAGE_SIZE) * 100) / free_limit_bytes)
392	+ != ((offset * 100) / free_limit_bytes)) {
393	+ fprintf(stderr, " %lu",
394	+ (ulong)((ib_int64_t)((offset + UNIV_PAGE_SIZE) * 100) / free_limit_bytes));
395	+ }
396	+ }
397	+
398	+ fprintf(stderr, " done.\n");
399	+
400	+ /* update SYS_INDEXES set root page */
401	+ index = dict_table_get_first_index(table);
402	+ while (index) {
403	+ for (i = 0; i < n_index; i++) {
404	+ if (new_id[i] == index->id) {
405	+ break;
406	+ }
407	+ }
408	+
409	+ if (i != n_index
410	+ && root_page[i] != index->page) {
411	+ /* must update */
412	+ ulint error;
413	+ trx_t* trx;
414	+ pars_info_t* info = NULL;
415	+
416	+ trx = trx_allocate_for_mysql();
417	+ trx->op_info = "extended import";
418	+
419	+ info = pars_info_create();
420	+
421	+ pars_info_add_ull_literal(info, "indexid", new_id[i]);
422	+ pars_info_add_int4_literal(info, "new_page", (lint) root_page[i]);
423	+
424	+ error = que_eval_sql(info,
425	+ "PROCEDURE UPDATE_INDEX_PAGE () IS\n"
426	+ "BEGIN\n"
427	+ "UPDATE SYS_INDEXES"
428	+ " SET PAGE_NO = :new_page"
429	+ " WHERE ID = :indexid;\n"
430	+ "COMMIT WORK;\n"
431	+ "END;\n",
432	+ FALSE, trx);
433	+
434	+ if (error != DB_SUCCESS) {
435	+ fprintf(stderr, "InnoDB: failed to update SYS_INDEXES\n");
436	+ }
437	+
438	+ trx_commit_for_mysql(trx);
439	+
440	+ trx_free_for_mysql(trx);
441	+
442	+ index->page = root_page[i];
443	+ }
444	+
445	+ index = dict_table_get_next_index(index);
446	+ }
447	+ if (UNIV_LIKELY_NULL(heap)) {
448	+ mem_heap_free(heap);
449	+ }
450	+ } else {
451	+ /* zip page? */
452	+ size = (ulint)
453	+ (size_bytes
454	+ / dict_table_flags_to_zip_size(flags));
d8778560 AM	455	+ fprintf(stderr, "InnoDB: Import: The table %s seems to be in a newer format."
d8778560 AM	456	+ " It may not be possible to process it.\n", name);
b4e1fa2c AM	457	+ }
	458	+ /* .exp file should be removed */
	459	+ success = os_file_delete(info_file_path);
	460	+ if (!success) {
	461	+ success = os_file_delete_if_exists(info_file_path);
	462	+ }
	463	+ mem_free(info_file_path);
	464	+
	465	+ system = fil_system;
	466	+ mutex_enter(&(system->mutex));
	467	+ space = fil_space_get_by_id(id);
	468	+ if (space)
	469	+ node = UT_LIST_GET_FIRST(space->chain);
	470	+ if (node && node->size < size) {
	471	+ space->size += (size - node->size);
	472	+ node->size = size;
	473	+ }
	474	+ mutex_exit(&(system->mutex));
	475	+
	476	+ ut_free(buf3);
	477	+
	478	+ if (file_is_corrupt) {
	479	+ ut_print_timestamp(stderr);
	480	+ fputs(" InnoDB: Error: file ",
	481	+ stderr);
	482	+ ut_print_filename(stderr, filepath);
	483	+ fprintf(stderr, " seems to be corrupt.\n"
d8778560	484	+ "InnoDB: An attempt to convert and salvage all corrupt pages was not made.\n"
b4e1fa2c	485	+ "InnoDB: ##### CAUTION #####\n"
d8778560 AM	486	+ "InnoDB: ## The .ibd file may cause InnoDB to crash, even though its re-import seems to have succeeded.\n"
d8778560 AM	487	+ "InnoDB: ## If you don't know how to salvage data from a .ibd, you should not use the file.\n"
b4e1fa2c AM	488	+ "InnoDB: ###################\n");
	489	+ success = FALSE;
	490	+
	491	+ ut_free(buf2);
	492	+
	493	+ goto func_exit;
	494	+ }
	495	+ }
	496	+
	497	ut_free(buf2);
	498
	499	if (UNIV_UNLIKELY(space_id != id
	500	diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
	501	--- a/storage/innobase/handler/ha_innodb.cc 2010-12-03 15:49:59.195023983 +0900
	502	+++ b/storage/innobase/handler/ha_innodb.cc 2010-12-03 15:52:23.555957062 +0900
d8778560	503	@@ -7337,6 +7337,14 @@
b4e1fa2c AM	504	err = row_discard_tablespace_for_mysql(dict_table->name, trx);
	505	} else {
	506	err = row_import_tablespace_for_mysql(dict_table->name, trx);
	507	+
	508	+ /* in expanded import mode re-initialize auto_increment again */
	509	+ if ((err == DB_SUCCESS) && srv_expand_import &&
	510	+ (table->found_next_number_field != NULL)) {
	511	+ dict_table_autoinc_lock(dict_table);
	512	+ innobase_initialize_autoinc();
	513	+ dict_table_autoinc_unlock(dict_table);
	514	+ }
	515	}
	516
	517	err = convert_error_code_to_mysql(err, dict_table->flags, NULL);
d8778560 AM	518	@@ -11538,6 +11546,11 @@
	519	"Choose method of innodb_adaptive_flushing. (native, [estimate], keep_average)",
	520	NULL, innodb_adaptive_flushing_method_update, 1, &adaptive_flushing_method_typelib);
b4e1fa2c	521
a9ee80b9	522	+static MYSQL_SYSVAR_ULONG(import_table_from_xtrabackup, srv_expand_import,
b4e1fa2c AM	523	+ PLUGIN_VAR_RQCMDARG,
	524	+ "Enable/Disable converting automatically *.ibd files when import tablespace.",
	525	+ NULL, NULL, 0, 0, 1, 0);
	526	+
	527	static MYSQL_SYSVAR_ULONG(extra_rsegments, srv_extra_rsegments,
	528	PLUGIN_VAR_RQCMDARG,
	529	"Number of extra user rollback segments which are used in a round-robin fashion.",
d8778560 AM	530	@@ -11614,6 +11627,7 @@
d8778560 AM	531	MYSQL_SYSVAR(flush_neighbor_pages),
b4e1fa2c AM	532	MYSQL_SYSVAR(read_ahead),
b4e1fa2c AM	533	MYSQL_SYSVAR(adaptive_flushing_method),
a9ee80b9	534	+ MYSQL_SYSVAR(import_table_from_xtrabackup),
b4e1fa2c AM	535	MYSQL_SYSVAR(extra_rsegments),
	536	MYSQL_SYSVAR(dict_size_limit),
	537	MYSQL_SYSVAR(use_sys_malloc),
	538	diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
	539	--- a/storage/innobase/include/srv0srv.h 2010-12-03 15:48:03.077954270 +0900
	540	+++ b/storage/innobase/include/srv0srv.h 2010-12-03 15:52:23.561986996 +0900
	541	@@ -227,6 +227,8 @@
	542	extern ulint srv_read_ahead;
	543	extern ulint srv_adaptive_flushing_method;
	544
	545	+extern ulint srv_expand_import;
	546	+
	547	extern ulint srv_extra_rsegments;
	548	extern ulint srv_dict_size_limit;
	549	/-------------------------------------------/
	550	diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
	551	--- a/storage/innobase/srv/srv0srv.c 2010-12-03 15:49:59.230956118 +0900
	552	+++ b/storage/innobase/srv/srv0srv.c 2010-12-03 15:52:23.562954411 +0900
d8778560	553	@@ -415,6 +415,8 @@
b4e1fa2c AM	554	UNIV_INTERN ulint srv_read_ahead = 3; /* 1: random 2: linear 3: Both */
	555	UNIV_INTERN ulint srv_adaptive_flushing_method = 0; /* 0: native 1: estimate 2: keep_average */
	556
	557	+UNIV_INTERN ulint srv_expand_import = 0; /* 0:disable 1:enable */
	558	+
	559	UNIV_INTERN ulint srv_extra_rsegments = 127; /* extra rseg for users */
	560	UNIV_INTERN ulint srv_dict_size_limit = 0;
	561	/-------------------------------------------/