Merge lp:~laurynas-biveinis/percona-xtrabackup/BT-28340-2.1 into lp:percona-xtrabackup/2.1

[Laurynas Biveinis]

Support for building XtraBackup against MySQL 5.6.

BT 28340

http://jenkins.percona.com/job/percona-xtrabackup-2.1-param/233/

Merge build against MySQL 5.6 support from 2.0.

Additional changes for 2.1:

- Port compact backups support to 5.6. Remove
  dict_sys_table_get_flags() function, fixing bug 1156195
  (dict_sys_tables_get_flags() in compact.cc redundant). Commit the
  transaction after each rebuilt table and remove the temporary data
  dictionary unlocks.

- New functions in the InnoDB compatibility/internals layer
  xb_parse_log_group_home_dirs(), xb_set_innodb_read_only(),
  xb_adjust_fatal_semaphore_wait_threshold(), and
  xb_dict_index_field_to_index_field(). Define trx_start_for_ddl()
  and ut_crc32_init() as no-op macros for 5.5-.

- Decouple ds_encrypt.c and xbcrypt_common.c from InnoDB by removing
  univ.i includes and replacing ut_a with xb_a.

- Link xbcrypt with the C++ compiler.

[Laurynas Biveinis (laurynas-biveinis)]

The original goal was to contain the MYSQL_VERSION_ID checks to innodb_int.[hc], but I didn't succeed with it. In the case of compact backups it would require creating some "compact backup rebuilder context" in innodb_int and then calling some functions in predefined sequence, which didn't seem worth the hassle.

[Stewart Smith (stewart)]

(preliminary review) looks good. Far better than existing 2.1 innodb56 support :)

We should wait for Alexey to review before merging, also as mine was not too in depth.

review: Approve

[Alexey Kopytov (akopytov)]

Approved, but it also contains bug #1164979 which I overlooked when reviewing the 2.0 MP.

review: Approve

=== modified file 'BUILD.txt'
--- BUILD.txt	2012-11-22 09:55:05 +0000
+++ BUILD.txt	2013-03-22 15:32:33 +0000
@@ -34,6 +34,7 @@
   innodb55           5.5	build against InnoDB in MySQL 5.5
   xtradb51           xtradb     build against Percona Server with XtraDB 5.1
   xtradb55           xtradb55   build against Percona Server with XtraDB 5.5
+  innodb56           5.6        build against InnoDB in MySQL 5.6
   ================== =========  =============================================
 
 Note that the script must be executed from the base directory of Xtrabackup 

=== added file 'patches/innodb56.patch'
--- patches/innodb56.patch	1970-01-01 00:00:00 +0000
+++ patches/innodb56.patch	2013-03-22 15:32:33 +0000
@@ -0,0 +1,974 @@
+--- a/storage/innobase/btr/btr0btr.cc
++++ b/storage/innobase/btr/btr0btr.cc
+@@ -700,7 +700,7 @@
+ /**************************************************************//**
+ Gets the root node of a tree and x- or s-latches it.
+ @return	root page, x- or s-latched */
+-static
++UNIV_INTERN
+ buf_block_t*
+ btr_root_block_get(
+ /*===============*/
+@@ -1346,7 +1346,7 @@
+ /************************************************************//**
+ Returns the child page of a node pointer and x-latches it.
+ @return	child page, x-latched */
+-static
++UNIV_INTERN
+ buf_block_t*
+ btr_node_ptr_get_child(
+ /*===================*/
+--- a/storage/innobase/buf/buf0buf.cc
++++ b/storage/innobase/buf/buf0buf.cc
+@@ -53,6 +53,7 @@
+ #include "page0zip.h"
+ #include "srv0mon.h"
+ #include "buf0checksum.h"
++#include "xb0xb.h"
+ 
+ /*
+ 		IMPLEMENTATION OF THE BUFFER POOL
+@@ -549,9 +550,15 @@
+ 	if (checksum_field1 == 0 && checksum_field2 == 0
+ 	    && mach_read_from_4(read_buf + FIL_PAGE_LSN) == 0) {
+ 		/* make sure that the page is really empty */
++#if 0
++		/* Do not make sure that the page is really empty as this check
++		is incompatible with 1st newly-created tablespace pages, which
++		have FIL_PAGE_FIL_FLUSH_LSN != 0, FIL_PAGE_OR_CHKSUM == 0,
++		FIL_PAGE_END_LSN_OLD_CHKSUM == 0 */
+ 		ut_d(for (ulint i = 0; i < UNIV_PAGE_SIZE; i++) {
+ 		     ut_a(read_buf[i] == 0); });
+ 
++#endif
+ 		return(FALSE);
+ 	}
+ 
+@@ -976,6 +983,7 @@
+ 	block->page.in_flush_list = FALSE;
+ 	block->page.in_free_list = FALSE;
+ 	block->page.in_LRU_list = FALSE;
++	block->page.is_compacted = FALSE;
+ 	block->in_unzip_LRU_list = FALSE;
+ #endif /* UNIV_DEBUG */
+ #if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
+@@ -3951,6 +3959,13 @@
+ 			frame = ((buf_block_t*) bpage)->frame;
+ 		}
+ 
++		/* Do not validate, recover and apply change buffer entries to
++		bogus pages which replace skipped pages in compact backups. */
++		if (srv_compact_backup && buf_page_is_compacted(frame)) {
++
++			bpage->is_compacted = TRUE;
++		}
++
+ 		/* If this page is not uninitialized and not in the
+ 		doublewrite buffer, then the page number and space id
+ 		should be the same as in block. */
+@@ -4068,7 +4083,7 @@
+ 			recv_recover_page(TRUE, (buf_block_t*) bpage);
+ 		}
+ 
+-		if (uncompressed && !recv_no_ibuf_operations) {
++		if (uncompressed && !recv_no_ibuf_operations && !bpage->is_compacted) {
+ 			ibuf_merge_or_delete_for_page(
+ 				(buf_block_t*) bpage, bpage->space,
+ 				bpage->offset, buf_page_get_zip_size(bpage),
+--- a/storage/innobase/fil/fil0fil.cc
++++ b/storage/innobase/fil/fil0fil.cc
+@@ -43,6 +43,8 @@
+ #include "dict0dict.h"
+ #include "page0page.h"
+ #include "page0zip.h"
++#include "pars0pars.h"
++#include "que0que.h"
+ #include "trx0sys.h"
+ #include "row0mysql.h"
+ #ifndef UNIV_HOTBACKUP
+@@ -311,7 +313,7 @@
+ 
+ /** The tablespace memory cache. This variable is NULL before the module is
+ initialized. */
+-static fil_system_t*	fil_system	= NULL;
++fil_system_t*	fil_system	= NULL;
+ 
+ /** Determine if (i) is a user tablespace id or not. */
+ # define fil_is_user_tablespace_id(i) ((i) > srv_undo_tablespaces_open)
+@@ -376,7 +378,7 @@
+ off the LRU list if it is in the LRU list. The caller must hold the fil_sys
+ mutex. */
+ static
+-void
++ulint
+ fil_node_prepare_for_io(
+ /*====================*/
+ 	fil_node_t*	node,	/*!< in: file node */
+@@ -691,7 +693,7 @@
+ Opens a file of a node of a tablespace. The caller must own the fil_system
+ mutex. */
+ static
+-void
++ulint
+ fil_node_open_file(
+ /*===============*/
+ 	fil_node_t*	node,	/*!< in: file node */
+@@ -725,6 +727,18 @@
+ 			OS_FILE_READ_ONLY, &success);
+ 		if (!success) {
+ 			/* The following call prints an error message */
++			if (os_file_get_last_error(TRUE) == OS_FILE_NOT_FOUND)
++			{
++				ut_print_timestamp(stderr);
++				fprintf(stderr,
++					" InnoDB: Warning: cannot open %s\n"
++					"InnoDB: this can happen if the table "
++					"was removed or renamed during an \n"
++					"InnoDB: xtrabackup run and is not dangerous.\n",
++					node->name);
++				return(OS_FILE_NOT_FOUND);
++			}
++
+ 			os_file_get_last_error(true);
+ 
+ 			ut_print_timestamp(stderr);
+@@ -783,12 +797,17 @@
+ 
+ 		if (UNIV_UNLIKELY(space_id != space->id)) {
+ 			fprintf(stderr,
+-				"InnoDB: Error: tablespace id is %lu"
++				"InnoDB: Warning: tablespace id is %lu"
+ 				" in the data dictionary\n"
+-				"InnoDB: but in file %s it is %lu!\n",
++				"InnoDB: but in file %s it is %lu!\n"
++				"InnoDB: this can happen if the table "
++				"metadata was modified during an xtrabackup "
++				"run\n"
++				"InnoDB: and is not dangerous.\n",
++
+ 				space->id, node->name, space_id);
+ 
+-			ut_error;
++			return(OS_FILE_NOT_FOUND);
+ 		}
+ 
+ 		if (UNIV_UNLIKELY(space_id == ULINT_UNDEFINED
+@@ -825,8 +844,9 @@
+ 		}
+ 
+ 		if (size_bytes >= 1024 * 1024) {
+-			/* Truncate the size to whole megabytes. */
+-			size_bytes = ut_2pow_round(size_bytes, 1024 * 1024);
++			/* The size should be exact for after applying
++			.delta */
++			//size_bytes = ut_2pow_round(size_bytes, 1024 * 1024);
+ 		}
+ 
+ 		if (!fsp_flags_is_compressed(flags)) {
+@@ -879,6 +899,8 @@
+ 		/* Put the node to the LRU list */
+ 		UT_LIST_ADD_FIRST(LRU, system->LRU, node);
+ 	}
++
++	return(0);
+ }
+ 
+ /**********************************************************************//**
+@@ -1491,7 +1513,12 @@
+ 		the file yet; the following calls will open it and update the
+ 		size fields */
+ 
+-		fil_node_prepare_for_io(node, fil_system, space);
++		if (fil_node_prepare_for_io(node, fil_system, space))
++		{
++			mutex_exit(&fil_system->mutex);
++
++			return(NULL);
++		}
+ 		fil_node_complete_io(node, fil_system, OS_FILE_READ);
+ 	}
+ 
+@@ -2095,7 +2122,7 @@
+ 	mem_free(path);
+ }
+ 
+-#ifndef UNIV_HOTBACKUP
++#if 0
+ /********************************************************//**
+ Writes a log record about an .ibd file create/rename/delete. */
+ static
+@@ -2329,7 +2356,7 @@
+ 				    space_id, name, path, flags,
+ 				    DICT_TF2_USE_TABLESPACE,
+ 				    FIL_IBD_FILE_INITIAL_SIZE) != DB_SUCCESS) {
+-				ut_error;
++				//ut_error;
+ 			}
+ 		}
+ 
+@@ -2687,7 +2714,7 @@
+ 	}
+ 
+ 	if (err == DB_SUCCESS) {
+-#ifndef UNIV_HOTBACKUP
++#if 0
+ 		/* Write a log record about the deletion of the .ibd
+ 		file, so that ibbackup can replay it in the
+ 		--apply-log phase. We use a dummy mtr and the familiar
+@@ -3042,7 +3069,7 @@
+ 
+ 	mutex_exit(&fil_system->mutex);
+ 
+-#ifndef UNIV_HOTBACKUP
++#if 0
+ 	if (success && !recv_recovery_on) {
+ 		mtr_t		mtr;
+ 
+@@ -3426,7 +3453,7 @@
+ 		goto error_exit_1;
+ 	}
+ 
+-#ifndef UNIV_HOTBACKUP
++#if 0
+ 	{
+ 		mtr_t		mtr;
+ 		ulint		mlog_file_flag = 0;
+@@ -3504,6 +3531,97 @@
+ #endif /* UNIV_LOG_ARCHIVE */
+ };
+ 
++static
++void
++fil_remove_invalid_table_from_data_dict(const char *name)
++{
++	trx_t*		trx;
++	pars_info_t*	info = NULL;
++
++	trx = trx_allocate_for_mysql();
++	trx_start_for_ddl(trx, TRX_DICT_OP_TABLE);
++
++	ut_ad(mutex_own(&dict_sys->mutex));
++
++	trx->op_info = "removing invalid table from data dictionary";
++
++	info = pars_info_create();
++
++	pars_info_add_str_literal(info, "table_name", name);
++
++	que_eval_sql(info,
++		     "PROCEDURE DROP_TABLE_PROC () IS\n"
++		     "sys_foreign_id CHAR;\n"
++		     "table_id CHAR;\n"
++		     "index_id CHAR;\n"
++		     "foreign_id CHAR;\n"
++		     "found INT;\n"
++		     "BEGIN\n"
++		     "SELECT ID INTO table_id\n"
++		     "FROM SYS_TABLES\n"
++		     "WHERE NAME = :table_name\n"
++		     "LOCK IN SHARE MODE;\n"
++		     "IF (SQL % NOTFOUND) THEN\n"
++		     "       RETURN;\n"
++		     "END IF;\n"
++		     "found := 1;\n"
++		     "SELECT ID INTO sys_foreign_id\n"
++		     "FROM SYS_TABLES\n"
++		     "WHERE NAME = 'SYS_FOREIGN'\n"
++		     "LOCK IN SHARE MODE;\n"
++		     "IF (SQL % NOTFOUND) THEN\n"
++		     "       found := 0;\n"
++		     "END IF;\n"
++		     "IF (:table_name = 'SYS_FOREIGN') THEN\n"
++		     "       found := 0;\n"
++		     "END IF;\n"
++		     "IF (:table_name = 'SYS_FOREIGN_COLS') THEN\n"
++		     "       found := 0;\n"
++		     "END IF;\n"
++		     "WHILE found = 1 LOOP\n"
++		     "       SELECT ID INTO foreign_id\n"
++		     "       FROM SYS_FOREIGN\n"
++		     "       WHERE FOR_NAME = :table_name\n"
++		     "               AND TO_BINARY(FOR_NAME)\n"
++		     "                 = TO_BINARY(:table_name)\n"
++		     "               LOCK IN SHARE MODE;\n"
++		     "       IF (SQL % NOTFOUND) THEN\n"
++		     "               found := 0;\n"
++		     "       ELSE\n"
++		     "               DELETE FROM SYS_FOREIGN_COLS\n"
++		     "               WHERE ID = foreign_id;\n"
++		     "               DELETE FROM SYS_FOREIGN\n"
++		     "               WHERE ID = foreign_id;\n"
++		     "       END IF;\n"
++		     "END LOOP;\n"
++		     "found := 1;\n"
++		     "WHILE found = 1 LOOP\n"
++		     "       SELECT ID INTO index_id\n"
++		     "       FROM SYS_INDEXES\n"
++		     "       WHERE TABLE_ID = table_id\n"
++		     "       LOCK IN SHARE MODE;\n"
++		     "       IF (SQL % NOTFOUND) THEN\n"
++		     "               found := 0;\n"
++		     "       ELSE\n"
++		     "               DELETE FROM SYS_FIELDS\n"
++		     "               WHERE INDEX_ID = index_id;\n"
++		     "               DELETE FROM SYS_INDEXES\n"
++		     "               WHERE ID = index_id\n"
++		     "               AND TABLE_ID = table_id;\n"
++		     "       END IF;\n"
++		     "END LOOP;\n"
++		     "DELETE FROM SYS_COLUMNS\n"
++		     "WHERE TABLE_ID = table_id;\n"
++		     "DELETE FROM SYS_TABLES\n"
++		     "WHERE ID = table_id;\n"
++		     "END;\n"
++		     , FALSE, trx);
++
++	trx_commit_for_mysql(trx);
++
++	trx_free_for_mysql(trx);
++}
++
+ /********************************************************************//**
+ Tries to open a single-table tablespace and optionally checks that the
+ space id in it is correct. If this does not succeed, print an error message
+@@ -3712,11 +3830,15 @@
+ 		/* The following call prints an error message */
+ 		os_file_get_last_error(true);
+ 
+-		ib_logf(IB_LOG_LEVEL_ERROR,
++		ib_logf(IB_LOG_LEVEL_WARN,
+ 			"Could not find a valid tablespace file for '%s'. "
+ 			"See " REFMAN "innodb-troubleshooting-datadict.html "
+ 			"for how to resolve the issue.",
+ 			tablename);
++		ib_logf(IB_LOG_LEVEL_WARN,
++			"It will be removed from the data dictionary.");
++
++		fil_remove_invalid_table_from_data_dict(tablename);
+ 
+ 		err = DB_CORRUPTION;
+ 
+@@ -4135,7 +4257,7 @@
+ 	cannot be ok. */
+ 	ulong minimum_size = FIL_IBD_FILE_INITIAL_SIZE * UNIV_PAGE_SIZE;
+ 	if (size < minimum_size) {
+-#ifndef UNIV_HOTBACKUP
++#if 0
+ 		ib_logf(IB_LOG_LEVEL_ERROR,
+ 			"The size of single-table tablespace file %s "
+ 			"is only " UINT64PF ", should be at least %lu!",
+@@ -4263,7 +4385,7 @@
+ idea is to read as much good data as we can and jump over bad data.
+ @return 0 if ok, -1 if error even after the retries, 1 if at the end
+ of the directory */
+-static
++UNIV_INTERN
+ int
+ fil_file_readdir_next_file(
+ /*=======================*/
+@@ -4359,7 +4481,9 @@
+ 			    "%s/%s", fil_path_to_mysql_datadir, dbinfo.name);
+ 		srv_normalize_path_for_win(dbpath);
+ 
+-		dbdir = os_file_opendir(dbpath, FALSE);
++		/* We want wrong directory permissions to be a fatal error for
++		XtraBackup. */
++		dbdir = os_file_opendir(dbpath, TRUE);
+ 
+ 		if (dbdir != NULL) {
+ 
+@@ -4538,6 +4662,7 @@
+ {
+ 	fil_space_t*	fnamespace;
+ 	fil_space_t*	space;
++	ibool		remove_from_data_dict = FALSE;
+ 
+ 	ut_ad(fil_system);
+ 
+@@ -4615,6 +4740,10 @@
+ 		if (fnamespace == NULL) {
+ 			if (print_error_if_does_not_exist) {
+ 				fil_report_missing_tablespace(name, id);
++				ib_logf(IB_LOG_LEVEL_WARN,
++					"It will be removed from "
++					"the data dictionary.");
++				remove_from_data_dict = TRUE;
+ 			}
+ 		} else {
+ 			ut_print_timestamp(stderr);
+@@ -4638,6 +4767,10 @@
+ 
+ 		mutex_exit(&fil_system->mutex);
+ 
++		if (remove_from_data_dict) {
++			fil_remove_invalid_table_from_data_dict(name);
++		}
++
+ 		return(FALSE);
+ 	}
+ 
+@@ -4728,6 +4861,7 @@
+ 	ulint		page_size;
+ 	ulint		pages_added;
+ 	ibool		success;
++	ulint		err = 0;
+ 
+ 	ut_ad(!srv_read_only_mode);
+ 
+@@ -4772,13 +4906,17 @@
+ 		goto retry;
+ 	}
+ 
+-	fil_node_prepare_for_io(node, fil_system, space);
++	err = fil_node_prepare_for_io(node, fil_system, space);
+ 
+ 	/* At this point it is safe to release fil_system mutex. No
+ 	other thread can rename, delete or close the file because
+ 	we have set the node->being_extended flag. */
+ 	mutex_exit(&fil_system->mutex);
+ 
++	if (err) {
++		return FALSE;
++	}
++
+ 	start_page_no = space->size;
+ 	file_start_page_no = space->size - node->size;
+ 
+@@ -5024,7 +5162,7 @@
+ off the LRU list if it is in the LRU list. The caller must hold the fil_sys
+ mutex. */
+ static
+-void
++ulint
+ fil_node_prepare_for_io(
+ /*====================*/
+ 	fil_node_t*	node,	/*!< in: file node */
+@@ -5044,9 +5182,12 @@
+ 	}
+ 
+ 	if (node->open == FALSE) {
++		ulint	err;
+ 		/* File is closed: open it */
+ 		ut_a(node->n_pending == 0);
+-		fil_node_open_file(node, system, space);
++		err = fil_node_open_file(node, system, space);
++		if (err)
++			return(err);
+ 	}
+ 
+ 	if (node->n_pending == 0 && fil_space_belongs_in_lru(space)) {
+@@ -5058,6 +5199,8 @@
+ 	}
+ 
+ 	node->n_pending++;
++
++	return(0);
+ }
+ 
+ /********************************************************************//**
+@@ -5259,6 +5402,16 @@
+ 
+ 	ut_ad(mode != OS_AIO_IBUF || space->purpose == FIL_TABLESPACE);
+ 
++	if (space->size > 0 && space->size <= block_offset) {
++		ulint	actual_size;
++
++		mutex_exit(&fil_system->mutex);
++		fil_extend_space_to_desired_size(&actual_size, space->id,
++						 block_offset + 1);
++		mutex_enter(&fil_system->mutex);
++		/* should retry? but it may safe for xtrabackup for now. */
++	}
++
+ 	node = UT_LIST_GET_FIRST(space->chain);
+ 
+ 	for (;;) {
+@@ -5290,7 +5443,11 @@
+ 	}
+ 
+ 	/* Open file if closed */
+-	fil_node_prepare_for_io(node, fil_system, space);
++	if (fil_node_prepare_for_io(node, fil_system, space)) {
++
++		mutex_exit(&fil_system->mutex);
++		return(DB_TABLESPACE_DELETED);
++	}
+ 
+ 	/* Check that at least the start offset is within the bounds of a
+ 	single-table tablespace, including rollback tablespaces. */
+@@ -6164,6 +6321,7 @@
+ 	return(err);
+ }
+ 
++#if 0
+ /****************************************************************//**
+ Generate redo logs for swapping two .ibd files */
+ UNIV_INTERN
+@@ -6187,4 +6345,4 @@
+ 			 0, 0, new_name, old_name, &mtr);
+ 	mtr_commit(&mtr);
+ }
+-
++#endif
+--- a/storage/innobase/handler/ha_innodb.cc
++++ b/storage/innobase/handler/ha_innodb.cc
+@@ -1548,7 +1548,7 @@
+ 		ut_ad(*mbminlen < DATA_MBMAX);
+ 		ut_ad(*mbmaxlen < DATA_MBMAX);
+ 	} else {
+-		THD*	thd = current_thd;
++		THD*	thd = NULL;
+ 
+ 		if (thd && thd_sql_command(thd) == SQLCOM_DROP_TABLE) {
+ 
+--- a/storage/innobase/include/srv0srv.h
++++ b/storage/innobase/include/srv0srv.h
+@@ -353,6 +353,9 @@
+ extern ulong	srv_max_purge_lag_delay;
+ 
+ extern ulong	srv_replication_delay;
++
++extern ibool	srv_apply_log_only;
++
+ /*-------------------------------------------*/
+ 
+ extern ibool	srv_print_innodb_monitor;
+--- a/storage/innobase/log/log0recv.cc
++++ b/storage/innobase/log/log0recv.cc
+@@ -43,20 +43,21 @@
+ #include "trx0undo.h"
+ #include "trx0rec.h"
+ #include "fil0fil.h"
+-#ifndef UNIV_HOTBACKUP
++//#ifndef UNIV_HOTBACKUP
+ # include "buf0rea.h"
+ # include "srv0srv.h"
+ # include "srv0start.h"
+ # include "trx0roll.h"
+ # include "row0merge.h"
+ # include "sync0sync.h"
+-#else /* !UNIV_HOTBACKUP */
++//#else /* !UNIV_HOTBACKUP */
++#include "xb0xb.h"
+ 
+ /** This is set to FALSE if the backup was originally taken with the
+ ibbackup --include regexp option: then we do not want to create tables in
+ directories which were not included */
+ UNIV_INTERN ibool	recv_replay_file_ops	= TRUE;
+-#endif /* !UNIV_HOTBACKUP */
++//#endif /* !UNIV_HOTBACKUP */
+ 
+ /** Log records are stored in the hash table in chunks at most of this size;
+ this must be less than UNIV_PAGE_SIZE as it is stored in the buffer pool */
+@@ -399,7 +400,7 @@
+ 	/* Set appropriate value of recv_n_pool_free_frames. */
+ 	if (buf_pool_get_curr_size() >= (10 * 1024 * 1024)) {
+ 		/* Buffer pool of size greater than 10 MB. */
+-		recv_n_pool_free_frames = 512;
++		recv_n_pool_free_frames = 1024;
+ 	}
+ 
+ 	recv_sys->buf = static_cast<byte*>(ut_malloc(RECV_PARSING_BUF_SIZE));
+@@ -703,7 +704,7 @@
+ /***********************************************************************//**
+ Checks the consistency of the checkpoint info
+ @return	TRUE if ok */
+-static
++UNIV_INTERN
+ ibool
+ recv_check_cp_is_consistent(
+ /*========================*/
+@@ -733,7 +734,7 @@
+ /********************************************************//**
+ Looks for the maximum consistent checkpoint from the log groups.
+ @return	error code or DB_SUCCESS */
+-static __attribute__((nonnull, warn_unused_result))
++UNIV_INTERN __attribute__((nonnull, warn_unused_result))
+ dberr_t
+ recv_find_max_checkpoint(
+ /*=====================*/
+@@ -893,7 +894,7 @@
+ InnoDB-3.23.52 where the checksum field contains the log block number.
+ @return TRUE if ok, or if the log block may be in the format of InnoDB
+ version predating 3.23.52 */
+-static
++UNIV_INTERN
+ ibool
+ log_block_checksum_is_ok_or_old_format(
+ /*===================================*/
+@@ -1588,6 +1589,8 @@
+ 					     buf_block_get_page_no(block));
+ 
+ 	if ((recv_addr == NULL)
++	    /* Fix for http://bugs.mysql.com/bug.php?id=44140 */
++	    || (recv_addr->state == RECV_BEING_READ && !just_read_in)
+ 	    || (recv_addr->state == RECV_BEING_PROCESSED)
+ 	    || (recv_addr->state == RECV_PROCESSED)) {
+ 
+@@ -1677,9 +1680,17 @@
+ 			if (page_zip) {
+ 				memset(FIL_PAGE_LSN + page_zip->data, 0, 8);
+ 			}
++
++			if (!block->page.is_compacted
++			    && block->page.is_compacted) {
++
++				ut_ad(srv_compact_backup);
++
++				block->page.is_compacted = FALSE;
++			}
+ 		}
+ 
+-		if (recv->start_lsn >= page_lsn) {
++		if (!block->page.is_compacted && recv->start_lsn >= page_lsn) {
+ 
+ 			lsn_t	end_lsn;
+ 
+@@ -2413,7 +2424,7 @@
+ 			   || type == MLOG_FILE_RENAME
+ 			   || type == MLOG_FILE_DELETE) {
+ 			ut_a(space);
+-#ifdef UNIV_HOTBACKUP
++//#ifdef UNIV_HOTBACKUP
+ 			if (recv_replay_file_ops) {
+ 
+ 				/* In ibbackup --apply-log, replay an .ibd file
+@@ -2436,7 +2447,7 @@
+ 					ut_error;
+ 				}
+ 			}
+-#endif
++//#endif
+ 			/* In normal mysqld crash recovery we do not try to
+ 			replay file operations */
+ #ifdef UNIV_LOG_LSN_DEBUG
+@@ -2863,8 +2874,14 @@
+ 
+ 			fprintf(stderr,
+ 				"InnoDB: Doing recovery: scanned up to"
+-				" log sequence number " LSN_PF "\n",
+-				*group_scanned_lsn);
++				" log sequence number " LSN_PF " (%lu%%)\n",
++				*group_scanned_lsn,
++				(ulong) ((*group_scanned_lsn
++					  - recv_sys->parse_start_lsn)
++					 / (8 * log_group_get_capacity(
++						UT_LIST_GET_FIRST(
++						    log_sys->log_groups))
++					    / 900)));
+ 		}
+ 	}
+ 
+@@ -3456,7 +3473,8 @@
+ 	that the data dictionary tables will be free of any locks.
+ 	The data dictionary latch should guarantee that there is at
+ 	most one data dictionary transaction active at a time. */
+-	if (srv_force_recovery < SRV_FORCE_NO_TRX_UNDO) {
++	if (srv_force_recovery < SRV_FORCE_NO_TRX_UNDO
++	    && !srv_apply_log_only) {
+ 		trx_rollback_or_clean_recovered(FALSE);
+ 	}
+ }
+--- a/storage/innobase/os/os0file.cc
++++ b/storage/innobase/os/os0file.cc
+@@ -699,7 +699,7 @@
+ }
+ 
+ #undef USE_FILE_LOCK
+-#define USE_FILE_LOCK
++//#define USE_FILE_LOCK
+ #if defined(UNIV_HOTBACKUP) || defined(__WIN__)
+ /* InnoDB Hot Backup does not lock the data files.
+  * On Windows, mandatory locking is used.
+--- a/storage/innobase/row/row0merge.cc
++++ b/storage/innobase/row/row0merge.cc
+@@ -3227,9 +3227,11 @@
+ 		goto err_exit;
+ 	}
+ 
++#if 0
+ 	/* Generate the redo logs for file operations */
+ 	fil_mtr_rename_log(old_table->space, old_name,
+ 			   new_table->space, new_table->name, tmp_name);
++#endif
+ 
+ 	/* What if the redo logs are flushed to disk here?  This is
+ 	tested with following crash point */
+--- a/storage/innobase/srv/srv0srv.cc
++++ b/storage/innobase/srv/srv0srv.cc
+@@ -349,6 +349,8 @@
+ 
+ UNIV_INTERN ulong	srv_replication_delay		= 0;
+ 
++UNIV_INTERN ibool	srv_apply_log_only	= FALSE;
++
+ /*-------------------------------------------*/
+ UNIV_INTERN ulong	srv_n_spin_wait_rounds	= 30;
+ UNIV_INTERN ulong	srv_spin_wait_delay	= 6;
+@@ -1808,7 +1810,8 @@
+ 	if (ret == SRV_NONE
+ 	    && srv_shutdown_state != SRV_SHUTDOWN_NONE
+ 	    && trx_purge_state() != PURGE_STATE_DISABLED
+-	    && trx_purge_state() != PURGE_STATE_EXIT) {
++	    && trx_purge_state() != PURGE_STATE_EXIT
++	    && trx_purge_state() != PURGE_STATE_INIT) {
+ 
+ 		ret = SRV_PURGE;
+ 	}
+--- a/storage/innobase/srv/srv0start.cc
++++ b/storage/innobase/srv/srv0start.cc
+@@ -63,6 +63,7 @@
+ #include "ibuf0ibuf.h"
+ #include "srv0start.h"
+ #include "srv0srv.h"
++#include "xb0xb.h"
+ #ifndef UNIV_HOTBACKUP
+ # include "trx0rseg.h"
+ # include "os0proc.h"
+@@ -121,7 +122,7 @@
+ UNIV_INTERN enum srv_shutdown_state	srv_shutdown_state = SRV_SHUTDOWN_NONE;
+ 
+ /** Files comprising the system tablespace */
+-static os_file_t	files[1000];
++os_file_t	files[1000];
+ 
+ /** io_handler_thread parameters for thread identification */
+ static ulint		n[SRV_MAX_N_IO_THREADS + 6];
+@@ -731,7 +732,7 @@
+ /*********************************************************************//**
+ Creates or opens database data files and closes them.
+ @return	DB_SUCCESS or error code */
+-static __attribute__((nonnull, warn_unused_result))
++UNIV_INTERN __attribute__((nonnull, warn_unused_result))
+ dberr_t
+ open_or_create_data_files(
+ /*======================*/
+@@ -2065,11 +2066,13 @@
+ 					max_flushed_lsn = min_flushed_lsn
+ 						= log_get_lsn();
+ 					goto files_checked;
++#if 0
+ 				} else if (i < 2) {
+ 					/* must have at least 2 log files */
+ 					ib_logf(IB_LOG_LEVEL_ERROR,
+ 						"Only one log file found.");
+ 					return(err);
++#endif
+ 				}
+ 
+ 				/* opened all files */
+@@ -2326,6 +2329,10 @@
+ 
+ 		recv_recovery_from_checkpoint_finish();
+ 
++		if (srv_apply_log_only) {
++			goto skip_processes;
++		}
++
+ 		if (srv_force_recovery < SRV_FORCE_NO_IBUF_MERGE) {
+ 			/* The following call is necessary for the insert
+ 			buffer to work with multiple tablespaces. We must
+@@ -2647,6 +2654,7 @@
+ 	    && srv_auto_extend_last_data_file
+ 	    && sum_of_data_file_sizes < tablespace_size_in_header) {
+ 
++#ifdef UNDEFINED
+ 		ut_print_timestamp(stderr);
+ 		fprintf(stderr,
+ 			" InnoDB: Error: tablespace size stored in header"
+@@ -2683,6 +2691,7 @@
+ 
+ 			return(DB_ERROR);
+ 		}
++#endif
+ 	}
+ 
+ 	/* Check that os_fast_mutexes work as expected */
+@@ -2707,6 +2716,10 @@
+ 
+ 	os_fast_mutex_free(&srv_os_test_mutex);
+ 
++	if (srv_rebuild_indexes) {
++		xb_compact_rebuild_indexes();
++	}
++
+ 	if (srv_print_verbose_log) {
+ 		ib_logf(IB_LOG_LEVEL_INFO,
+ 			"%s started; log sequence number " LSN_PF "",
+@@ -2739,6 +2752,7 @@
+ 		fts_optimize_init();
+ 	}
+ 
++skip_processes:
+ 	srv_was_started = TRUE;
+ 
+ 	return(DB_SUCCESS);
+@@ -2794,7 +2808,7 @@
+ 		return(DB_SUCCESS);
+ 	}
+ 
+-	if (!srv_read_only_mode) {
++	if (!srv_read_only_mode && !srv_apply_log_only) {
+ 		/* Shutdown the FTS optimize sub system. */
+ 		fts_optimize_start_shutdown();
+ 
+--- a/storage/innobase/trx/trx0rseg.cc
++++ b/storage/innobase/trx/trx0rseg.cc
+@@ -121,9 +121,11 @@
+ 
+ 	mutex_free(&rseg->mutex);
+ 
++	if (!srv_apply_log_only) {
+ 	/* There can't be any active transactions. */
+ 	ut_a(UT_LIST_GET_LEN(rseg->update_undo_list) == 0);
+ 	ut_a(UT_LIST_GET_LEN(rseg->insert_undo_list) == 0);
++	}
+ 
+ 	for (undo = UT_LIST_GET_FIRST(rseg->update_undo_cached);
+ 	     undo != NULL;
+--- a/storage/innobase/trx/trx0sys.cc
++++ b/storage/innobase/trx/trx0sys.cc
+@@ -1191,12 +1191,14 @@
+ 
+ 	ut_a(UT_LIST_GET_LEN(trx_sys->ro_trx_list) == 0);
+ 
++	if (!srv_apply_log_only) {
+ 	/* Only prepared transactions may be left in the system. Free them. */
+ 	ut_a(UT_LIST_GET_LEN(trx_sys->rw_trx_list) == trx_sys->n_prepared_trx);
+ 
+ 	while ((trx = UT_LIST_GET_FIRST(trx_sys->rw_trx_list)) != NULL) {
+ 		trx_free_prepared(trx);
+ 	}
++	}
+ 
+ 	/* There can't be any active transactions. */
+ 	for (i = 0; i < TRX_SYS_N_RSEGS; ++i) {
+@@ -1223,10 +1225,12 @@
+ 		UT_LIST_REMOVE(view_list, trx_sys->view_list, prev_view);
+ 	}
+ 
++	if (!srv_apply_log_only) {
+ 	ut_a(UT_LIST_GET_LEN(trx_sys->view_list) == 0);
+ 	ut_a(UT_LIST_GET_LEN(trx_sys->ro_trx_list) == 0);
+ 	ut_a(UT_LIST_GET_LEN(trx_sys->rw_trx_list) == 0);
+ 	ut_a(UT_LIST_GET_LEN(trx_sys->mysql_trx_list) == 0);
++	}
+ 
+ 	mutex_exit(&trx_sys->mutex);
+ 
+@@ -1247,6 +1251,10 @@
+ {
+ 	ulint	total_trx = 0;
+ 
++	if (srv_apply_log_only) {
++		return(0);
++	}
++
+ 	mutex_enter(&trx_sys->mutex);
+ 
+ 	total_trx = UT_LIST_GET_LEN(trx_sys->rw_trx_list)
+--- a/storage/innobase/trx/trx0trx.cc
++++ b/storage/innobase/trx/trx0trx.cc
+@@ -2053,7 +2053,8 @@
+ 		scenario where some undo generated by a transaction,
+ 		has XA stuff, and other undo, generated by the same
+ 		transaction, doesn't. */
+-		trx->support_xa = thd_supports_xa(trx->mysql_thd);
++		trx->support_xa = trx->mysql_thd
++		    ? thd_supports_xa(trx->mysql_thd) : FALSE;
+ 
+ 		trx_start_low(trx);
+ 		/* fall through */
+--- a/storage/innobase/CMakeLists.txt
++++ b/storage/innobase/CMakeLists.txt
+@@ -44,8 +44,10 @@
+ #	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions")
+ ENDIF()
+ 
+-# Enable InnoDB's UNIV_DEBUG and UNIV_SYNC_DEBUG in debug builds
+-SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DUNIV_DEBUG -DUNIV_SYNC_DEBUG")
++# In XtraBackup do not enable UNIV_SYNC_DEBUG when UNIV_DEBUG is enabled
++# due to extreme slowness on compact backup testcases
++## Enable InnoDB's UNIV_DEBUG and UNIV_SYNC_DEBUG in debug builds
++#SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DUNIV_DEBUG -DUNIV_SYNC_DEBUG")
+ 
+ # Add -Wconversion if compiling with GCC
+ ## As of Mar 15 2011 this flag causes 3573+ warnings. If you are reading this
+--- a/storage/innobase/sync/sync0arr.cc
++++ b/storage/innobase/sync/sync0arr.cc
+@@ -42,6 +42,7 @@
+ #include "lock0lock.h"
+ #include "srv0srv.h"
+ #include "ha_prototypes.h"
++#include "xb0xb.h"
+ 
+ /*
+ 			WAIT ARRAY
+@@ -903,6 +904,13 @@
+ 	ibool		fatal = FALSE;
+ 	double		longest_diff = 0;
+ 
++	if (srv_rebuild_indexes) {
++
++		/* Avoid long semaphore waits when rebuilding indexes */
++
++		return(FALSE);
++	}
++
+ 	/* For huge tables, skip the check during CHECK TABLE etc... */
+ 	if (fatal_timeout > SRV_SEMAPHORE_WAIT_EXTENSION) {
+ 		return(FALSE);
+--- a/storage/innobase/include/buf0buf.h
++++ b/storage/innobase/include/buf0buf.h
+@@ -1583,6 +1583,8 @@
+ 					or buf_block_t::mutex. */
+ # endif /* UNIV_DEBUG_FILE_ACCESSES || UNIV_DEBUG */
+ #endif /* !UNIV_HOTBACKUP */
++	ibool		is_compacted;	/*!< TRUE if page was skipped in
++					compact backups */
+ };
+ 
+ /** The buffer control block structure */
+--- a/storage/innobase/mem/mem0dbg.cc
++++ b/storage/innobase/mem/mem0dbg.cc
+@@ -278,18 +278,10 @@
+ 	byte*	buf,	/*!< in: pointer to buffer */
+ 	ulint	 n)	/*!< in: length of buffer */
+ {
+-	byte*	ptr;
+-
+ 	UNIV_MEM_ASSERT_W(buf, n);
+ 
+-	for (ptr = buf; ptr < buf + n; ptr++) {
+-
+-		if (ut_rnd_gen_ibool()) {
+-			*ptr = 0xBA;
+-		} else {
+-			*ptr = 0xBE;
+-		}
+-	}
++	/* Fix https://bugs.launchpad.net/percona-xtrabackup/+bug/1158154 */
++	memset(buf, 0xBA, n);
+ 
+ 	UNIV_MEM_INVALID(buf, n);
+ }
+@@ -304,17 +296,10 @@
+ 	byte*	buf,	/*!< in: pointer to buffer */
+ 	ulint	n)	/*!< in: length of buffer */
+ {
+-	byte*	ptr;
+-
+ 	UNIV_MEM_ASSERT_W(buf, n);
+ 
+-	for (ptr = buf; ptr < buf + n; ptr++) {
+-		if (ut_rnd_gen_ibool()) {
+-			*ptr = 0xDE;
+-		} else {
+-			*ptr = 0xAD;
+-		}
+-	}
++	/* Fix https://bugs.launchpad.net/percona-xtrabackup/+bug/1158154 */
++	memset(buf, 0xDE, n);
+ 
+ 	UNIV_MEM_FREE(buf, n);
+ }

=== modified file 'src/Makefile'
--- src/Makefile	2013-03-19 11:53:10 +0000
+++ src/Makefile	2013-03-22 15:32:33 +0000
@@ -1,13 +1,14 @@
 # Makefile to build XtraBackup for Percona Server and different versions of MySQL
 #
 # Syntax:
-# make [5.1|5.5|plugin|xtradb|xtradb55]
+# make [5.1|5.5|5.6|plugin|xtradb|xtradb55]
 #
 # Default is xtradb - to build XtraBackup for Percona Server 5.1
 # xtradb55 - Xtrabackup for Percona Server 5.5
 # 5.1 - XtraBackup for MySQL versions 5.1.* with builtin InnoDB
 # plugin - XtraBackup for MySQL versions 5.1.* with InnoDB plugin
 # 5.5 - XtraBackup for MySQL versions 5.5.*	
+# 5.6 - XtraBackup for MySQL version 5.6
 
 LIBS += -lpthread `libgcrypt-config --libs`
 DEFS = -DUNIV_LINUX -DMYSQL_SERVER
@@ -41,6 +42,7 @@
 	xbstream_write.o \
 	quicklz/quicklz.o
 XTRABACKUPCCOBJS = xtrabackup.o innodb_int.o compact.o fil_cur.o write_filt.o
+
 XBSTREAMOBJS = xbstream.o xbstream_write.o xbstream_read.o
 
 XBCRYPTOBJS = xbcrypt.o xbcrypt_common.o xbcrypt_read.o xbcrypt_write.o
@@ -122,6 +124,29 @@
 	sed -e 's/C_DEFINES = //')
 5.5: $(TARGET) xbstream xbcrypt
 
+# XtraBackup for MySQL 5.6
+5.6: INC = $(COMMON_INC) $(addprefix -isystem$(MYSQL_ROOT_DIR)/, \
+	include sql storage/innobase/include sql)
+5.6: INNODBOBJS =
+
+ifeq "$(wildcard $(MYSQL_ROOT_DIR)/zlib/.libs/libzlt.a)" ""
+5.6: LIBZ= -lz
+else
+5.6: LIBZ= $(MYSQL_ROOT_DIR)/zlib/.libs/libzlt.a
+endif
+
+5.6: MYSQLOBJS = $(MYSQL_ROOT_DIR)/libmysqld/libmysqld.a
+ifeq ($(shell uname -s),Linux)
+5.6: LIBS += -laio -ldl -lcrypt
+endif
+5.6: TARGET := xtrabackup_innodb56
+# In CMake server builds it is important to build with exactly the same preprocessor flags
+# as were used to build InnoDB
+5.6: DEFS = $(shell grep CXX_DEFINES \
+	$(MYSQL_ROOT_DIR)/storage/innobase/CMakeFiles/innobase.dir/flags.make | \
+	sed -e 's/CXX_DEFINES = //')
+5.6: $(TARGET) xbstream xbcrypt
+
 # XtraBackup for XtraDB 
 xtradb: INC = $(COMMON_INC) $(addprefix -isystem$(MYSQL_ROOT_DIR)/, \
 	include storage/innodb_plugin/include)
@@ -198,13 +223,13 @@
 	$(CC) $(CFLAGS) $(INC) $(DEFS) -c $< -o $@
 
 xbstream: $(XBSTREAMOBJS) $(MYSQLOBJS) ds_local.o ds_buffer.o ds_stdout.o datasink.o
-	$(CC) $(CFLAGS) $^ $(INC) $(MYSQLOBJS) $(LIBS) -o $@
+	$(CXX) $(CXXFLAGS) $^ $(INC) $(MYSQLOBJS) $(LIBS) -o $@
 
 xbcrypt.o xbcrypt_read.o: %.o: %.c
 	$(CC) $(CFLAGS) $(INC) $(DEFS) -c $< -o $@
 
 xbcrypt: $(XBCRYPTOBJS) $(MYSQLOBJS)
-	$(CC) $(CFLAGS) $^ $(INC) $(MYSQLOBJS) $(LIBS) -o $@
+	$(CXX) $(CXXFLAGS) $^ $(INC) $(MYSQLOBJS) $(LIBS) -o $@
 
 xtrabackup.o: xtrabackup.cc xb_regex.h write_filt.h fil_cur.h xtrabackup.h compact.h
 

=== modified file 'src/compact.cc'
--- src/compact.cc	2013-02-20 10:20:00 +0000
+++ src/compact.cc	2013-03-22 15:32:33 +0000
@@ -24,6 +24,9 @@
 
 #include <my_base.h>
 #include "common.h"
+#if MYSQL_VERSION_ID >= 50600
+#include "table.h"
+#endif
 #include "innodb_int.h"
 #include "write_filt.h"
 #include "fil_cur.h"
@@ -649,65 +652,6 @@
 		       compacted_page_magic, compacted_page_magic_size);
 }
 
-/********************************************************************//**
-Determine the flags of a table described in SYS_TABLES.
-@return compressed page size in kilobytes; or 0 if the tablespace is
-uncompressed, ULINT_UNDEFINED on error */
-static
-ulint
-dict_sys_tables_get_flags(
-/*======================*/
-	const rec_t*	rec)	/*!< in: a record of SYS_TABLES */
-{
-	const byte*	field;
-	ulint		len;
-	ulint		n_cols;
-	ulint		flags;
-
-	field = rec_get_nth_field_old(rec, 5, &len);
-	ut_a(len == 4);
-
-	flags = mach_read_from_4(field);
-
-	if (UNIV_LIKELY(flags == DICT_TABLE_ORDINARY)) {
-		return(0);
-	}
-
-	field = rec_get_nth_field_old(rec, 4/*N_COLS*/, &len);
-	n_cols = mach_read_from_4(field);
-
-	if (UNIV_UNLIKELY(!(n_cols & 0x80000000UL))) {
-		/* New file formats require ROW_FORMAT=COMPACT. */
-		return(ULINT_UNDEFINED);
-	}
-
-	switch (flags & (DICT_TF_FORMAT_MASK | DICT_TF_COMPACT)) {
-	default:
-	case DICT_TF_FORMAT_51 << DICT_TF_FORMAT_SHIFT:
-	case DICT_TF_FORMAT_51 << DICT_TF_FORMAT_SHIFT | DICT_TF_COMPACT:
-		/* flags should be DICT_TABLE_ORDINARY,
-		or DICT_TF_FORMAT_MASK should be nonzero. */
-		return(ULINT_UNDEFINED);
-
-	case DICT_TF_FORMAT_ZIP << DICT_TF_FORMAT_SHIFT | DICT_TF_COMPACT:
-		/* We support this format. */
-		break;
-	}
-
-	if (UNIV_UNLIKELY((flags & DICT_TF_ZSSIZE_MASK)
-			  > (DICT_TF_ZSSIZE_MAX << DICT_TF_ZSSIZE_SHIFT))) {
-		/* Unsupported compressed page size. */
-		return(ULINT_UNDEFINED);
-	}
-
-	if (UNIV_UNLIKELY(flags & (~0 << DICT_TF_BITS))) {
-		/* Some unused bits are set. */
-		return(ULINT_UNDEFINED);
-	}
-
-	return(flags);
-}
-
 /*****************************************************************************
 Builds an index definition corresponding to an index object. It is roughly
 similar to innobase_create_index_def() / innobase_create_index_field_def() and
@@ -718,11 +662,11 @@
 /*=======================*/
 	mem_heap_t*		heap,		/*!< in: heap */
 	const dict_index_t*	index,		/*!< in: index */
-	merge_index_def_t*	index_def)	/*!< out: index definition */
+	index_def_t*		index_def)	/*!< out: index definition */
 {
-	merge_index_field_t*	fields;
-	ulint			n_fields;
-	ulint			i;
+	index_field_t*	fields;
+	ulint		n_fields;
+	ulint		i;
 
 	ut_a(index->n_fields);
 	ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
@@ -738,22 +682,30 @@
 	index_def->name = mem_heap_strdup(heap, index->name);
 	index_def->ind_type = index->type;
 
-	fields = static_cast<merge_index_field_t *>
+	fields = static_cast<index_field_t *>
 		(mem_heap_alloc(heap, n_fields * sizeof(*fields)));
 
 	for (i = 0; i < n_fields; i++) {
 		dict_field_t*	field;
 
 		field = dict_index_get_nth_field(index, i);
+		xb_dict_index_field_to_index_field(heap, field, &fields[i]);
 
-		fields[i].field_name = mem_heap_strdup(heap, field->name);
-		fields[i].prefix_len = field->prefix_len;
 	}
 
 	index_def->fields = fields;
 	index_def->n_fields = n_fields;
 }
 
+#if MYSQL_VERSION_ID >= 50600
+/* A dummy autoc_inc sequence for row_merge_build_indexes().  */
+static ib_sequence_t null_seq(NULL, 0, 0);
+/* A dummy table share and table for row_merge_build_indexes() error reporting.
+Assumes that no errors are going to be reported. */
+static struct TABLE_SHARE dummy_table_share;
+static struct TABLE dummy_table;
+#endif
+
 /********************************************************************//**
 Rebuild secondary indexes for a given table. */
 static
@@ -763,13 +715,16 @@
 	dict_table_t*	table,	/*!< in: table */
 	trx_t*		trx)	/*!< in: transaction handle */
 {
-	dict_index_t*		index;
-	dict_index_t**		indexes;
-	ulint			n_indexes;
-	merge_index_def_t*	index_defs;
-	ulint			i;
-	mem_heap_t*		heap;
-	ulint			error;
+	dict_index_t*	index;
+	dict_index_t**	indexes;
+	ulint		n_indexes;
+	index_def_t*	index_defs;
+	ulint		i;
+	mem_heap_t*	heap;
+	ulint		error;
+#if MYSQL_VERSION_ID >= 50600
+	ulint*		add_key_nums;
+#endif
 
 	ut_ad(mutex_own(&(dict_sys->mutex)));
 	ut_ad(table);
@@ -786,42 +741,98 @@
 
 	indexes = (dict_index_t**) mem_heap_alloc(heap,
 						  n_indexes * sizeof(*indexes));
-	index_defs = (merge_index_def_t*) mem_heap_alloc(heap,
-							 n_indexes *
+	index_defs = (index_def_t*) mem_heap_alloc(heap, n_indexes *
 							 sizeof(*index_defs));
+#if MYSQL_VERSION_ID >= 50600
+	add_key_nums = static_cast<ulint *>
+		(mem_heap_alloc(heap, n_indexes * sizeof(*add_key_nums)));
+#endif
 
 	/* Skip the primary key. */
 	index = dict_table_get_first_index(table);
 	ut_a(dict_index_is_clust(index));
 
+	msg("  Dropping %lu index(es).\n", n_indexes);
+
 	for (i = 0; (index = dict_table_get_next_index(index)); i++) {
 
 		msg("  Found index %s\n", index->name);
 
+		/* Pretend that it's the current trx that created this index.
+		Required to avoid 5.6+ debug assertions. */
+		index->trx_id = xb_trx_id_to_index_trx_id(trx->id);
+
+		xb_build_index_def(heap, index, &index_defs[i]);
+
+#if MYSQL_VERSION_ID >= 50600
+		/* In 5.6+, row_merge_drop_indexes() drops all the indexes on
+		the table that have the temp index prefix.  It does not accept
+		an array of indexes to drop as in 5.5-.  */
+		row_merge_rename_index_to_drop(trx, table->id, index->id);
+#else
 		indexes[i] = index;
-
-		xb_build_index_def(heap, index, &index_defs[i]);
+#endif
 	}
 
 	ut_ad(i == n_indexes);
 
-	msg("  Dropping %lu index(es).\n", n_indexes);
-
+#if MYSQL_VERSION_ID >= 50600
+	ut_d(table->n_ref_count++);
+	row_merge_drop_indexes(trx, table, TRUE);
+	ut_d(table->n_ref_count--);
+
+	index = dict_table_get_first_index(table);
+	ut_a(dict_index_is_clust(index));
+	index = dict_table_get_next_index(index);
+	while (index) {
+
+		/* In 5.6+, row_merge_drop_indexes() does not remove the
+		indexes from the dictionary cache nor from any foreign key
+		list.  This may cause invalid dereferences as we try to access
+		the dropped indexes from other tables as FKs.  */
+
+		dict_index_t* next_index = dict_table_get_next_index(index);
+		index->to_be_dropped = 1;
+
+		/* Patch up any FK referencing this index with NULL */
+		dict_foreign_replace_index(table, index, trx);
+
+		dict_index_remove_from_cache(table, index);
+
+		index = next_index;
+	}
+#else
 	row_merge_drop_indexes(trx, table, indexes, n_indexes);
+#endif
 
 	msg("  Rebuilding %lu index(es).\n", n_indexes);
 
-	row_merge_lock_table(trx, table, LOCK_X);
+	error = row_merge_lock_table(trx, table, LOCK_X);
+	xb_a(error == DB_SUCCESS);
 
 	for (i = 0; i < n_indexes; i++) {
-		indexes[i] = row_merge_create_index(trx, table, &index_defs[i]);
+		indexes[i] = row_merge_create_index(trx, table,
+						    &index_defs[i]);
+#if MYSQL_VERSION_ID >= 50600
+		add_key_nums[i] = index_defs[i].key_number;
+#endif
 	}
 
+#if MYSQL_VERSION_ID >= 50600
+	error = row_merge_build_indexes(trx, table, table, FALSE, indexes,
+					add_key_nums, n_indexes, &dummy_table,
+					NULL, NULL, ULINT_UNDEFINED, null_seq);
+#else
 	error = row_merge_build_indexes(trx, table, table, indexes, n_indexes,
 					NULL);
+#endif
 	ut_a(error == DB_SUCCESS);
 
 	mem_heap_free(heap);
+
+	trx_commit_for_mysql(trx);
+
+	trx_start_for_ddl(trx, TRX_DICT_OP_INDEX);
 }
 
 /******************************************************************************
@@ -839,14 +850,20 @@
 	const byte*	field;
 	ulint		len;
 	ulint		space_id;
-	ulint		flags;
 	char*		name;
 	dict_table_t*	table;
 	trx_t*		trx;
 
+#if MYSQL_VERSION_ID >= 50600
+	/* Set up the dummy table for the index rebuild error reporting */
+	dummy_table_share.fields = 0;
+	dummy_table.s = &dummy_table_share;
+#endif
+
 	/* Iterate all tables that are not in the system tablespace. */
 
 	trx = trx_allocate_for_mysql();
+	trx_start_for_ddl(trx, TRX_DICT_OP_INDEX);
 
 	/* Suppress foreign key checks, as we are going to drop and recreate all
 	secondary keys. */
@@ -856,9 +873,7 @@
 
 	/* Enlarge the fatal lock wait timeout during index rebuild
 	operation. */
-	mutex_enter(&kernel_mutex);
-	srv_fatal_semaphore_wait_threshold += 7200; /* 2 hours */
-	mutex_exit(&kernel_mutex);
+	xb_adjust_fatal_semaphore_wait_threshold(7200); /* 2 hours */
 
 	mtr_start(&mtr);
 
@@ -866,8 +881,8 @@
 	sys_index = UT_LIST_GET_FIRST(sys_tables->indexes);
 	ut_a(!dict_table_is_comp(sys_tables));
 
-	btr_pcur_open_at_index_side(TRUE, sys_index, BTR_SEARCH_LEAF, &pcur,
-				    TRUE, &mtr);
+	xb_btr_pcur_open_at_index_side(TRUE, sys_index, BTR_SEARCH_LEAF, &pcur,
+				       TRUE, 0, &mtr);
 	for (;;) {
 		btr_pcur_move_to_next_user_rec(&pcur, &mtr);
 
@@ -897,25 +912,6 @@
 		field = rec_get_nth_field_old(rec, 0, &len);
 		name = mem_strdupl((char*) field, len);
 
-		flags = dict_sys_tables_get_flags(rec);
-		if (UNIV_UNLIKELY(flags == ULINT_UNDEFINED)) {
-
-			field = rec_get_nth_field_old(rec, 5, &len);
-			flags = mach_read_from_4(field);
-
-			ut_print_timestamp(stderr);
-			fputs("  InnoDB: Error: table ", stderr);
-			ut_print_filename(stderr, name);
-			fprintf(stderr, "\n"
-				"InnoDB: in InnoDB data dictionary"
-				" has unknown type %lx.\n",
-				(ulong) flags);
-
-			mem_free(name);
-
-			continue;
-		}
-
 		btr_pcur_store_position(&pcur, &mtr);
 
 		mtr_commit(&mtr);
@@ -933,11 +929,6 @@
 
 		mem_free(name);
 
-		/* Temporarily unlock the data dictionary to avoid long
-		semaphore waits. */
-		row_mysql_unlock_data_dictionary(trx);
-		row_mysql_lock_data_dictionary(trx);
-
 		mtr_start(&mtr);
 
 		btr_pcur_restore_position(BTR_SEARCH_LEAF, &pcur, &mtr);

=== modified file 'src/ds_encrypt.c'
--- src/ds_encrypt.c	2013-03-11 19:11:29 +0000
+++ src/ds_encrypt.c	2013-03-22 15:32:33 +0000
@@ -20,7 +20,6 @@
 
 
 #include <my_base.h>
-#include <univ.i>
 #include "common.h"
 #include "datasink.h"
 #include <gcrypt.h>
@@ -169,8 +168,8 @@
 
 	/* Set up the iv length */
 	encrypt_iv_len = gcry_cipher_get_algo_blklen(encrypt_algo);
-	ut_a(encrypt_iv_len > 0);
-	ut_a(encrypt_iv_len <= sizeof(encrypt_iv));
+	xb_a(encrypt_iv_len > 0);
+	xb_a(encrypt_iv_len <= sizeof(encrypt_iv));
 
 	/* Now set up the key */
 	if (xtrabackup_encrypt_key == NULL &&
@@ -330,7 +329,7 @@
 						  &thd->data_mutex);
 			}
 
-			ut_a(threads[i].to_len > 0);
+			xb_a(threads[i].to_len > 0);
 
 			if (xb_crypt_write_chunk(crypt_file->xbcrypt_file,
 						 threads[i].to,

=== modified file 'src/fil_cur.cc'
--- src/fil_cur.cc	2013-03-05 15:25:00 +0000
+++ src/fil_cur.cc	2013-03-22 15:32:33 +0000
@@ -156,28 +156,23 @@
 {
 	ibool			success;
 	ulint			page_size;
-	ulint			offset_high;
-	ulint			offset_low;
 	byte*			page;
 	ulint			i;
 	ulint			npages;
 	ulint			retry_count;
 	xb_fil_cur_result_t	ret;
-	IB_INT64		to_read;
+	ib_int64_t		to_read;
 
 	page_size = cursor->page_size;
 
-	offset_high = (ulint) (cursor->offset >> 32);
-	offset_low = (ulint) (cursor->offset & 0xFFFFFFFFUL);
-
-	to_read = (IB_INT64) cursor->statinfo.st_size - cursor->offset;
+	to_read = (ib_int64_t) cursor->statinfo.st_size - cursor->offset;
 
 	if (to_read == 0LL) {
 		return(XB_FIL_CUR_EOF);
 	}
 
-	if (to_read > (IB_INT64) cursor->buf_size) {
-		to_read = (IB_INT64) cursor->buf_size;
+	if (to_read > (ib_int64_t) cursor->buf_size) {
+		to_read = (ib_int64_t) cursor->buf_size;
 	}
 	ut_a(to_read > 0 && to_read <= 0xFFFFFFFFLL);
 	ut_a(to_read % page_size == 0);
@@ -196,8 +191,8 @@
 	cursor->buf_page_no = (ulint) (cursor->offset >>
 				       cursor->page_size_shift);
 
-	success = os_file_read(cursor->file, cursor->buf,
-			       offset_low, offset_high, to_read);
+	success = xb_os_file_read(cursor->file, cursor->buf, cursor->offset,
+				  to_read);
 	if (!success) {
 		return(XB_FIL_CUR_ERROR);
 	}

=== modified file 'src/fil_cur.h'
--- src/fil_cur.h	2013-01-14 11:02:59 +0000
+++ src/fil_cur.h	2013-03-22 15:32:33 +0000
@@ -38,7 +38,7 @@
 					UNIV_PAGE_SIZE for uncompressed ones */
 	ulint		page_size_shift;/*!< bit shift corresponding to
 					page_size */
-	IB_INT64	offset;		/*!< current file offset in bytes */
+	ib_int64_t	offset;		/*!< current file offset in bytes */
 	my_bool		is_system;	/*!< TRUE for system tablespace, FALSE
 					otherwise */
 	byte*		orig_buf;	/*!< read buffer */
@@ -48,7 +48,7 @@
 					after the last cursor read */
 	ulint		buf_npages;	/*!< number of pages in buffer after the
 					last cursor read */
-	IB_INT64	buf_offset;	/*!< file offset of the first page in
+	ib_int64_t	buf_offset;	/*!< file offset of the first page in
 					buffer */
 	ulint		buf_page_no;	/*!< number of the first page in
 					buffer */

=== modified file 'src/innodb_int.cc'
--- src/innodb_int.cc	2013-02-20 10:20:00 +0000
+++ src/innodb_int.cc	2013-03-22 15:32:33 +0000
@@ -31,7 +31,21 @@
 
 extern long innobase_lock_wait_timeout;
 
+#if MYSQL_VERSION_ID < 50600
 char *opt_mysql_tmpdir = NULL;
+#endif
+
+#if MYSQL_VERSION_ID >= 50600
+const char*	xb_dict_prefix	= "";
+#else
+const char*	xb_dict_prefix	= "./";
+#endif
+
+#if MYSQL_VERSION_ID < 50600
+char*	innobase_log_group_home_dir		= NULL;
+#endif
+
+long innobase_mirrored_log_groups = 1;
 
 /****************************************************************//**
 A simple function to open or create a file.
@@ -89,12 +103,22 @@
 	ulint		type,	/*!< in: OS_DATA_FILE or OS_LOG_FILE */
 	ibool*		success)/*!< out: TRUE if succeed, FALSE if error */
 {
+	os_file_t	result;
+#if MYSQL_VERSION_ID >= 50600
+	ibool	old_srv_read_only_mode = srv_read_only_mode;
+
+	srv_read_only_mode = FALSE;
+#endif
 #if MYSQL_VERSION_ID > 50500
-	return os_file_create(0 /* innodb_file_data_key */,
-			      name, create_mode, purpose, type, success);
+	result = os_file_create(0 /* innodb_file_data_key */,
+				name, create_mode, purpose, type, success);
 #else
-	return os_file_create(name, create_mode, purpose, type, success);
-#endif
+	result=  os_file_create(name, create_mode, purpose, type, success);
+#endif
+#if MYSQL_VERSION_ID >= 50600
+	srv_read_only_mode = old_srv_read_only_mode;
+#endif
+	return result;
 }
 
 /***********************************************************************//**
@@ -215,8 +239,8 @@
 		return ret;
 	}
 
-	ret = os_file_set_size(path, *file,
-			       FIL_IBD_FILE_INITIAL_SIZE * UNIV_PAGE_SIZE, 0);
+	ret = xb_os_file_set_size(path, *file,
+				  FIL_IBD_FILE_INITIAL_SIZE * UNIV_PAGE_SIZE);
 	if (!ret) {
 		msg("xtrabackup: cannot set size for file %s\n", path);
 		os_file_close(*file);
@@ -233,18 +257,16 @@
 	fsp_header_init_fields(page, space_id, flags);
 	mach_write_to_4(page + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID, space_id);
 
-	if (!(flags & DICT_TF_ZSSIZE_MASK)) {
+	if (!fsp_flags_is_compressed(flags)) {
 		buf_flush_init_for_writing(page, NULL, 0);
 
-		ret = os_file_write(path, *file, page, 0, 0, UNIV_PAGE_SIZE);
+		ret = xb_os_file_write(path, *file, page, 0, UNIV_PAGE_SIZE);
 	}
 	else {
 		page_zip_des_t	page_zip;
 		ulint		zip_size;
 
-		zip_size = (PAGE_ZIP_MIN_SIZE >> 1)
-			<< ((flags & DICT_TF_ZSSIZE_MASK)
-			    >> DICT_TF_ZSSIZE_SHIFT);
+		zip_size = fsp_flags_get_zip_size(flags);
 		page_zip_set_size(&page_zip, zip_size);
 		page_zip.data = page + UNIV_PAGE_SIZE;
 		fprintf(stderr, "zip_size = %lu\n", zip_size);
@@ -257,8 +279,8 @@
 
 		buf_flush_init_for_writing(page, &page_zip, 0);
 
-		ret = os_file_write(path, *file, page_zip.data, 0, 0,
-				    zip_size);
+		ret = xb_os_file_write(path, *file, page_zip.data, 0,
+				       zip_size);
 	}
 
 	ut_free(buf);
@@ -298,6 +320,7 @@
 	srv_lock_table_size = 5 * (srv_buf_pool_size / UNIV_PAGE_SIZE);
 }
 
+#if MYSQL_VERSION_ID < 50600
 
 void
 innobase_invalidate_query_cache(
@@ -650,6 +673,8 @@
 	return(FALSE);
 }
 
+#endif /* MYSQL_VERSION_ID < 50600 */
+
 #ifdef XTRADB_BASED
 trx_t*
 innobase_get_trx()
@@ -664,6 +689,8 @@
 }
 #endif
 
+#if MYSQL_VERSION_ID < 50600
+
 extern "C" {
 
 ibool
@@ -848,8 +875,6 @@
 	return(fd2);
 }
 
-} /* extern "C" */
-
 /* The following is used by row0merge for error reporting. Define a stub so we
 can use fast index creation from XtraBackup. */
 void
@@ -871,7 +896,11 @@
 {
 }
 
-#if MYSQL_VERSION_ID >= 50507
+} /* extern "C" */
+
+#endif /* MYSQL_VERSION_ID < 50600 */
+
+#if (MYSQL_VERSION_ID >= 50507) && (MYSQL_VERSION_ID < 50600)
 /*
    As of MySQL 5.5.7, InnoDB uses thd_wait plugin service.
    We have to provide mock functions to avoid linker errors.
@@ -892,7 +921,7 @@
 	return;
 }
 
-#endif /* MYSQL_VERSION_ID >= 50507 */
+#endif /* (MYSQL_VERSION_ID >= 50507) && (MYSQL_VERSION_ID < 50600) */
 
 #ifdef XTRADB_BASED
 /******************************************************************//*******
@@ -905,3 +934,200 @@
 	return(FALSE);
 }
 #endif /* XTRADB_BASED */
+
+#if MYSQL_VERSION_ID >= 50600
+
+/*********************************************************************//**
+Creates or opens the log files and closes them.
+@return	DB_SUCCESS or error code */
+ulint
+open_or_create_log_file(
+/*====================*/
+	ibool	create_new_db,		/*!< in: TRUE if we should create a
+					new database */
+	ibool*	log_file_created,	/*!< out: TRUE if new log file
+					created */
+	ibool	log_file_has_been_opened,/*!< in: TRUE if a log file has been
+					opened before: then it is an error
+					to try to create another log file */
+	ulint	k,			/*!< in: log group number */
+	ulint	i)			/*!< in: log file number in group */
+{
+	ibool	ret;
+	os_offset_t	size;
+	char	name[10000];
+	ulint	dirnamelen;
+
+	UT_NOT_USED(create_new_db);
+	UT_NOT_USED(log_file_has_been_opened);
+	UT_NOT_USED(k);
+	ut_ad(k == 0);
+
+	*log_file_created = FALSE;
+
+	srv_normalize_path_for_win(srv_log_group_home_dir);
+
+	dirnamelen = strlen(srv_log_group_home_dir);
+	ut_a(dirnamelen < (sizeof name) - 10 - sizeof "ib_logfile");
+	memcpy(name, srv_log_group_home_dir, dirnamelen);
+
+	/* Add a path separator if needed. */
+	if (dirnamelen && name[dirnamelen - 1] != SRV_PATH_SEPARATOR) {
+		name[dirnamelen++] = SRV_PATH_SEPARATOR;
+	}
+
+	sprintf(name + dirnamelen, "%s%lu", "ib_logfile", (ulong) i);
+
+	files[i] = os_file_create(innodb_file_log_key, name,
+				  OS_FILE_OPEN, OS_FILE_NORMAL,
+				  OS_LOG_FILE, &ret);
+	if (ret == FALSE) {
+		fprintf(stderr, "InnoDB: Error in opening %s\n", name);
+
+		return(DB_ERROR);
+	}
+
+	size = os_file_get_size(files[i]);
+
+	if (size != srv_log_file_size * UNIV_PAGE_SIZE) {
+
+		fprintf(stderr,
+			"InnoDB: Error: log file %s is"
+			" of different size " UINT64PF " bytes\n"
+			"InnoDB: than specified in the .cnf"
+			" file " UINT64PF " bytes!\n",
+			name, size, srv_log_file_size * UNIV_PAGE_SIZE);
+
+		return(DB_ERROR);
+	}
+
+	ret = os_file_close(files[i]);
+	ut_a(ret);
+
+	if (i == 0) {
+		/* Create in memory the file space object
+		which is for this log group */
+
+		fil_space_create(name,
+				 2 * k + SRV_LOG_SPACE_FIRST_ID, 0, FIL_LOG);
+	}
+
+	ut_a(fil_validate());
+
+	ut_a(fil_node_create(name, srv_log_file_size,
+			     2 * k + SRV_LOG_SPACE_FIRST_ID, FALSE));
+	if (i == 0) {
+		log_group_init(k, srv_n_log_files,
+			       srv_log_file_size * UNIV_PAGE_SIZE,
+			       2 * k + SRV_LOG_SPACE_FIRST_ID,
+			       SRV_LOG_SPACE_FIRST_ID + 1); /* dummy arch
+							    space id */
+	}
+
+	return(DB_SUCCESS);
+}
+
+#endif /* MYSQL_VERSION_ID >= 50600 */
+
+/*****************************************************************//**
+Parse, validate, and set the InnoDB variables from
+innodb_log_group_home_dir and innodb_mirrored_log_group_groups
+options.
+
+@return TRUE if server variables set OK, FALSE otherwise */
+ibool
+xb_parse_log_group_home_dirs(void)
+/*==============================*/
+{
+	ibool	ret = TRUE;
+#if MYSQL_VERSION_ID < 50600
+	ret = srv_parse_log_group_home_dirs(INNODB_LOG_DIR);
+
+	if (ret == FALSE || innobase_mirrored_log_groups != 1) {
+
+		msg("xtrabackup: syntax error in innodb_log_group_home_dir, "
+		    "or a wrong number of mirrored log groups\n");
+		ret = FALSE;
+	}
+	srv_n_log_groups = (ulint) innobase_mirrored_log_groups;
+#else
+	srv_normalize_path_for_win(srv_log_group_home_dir);
+
+	if (strchr(srv_log_group_home_dir, ';')
+	    || innobase_mirrored_log_groups != 1) {
+
+		msg("syntax error in innodb_log_group_home_dir, "
+		    "or a wrong number of mirrored log groups");
+		ret = FALSE;
+	}
+#endif
+	return ret;
+}
+
+/*****************************************************************//**
+Set InnoDB to read-only mode. */
+void
+xb_set_innodb_read_only(void)
+/*=========================*/
+{
+#if MYSQL_VERSION_ID >= 50600
+	srv_read_only_mode = TRUE;
+#else
+	srv_read_only = TRUE;
+#endif
+}
+
+/*****************************************************************//**
+Adjust srv_fatal_semaphore_wait_threshold in a thread-safe manner.  */
+void
+xb_adjust_fatal_semaphore_wait_threshold(
+/*=====================================*/
+	ulint delta)	/*!<in: threshold adjustment delta in seconds */
+{
+#if MYSQL_VERSION_ID >= 50600
+	os_increment_counter_by_amount(server_mutex,
+				       srv_fatal_semaphore_wait_threshold,
+				       delta);
+#else
+	mutex_enter(&kernel_mutex);
+	srv_fatal_semaphore_wait_threshold += delta;
+	mutex_exit(&kernel_mutex);
+#endif
+}
+
+/*****************************************************************//**
+Wrapper around around recv_check_cp_is_consistent() for handling
+version differences.
+
+@return TRUE if checkpoint info in the buffer is OK */
+ibool
+xb_recv_check_cp_is_consistent(
+/*===========================*/
+	const byte*	buf)	/*!<in: buffer containing checkpoint info */
+{
+#if MYSQL_VERSION_ID >= 50600
+	return recv_check_cp_is_consistent(buf);
+#else
+	return recv_check_cp_is_consistent(const_cast<byte *>(buf));
+#endif
+}
+
+/*****************************************************************//**
+Initialize a index_field_t variable from a dict_field_t */
+void
+xb_dict_index_field_to_index_field(
+/*===============================*/
+	mem_heap_t*		heap __attribute__((unused)),/*!< in: heap for
+						field name string allocation on
+						5.5 or earlier version. */
+	const dict_field_t*	dict_index_field,	/*!< in: field */
+	index_field_t*		index_field)		/*!< out: field */
+{
+#if MYSQL_VERSION_ID >= 50600
+	index_field->col_no = dict_col_get_no(dict_index_field->col);
+#else
+	index_field->field_name = mem_heap_strdup(heap,
+						  dict_index_field->name);
+#endif
+	index_field->prefix_len = dict_index_field->prefix_len;
+}

=== modified file 'src/innodb_int.h'
--- src/innodb_int.h	2013-02-20 10:20:00 +0000
+++ src/innodb_int.h	2013-03-22 15:32:33 +0000
@@ -25,11 +25,14 @@
 #ifndef INNODB_INT_H
 #define INNODB_INT_H
 
+#include <mysql_version.h>
 #include <my_base.h>
 
 /* Only include InnoDB headers here, please keep the list sorted */
 
+#if MYSQL_VERSION_ID < 50600
 extern "C" {
+#endif
 
 #include <univ.i>
 
@@ -43,10 +46,17 @@
 #include <dict0crea.h>
 #include <dict0dict.h>
 #include <dict0load.h>
+#if MYSQL_VERSION_ID >= 50600
+#include <dict0priv.h>
+#include <dict0stats.h>
+#endif
 #include <fil0fil.h>
 #include <fsp0fsp.h>
 #include <fsp0types.h>
 #include <ha_prototypes.h>
+#if MYSQL_VERSION_ID >= 50600
+#include <handler0alter.h>
+#endif
 #include <hash0hash.h>
 #include <ibuf0ibuf.h>
 #include <lock0lock.h>
@@ -54,6 +64,7 @@
 #include <log0recv.h>
 #include <mtr0mtr.h>
 #include <os0file.h>
+#include <os0sync.h>
 #include <os0thread.h>
 #include <page0page.h>
 #include <page0zip.h>
@@ -70,13 +81,17 @@
 #include <trx0sys.h>
 #include <trx0trx.h>
 #include <trx0xa.h>
+#if MYSQL_VERSION_ID >= 50600
+#include <ut0crc32.h>
+#endif
 #include <ut0mem.h>
 
+#if MYSQL_VERSION_ID < 50600
 }
+#endif
 
-#  define IB_INT64 ib_int64_t
-#  define LSN64 ib_uint64_t
 #  if (MYSQL_VERSION_ID < 50500)
+     /* MySQL and Percona Server 5.1 */
 #    define MACH_READ_64 mach_read_ull
 #    define MACH_WRITE_64 mach_write_ull
 #    define INDEX_ID_T dulint
@@ -84,15 +99,107 @@
 			       ((a).high - (b).high) : \
 			       ((a).low - (b).low))
 #    define OS_MUTEX_CREATE() os_mutex_create(NULL)
-#  else
+#    define xb_os_file_write(name, file, buf, offset, n)		\
+	os_file_write(name, file, buf,					\
+		      (ulint)(offset & 0xFFFFFFFFUL),			\
+		      (ulint)(((ullint)offset) >> 32),			\
+		      n)
+#    define xb_os_file_read(file, buf, offset, n)			\
+	os_file_read(file, buf,						\
+		     (ulint)(offset & 0xFFFFFFFFUL),			\
+		     (ulint)(((ullint)offset) >> 32),			\
+		     n)
+#    define xb_trx_id_to_index_trx_id(trx_id) \
+	((ib_uint64_t) ut_conv_dulint_to_longlong(trx_id))
+#  else /* MYSQL_VERSION_ID < 50500 */
+     /* MySQL and Percona Server 5.5+ */
 #    define MACH_READ_64 mach_read_from_8
 #    define MACH_WRITE_64 mach_write_to_8
 #    define INDEX_ID_T index_id_t
 #    define INDEX_ID_CMP(a,b) ((a) - (b))
 #    define OS_MUTEX_CREATE() os_mutex_create()
-#  endif
+#    define xb_trx_id_to_index_trx_id(trx_id) (trx_id)
+#  endif /* MYSQL_VERSION_ID < 50500 */
+#  if (MYSQL_VERSION_ID >= 50600)
+   /* MySQL 5.6+ */
+#  define PAGE_ZIP_MIN_SIZE_SHIFT	10
+#  define DICT_TF_ZSSIZE_SHIFT	1
+#  define DICT_TF_FORMAT_ZIP	1
+#  define DICT_TF_FORMAT_SHIFT		5
+#  define xb_os_file_read(file, buf, offset, n)				\
+	pfs_os_file_read_func(file, buf, offset, n, __FILE__, __LINE__)
+#  define xb_os_file_write(name, file, buf, offset, n)	\
+	pfs_os_file_write_func(name, file, buf, offset,	\
+			       n, __FILE__, __LINE__)
+#  define xb_buf_page_is_corrupted(page, zip_size)	\
+	buf_page_is_corrupted(TRUE, page, zip_size)
+#  define xb_btr_pcur_open_at_index_side(from_left, index, latch_mode, pcur, \
+				       init_pcur, level, mtr)		\
+	btr_pcur_open_at_index_side(from_left, index, latch_mode, pcur,	\
+				    init_pcur, 0, mtr)
+#  define xb_os_file_set_size(name, file, size)	\
+	os_file_set_size(name, file, size)
+#  define xb_fil_rename_tablespace(old_name_in, id, new_name, new_path)	\
+	fil_rename_tablespace(old_name_in, id, new_name, new_path)
+#  define xb_btr_root_block_get(index, mode, mtr) \
+	btr_root_block_get(index, mode, mtr)
+   typedef ib_mutex_t	mutex_t;
+#  define INNODB_LOG_DIR srv_log_group_home_dir
+#  define DEFAULT_LOG_FILE_SIZE 48*1024*1024
+   /* InnoDB data dictionary API in MySQL 5.5- works on on tables named
+   "./database/table.ibd", and in 5.6+ on "database/table".  This variable
+   handles truncating or leaving the final ".ibd".  */
+#  define XB_DICT_SUFFIX_LEN 4
+#  define xb_os_event_create(name) os_event_create()
+#else /* MYSQL_VERSION_ID >= 50600 */
+   /* MySQL and Percona Server 5.1 and 5.5 */
 #  define xb_buf_page_is_corrupted(page, zip_size)	\
 	buf_page_is_corrupted(page, zip_size)
+#  define xb_os_event_create(name) os_event_create(name)
+#  define XB_DICT_SUFFIX_LEN 0
+#  define INT64PF	"%lld"
+#  define UINT64PF "%llu"
+#  define LSN_PF UINT64PF
+#  define DEFAULT_LOG_FILE_SIZE 5*1024*1024
+   typedef ulint		dberr_t;
+   typedef os_mutex_t		os_ib_mutex_t;
+   typedef ib_uint64_t		lsn_t;
+   typedef merge_index_def_t	index_def_t;
+   typedef merge_index_field_t	index_field_t;
+#  define xb_btr_pcur_open_at_index_side(from_left, index, latch_mode, pcur, \
+				       init_pcur, level, mtr)		\
+	btr_pcur_open_at_index_side(from_left, index, latch_mode, pcur,	\
+				    init_pcur, mtr)
+#  define xb_fil_rename_tablespace(old_name_in, id, new_name, new_path)	\
+	fil_rename_tablespace(old_name_in, id, new_name)
+#  define xb_btr_root_block_get(index, mode, mtr) \
+	btr_root_block_get(index, mtr)
+#  define UNIV_FORMAT_MAX DICT_TF_FORMAT_51;
+#  define dict_tf_get_zip_size dict_table_flags_to_zip_size
+#  define os_file_get_size(file) os_file_get_size_as_iblonglong(file)
+#  define xb_os_file_set_size(name, file, size)				\
+	os_file_set_size(name, file, (ulong)(size & 0xFFFFFFFFUL),	\
+			 (ulong)((ullint)size >> 32))
+#  define fsp_flags_is_compressed(flags) ((flags) & DICT_TF_ZSSIZE_MASK)
+#  define fsp_flags_get_zip_size(flags)					\
+	((PAGE_ZIP_MIN_SIZE >> 1) << (((flags) & DICT_TF_ZSSIZE_MASK)	\
+				      >> DICT_TF_ZSSIZE_SHIFT))
+
+#  define trx_start_for_ddl(trx, op)
+#  define ut_crc32_init()
+
+#  define LOG_CHECKPOINT_OFFSET_LOW32	LOG_CHECKPOINT_OFFSET
+#  define INNODB_LOG_DIR innobase_log_group_home_dir
+#  ifndef XTRADB_BASED
+     /* MySQL 5.1 and 5.5 */
+#    define dict_stats_update_transient(table)	\
+	dict_update_statistics(table, TRUE)
+#  else /* XTRADB_BASED */
+     /* Percona Server 5.1 and 5.5 */
+#    define dict_stats_update_transient(table)	\
+    dict_update_statistics(table, TRUE, FALSE)
+#  endif /* XTRADB_BASED */
+#endif /* MYSQL_VERSION_ID >= 50600 */
 #  define xb_fil_space_create(name, space_id, zip_size, purpose) \
 	fil_space_create(name, space_id, zip_size, purpose)
 #  define ut_dulint_zero 0
@@ -103,8 +210,33 @@
 #  define ut_dulint_align_up(A, B) ((A + B - 1) & ~((ib_int64_t)B - 1))
 
 #ifndef XTRADB_BASED
+/* MySQL 5.1 - 5.6 */
 #define trx_sys_sys_space(id) (id == 0)
-#endif
+#endif /* XTRADB_BASED */
+
+#if (MYSQL_VERSION_ID >= 50500) && (MYSQL_VERSION_ID < 50600)
+/* MySQL and Percona Server 5.5 */
+#define xb_os_file_write(name, file, buf, offset, n)			\
+	pfs_os_file_write_func(name, file, buf,				\
+			       (ulint)(offset & 0xFFFFFFFFUL),		\
+			       (ulint)(((ullint)offset) >> 32),		\
+			       n, __FILE__, __LINE__)
+#ifdef XTRADB_BASED
+/* Percona Server 5.5 only */
+#define xb_os_file_read(file, buf, offset, n)			\
+	pfs_os_file_read_func(file, buf,				\
+			      (ulint)(offset & 0xFFFFFFFFUL),		\
+			      (ulint)(((ullint)offset) >> 32),		\
+			      n,  NULL, __FILE__, __LINE__)
+#else /* XTRADB_BASED */
+/* MySQL 5.5 only */
+#define xb_os_file_read(file, buf, offset, n)			\
+	pfs_os_file_read_func(file, buf,			\
+			      (ulint)(offset & 0xFFFFFFFFUL),	\
+			      (ulint)(((ullint)offset) >> 32),	\
+			      n,  __FILE__, __LINE__)
+#endif /* XTRADB_BASED */
+#endif /* (MYSQL_VERSION_ID >= 50500) && (MYSQL_VERSION_ID < 50600) */
 
 #ifdef __WIN__
 #define SRV_PATH_SEPARATOR	'\\'
@@ -152,6 +284,7 @@
 // NOTE: We should check the following definitions fit to the source.
 // ##################################################################
 
+#if MYSQL_VERSION_ID < 50600
 //Plugin ?
 /** File node of a tablespace or the log data space */
 struct fil_node_struct {
@@ -312,9 +445,187 @@
 					potential space_id reuse */
 };
 
+#else /* MYSQL_VERSION_ID < 50600 */
+
+/** Tablespace or log data space: let us call them by a common name space */
+struct fil_space_t {
+	char*		name;	/*!< space name = the path to the first file in
+				it */
+	ulint		id;	/*!< space id */
+	ib_int64_t	tablespace_version;
+				/*!< in DISCARD/IMPORT this timestamp
+				is used to check if we should ignore
+				an insert buffer merge request for a
+				page because it actually was for the
+				previous incarnation of the space */
+	ibool		mark;	/*!< this is set to TRUE at database startup if
+				the space corresponds to a table in the InnoDB
+				data dictionary; so we can print a warning of
+				orphaned tablespaces */
+	ibool		stop_ios;/*!< TRUE if we want to rename the
+				.ibd file of tablespace and want to
+				stop temporarily posting of new i/o
+				requests on the file */
+	ibool		stop_new_ops;
+				/*!< we set this TRUE when we start
+				deleting a single-table tablespace.
+				When this is set following new ops
+				are not allowed:
+				* read IO request
+				* ibuf merge
+				* file flush
+				Note that we can still possibly have
+				new write operations because we don't
+				check this flag when doing flush
+				batches. */
+	ulint		purpose;/*!< FIL_TABLESPACE, FIL_LOG, or
+				FIL_ARCH_LOG */
+	UT_LIST_BASE_NODE_T(fil_node_t) chain;
+	/*!< base node for the file chain */
+	ulint		size;	/*!< space size in pages; 0 if a single-table
+				tablespace whose size we do not know yet;
+				last incomplete megabytes in data files may be
+				ignored if space == 0 */
+	ulint		flags;	/*!< tablespace flags; see
+				fsp_flags_is_valid(),
+				fsp_flags_get_zip_size() */
+	ulint		n_reserved_extents;
+				/*!< number of reserved free extents for
+				ongoing operations like B-tree page split */
+	ulint		n_pending_flushes; /*!< this is positive when flushing
+				the tablespace to disk; dropping of the
+				tablespace is forbidden if this is positive */
+	ulint		n_pending_ops;/*!< this is positive when we
+				have pending operations against this
+				tablespace. The pending operations can
+				be ibuf merges or lock validation code
+				trying to read a block.
+				Dropping of the tablespace is forbidden
+				if this is positive */
+	hash_node_t	hash;	/*!< hash chain node */
+	hash_node_t	name_hash;/*!< hash chain the name_hash table */
+#ifndef UNIV_HOTBACKUP
+	rw_lock_t	latch;	/*!< latch protecting the file space storage
+				  allocation */
+#endif /* !UNIV_HOTBACKUP */
+	UT_LIST_NODE_T(fil_space_t) unflushed_spaces;
+				/*!< list of spaces with at least one unflushed
+				file we have written to */
+	bool		is_in_unflushed_spaces;
+				/*!< true if this space is currently in
+				unflushed_spaces */
+	UT_LIST_NODE_T(fil_space_t) space_list;
+				/*!< list of all spaces */
+	ulint		magic_n;/*!< FIL_SPACE_MAGIC_N */
+};
+
+/** The tablespace memory cache; also the totality of logs (the log
+    data space) is stored here; below we talk about tablespaces, but also
+    the ib_logfiles form a 'space' and it is handled here */
+struct fil_system_t {
+#ifndef UNIV_HOTBACKUP
+	ib_mutex_t		mutex;		/*!< The mutex protecting the cache */
+#endif /* !UNIV_HOTBACKUP */
+	hash_table_t*	spaces;		/*!< The hash table of spaces in the
+					system; they are hashed on the space
+					id */
+	hash_table_t*	name_hash;	/*!< hash table based on the space
+					name */
+	UT_LIST_BASE_NODE_T(fil_node_t) LRU;
+					/*!< base node for the LRU list of the
+					most recently used open files with no
+					pending i/o's; if we start an i/o on
+					the file, we first remove it from this
+					list, and return it to the start of
+					the list when the i/o ends;
+					log files and the system tablespace are
+					not put to this list: they are opened
+					after the startup, and kept open until
+					shutdown */
+	UT_LIST_BASE_NODE_T(fil_space_t) unflushed_spaces;
+					/*!< base node for the list of those
+					tablespaces whose files contain
+					unflushed writes; those spaces have
+					at least one file node where
+					modification_counter > flush_counter */
+	ulint		n_open;		/*!< number of files currently open */
+	ulint		max_n_open;	/*!< n_open is not allowed to exceed
+					this */
+	ib_int64_t	modification_counter;/*!< when we write to a file we
+					increment this by one */
+	ulint		max_assigned_id;/*!< maximum space id in the existing
+					tables, or assigned during the time
+					mysqld has been up; at an InnoDB
+					startup we scan the data dictionary
+					and set here the maximum of the
+					space id's of the tables there */
+	ib_int64_t	tablespace_version;
+					/*!< a counter which is incremented for
+					every space object memory creation;
+					every space mem object gets a
+					'timestamp' from this; in DISCARD/
+					IMPORT this is used to check if we
+					should ignore an insert buffer merge
+					request */
+	UT_LIST_BASE_NODE_T(fil_space_t) space_list;
+					/*!< list of all file spaces */
+	ibool		space_id_reuse_warned;
+					/* !< TRUE if fil_space_create()
+					has issued a warning about
+					potential space_id reuse */
+};
+
+/** File node of a tablespace or the log data space */
+struct fil_node_t {
+	fil_space_t*	space;	/*!< backpointer to the space where this node
+				belongs */
+	char*		name;	/*!< path to the file */
+	ibool		open;	/*!< TRUE if file open */
+	os_file_t	handle;	/*!< OS handle to the file, if file open */
+	ibool		is_raw_disk;/*!< TRUE if the 'file' is actually a raw
+				device or a raw disk partition */
+	ulint		size;	/*!< size of the file in database pages, 0 if
+				not known yet; the possible last incomplete
+				megabyte may be ignored if space == 0 */
+	ulint		n_pending;
+				/*!< count of pending i/o's on this file;
+				closing of the file is not allowed if
+				this is > 0 */
+	ulint		n_pending_flushes;
+				/*!< count of pending flushes on this file;
+				closing of the file is not allowed if
+				this is > 0 */
+	ibool		being_extended;
+				/*!< TRUE if the node is currently
+				being extended. */
+	ib_int64_t	modification_counter;/*!< when we write to the file we
+				increment this by one */
+	ib_int64_t	flush_counter;/*!< up to what
+				modification_counter value we have
+				flushed the modifications to disk */
+	UT_LIST_NODE_T(fil_node_t) chain;
+				/*!< link field for the file chain */
+	UT_LIST_NODE_T(fil_node_t) LRU;
+				/*!< link field for the LRU list */
+	ulint		magic_n;/*!< FIL_NODE_MAGIC_N */
+};
+
+#endif /* MYSQL_VERSION_ID < 50600 */
+
 extern fil_system_t*   fil_system;
 extern char *opt_mysql_tmpdir;
 
+/* InnoDB data dictionary API in MySQL 5.5- works on on tables named
+"./database/table.ibd", and in 5.6+ on "database/table".  This variable
+handles the presence or absence of "./".  */
+extern const char* xb_dict_prefix;
+
+#if MYSQL_VERSION_ID < 50600
+extern char*	innobase_log_group_home_dir;
+#endif
+
+extern long innobase_mirrored_log_groups;
+
 /** Value of fil_space_struct::magic_n */
 #define	FIL_SPACE_MAGIC_N	89472
 
@@ -324,16 +635,55 @@
 struct TABLE;
 #endif
 
-extern "C" {
-
 /* prototypes for static and non-prototyped functions in original */
+
+#if MYSQL_VERSION_ID < 50600
+extern "C" {
+#endif
+
+#if MYSQL_VERSION_ID >= 50600
+
 buf_block_t*
-btr_node_ptr_get_child(
-/*===================*/
-	const rec_t*	node_ptr,/*!< in: node pointer */
-	dict_index_t*	index,	/*!< in: index */
-	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
-	mtr_t*		mtr);	/*!< in: mtr */
+btr_root_block_get(
+/*===============*/
+	const dict_index_t*	index,	/*!< in: index tree */
+	ulint			mode,	/*!< in: either RW_S_LATCH
+					or RW_X_LATCH */
+	mtr_t*			mtr);	/*!< in: mtr */
+
+int
+fil_file_readdir_next_file(
+/*=======================*/
+	dberr_t*	err,	/*!< out: this is set to DB_ERROR if an error
+				was encountered, otherwise not changed */
+	const char*	dirname,/*!< in: directory name or path */
+	os_file_dir_t	dir,	/*!< in: directory stream */
+	os_file_stat_t*	info);	/*!< in/out: buffer where the
+				info is returned */
+
+ibool
+recv_check_cp_is_consistent(
+/*========================*/
+	const byte*	buf);	/*!< in: buffer containing checkpoint info */
+
+dberr_t
+open_or_create_data_files(
+/*======================*/
+	ibool*		create_new_db,	/*!< out: TRUE if new database should be
+					created */
+	lsn_t*		min_flushed_lsn,/*!< out: min of flushed lsn
+					values in data files */
+	lsn_t*		max_flushed_lsn,/*!< out: max of flushed lsn
+					values in data files */
+	ulint*		sum_of_new_sizes);/*!< out: sum of sizes of the
+					new files added */
+
+ibool
+log_block_checksum_is_ok_or_old_format(
+/*===================================*/
+	const byte*     block); /*!< in: pointer to a log block */
+
+#else /* MYSQL_VERSION_ID >= 50600 */
 
 buf_block_t*
 btr_root_block_get(
@@ -347,7 +697,7 @@
 				/* out: 0 if ok, -1 if error even after the
 				retries, 1 if at the end of the directory */
 	ulint*		err,	/* out: this is set to DB_ERROR if an error
-				was encountered, otherwise not changed */
+			        was encountered, otherwise not changed */
 	const char*	dirname,/* in: directory name or path */
 	os_file_dir_t	dir,	/* in: directory stream */
 	os_file_stat_t*	info);	/* in/out: buffer where the info is returned */
@@ -359,6 +709,38 @@
 	byte*	buf);	/* in: buffer containing checkpoint info */
 
 ulint
+open_or_create_data_files(
+/*======================*/
+				/* out: DB_SUCCESS or error code */
+	ibool*	create_new_db,	/* out: TRUE if new database should be
+				created */
+#ifdef XTRADB_BASED
+	ibool*	create_new_doublewrite_file,
+#endif
+	lsn_t*	min_flushed_lsn,/* out: min of flushed lsn values in data
+				files */
+	lsn_t*	max_flushed_lsn,/* out: */
+	ulint*	sum_of_new_sizes);/* out: sum of sizes of the new files added
+				*/
+
+ibool
+log_block_checksum_is_ok_or_old_format(
+/*===================================*/
+			/* out: TRUE if ok, or if the log block may be in the
+			format of InnoDB version < 3.23.52 */
+	byte*	block);	/* in: pointer to a log block */
+
+#endif /* MYSQL_VERSION_ID >= 50600 */
+
+buf_block_t*
+btr_node_ptr_get_child(
+/*===================*/
+	const rec_t*	node_ptr,/*!< in: node pointer */
+	dict_index_t*	index,	/*!< in: index */
+	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */
+	mtr_t*		mtr);	/*!< in: mtr */
+
+ulint
 recv_find_max_checkpoint(
 /*=====================*/
 					/* out: error code or DB_SUCCESS */
@@ -366,13 +748,6 @@
 	ulint*		max_field);	/* out: LOG_CHECKPOINT_1 or
 					LOG_CHECKPOINT_2 */
 
-ibool
-log_block_checksum_is_ok_or_old_format(
-/*===================================*/
-			/* out: TRUE if ok, or if the log block may be in the
-			format of InnoDB version < 3.23.52 */
-	byte*	block);	/* in: pointer to a log block */
-
 ulint
 open_or_create_log_file(
 /*====================*/
@@ -387,26 +762,6 @@
 	ulint	k,			/* in: log group number */
 	ulint	i);			/* in: log file number in group */
 
-ulint
-open_or_create_data_files(
-/*======================*/
-				/* out: DB_SUCCESS or error code */
-	ibool*	create_new_db,	/* out: TRUE if new database should be
-								created */
-#ifdef XTRADB_BASED
-	ibool*	create_new_doublewrite_file,
-#endif
-#ifdef UNIV_LOG_ARCHIVE
-	ulint*	min_arch_log_no,/* out: min of archived log numbers in data
-				files */
-	ulint*	max_arch_log_no,/* out: */
-#endif /* UNIV_LOG_ARCHIVE */
-	LSN64*	min_flushed_lsn,/* out: min of flushed lsn values in data
-				files */
-	LSN64*	max_flushed_lsn,/* out: */
-	ulint*	sum_of_new_sizes);/* out: sum of sizes of the new files added
-				  */
-
 void
 os_file_set_nocache(
 /*================*/
@@ -418,7 +773,9 @@
 					a file, so this is either "open" or
 					"create" */
 
+#if MYSQL_VERSION_ID < 50600
 } /* extern "C" */
+#endif
 
 /****************************************************************//**
 A simple function to open or create a file.
@@ -535,7 +892,9 @@
 xb_normalize_init_values(void);
 /*==========================*/
 
+#if MYSQL_VERSION_ID < 50600
 extern "C" {
+#endif
 
 #if MYSQL_VERSION_ID >= 50500
 
@@ -582,12 +941,16 @@
 
 #endif
 
+#if MYSQL_VERSION_ID < 50600
+
 void
 innobase_invalidate_query_cache(
 	trx_t*	trx,
 	const char*	full_name,
 	ulint	full_name_len);
 
+#endif /* MYSQL_VERSION_ID < 50600 */
+
 /*****************************************************************//**
 Convert a table or index name to the MySQL system_charset_info (UTF-8)
 and quote it if needed.
@@ -655,6 +1018,75 @@
 	const dict_index_t*	index,
 	const ulint*		offsets);
 
+#if MYSQL_VERSION_ID < 50600
 } /* extern "C" */
+#endif
+
+#if MYSQL_VERSION_ID >= 50600
+
+extern os_file_t	files[1000];
+
+/*********************************************************************//**
+Creates or opens the log files and closes them.
+@return	DB_SUCCESS or error code */
+ulint
+open_or_create_log_file(
+/*====================*/
+	ibool	create_new_db,		/*!< in: TRUE if we should create a
+					new database */
+	ibool*	log_file_created,	/*!< out: TRUE if new log file
+					created */
+	ibool	log_file_has_been_opened,/*!< in: TRUE if a log file has been
+					opened before: then it is an error
+					to try to create another log file */
+	ulint	k,			/*!< in: log group number */
+	ulint	i);			/*!< in: log file number in group */
+
+#endif
+
+/*****************************************************************//**
+Parse, validate, and set the InnoDB variables from
+innodb_log_group_home_dir and innodb_mirrored_log_group_groups
+options.
+
+@return TRUE if server variables set OK, FALSE otherwise */
+ibool
+xb_parse_log_group_home_dirs(void);
+/*===============================*/
+
+/*****************************************************************//**
+Set InnoDB to read-only mode. */
+void
+xb_set_innodb_read_only(void);
+/*==========================*/
+
+/*****************************************************************//**
+Adjust srv_fatal_semaphore_wait_threshold in a thread-safe manner.  */
+void
+xb_adjust_fatal_semaphore_wait_threshold(
+/*=====================================*/
+	ulint delta);
+
+/*****************************************************************//**
+Wrapper around around recv_check_cp_is_consistent() for handling
+version differences.
+
+@return TRUE if checkpoint info in the buffer is OK */
+ibool
+xb_recv_check_cp_is_consistent(
+/*===========================*/
+	const byte*	buf);	/*!<in: buffer containing checkpoint info */
+
+/*****************************************************************//**
+Initialize a index_field_t variable from a dict_field_t */
+void
+xb_dict_index_field_to_index_field(
+/*===============================*/
+	 mem_heap_t*		heap,			/*!< in: heap for
+							field name string
+							allocation on 5.5 or
+							earlier version. */
+	 const dict_field_t*	dict_index_field,	/*!< in: field */
+	 index_field_t*		index_field);		/*!< out: field */
 
 #endif /* INNODB_INT_H */

=== modified file 'src/write_filt.cc'
--- src/write_filt.cc	2013-02-20 10:20:00 +0000
+++ src/write_filt.cc	2013-03-22 15:32:33 +0000
@@ -78,7 +78,7 @@
 	/* allocate buffer for incremental backup (4096 pages) */
 	buf_size = (UNIV_PAGE_SIZE_MAX / 4 + 1) * UNIV_PAGE_SIZE_MAX;
 	cp->delta_buf_base = static_cast<byte *>(ut_malloc(buf_size));
-	bzero(cp->delta_buf_base, buf_size);
+	memset(cp->delta_buf_base, 0, buf_size);
 	cp->delta_buf = static_cast<byte *>
 		(ut_align(cp->delta_buf_base, UNIV_PAGE_SIZE_MAX));
 
@@ -134,7 +134,7 @@
 			}
 
 			/* clear buffer */
-			bzero(cp->delta_buf, page_size / 4 * page_size);
+			memset(cp->delta_buf, 0, page_size / 4 * page_size);
 			/*"xtra"*/
 			mach_write_to_4(cp->delta_buf, 0x78747261UL);
 			cp->npages = 1;

=== modified file 'src/xbcrypt_common.c'
--- src/xbcrypt_common.c	2013-03-11 19:11:29 +0000
+++ src/xbcrypt_common.c	2013-03-22 15:32:33 +0000
@@ -19,7 +19,6 @@
 *******************************************************/
 
 #include <my_base.h>
-#include <univ.i>
 #include "common.h"
 #include "xbcrypt.h"
 #include <gcrypt.h>

=== modified file 'src/xtrabackup.cc'
--- src/xtrabackup.cc	2013-03-19 12:30:53 +0000
+++ src/xtrabackup.cc	2013-03-22 15:32:33 +0000
@@ -52,6 +52,10 @@
 #include <my_base.h>
 #include <my_getopt.h>
 #include <mysql_com.h>
+#if MYSQL_VERSION_ID >= 50600
+#include <my_default.h>
+#include <mysqld.h>
+#endif
 
 #include <fcntl.h>
 
@@ -92,9 +96,9 @@
 os_event_t wait_throttle = NULL;
 
 char *xtrabackup_incremental = NULL;
-LSN64 incremental_lsn;
-LSN64 incremental_to_lsn;
-LSN64 incremental_last_lsn;
+lsn_t incremental_lsn;
+lsn_t incremental_to_lsn;
+lsn_t incremental_last_lsn;
 
 char *xtrabackup_incremental_basedir = NULL; /* for --backup */
 char *xtrabackup_extra_lsndir = NULL; /* for --backup with --extra-lsndir */
@@ -122,9 +126,9 @@
 static os_thread_id_t	thread_ids[SRV_MAX_N_IO_THREADS + 6];
 #endif
 
-LSN64 checkpoint_lsn_start;
-LSN64 checkpoint_no_start;
-LSN64 log_copy_scanned_lsn;
+lsn_t checkpoint_lsn_start;
+lsn_t checkpoint_no_start;
+lsn_t log_copy_scanned_lsn;
 ibool log_copying = TRUE;
 ibool log_copying_running = FALSE;
 ibool log_copying_succeed = FALSE;
@@ -159,17 +163,20 @@
 /* === metadata of backup === */
 #define XTRABACKUP_METADATA_FILENAME "xtrabackup_checkpoints"
 char metadata_type[30] = ""; /*[full-backuped|full-prepared|incremental]*/
-ib_uint64_t metadata_from_lsn = 0;
-ib_uint64_t metadata_to_lsn = 0;
-ib_uint64_t metadata_last_lsn = 0;
+lsn_t metadata_from_lsn = 0;
+lsn_t metadata_to_lsn = 0;
+lsn_t metadata_last_lsn = 0;
 
 #define XB_LOG_FILENAME "xtrabackup_logfile"
 
 ds_file_t	*dst_log_file = NULL;
 
 /* === some variables from mysqld === */
+#if MYSQL_VERSION_ID < 50600
 char mysql_real_data_home[FN_REFLEN] = "./";
+MY_TMPDIR mysql_tmpdir_list;
 char *mysql_data_home= mysql_real_data_home;
+#endif
 static char mysql_data_home_buff[2];
 
 const char *defaults_group = "mysqld";
@@ -193,7 +200,6 @@
 long innobase_lock_wait_timeout = 50;
 long innobase_log_buffer_size = 1024*1024L;
 long innobase_log_files_in_group = 2;
-long innobase_mirrored_log_groups = 1;
 long innobase_open_files = 300L;
 
 long innobase_page_size = (1 << 14); /* 16KB */
@@ -205,7 +211,7 @@
 char*	innobase_doublewrite_file = NULL;
 
 longlong innobase_buffer_pool_size = 8*1024*1024L;
-longlong innobase_log_file_size = 5*1024*1024L;
+longlong innobase_log_file_size = DEFAULT_LOG_FILE_SIZE;
 
 /* The default values for the following char* start-up parameters
 are determined in innobase_init below: */
@@ -213,7 +219,6 @@
 char*	innobase_ignored_opt			= NULL;
 char*	innobase_data_home_dir			= NULL;
 char*	innobase_data_file_path 		= NULL;
-char*	innobase_log_group_home_dir		= NULL;
 char*	innobase_log_arch_dir			= NULL;/* unused */
 /* The following has a misleading name: starting from 4.0.5, this also
 affects Windows: */
@@ -336,7 +341,7 @@
 	datafiles_iter_t 	*it;
 	uint			num;
 	uint			*count;
-	os_mutex_t		count_mutex;
+	os_ib_mutex_t		count_mutex;
 	os_thread_id_t		id;
 } data_thread_ctxt_t;
 
@@ -421,10 +426,36 @@
   OPT_XTRA_DEBUG_SYNC,
   OPT_XTRA_COMPACT,
   OPT_XTRA_REBUILD_INDEXES,
+#if MYSQL_VERSION_ID >= 50600
+  OPT_INNODB_CHECKSUM_ALGORITHM,
+  OPT_UNDO_TABLESPACES,
+#endif
   OPT_DEFAULTS_GROUP
 };
 
-static struct my_option my_long_options[] =
+#if MYSQL_VERSION_ID >= 50600
+/** Possible values for system variable "innodb_checksum_algorithm". */
+static const char* innodb_checksum_algorithm_names[] = {
+	"crc32",
+	"strict_crc32",
+	"innodb",
+	"strict_innodb",
+	"none",
+	"strict_none",
+	NullS
+};
+
+/** Used to define an enumerate type of the system variable
+    innodb_checksum_algorithm. */
+static TYPELIB innodb_checksum_algorithm_typelib = {
+	array_elements(innodb_checksum_algorithm_names) - 1,
+	"innodb_checksum_algorithm_typelib",
+	innodb_checksum_algorithm_names,
+	NULL
+};
+#endif
+
+static struct my_option xb_long_options[] =
 {
   {"version", 'v', "print xtrabackup version information",
    (G_PTR *) &xtrabackup_version, (G_PTR *) &xtrabackup_version, 0, GET_BOOL,
@@ -600,7 +631,7 @@
   {"innodb_io_capacity", OPT_INNODB_IO_CAPACITY,
    "Number of IOPs the server can do. Tunes the background IO rate",
    (G_PTR*) &srv_io_capacity, (G_PTR*) &srv_io_capacity,
-   0, GET_ULONG, OPT_ARG, 200, 100, ~0L, 0, 0, 0},
+   0, GET_ULONG, OPT_ARG, 200, 100, ~0UL, 0, 0, 0},
 /*
   {"innodb_fast_shutdown", OPT_INNODB_FAST_SHUTDOWN,
    "Speeds up the shutdown process of the InnoDB storage engine. Possible "
@@ -666,15 +697,15 @@
   {"innodb_log_file_size", OPT_INNODB_LOG_FILE_SIZE,
    "Size of each log file in a log group.",
    (G_PTR*) &innobase_log_file_size, (G_PTR*) &innobase_log_file_size, 0,
-   GET_LL, REQUIRED_ARG, 5*1024*1024L, 1*1024*1024L, LONGLONG_MAX, 0,
+   GET_LL, REQUIRED_ARG, DEFAULT_LOG_FILE_SIZE, 1*1024*1024L, LONGLONG_MAX, 0,
    1024*1024L, 0},
   {"innodb_log_files_in_group", OPT_INNODB_LOG_FILES_IN_GROUP,
    "Number of log files in the log group. InnoDB writes to the files in a circular fashion. Value 3 is recommended here.",
    (G_PTR*) &innobase_log_files_in_group, (G_PTR*) &innobase_log_files_in_group,
    0, GET_LONG, REQUIRED_ARG, 2, 2, 100, 0, 1, 0},
   {"innodb_log_group_home_dir", OPT_INNODB_LOG_GROUP_HOME_DIR,
-   "Path to InnoDB log files.", (G_PTR*) &innobase_log_group_home_dir,
-   (G_PTR*) &innobase_log_group_home_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0,
+   "Path to InnoDB log files.", (G_PTR*) &INNODB_LOG_DIR,
+   (G_PTR*) &INNODB_LOG_DIR, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0,
    0, 0},
   {"innodb_max_dirty_pages_pct", OPT_INNODB_MAX_DIRTY_PAGES_PCT,
    "Percentage of dirty pages allowed in bufferpool.", (G_PTR*) &srv_max_buf_pool_modified_pct,
@@ -748,6 +779,19 @@
    (G_PTR*) &xtrabackup_rebuild_indexes, (G_PTR*) &xtrabackup_rebuild_indexes,
    0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
+#if MYSQL_VERSION_ID >= 50600
+  {"checksum-algorithm", OPT_INNODB_CHECKSUM_ALGORITHM,
+  "The algorithm InnoDB uses for page checksumming. [CRC32, STRICT_CRC32, "
+   "INNODB, STRICT_INNODB, NONE, STRICT_NONE]", &srv_checksum_algorithm,
+   &srv_checksum_algorithm, &innodb_checksum_algorithm_typelib, GET_ENUM,
+   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  {"undo-tablespaces", OPT_UNDO_TABLESPACES,
+   "Number of undo tablespaces to use. NON-ZERO VALUES ARE NOT "
+   "CURRENTLY SUPPORTED",
+   (G_PTR*)&srv_undo_tablespaces, (G_PTR*)&srv_undo_tablespaces,
+   0, GET_ULONG, REQUIRED_ARG, 0, 0, 126, 0, 1, 0},
+#endif
+
   {"defaults_group", OPT_DEFAULTS_GROUP, "defaults group in config file (default \"mysqld\").",
    (G_PTR*) &defaults_group, (G_PTR*) &defaults_group,
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
@@ -809,7 +853,7 @@
 #endif
 }
 
-static const char *load_default_groups[]= { "mysqld","xtrabackup",0,0 };
+static const char *xb_load_default_groups[]= { "mysqld", "xtrabackup", 0, 0 };
 
 static void print_version(void)
 {
@@ -844,9 +888,9 @@
 You can download full text of the license on http://www.gnu.org/licenses/gpl-2.0.txt\n");
 
   printf("Usage: [%s [--defaults-file=#] --backup | %s [--defaults-file=#] --prepare] [OPTIONS]\n",my_progname,my_progname);
-  print_defaults("my",load_default_groups);
-  my_print_help(my_long_options);
-  my_print_variables(my_long_options);
+  print_defaults("my", xb_load_default_groups);
+  my_print_help(xb_long_options);
+  my_print_variables(xb_long_options);
 }
 
 static my_bool
@@ -855,7 +899,7 @@
 {
   switch(optid) {
   case 'h':
-    strmake(mysql_real_data_home,argument, sizeof(mysql_real_data_home)-1);
+    strmake(mysql_real_data_home,argument, FN_REFLEN - 1);
     mysql_data_home= mysql_real_data_home;
     break;
   case OPT_XTRA_TARGET_DIR:
@@ -944,7 +988,7 @@
 	char		*default_path;
 
 	/* === some variables from mysqld === */
-	bzero((G_PTR) &mysql_tmpdir_list, sizeof(mysql_tmpdir_list));
+	memset((G_PTR) &mysql_tmpdir_list, 0, sizeof(mysql_tmpdir_list));
 
 	if (init_tmpdir(&mysql_tmpdir_list, opt_mysql_tmpdir))
 		exit(EXIT_FAILURE);
@@ -1099,48 +1143,32 @@
 
 	/* The default dir for log files is the datadir of MySQL */
 
-	if (!((xtrabackup_backup || xtrabackup_stats) && innobase_log_group_home_dir)) {
-	  	innobase_log_group_home_dir = default_path;
+	if (!((xtrabackup_backup || xtrabackup_stats) && INNODB_LOG_DIR)) {
+		INNODB_LOG_DIR = default_path;
 	}
 	if (xtrabackup_prepare && xtrabackup_incremental_dir) {
-		innobase_log_group_home_dir = xtrabackup_incremental_dir;
+		INNODB_LOG_DIR = xtrabackup_incremental_dir;
 	}
-	msg("xtrabackup:   innodb_log_group_home_dir = %s\n",
-	    innobase_log_group_home_dir);
-
-#ifdef UNIV_LOG_ARCHIVE
-	/* Since innodb_log_arch_dir has no relevance under MySQL,
-	starting from 4.0.6 we always set it the same as
-	innodb_log_group_home_dir: */
-
-	innobase_log_arch_dir = innobase_log_group_home_dir;
-
-	srv_arch_dir = innobase_log_arch_dir;
-#endif /* UNIG_LOG_ARCHIVE */
-
-	ret = (my_bool)
-		srv_parse_log_group_home_dirs(innobase_log_group_home_dir);
-
-	if (ret == FALSE || innobase_mirrored_log_groups != 1) {
-		msg("xtrabackup: syntax error in innodb_log_group_home_dir, "
-		    "or a wrong number of mirrored log groups\n");
-
-                goto mem_free_and_error;
+	msg("xtrabackup:   innodb_log_group_home_dir = %s\n", INNODB_LOG_DIR);
+
+	ret = (my_bool) xb_parse_log_group_home_dirs();
+	if (ret == FALSE) {
+
+		goto mem_free_and_error;
 	}
 
 	srv_adaptive_flushing = FALSE;
 	srv_use_sys_malloc = TRUE;
 	srv_file_format = 1; /* Barracuda */
 #if (MYSQL_VERSION_ID < 50500)
-	srv_check_file_format_at_startup = DICT_TF_FORMAT_51; /* on */
+	srv_check_file_format_at_startup = UNIV_FORMAT_MAX; /* on */
 #else
-	srv_max_file_format_at_startup = DICT_TF_FORMAT_51; /* on */
+	srv_max_file_format_at_startup = UNIV_FORMAT_MAX; /* on */
 #endif
 	/* --------------------------------------------------*/
 
 	srv_file_flush_method_str = innobase_unix_file_flush_method;
 
-	srv_n_log_groups = (ulint) innobase_mirrored_log_groups;
 	srv_n_log_files = (ulint) innobase_log_files_in_group;
 	srv_log_file_size = (ulint) innobase_log_file_size;
 	msg("xtrabackup:   innodb_log_files_in_group = %ld\n",
@@ -1168,7 +1196,9 @@
 	srv_force_recovery = (ulint) innobase_force_recovery;
 
 	srv_use_doublewrite_buf = (ibool) innobase_use_doublewrite;
+#if MYSQL_VERSION_ID < 50600
 	srv_use_checksums = (ibool) innobase_use_checksums;
+#endif
 
 	btr_search_enabled = (char) innobase_adaptive_hash_index;
 
@@ -1362,17 +1392,19 @@
 		r = FALSE;
 		goto end;
 	}
-	if (fscanf(fp, "from_lsn = %llu\n", &metadata_from_lsn)
-			!= 1) {
-		r = FALSE;
-		goto end;
-	}
-	if (fscanf(fp, "to_lsn = %llu\n", &metadata_to_lsn)
-			!= 1) {
-		r = FALSE;
-		goto end;
-	}
-	if (fscanf(fp, "last_lsn = %llu\n", &metadata_last_lsn)
+	/* Use UINT64PF instead of LSN_PF here, as we have to maintain the file
+	format. */
+	if (fscanf(fp, "from_lsn = " UINT64PF "\n", &metadata_from_lsn)
+			!= 1) {
+		r = FALSE;
+		goto end;
+	}
+	if (fscanf(fp, "to_lsn = " UINT64PF "\n", &metadata_to_lsn)
+			!= 1) {
+		r = FALSE;
+		goto end;
+	}
+	if (fscanf(fp, "last_lsn = " UINT64PF "\n", &metadata_last_lsn)
 			!= 1) {
 		metadata_last_lsn = 0;
 	}
@@ -1394,11 +1426,13 @@
 void
 xtrabackup_print_metadata(char *buf, size_t buf_len)
 {
+	/* Use UINT64PF instead of LSN_PF here, as we have to maintain the file
+	format. */
 	snprintf(buf, buf_len,
 		 "backup_type = %s\n"
-		 "from_lsn = %llu\n"
-		 "to_lsn = %llu\n"
-		 "last_lsn = %llu\n"
+		 "from_lsn = " UINT64PF "\n"
+		 "to_lsn = " UINT64PF "\n"
+		 "last_lsn = " UINT64PF "\n"
 		 "compact = %d\n",
 		 metadata_type,
 		 metadata_from_lsn,
@@ -1686,14 +1720,14 @@
 	buf = static_cast<byte *>(ut_malloc(2 * UNIV_PAGE_SIZE_MAX));
 	page = static_cast<byte *>(ut_align(buf, UNIV_PAGE_SIZE_MAX));
 
-	success = os_file_read(file, page, 0, 0, UNIV_PAGE_SIZE_MAX);
+	success = xb_os_file_read(file, page, 0, UNIV_PAGE_SIZE_MAX);
 	if (!success) {
 		goto end;
 	}
 
 	space = mach_read_from_4(page + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID);
 	zip_size = (space == 0 ) ? 0 :
-		dict_table_flags_to_zip_size(fsp_header_get_flags(page));
+		dict_tf_get_zip_size(fsp_header_get_flags(page));
 end:
 	ut_free(buf);
 
@@ -1839,12 +1873,12 @@
 }
 
 static my_bool
-xtrabackup_copy_logfile(LSN64 from_lsn, my_bool is_last)
+xtrabackup_copy_logfile(lsn_t from_lsn, my_bool is_last)
 {
 	/* definition from recv_recovery_from_checkpoint_start() */
 	log_group_t*	group;
-	LSN64		group_scanned_lsn;
-	LSN64		contiguous_lsn;
+	lsn_t		group_scanned_lsn;
+	lsn_t		contiguous_lsn;
 
 	ut_a(dst_log_file != NULL);
 
@@ -1858,8 +1892,8 @@
 
 	while (group) {
 		ibool	finished;
-		LSN64	start_lsn;
-		LSN64	end_lsn;
+		lsn_t	start_lsn;
+		lsn_t	end_lsn;
 
 		/* reference recv_group_scan_log_recs() */
 	finished = FALSE;
@@ -1880,7 +1914,7 @@
 		/* reference recv_scan_log_recs() */
 		{
 	byte*	log_block;
-	LSN64	scanned_lsn;
+	lsn_t	scanned_lsn;
 	ulint	data_len;
 
 	ulint	scanned_checkpoint_no = 0;
@@ -1928,7 +1962,7 @@
 			/* Garbage or an incompletely written log block */
 
 			msg("xtrabackup: warning: Log block checksum mismatch"
-			    " (block no %lu at lsn %llu): \n"
+			    " (block no %lu at lsn " LSN_PF "): \n"
 			    "expected %lu, calculated checksum %lu\n",
 				(ulong) no,
 				scanned_lsn,
@@ -2023,7 +2057,8 @@
 
 		group->scanned_lsn = group_scanned_lsn;
 
-		msg(">> log scanned up to (%llu)\n", group->scanned_lsn);
+		msg(">> log scanned up to (" LSN_PF ")\n",
+		    group->scanned_lsn);
 
 		group = UT_LIST_GET_NEXT(log_groups, group);
 
@@ -2332,12 +2367,16 @@
 	ibool	create_new_doublewrite_file;
 #endif
 	ulint	err;
-	LSN64	min_flushed_lsn;
-	LSN64	max_flushed_lsn;
+	lsn_t	min_flushed_lsn;
+	lsn_t	max_flushed_lsn;
 	ulint   sum_of_new_sizes;
 
+#if MYSQL_VERSION_ID >= 50600
+	srv_n_file_io_threads = srv_n_read_io_threads;
+#else
 	srv_n_file_io_threads = 2 + srv_n_read_io_threads +
 		srv_n_write_io_threads;
+#endif
 
 	os_aio_init(8 * SRV_N_PENDING_IOS_PER_THREAD,
 		    srv_n_read_io_threads,
@@ -2606,10 +2645,10 @@
 xtrabackup_backup_func(void)
 {
 	MY_STAT			 stat_info;
-	LSN64			 latest_cp;
+	lsn_t			 latest_cp;
 	uint			 i;
 	uint			 count;
-	os_mutex_t		 count_mutex;
+	os_ib_mutex_t		 count_mutex;
 	data_thread_ctxt_t 	*data_threads;
 	char			suspend_path[FN_REFLEN];
 	ibool			success;
@@ -2631,8 +2670,7 @@
 	mysql_data_home[0]=FN_CURLIB;		// all paths are relative from here
 	mysql_data_home[1]=0;
 
-	/* set read only */
-	srv_read_only = TRUE;
+	xb_set_innodb_read_only();
 
 	/* initialize components */
         if(innodb_init_param())
@@ -2711,6 +2749,7 @@
 
 	os_sync_mutex = NULL;
 	srv_general_init();
+	ut_crc32_init();
 
 	xb_filters_init();
 
@@ -2891,7 +2930,7 @@
 		os_thread_id_t io_watching_thread_id;
 
 		io_ticket = xtrabackup_throttle;
-		wait_throttle = os_event_create(NULL);
+		wait_throttle = xb_os_event_create(NULL);
 
 		os_thread_create(io_watching_thread, NULL, &io_watching_thread_id);
 	}
@@ -2996,7 +3035,7 @@
 		mutex_exit(&log_sys->mutex);
 
 		msg("xtrabackup: The latest check point (for incremental): "
-		    "'%llu'\n", latest_cp);
+		    "'" LSN_PF "'\n", latest_cp);
 	}
 skip_last_cp:
 	/* stop log_copying_thread */
@@ -3051,9 +3090,8 @@
 	if (wait_throttle)
 		os_event_free(wait_throttle);
 
-	msg("xtrabackup: Transaction log of lsn (%llu) to (%llu) was copied.\n",
-	    checkpoint_lsn_start, log_copy_scanned_lsn);
-
+	msg("xtrabackup: Transaction log of lsn (" LSN_PF ") to (" LSN_PF
+	    ") was copied.\n", checkpoint_lsn_start, log_copy_scanned_lsn);
 	xb_filters_free();
 
 	xb_data_files_close();
@@ -3098,7 +3136,7 @@
 	mtr_start(&mtr);
 
 	mtr_x_lock(&(index->lock), &mtr);
-	block = btr_root_block_get(index, &mtr);
+	block = xb_btr_root_block_get(index, RW_X_LATCH, &mtr);
 	page = buf_block_get_frame(block);
 
 	space = page_get_space_id(page);
@@ -3254,9 +3292,9 @@
 	}
 
 	if (level == 0)
-		fprintf(stdout, "recs=%lld, ", n_recs);
+		fprintf(stdout, "recs=%llu, ", n_recs);
 
-	fprintf(stdout, "pages=%lld, data=%lld bytes, data/pages=%lld%%",
+	fprintf(stdout, "pages=%llu, data=%llu bytes, data/pages=%lld%%",
 		n_pages, sum_data,
 		((sum_data * 100)/ page_size)/n_pages);
 
@@ -3266,7 +3304,7 @@
 		/* also scan blob pages*/
 		fprintf(stdout, "    external pages: ");
 
-		fprintf(stdout, "pages=%lld, data=%lld bytes, data/pages=%lld%%",
+		fprintf(stdout, "pages=%llu, data=%llu bytes, data/pages=%lld%%",
 			n_pages_extern, sum_data_extern,
 			((sum_data_extern * 100)/ page_size)/n_pages_extern);
 	}
@@ -3298,10 +3336,12 @@
 	mysql_data_home[0]=FN_CURLIB;		// all paths are relative from here
 	mysql_data_home[1]=0;
 
+	xb_set_innodb_read_only();
 	/* set read only */
-	srv_read_only = TRUE;
+#if MYSQL_VERSION_ID < 50600
 	srv_fake_write = TRUE;
-#if MYSQL_VERSION_ID >= 50500
+#endif
+#if (MYSQL_VERSION_ID >= 50500) && (MYSQL_VERSION_ID < 50600)
 	/* AIO is incompatible with srv_read_only/srv_fake_write */
 	srv_use_native_aio = FALSE;
 #endif
@@ -3359,9 +3399,7 @@
 	/* Enlarge the fatal semaphore wait timeout during the InnoDB table
 	monitor printout */
 
-	mutex_enter(&kernel_mutex);
-	srv_fatal_semaphore_wait_threshold += 72000; /* 20 hours */
-	mutex_exit(&kernel_mutex);
+	xb_adjust_fatal_semaphore_wait_threshold(72000); /* 20 hours */
 
 	mutex_enter(&(dict_sys->mutex));
 
@@ -3370,8 +3408,8 @@
 	sys_tables = dict_table_get_low("SYS_TABLES");
 	sys_index = UT_LIST_GET_FIRST(sys_tables->indexes);
 
-	btr_pcur_open_at_index_side(TRUE, sys_index, BTR_SEARCH_LEAF, &pcur,
-								TRUE, &mtr);
+	xb_btr_pcur_open_at_index_side(TRUE, sys_index, BTR_SEARCH_LEAF, &pcur,
+				       TRUE, 0, &mtr);
 loop:
 	btr_pcur_move_to_next_user_rec(&pcur, &mtr);
 
@@ -3387,10 +3425,7 @@
 		mutex_exit(&(dict_sys->mutex));
 
 		/* Restore the fatal semaphore wait timeout */
-
-		mutex_enter(&kernel_mutex);
-		srv_fatal_semaphore_wait_threshold -= 72000; /* 20 hours */
-		mutex_exit(&kernel_mutex);
+		xb_adjust_fatal_semaphore_wait_threshold(-72000);
 
 		goto end;
 	}
@@ -3435,11 +3470,7 @@
 			is no index */
 
 			if (dict_table_get_first_index(table)) {
-#ifdef XTRADB_BASED
-				dict_update_statistics(table, TRUE, FALSE);
-#else
-				dict_update_statistics(table, TRUE);
-#endif
+				dict_stats_update_transient(table);
 			}
 
 			//dict_table_print_low(table);
@@ -3447,7 +3478,7 @@
 			index = UT_LIST_GET_FIRST(table->indexes);
 			while (index != NULL) {
 {
-	IB_INT64	n_vals;
+	ib_int64_t	n_vals;
 
 	if (index->n_user_defined_cols > 0) {
 		n_vals = index->stat_n_diff_key_vals[
@@ -3534,11 +3565,11 @@
 	byte*	log_buf;
 	byte*	log_buf_ = NULL;
 
-	IB_INT64	file_size;
+	ib_int64_t	file_size;
 
-	LSN64	max_no;
-	LSN64	max_lsn;
-	LSN64	checkpoint_no;
+	lsn_t	max_no;
+	lsn_t	max_lsn;
+	lsn_t	checkpoint_no;
 
 	ulint	fold;
 
@@ -3589,7 +3620,8 @@
 		log_buf = static_cast<byte *>
 			(ut_align(log_buf_, UNIV_PAGE_SIZE_MAX));
 
-		success = os_file_read(src_file, log_buf, 0, 0, LOG_FILE_HDR_SIZE);
+		success = xb_os_file_read(src_file, log_buf, 0,
+					  LOG_FILE_HDR_SIZE);
 		if (!success) {
 			goto error;
 		}
@@ -3631,7 +3663,7 @@
 
 	xb_file_set_nocache(src_file, src_path, "OPEN");
 
-	file_size = os_file_get_size_as_iblonglong(src_file);
+	file_size = os_file_get_size(src_file);
 
 
 	/* TODO: We should skip the following modifies, if it is not the first time. */
@@ -3639,7 +3671,7 @@
 	log_buf = static_cast<byte *>(ut_align(log_buf_, UNIV_PAGE_SIZE));
 
 	/* read log file header */
-	success = os_file_read(src_file, log_buf, 0, 0, LOG_FILE_HDR_SIZE);
+	success = xb_os_file_read(src_file, log_buf, 0, LOG_FILE_HDR_SIZE);
 	if (!success) {
 		goto error;
 	}
@@ -3658,7 +3690,8 @@
 	/* read last checkpoint lsn */
 	for (field = LOG_CHECKPOINT_1; field <= LOG_CHECKPOINT_2;
 			field += LOG_CHECKPOINT_2 - LOG_CHECKPOINT_1) {
-		if (!recv_check_cp_is_consistent(log_buf + field))
+		if (!xb_recv_check_cp_is_consistent(const_cast<const byte *>
+						    (log_buf + field)))
 			goto not_consistent;
 
 		checkpoint_no = MACH_READ_64(log_buf + field + LOG_CHECKPOINT_NO);
@@ -3692,7 +3725,8 @@
 
 	/* It seems to be needed to overwrite the both checkpoint area. */
 	MACH_WRITE_64(log_buf + LOG_CHECKPOINT_1 + LOG_CHECKPOINT_LSN, max_lsn);
-	mach_write_to_4(log_buf + LOG_CHECKPOINT_1 + LOG_CHECKPOINT_OFFSET,
+	mach_write_to_4(log_buf + LOG_CHECKPOINT_1
+			+ LOG_CHECKPOINT_OFFSET_LOW32,
 			LOG_FILE_HDR_SIZE + (ulint) ut_dulint_minus(max_lsn,
 			ut_dulint_align_down(max_lsn,OS_FILE_LOG_BLOCK_SIZE)));
 #ifdef XTRADB_BASED
@@ -3708,9 +3742,10 @@
 	mach_write_to_4(log_buf + LOG_CHECKPOINT_1 + LOG_CHECKPOINT_CHECKSUM_2, fold);
 
 	MACH_WRITE_64(log_buf + LOG_CHECKPOINT_2 + LOG_CHECKPOINT_LSN, max_lsn);
-        mach_write_to_4(log_buf + LOG_CHECKPOINT_2 + LOG_CHECKPOINT_OFFSET,
-                        LOG_FILE_HDR_SIZE + (ulint) ut_dulint_minus(max_lsn,
-                        ut_dulint_align_down(max_lsn,OS_FILE_LOG_BLOCK_SIZE)));
+	mach_write_to_4(log_buf + LOG_CHECKPOINT_2
+			+ LOG_CHECKPOINT_OFFSET_LOW32,
+			LOG_FILE_HDR_SIZE + (ulint) ut_dulint_minus(max_lsn,
+			ut_dulint_align_down(max_lsn,OS_FILE_LOG_BLOCK_SIZE)));
 #ifdef XTRADB_BASED
 	MACH_WRITE_64(log_buf + LOG_CHECKPOINT_2 + LOG_CHECKPOINT_ARCHIVED_LSN,
 			(ib_uint64_t)(LOG_FILE_HDR_SIZE + ut_dulint_minus(max_lsn,
@@ -3724,7 +3759,8 @@
         mach_write_to_4(log_buf + LOG_CHECKPOINT_2 + LOG_CHECKPOINT_CHECKSUM_2, fold);
 
 
-	success = os_file_write(src_path, src_file, log_buf, 0, 0, LOG_FILE_HDR_SIZE);
+	success = xb_os_file_write(src_path, src_file, log_buf, 0,
+				   LOG_FILE_HDR_SIZE);
 	if (!success) {
 		goto error;
 	}
@@ -3733,15 +3769,16 @@
 
 	if (file_size % UNIV_PAGE_SIZE) {
 		memset(log_buf, 0, UNIV_PAGE_SIZE);
-		success = os_file_write(src_path, src_file, log_buf,
-				(ulint)(file_size & 0xFFFFFFFFUL),
-				(ulint)(file_size >> 32),
-				UNIV_PAGE_SIZE - (ulint) (file_size % UNIV_PAGE_SIZE));
+		success = xb_os_file_write(src_path, src_file, log_buf,
+					    file_size,
+					    UNIV_PAGE_SIZE
+					    - (ulint) (file_size
+						       % UNIV_PAGE_SIZE));
 		if (!success) {
 			goto error;
 		}
 
-		file_size = os_file_get_size_as_iblonglong(src_file);
+		file_size = os_file_get_size(src_file);
 	}
 
 	/* TODO: We should judge whether the file is already expanded or not... */
@@ -3752,10 +3789,9 @@
 		expand = (ulint) (file_size / UNIV_PAGE_SIZE / 8);
 
 		for (; expand > 128; expand -= 128) {
-			success = os_file_write(src_path, src_file, log_buf,
-					(ulint)(file_size & 0xFFFFFFFFUL),
-					(ulint)(file_size >> 32),
-					UNIV_PAGE_SIZE * 128);
+			success = xb_os_file_write(src_path, src_file, log_buf,
+						   file_size,
+						   UNIV_PAGE_SIZE * 128);
 			if (!success) {
 				goto error;
 			}
@@ -3763,10 +3799,9 @@
 		}
 
 		if (expand) {
-			success = os_file_write(src_path, src_file, log_buf,
-					(ulint)(file_size & 0xFFFFFFFFUL),
-					(ulint)(file_size >> 32),
-					expand * UNIV_PAGE_SIZE);
+			success = xb_os_file_write(src_path, src_file, log_buf,
+						   file_size,
+						   expand * UNIV_PAGE_SIZE);
 			if (!success) {
 				goto error;
 			}
@@ -3778,26 +3813,24 @@
 	if (file_size < 2*1024*1024L) {
 		memset(log_buf, 0, UNIV_PAGE_SIZE);
 		while (file_size < 2*1024*1024L) {
-			success = os_file_write(src_path, src_file, log_buf,
-				(ulint)(file_size & 0xFFFFFFFFUL),
-				(ulint)(file_size >> 32),
-				UNIV_PAGE_SIZE);
+			success = xb_os_file_write(src_path, src_file, log_buf,
+						   file_size, UNIV_PAGE_SIZE);
 			if (!success) {
 				goto error;
 			}
 			file_size += UNIV_PAGE_SIZE;
 		}
-		file_size = os_file_get_size_as_iblonglong(src_file);
+		file_size = os_file_get_size(src_file);
 	}
 
-	msg("xtrabackup: xtrabackup_logfile detected: size=%lld, "
-	    "start_lsn=(%llu)\n", file_size, max_lsn);
+	msg("xtrabackup: xtrabackup_logfile detected: size=" INT64PF ", "
+	    "start_lsn=(" LSN_PF ")\n", file_size, max_lsn);
 
 	os_file_close(src_file);
 	src_file = XB_FILE_UNDEFINED;
 
 	/* fake InnoDB */
-	innobase_log_group_home_dir = NULL;
+	INNODB_LOG_DIR = NULL;
 	innobase_log_file_size      = file_size;
 	innobase_log_files_in_group = 1;
 
@@ -3888,19 +3921,21 @@
 			xtrabackup_target_dir, dbname);
 		srv_normalize_path_for_win(dest_dir);
 
-		snprintf(dest_space_name, FN_REFLEN, "./%s/%s",
-			dbname, name);
+		snprintf(dest_space_name, FN_REFLEN, "%s%s/%s",
+			 xb_dict_prefix, dbname, name);
 	} else {
 		snprintf(dest_dir, FN_REFLEN, "%s", xtrabackup_target_dir);
 		srv_normalize_path_for_win(dest_dir);
 
-		snprintf(dest_space_name, FN_REFLEN, "./%s", name);
+		snprintf(dest_space_name, FN_REFLEN, "%s%s", xb_dict_prefix,
+			 name);
 	}
 
 	snprintf(real_name, real_name_len,
 		 "%s/%s",
 		 xtrabackup_target_dir, dest_space_name);
 	srv_normalize_path_for_win(real_name);
+	dest_space_name[strlen(dest_space_name) - XB_DICT_SUFFIX_LEN] = '\0';
 
 	/* Create the database directory if it doesn't exist yet */
 	if (!os_file_create_directory(dest_dir, FALSE)) {
@@ -3924,14 +3959,14 @@
 
 			char	tmpname[FN_REFLEN];
 
-			snprintf(tmpname, FN_REFLEN, "./%s/xtrabackup_tmp_#%lu",
-				dbname, fil_space->id);
+			snprintf(tmpname, FN_REFLEN, "%s%s/xtrabackup_tmp_#%lu",
+				 xb_dict_prefix, dbname, fil_space->id);
 
 			msg("xtrabackup: Renaming %s to %s.ibd\n",
 				fil_space->name, tmpname);
 
-			if (!fil_rename_tablespace(NULL,
-					fil_space->id, tmpname))
+			if (!xb_fil_rename_tablespace(NULL, fil_space->id,
+						      tmpname, NULL))
 			{
 				msg("xtrabackup: Cannot rename %s to %s\n",
 					fil_space->name, tmpname);
@@ -3953,13 +3988,17 @@
 		char	tmpname[FN_REFLEN];
 
 		strncpy(tmpname, dest_space_name, FN_REFLEN);
+#if MYSQL_VERSION_ID < 50600
+		/* Need to truncate .ibd before renaming.  For MySQL 5.6 it's
+		already truncated.  */
 		tmpname[strlen(tmpname) - 4] = 0;
+#endif
 
 		msg("xtrabackup: Renaming %s to %s\n",
 		    fil_space->name, dest_space_name);
 
-		if (!fil_rename_tablespace(NULL,
-				      fil_space->id, tmpname))
+		if (!xb_fil_rename_tablespace(NULL, fil_space->id, tmpname,
+					      NULL))
 		{
 			msg("xtrabackup: Cannot rename %s to %s\n",
 				fil_space->name, dest_space_name);
@@ -3989,7 +4028,7 @@
 			   << DICT_TF_ZSSIZE_SHIFT)
 			| DICT_TF_COMPACT
 			| (DICT_TF_FORMAT_ZIP << DICT_TF_FORMAT_SHIFT);
-		ut_a(dict_table_flags_to_zip_size(tablespace_flags)
+		ut_a(dict_tf_get_zip_size(tablespace_flags)
 		     == zip_size);
 	}
 	*success = xb_space_create_file(real_name, space_id, tablespace_flags,
@@ -4126,12 +4165,11 @@
 
 		/* read to buffer */
 		/* first block of block cluster */
-		success = os_file_read(src_file, incremental_buffer,
-				       ((incremental_buffers * (page_size / 4))
-					<< page_size_shift) & 0xFFFFFFFFUL,
-				       (incremental_buffers * (page_size / 4))
-				       >> (32 - page_size_shift),
-				       page_size);
+		success = xb_os_file_read(src_file, incremental_buffer,
+					  ((incremental_buffers
+					    * (page_size / 4))
+					   << page_size_shift),
+					  page_size);
 		if (!success) {
 			goto error;
 		}
@@ -4159,12 +4197,11 @@
 		ut_a(last_buffer || page_in_buffer == page_size / 4);
 
 		/* read whole of the cluster */
-		success = os_file_read(src_file, incremental_buffer,
-				       ((incremental_buffers * (page_size / 4))
-					<< page_size_shift) & 0xFFFFFFFFUL,
-				       (incremental_buffers * (page_size / 4))
-				       >> (32 - page_size_shift),
-				       page_in_buffer * page_size);
+		success = xb_os_file_read(src_file, incremental_buffer,
+					  ((incremental_buffers
+					    * (page_size / 4))
+					   << page_size_shift),
+					  page_in_buffer * page_size);
 		if (!success) {
 			goto error;
 		}
@@ -4185,12 +4222,10 @@
 //						 + FIL_PAGE_LSN)) >= 0)
 //				continue;
 
-			success = os_file_write(dst_path, dst_file,
+			success = xb_os_file_write(dst_path, dst_file,
 					incremental_buffer +
 						page_in_buffer * page_size,
-					(offset_on_page << page_size_shift) &
-						0xFFFFFFFFUL,
-					offset_on_page >> (32 - page_size_shift),
+					(offset_on_page << page_size_shift),
 					page_size);
 			if (!success) {
 				goto error;
@@ -4227,13 +4262,13 @@
 ibool
 xtrabackup_apply_deltas(my_bool check_newer)
 {
-	int		ret;
+	ulint		ret;
 	char		dbpath[FN_REFLEN];
 	os_file_dir_t	dir;
 	os_file_dir_t	dbdir;
 	os_file_stat_t	dbinfo;
 	os_file_stat_t	fileinfo;
-	ulint		err 		= DB_SUCCESS;
+	dberr_t		err		= DB_SUCCESS;
 	static char	current_dir[2];
 
 	current_dir[0] = FN_CURLIB;
@@ -4395,14 +4430,15 @@
 						 UNIV_PAGE_SIZE_MAX));
 	log_buf = static_cast<byte *>(ut_align(log_buf_, UNIV_PAGE_SIZE_MAX));
 
-	success = os_file_read(src_file, log_buf, 0, 0, LOG_FILE_HDR_SIZE);
+	success = xb_os_file_read(src_file, log_buf, 0, LOG_FILE_HDR_SIZE);
 	if (!success) {
 		goto error;
 	}
 
 	memset(log_buf + LOG_FILE_WAS_CREATED_BY_HOT_BACKUP, ' ', 4);
 
-	success = os_file_write(src_path, src_file, log_buf, 0, 0, LOG_FILE_HDR_SIZE);
+	success = xb_os_file_write(src_path, src_file, log_buf, 0,
+				   LOG_FILE_HDR_SIZE);
 	if (!success) {
 		goto error;
 	}
@@ -4492,6 +4528,7 @@
 	sync_init();
 	os_io_init_simple();
 	mem_init(srv_mem_pool_size);
+	ut_crc32_init();
 
 	if(xtrabackup_init_temp_log())
 		goto error;
@@ -4593,7 +4630,7 @@
 		mtr_s_lock(fil_space_get_latch(space->id, &flags), &mtr);
 
 		block = buf_page_get(space->id,
-				     dict_table_flags_to_zip_size(flags),
+				     dict_tf_get_zip_size(flags),
 				     0, RW_S_LATCH, &mtr);
 		header = FSP_HEADER_OFFSET + buf_block_get_frame(block);
 
@@ -4682,7 +4719,7 @@
 			}
 
 			/* init exp file */
-			bzero(page, UNIV_PAGE_SIZE);
+			memset(page, 0, UNIV_PAGE_SIZE);
 			mach_write_to_4(page    , 0x78706f72UL);
 			mach_write_to_4(page + 4, 0x74696e66UL);/*"xportinf"*/
 			mach_write_to_4(page + 8, n_index);
@@ -4699,12 +4736,7 @@
 			while (index) {
 				mach_write_to_8(page + n_index * 512, index->id);
 				mach_write_to_4(page + n_index * 512 + 8,
-#if (MYSQL_VERSION_ID < 50100)
-						index->tree->page
-#else /* MYSQL_VERSION_ID < 51000 */
-				index->page
-#endif
-						);
+						index->page);
 				strncpy((char *) page + n_index * 512 +
 					12, index->name, 500);
 
@@ -4717,12 +4749,7 @@
 				    (ulint)(index->id &
 					    0xFFFFFFFFUL),
 #endif
-#if (MYSQL_VERSION_ID < 50100)
-				    index->tree->page
-#else /* MYSQL_VERSION_ID < 51000 */
-				    (ulint) index->page
-#endif
-				    );
+				    (ulint) index->page);
 				index = dict_table_get_next_index(index);
 				n_index++;
 
@@ -4736,9 +4763,9 @@
 					os_file_get_last_error(TRUE);
 					goto next_node;
 				}
-				success = os_file_write(info_file_path,
-							info_file, page,
-							0, 0, UNIV_PAGE_SIZE);
+				success = xb_os_file_write(info_file_path,
+							   info_file, page,
+							   0, UNIV_PAGE_SIZE);
 				if (!success) {
 					os_file_get_last_error(TRUE);
 					goto next_node;
@@ -4773,7 +4800,9 @@
 
 		fp = fopen("xtrabackup_binlog_pos_innodb", "w");
 		if (fp) {
-			fprintf(fp, "%s\t%llu\n",
+			/* Use UINT64PF instead of LSN_PF here, as we have to
+			maintain the file format. */
+			fprintf(fp, "%s\t" UINT64PF "\n",
 				trx_sys_mysql_bin_log_name,
 				trx_sys_mysql_bin_log_pos);
 			fclose(fp);
@@ -4796,10 +4825,10 @@
 "xtrabackup: ########################################################\n"
 		    );
 		if (xtrabackup_incremental) {
-			msg("xtrabackup: The intended lsn is %llu\n",
+			msg("xtrabackup: The intended lsn is " LSN_PF "\n",
 			    incremental_last_lsn);
 		} else {
-			msg("xtrabackup: The intended lsn is %llu\n",
+			msg("xtrabackup: The intended lsn is " LSN_PF "\n",
 			    metadata_last_lsn);
 		}
 	}
@@ -4872,6 +4901,11 @@
 	MY_INIT(argv[0]);
 	xb_regex_init();
 
+#if MYSQL_VERSION_ID >= 50600
+	system_charset_info= &my_charset_utf8_general_ci;
+	key_map_full.set_all();
+#endif
+
 	/* scan options for group to load defaults from */
 	{
 		int	i;
@@ -4879,11 +4913,11 @@
 		for (i=1; i < argc; i++) {
 			optend = strcend(argv[i], '=');
 			if (strncmp(argv[i], "--defaults-group", optend - argv[i]) == 0) {
-				load_default_groups[2] = defaults_group = optend + 1;
+				xb_load_default_groups[2] = defaults_group = optend + 1;
 			}
 		}
 	}
-	load_defaults("my",load_default_groups,&argc,&argv);
+	load_defaults("my", xb_load_default_groups, &argc, &argv);
 
 	/* ignore unsupported options */
 	{
@@ -4894,7 +4928,7 @@
 	j=1;
 	for (i=1 ; i < argc ; i++) {
 		uint count;
-		struct my_option *opt= (struct my_option *) my_long_options;
+		struct my_option *opt= (struct my_option *) xb_long_options;
 		optend= strcend((argv)[i], '=');
 		if (!strncmp(argv[i], "--defaults-file", optend - argv[i]))
 		{
@@ -4933,7 +4967,7 @@
 	argv[argc] = NULL;
 	}
 
-	if ((ho_error=handle_options(&argc, &argv, my_long_options, get_one_option)))
+	if ((ho_error=handle_options(&argc, &argv, xb_long_options, get_one_option)))
 		exit(ho_error);
 
 	if ((!xtrabackup_print_param) && (!xtrabackup_prepare) && (strcmp(mysql_data_home, "./") == 0)) {
@@ -5004,7 +5038,8 @@
 	/* --print-param */
 	if (xtrabackup_print_param) {
 		/* === some variables from mysqld === */
-		bzero((G_PTR) &mysql_tmpdir_list, sizeof(mysql_tmpdir_list));
+		memset((G_PTR) &mysql_tmpdir_list, 0,
+		       sizeof(mysql_tmpdir_list));
 
 		if (init_tmpdir(&mysql_tmpdir_list, opt_mysql_tmpdir))
 			exit(EXIT_FAILURE);
@@ -5018,7 +5053,7 @@
 		printf("innodb_data_file_path = \"%s\"\n",
 			innobase_data_file_path ? innobase_data_file_path : "ibdata1:10M:autoextend");
 		printf("innodb_log_group_home_dir = \"%s\"\n",
-			innobase_log_group_home_dir ? innobase_log_group_home_dir : mysql_data_home);
+			INNODB_LOG_DIR ? INNODB_LOG_DIR : mysql_data_home);
 		printf("innodb_log_files_in_group = %ld\n", innobase_log_files_in_group);
 		printf("innodb_log_file_size = %lld\n", innobase_log_file_size);
 		printf("innodb_flush_method = \"%s\"\n",
@@ -5039,7 +5074,7 @@
 
 	print_version();
 	if (xtrabackup_incremental) {
-		msg("incremental backup from %llu is enabled.\n",
+		msg("incremental backup from " LSN_PF " is enabled.\n",
 		    incremental_lsn);
 	}
 

=== modified file 'src/xtrabackup.h'
--- src/xtrabackup.h	2013-02-20 10:20:00 +0000
+++ src/xtrabackup.h	2013-03-22 15:32:33 +0000
@@ -32,15 +32,15 @@
 
 /* ======== Datafiles iterator ======== */
 typedef struct {
-	fil_system_t *system;
-	fil_space_t  *space;
-	fil_node_t   *node;
-	ibool        started;
-	os_mutex_t   mutex;
+	fil_system_t	*system;
+	fil_space_t	*space;
+	fil_node_t	*node;
+	ibool		started;
+	os_ib_mutex_t	mutex;
 } datafiles_iter_t;
 
 /* value of the --incremental option */
-extern LSN64 incremental_lsn;
+extern lsn_t incremental_lsn;
 
 extern char		*xtrabackup_target_dir;
 extern ds_ctxt_t	*ds_meta;

=== modified file 'test/bootstrap.sh'
--- test/bootstrap.sh	2013-03-18 09:30:00 +0000
+++ test/bootstrap.sh	2013-03-22 15:32:33 +0000
@@ -13,7 +13,7 @@
 tests.
 
 If the argument is one of the build targets passed to build.sh 
-(i.e. innodb51 innodb55 xtradb51 xtradb55) then the 
+(i.e. innodb51 innodb55 innodb56 xtradb51 xtradb55) then the 
 appropriate Linux tarball is downloaded from a pre-defined location and
 unpacked into the specified installation  directory ('./server' by default).
 
@@ -50,6 +50,11 @@
 	tarball="mysql-5.5.16-linux2.6-$arch.tar.gz"
 	;;
 
+    innodb56)
+        url="http://s3.amazonaws.com/percona.com/downloads/community"
+        tarball="mysql-5.6.10-linux-glibc2.5-$arch.tar.gz"
+        ;;
+
     xtradb51)
 	url="http://www.percona.com/redir/downloads/Percona-Server-5.1/Percona-Server-5.1.67-14.4/binary/linux/$arch"
 	tarball="Percona-Server-5.1.67-rel14.4-511.Linux.$arch.tar.gz"

=== modified file 'test/inc/common.sh'
--- test/inc/common.sh	2013-03-07 11:45:53 +0000
+++ test/inc/common.sh	2013-03-22 15:32:33 +0000
@@ -44,7 +44,7 @@
 	vlog "Creating server data directory: $MYSQLD_DATADIR"
 	mkdir -p "$MYSQLD_DATADIR"
 	vlog "Calling mysql_install_db"
-	$MYSQL_INSTALL_DB --no-defaults --basedir=$MYSQL_BASEDIR --datadir="$MYSQLD_DATADIR" --tmpdir="$MYSQLD_TMPDIR"
+	$MYSQL_INSTALL_DB --no-defaults --basedir=$MYSQL_BASEDIR --datadir="$MYSQLD_DATADIR" --tmpdir="$MYSQLD_TMPDIR" ${MYSQLD_EXTRA_ARGS}
     fi
 }
 
@@ -417,7 +417,7 @@
 ########################################################################
 function checksum_table()
 {
-    $MYSQL $MYSQL_ARGS -Ns -e "CHECKSUM TABLE $2" $1 | awk {'print $2'}
+    $MYSQL $MYSQL_ARGS -Ns -e "CHECKSUM TABLE $2 EXTENDED" $1 | awk {'print $2'}
 }
 
 ##########################################################################

=== modified file 'test/t/bug1062684.sh'
--- test/t/bug1062684.sh	2012-11-16 10:40:34 +0000
+++ test/t/bug1062684.sh	2013-03-22 15:32:33 +0000
@@ -1,9 +1,10 @@
+MYSQLD_EXTRA_ARGS=--innodb-data-file-path="ibdata1:${DEFAULT_IBDATA_SIZE};ibdata2:5M:autoextend"
 . inc/common.sh
 
-start_server --innodb-data-file-path="ibdata1:10M;ibdata2:5M:autoextend"
+start_server --innodb-data-file-path="ibdata1:${DEFAULT_IBDATA_SIZE};ibdata2:5M:autoextend"
 load_dbase_schema incremental_sample
 
-echo "innodb-data-file-path=ibdata1:10M;ibdata2:5M:autoextend" >>$topdir/my.cnf
+echo "innodb-data-file-path=ibdata1:${DEFAULT_IBDATA_SIZE};ibdata2:5M:autoextend" >>$topdir/my.cnf
 
 # Adding initial rows
 vlog "Adding initial rows to database..."
@@ -76,7 +77,7 @@
 innobackupex --copy-back $full_backup_dir
 vlog "Data restored"
 
-start_server --innodb-data-file-path="ibdata1:10M;ibdata2:5M:autoextend"
+start_server --innodb-data-file-path="ibdata1:${DEFAULT_IBDATA_SIZE};ibdata2:5M:autoextend"
 
 vlog "Checking checksums"
 checksum_test_b=`checksum_table incremental_sample test`

=== modified file 'test/t/bug891496.sh'
--- test/t/bug891496.sh	2012-10-15 16:14:59 +0000
+++ test/t/bug891496.sh	2013-03-22 15:32:33 +0000
@@ -1,6 +1,7 @@
 ##########################################################################
 # Bug #891496: tar4ibd fails on datafiles generated on 5.0               #
 ##########################################################################
+MYSQLD_EXTRA_ARGS=--innodb-data-file-path="ibdata1:3M;ibdata2:10M:autoextend"
 
 . inc/common.sh
 

=== modified file 'test/testrun.sh'
--- test/testrun.sh	2013-03-11 09:29:11 +0000
+++ test/testrun.sh	2013-03-22 15:32:33 +0000
@@ -129,6 +129,8 @@
 		;;
 	    "innodb55" )
 		XB_BIN="xtrabackup_innodb55";;
+            "innodb56" )
+                XB_BIN="xtrabackup_innodb56" ;;
 	    "xtradb51" | "mariadb51" | "mariadb52" | "mariadb53")
 		XB_BIN="xtrabackup";;
 	    "xtradb55" | "mariadb55")
@@ -157,6 +159,9 @@
     INNODB_VERSION=${INNODB_VERSION#"innodb_version	"}
     XTRADB_VERSION="`echo $INNODB_VERSION  | sed 's/[0-9]\.[0-9]\.[0-9][0-9]*\(-[0-9][0-9]*\.[0-9][0-9]*\)*$/\1/'`"
 
+    # Version-specific defaults
+    DEFAULT_IBDATA_SIZE="10M"
+
     # Determine MySQL flavor
     if [[ "$MYSQL_VERSION" =~ "MariaDB" ]]
     then
@@ -198,8 +203,12 @@
 	    else
 		XB_BIN="xtrabackup_innodb55"
 	    fi
+        elif [ "${MYSQL_VERSION:0:3}" = "5.6" ]
+        then
+            XB_BIN="xtrabackup_innodb56"
+            DEFAULT_IBDATA_SIZE="12M"
 	else
-	    vlog "Uknown MySQL/InnoDB version: $MYSQL_VERSION/$INNODB_VERSION"
+	    vlog "Unknown MySQL/InnoDB version: $MYSQL_VERSION/$INNODB_VERSION"
 	    exit -1
 	fi
     fi
@@ -224,7 +233,8 @@
 
     export MYSQL_VERSION MYSQL_VERSION_COMMENT MYSQL_FLAVOR \
 	INNODB_VERSION XTRADB_VERSION INNODB_FLAVOR \
-	XB_BIN IB_BIN IB_ARGS XB_ARGS MYSQLD_EXTRA_ARGS
+	XB_BIN IB_BIN IB_ARGS XB_ARGS MYSQLD_EXTRA_ARGS \
+        DEFAULT_IBDATA_SIZE
 }
 
 export SKIPPED_EXIT_CODE=200

=== modified file 'utils/build.sh'
--- utils/build.sh	2013-03-11 19:11:29 +0000
+++ utils/build.sh	2013-03-22 15:32:33 +0000
@@ -4,6 +4,7 @@
 
 MYSQL_51_VERSION=5.1.59
 MYSQL_55_VERSION=5.5.17
+MYSQL_56_VERSION=5.6.10
 PS_51_VERSION=5.1.59-13.0
 PS_55_VERSION=5.5.16-22.0
 
@@ -20,6 +21,9 @@
 "5.5" )
         type="innodb55"
         ;;
+"5.6" )
+        type="innodb56"
+        ;;
 "xtradb" )
         type="xtradb51"
         ;;
@@ -40,12 +44,12 @@
     CFLAGS="$CFLAGS -g -O0 $innodb_extra_debug -DSAFE_MUTEX -DSAFEMALLOC"
     CXXFLAGS="$CXXFLAGS -g -O0 $innodb_extra_debug -DSAFE_MUTEX -DSAFEMALLOC"
     extra_config_51="--with-debug=full"
-    extra_config_55="-DWITH_DEBUG=ON"
+    extra_config_55plus="-DWITH_DEBUG=ON -DMYSQL_MAINTAINER_MODE=OFF"
 else
     CFLAGS="$CFLAGS -g -O3"
     CXXFLAGS="$CXXFLAGS -g -O3"
     extra_config_51=
-    extra_config_55=
+    extra_config_55plus=
 fi
 
 xtrabackup_include_dir="$top_dir/src"
@@ -69,6 +73,7 @@
     echo "where CODEBASE can be one of the following values or aliases:"
     echo "  innodb51         | plugin                build agsinst InnoDB plugin in MySQL 5.1"
     echo "  innodb55         | 5.5                   build against InnoDB in MySQL 5.5"
+    echo "  innodb56         | 5.6                   build against InnoDB in MySQL 5.6"
     echo "  xtradb51         | xtradb,mariadb51      build against Percona Server with XtraDB 5.1"
     echo "                   | mariadb52,mariadb53"
     echo "  xtradb55         | xtradb55,galera55,    build against Percona Server with XtraDB 5.5"
@@ -123,14 +128,20 @@
 
 function build_server()
 {
+    local $type=$1
     echo "Configuring the server"
     cd $server_dir
     BUILD/autorun.sh
     eval $configure_cmd
 
     echo "Building the server"
-    make_dirs include zlib strings mysys dbug extra
-    make_dirs $innodb_dir
+    if [ "$type" = "innodb56" ]
+    then
+        make_dirs libmysqld
+    else
+        make_dirs include zlib strings mysys dbug extra
+        make_dirs $innodb_dir
+    fi
     cd $top_dir
 }
 
@@ -181,6 +192,7 @@
 ################################################################################
 function build_all()
 {
+    local type=$1
     local mysql_version_short=${mysql_version:0:3}
     server_dir=$top_dir/mysql-$mysql_version_short
     server_tarball=mysql-$mysql_version.tar.gz
@@ -195,7 +207,7 @@
     unpack_and_patch $server_tarball $server_patch
     mv $top_dir/mysql-$mysql_version $server_dir
 
-    build_server
+    build_server $type
 
     build_xtrabackup
 }
@@ -219,7 +231,7 @@
            --enable-shared \
            --with-extra-charsets=all $extra_config_51"
 
-       build_all
+       build_all $type
        ;;
 "innodb55")
 	mysql_version=$MYSQL_55_VERSION
@@ -233,11 +245,24 @@
 		-DWITH_PARTITION_STORAGE_ENGINE=ON \
 		-DWITH_ZLIB=bundled \
 		-DWITH_EXTRA_CHARSETS=all \
-		-DENABLE_DTRACE=OFF $extra_config_55"
+		-DENABLE_DTRACE=OFF $extra_config_55plus"
 
-	build_all
+	build_all $type
 	;;
 
+"innodb56")
+        mysql_version=$MYSQL_56_VERSION
+        server_patch=innodb56.patch
+        innodb_name=innobase
+        xtrabackup_target=5.6
+        configure_cmd="cmake . \
+                -DWITH_INNOBASE_STORAGE_ENGINE=ON \
+                -DWITH_ZLIB=bundled \
+                -DWITH_EXTRA_CHARSETS=all \
+                -DWITH_EMBEDDED_SERVER=1 $extra_config_55plus"
+        build_all $type
+        ;;
+
 "xtradb51" | "mariadb51" | "mariadb52" | "mariadb53")
 	server_dir=$top_dir/Percona-Server
 	branch_dir=percona-server-5.1-xtrabackup
@@ -284,7 +309,7 @@
 	cd $server_dir
 	patch -p1 < $top_dir/patches/xtradb51.patch
 
-	build_server
+	build_server $type
 
 	build_xtrabackup
 
@@ -301,7 +326,7 @@
 		-DWITH_PARTITION_STORAGE_ENGINE=ON \
 		-DWITH_ZLIB=bundled \
 		-DWITH_EXTRA_CHARSETS=all \
-		-DENABLE_DTRACE=OFF $extra_config_55"
+		-DENABLE_DTRACE=OFF $extra_config_55plus"
 	if [ "`uname -s`" = "Linux" ]
 	then
 		configure_cmd="LIBS=-lrt $configure_cmd"
@@ -338,7 +363,7 @@
 	cd $server_dir
 	patch -p1 < $top_dir/patches/xtradb55.patch
 
-	build_server
+	build_server $type
 
 	build_xtrabackup