Merge lp:~stewart/percona-server/5.6-doublewrite into lp:percona-server/5.6

[Stewart Smith]

Port innodb_doublewrite_file over to PS 5.6

[Laurynas Biveinis (laurynas-biveinis)]

I have logged bugs for the review points that apply to 5.1 and 5.5 too.

I think that for 5.6 everything except for bug 1078181 must be fixed at the MP.

- The main issue with this feature in general is bug 1078181.
- The testcase must do some actual work with data pages. For
  example, the workload must be larger than the log capacity. (bug
  1078187).
- The sys_vars testcase should be a bit more involved. (bug 1078188).
- trx_sys_doublewrite_space() should be used everywhere it
  applies. (bug 1078191).
- buf_dblwr_get space_id arg should have comment.
- buf_dblwr_create_low header should follow InnoDB coding style.
- s/SRV_LOG_SPACE_FIRST_ID/SRV_EXTRA_SYS_SPACE_FIRST_ID in several
  places (bug 1078201).
- Chunk at 410--411 looks wrong: fil_is_user_tablespace_id looks like
  a correct check already.
- Bogus UNIV_LIKELY/UNIV_UNLIKELY (bug 1078206).
- trx_sys_dummy_create() is missing comments and misformatted in
  trx0sys.h.
- For initalizations like at 255--261 and 296--302 personally I prefer
  the ternary operator.
- trx_sys_sys_space has wrong header comment. "Check if a space is a
  system tablespace", likewise for trx_sys_doublewrite_space.
- Style violation at line 766.
- Too long lines at 769+, 780, 822, 825+, 857, 874
- Spurious diff at lines 428, 436, 495, 507, 576.

review: Needs Fixing

Unmerged revisions

310. By Stewart Smith on 2012-10-25

Port innodb_doublewrite_file to Percona Server 5.6

This was a little bit involved as the doublewrite buffer code has been
refactored in MySQL 5.6 out into buf0dblwr.cc.

One design difference in the 5.6 patch versus 5.5 and before is that where
InnoDB code has needed to be duplicated, I have instead refactored that code
to accept tablespace id as a parameter rather than copy&pasting it. With
this method, we should get merge conflicts if this code is changed upstream,
making it easier to ensure our end result code is correct.

309. By Stewart Smith on 2012-10-24

merge 5.6.7

=== added file 'Percona-Server/mysql-test/suite/innodb/r/percona_innodb_doublewrite_file.result'
--- Percona-Server/mysql-test/suite/innodb/r/percona_innodb_doublewrite_file.result	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/innodb/r/percona_innodb_doublewrite_file.result	2012-11-13 06:02:21 +0000
@@ -0,0 +1,13 @@
+show variables like 'innodb_doublewrite_file%';
+Variable_name	Value
+innodb_doublewrite_file	ib_doublewrite
+create table t1 (a int primary key auto_increment, b varchar(100)) engine=innodb;
+insert into t1 (b) values ("hello");
+insert into t1 (b) values ("cruel");
+insert into t1 (b) values ("world");
+select * from t1 order by a;
+a	b
+1	hello
+2	cruel
+3	world
+drop table t1;
 
=== added file 'Percona-Server/mysql-test/suite/innodb/t/percona_innodb_doublewrite_file-master.opt'
--- Percona-Server/mysql-test/suite/innodb/t/percona_innodb_doublewrite_file-master.opt	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/innodb/t/percona_innodb_doublewrite_file-master.opt	2012-11-13 06:02:21 +0000
@@ -0,0 +1,1 @@
+--innodb_doublewrite_file=ib_doublewrite
 
=== added file 'Percona-Server/mysql-test/suite/innodb/t/percona_innodb_doublewrite_file.test'
--- Percona-Server/mysql-test/suite/innodb/t/percona_innodb_doublewrite_file.test	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/innodb/t/percona_innodb_doublewrite_file.test	2012-11-13 06:02:21 +0000
@@ -0,0 +1,12 @@
+--source include/have_innodb.inc
+show variables like 'innodb_doublewrite_file%';
+
+create table t1 (a int primary key auto_increment, b varchar(100)) engine=innodb;
+
+insert into t1 (b) values ("hello");
+insert into t1 (b) values ("cruel");
+insert into t1 (b) values ("world");
+
+select * from t1 order by a;
+
+drop table t1;
 
=== added file 'Percona-Server/mysql-test/suite/sys_vars/r/innodb_doublewrite_file_basic.result'
--- Percona-Server/mysql-test/suite/sys_vars/r/innodb_doublewrite_file_basic.result	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/sys_vars/r/innodb_doublewrite_file_basic.result	2012-11-13 06:02:21 +0000
@@ -0,0 +1,3 @@
+show variables like 'innodb_doublewrite_file%';
+Variable_name	Value
+innodb_doublewrite_file	ib_doublewrite
 
=== added file 'Percona-Server/mysql-test/suite/sys_vars/t/innodb_doublewrite_file_basic-master.opt'
--- Percona-Server/mysql-test/suite/sys_vars/t/innodb_doublewrite_file_basic-master.opt	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/sys_vars/t/innodb_doublewrite_file_basic-master.opt	2012-11-13 06:02:21 +0000
@@ -0,0 +1,1 @@
+--innodb_doublewrite_file=ib_doublewrite
 
=== added file 'Percona-Server/mysql-test/suite/sys_vars/t/innodb_doublewrite_file_basic.test'
--- Percona-Server/mysql-test/suite/sys_vars/t/innodb_doublewrite_file_basic.test	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/sys_vars/t/innodb_doublewrite_file_basic.test	2012-11-13 06:02:21 +0000
@@ -0,0 +1,2 @@
+--source include/have_innodb.inc
+show variables like 'innodb_doublewrite_file%';
 
=== modified file 'Percona-Server/storage/innobase/buf/buf0buf.cc'
--- Percona-Server/storage/innobase/buf/buf0buf.cc	2012-10-16 06:21:51 +0000
+++ Percona-Server/storage/innobase/buf/buf0buf.cc	2012-11-13 06:02:21 +0000
@@ -3951,7 +3951,8 @@
 		read_space_id = mach_read_from_4(
 			frame + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID);
 
-		if (bpage->space == TRX_SYS_SPACE
+		if ((bpage->space == TRX_SYS_SPACE
+		     || (srv_doublewrite_file && bpage->space == TRX_DOUBLEWRITE_SPACE))
 		    && buf_dblwr_page_inside(bpage->offset)) {
 
 			ut_print_timestamp(stderr);
 
=== modified file 'Percona-Server/storage/innobase/buf/buf0dblwr.cc'
--- Percona-Server/storage/innobase/buf/buf0dblwr.cc	2012-08-22 01:40:20 +0000
+++ Percona-Server/storage/innobase/buf/buf0dblwr.cc	2012-11-13 06:02:21 +0000
@@ -93,11 +93,12 @@
 byte*
 buf_dblwr_get(
 /*==========*/
+	ulint space_id,
 	mtr_t*	mtr)	/*!< in/out: MTR to hold the page latch */
 {
 	buf_block_t*	block;
 
-	block = buf_page_get(TRX_SYS_SPACE, 0, TRX_SYS_PAGE_NO,
+	block = buf_page_get(space_id, 0, TRX_SYS_PAGE_NO,
 			     RW_X_LATCH, mtr);
 	buf_block_dbg_add_level(block, SYNC_NO_ORDER_CHECK);
 
@@ -157,9 +158,9 @@
 /****************************************************************//**
 Creates the doublewrite buffer to a new InnoDB installation. The header of the
 doublewrite buffer is placed on the trx system header page. */
-UNIV_INTERN
+static
 void
-buf_dblwr_create(void)
+buf_dblwr_create_low(ulint space_id)
 /*==================*/
 {
 	buf_block_t*	block2;
@@ -171,24 +172,20 @@
 	ulint	i;
 	mtr_t	mtr;
 
-	if (buf_dblwr) {
-		/* Already inited */
-
-		return;
-	}
-
 start_again:
 	mtr_start(&mtr);
 	buf_dblwr_being_created = TRUE;
 
-	doublewrite = buf_dblwr_get(&mtr);
+	doublewrite = buf_dblwr_get(space_id, &mtr);
 
 	if (mach_read_from_4(doublewrite + TRX_SYS_DOUBLEWRITE_MAGIC)
 	    == TRX_SYS_DOUBLEWRITE_MAGIC_N) {
 		/* The doublewrite buffer has already been created:
 		just read in some numbers */
 
-		buf_dblwr_init(doublewrite);
+		if (space_id == TRX_SYS_SPACE) {
+			buf_dblwr_init(doublewrite);
+		}
 
 		mtr_commit(&mtr);
 		buf_dblwr_being_created = FALSE;
@@ -197,8 +194,8 @@
 
 	ut_print_timestamp(stderr);
 	fprintf(stderr,
-		" InnoDB: Doublewrite buffer not found:"
-		" creating new\n");
+		" InnoDB: Doublewrite buffer not found in tablespace (id %lu):"
+		" creating new\n", space_id);
 
 	if (buf_pool_get_curr_size()
 	    < ((2 * TRX_SYS_DOUBLEWRITE_BLOCK_SIZE
@@ -213,7 +210,7 @@
 		exit(1);
 	}
 
-	block2 = fseg_create(TRX_SYS_SPACE, TRX_SYS_PAGE_NO,
+	block2 = fseg_create(space_id, TRX_SYS_PAGE_NO,
 			     TRX_SYS_DOUBLEWRITE
 			     + TRX_SYS_DOUBLEWRITE_FSEG, &mtr);
 
@@ -303,7 +300,7 @@
 			are active, restart the MTR occasionally. */
 			mtr_commit(&mtr);
 			mtr_start(&mtr);
-			doublewrite = buf_dblwr_get(&mtr);
+			doublewrite = buf_dblwr_get(space_id, &mtr);
 			fseg_header = doublewrite
 				      + TRX_SYS_DOUBLEWRITE_FSEG;
 		}
@@ -332,12 +329,32 @@
 	buf_pool_invalidate();
 
 	ut_print_timestamp(stderr);
-	fprintf(stderr, " InnoDB: Doublewrite buffer created\n");
+	fprintf(stderr, " InnoDB: Doublewrite buffer created in tablespace id %lu\n", space_id);
 
 	goto start_again;
 }
 
 /****************************************************************//**
+Creates the doublewrite buffer to a new InnoDB installation. The header of the
+doublewrite buffer is placed on the trx system header page. */
+UNIV_INTERN
+void
+buf_dblwr_create(void)
+{
+	if (buf_dblwr) {
+		/* Already inited */
+
+		return;
+	}
+
+	buf_dblwr_create_low(TRX_SYS_SPACE);
+
+	if (srv_doublewrite_file) {
+		buf_dblwr_create_low(TRX_DOUBLEWRITE_SPACE);
+	}
+}
+
+/****************************************************************//**
 At a database startup initializes the doublewrite buffer memory structure if
 we already have a doublewrite buffer created in the data files. If we are
 upgrading to an InnoDB version which supports multiple tablespaces, then this
@@ -358,10 +375,20 @@
 	byte*	page;
 	ibool	reset_space_ids = FALSE;
 	byte*	doublewrite;
+	ulint	doublewrite_space_id;
 	ulint	space_id;
 	ulint	page_no;
 	ulint	i;
 
+	if (srv_doublewrite_file) {
+		doublewrite_space_id = TRX_DOUBLEWRITE_SPACE;
+		fprintf(stderr,
+			"InnoDB: doublewrite file '%s' is used.\n",
+			srv_doublewrite_file);
+	} else {
+		doublewrite_space_id = TRX_SYS_SPACE;
+	}
+
 	/* We do the file i/o past the buffer pool */
 
 	unaligned_read_buf = static_cast<byte*>(ut_malloc(2 * UNIV_PAGE_SIZE));
@@ -372,7 +399,7 @@
 	/* Read the trx sys header to check if we are using the doublewrite
 	buffer */
 
-	fil_io(OS_FILE_READ, TRUE, TRX_SYS_SPACE, 0, TRX_SYS_PAGE_NO, 0,
+	fil_io(OS_FILE_READ, TRUE, doublewrite_space_id, 0, TRX_SYS_PAGE_NO, 0,
 	       UNIV_PAGE_SIZE, read_buf, NULL);
 	doublewrite = read_buf + TRX_SYS_DOUBLEWRITE;
 
@@ -408,10 +435,10 @@
 
 	/* Read the pages from the doublewrite buffer to memory */
 
-	fil_io(OS_FILE_READ, TRUE, TRX_SYS_SPACE, 0, block1, 0,
+	fil_io(OS_FILE_READ, TRUE, doublewrite_space_id, 0, block1, 0,
 	       TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * UNIV_PAGE_SIZE,
 	       buf, NULL);
-	fil_io(OS_FILE_READ, TRUE, TRX_SYS_SPACE, 0, block2, 0,
+	fil_io(OS_FILE_READ, TRUE, doublewrite_space_id, 0, block2, 0,
 	       TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * UNIV_PAGE_SIZE,
 	       buf + TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * UNIV_PAGE_SIZE,
 	       NULL);
@@ -467,7 +494,8 @@
 				" doublewrite buf.\n",
 				(ulong) space_id, (ulong) page_no, (ulong) i);
 
-		} else if (space_id == TRX_SYS_SPACE
+		} else if ((space_id == TRX_SYS_SPACE
+			    || (srv_doublewrite_file && space_id == TRX_DOUBLEWRITE_SPACE))
 			   && ((page_no >= block1
 				&& page_no
 				< block1 + TRX_SYS_DOUBLEWRITE_BLOCK_SIZE)
@@ -751,6 +779,13 @@
 	ulint		len;
 	ulint		len2;
 	ulint		i;
+	ulint		doublewrite_space_id;
+
+	if (srv_doublewrite_file) {
+		doublewrite_space_id = TRX_DOUBLEWRITE_SPACE;
+	} else {
+		doublewrite_space_id = TRX_SYS_SPACE;
+	}
 
 	if (!srv_use_doublewrite_buf || buf_dblwr == NULL) {
 		/* Sync the writes to the disk. */
@@ -823,7 +858,7 @@
 	len = ut_min(TRX_SYS_DOUBLEWRITE_BLOCK_SIZE,
 		     buf_dblwr->first_free) * UNIV_PAGE_SIZE;
 
-	fil_io(OS_FILE_WRITE, TRUE, TRX_SYS_SPACE, 0,
+	fil_io(OS_FILE_WRITE, TRUE, doublewrite_space_id, 0,
 	       buf_dblwr->block1, 0, len,
 	       (void*) write_buf, NULL);
 
@@ -839,7 +874,7 @@
 	write_buf = buf_dblwr->write_buf
 		    + TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * UNIV_PAGE_SIZE;
 
-	fil_io(OS_FILE_WRITE, TRUE, TRX_SYS_SPACE, 0,
+	fil_io(OS_FILE_WRITE, TRUE, doublewrite_space_id, 0,
 	       buf_dblwr->block2, 0, len,
 	       (void*) write_buf, NULL);
 
@@ -849,7 +884,7 @@
 	srv_stats.dblwr_writes.inc();
 
 	/* Now flush the doublewrite buffer data to disk */
-	fil_flush(TRX_SYS_SPACE);
+	fil_flush(doublewrite_space_id);
 
 	/* We know that the writes have been flushed to disk now
 	and in recovery we will find them in the doublewrite buffer
@@ -967,6 +1002,13 @@
 	ulint		zip_size;
 	ulint		offset;
 	ulint		i;
+	ulint		doublewrite_space_id;
+
+	if (srv_doublewrite_file) {
+		doublewrite_space_id = TRX_DOUBLEWRITE_SPACE;
+	} else {
+		doublewrite_space_id = TRX_SYS_SPACE;
+	}
 
 	ut_a(buf_page_in_file(bpage));
 	ut_a(srv_use_doublewrite_buf);
@@ -1046,21 +1088,21 @@
 		memset(buf_dblwr->write_buf + UNIV_PAGE_SIZE * i
 		       + zip_size, 0, UNIV_PAGE_SIZE - zip_size);
 
-		fil_io(OS_FILE_WRITE, TRUE, TRX_SYS_SPACE, 0,
+		fil_io(OS_FILE_WRITE, TRUE, doublewrite_space_id, 0,
 		       offset, 0, UNIV_PAGE_SIZE,
 		       (void*) (buf_dblwr->write_buf
 				+ UNIV_PAGE_SIZE * i), NULL);
 	} else {
 		/* It is a regular page. Write it directly to the
 		doublewrite buffer */
-		fil_io(OS_FILE_WRITE, TRUE, TRX_SYS_SPACE, 0,
+		fil_io(OS_FILE_WRITE, TRUE, doublewrite_space_id, 0,
 		       offset, 0, UNIV_PAGE_SIZE,
 		       (void*) ((buf_block_t*) bpage)->frame,
 		       NULL);
 	}
 
 	/* Now flush the doublewrite buffer data to disk */
-	fil_flush(TRX_SYS_SPACE);
+	fil_flush(doublewrite_space_id);
 
 	/* We know that the write has been flushed to disk now
 	and during recovery we will find it in the doublewrite buffer
 
=== modified file 'Percona-Server/storage/innobase/buf/buf0rea.cc'
--- Percona-Server/storage/innobase/buf/buf0rea.cc	2012-10-16 06:21:51 +0000
+++ Percona-Server/storage/innobase/buf/buf0rea.cc	2012-11-13 06:02:21 +0000
@@ -133,7 +133,9 @@
 	ignore_nonexistent_pages = mode & BUF_READ_IGNORE_NONEXISTENT_PAGES;
 	mode &= ~BUF_READ_IGNORE_NONEXISTENT_PAGES;
 
-	if (space == TRX_SYS_SPACE && buf_dblwr_page_inside(offset)) {
+	if ((space == TRX_SYS_SPACE
+	     || (srv_doublewrite_file && space == TRX_DOUBLEWRITE_SPACE))
+	    && buf_dblwr_page_inside(offset)) {
 		ut_print_timestamp(stderr);
 		fprintf(stderr,
 			"  InnoDB: Warning: trying to read"
 
=== modified file 'Percona-Server/storage/innobase/dict/dict0load.cc'
--- Percona-Server/storage/innobase/dict/dict0load.cc	2012-10-16 06:21:51 +0000
+++ Percona-Server/storage/innobase/dict/dict0load.cc	2012-11-13 06:02:21 +0000
@@ -45,6 +45,7 @@
 #include "dict0priv.h"
 #include "ha_prototypes.h" /* innobase_casedn_str() */
 #include "fts0priv.h"
+#include "trx0sys.h"
 
 /** Following are the InnoDB system tables. The positions in
 this array are referenced by enum dict_system_table_id. */
@@ -1066,7 +1067,7 @@
 			discarded = !!(flags2 & DICT_TF2_DISCARDED);
 		}
 
-		if (space_id == 0) {
+		if (trx_sys_sys_space(space_id)) {
 			/* The system tablespace always exists. */
 			ut_ad(!discarded);
 		} else if (in_crash_recovery) {
@@ -2248,7 +2249,7 @@
 	btr_pcur_close(&pcur);
 	mtr_commit(&mtr);
 
-	if (table->space == 0) {
+	if (trx_sys_sys_space(table->space)) {
 		/* The system tablespace is always available. */
 	} else if (table->flags2 & DICT_TF2_DISCARDED) {
 
 
=== modified file 'Percona-Server/storage/innobase/fil/fil0fil.cc'
--- Percona-Server/storage/innobase/fil/fil0fil.cc	2012-10-16 06:21:51 +0000
+++ Percona-Server/storage/innobase/fil/fil0fil.cc	2012-11-13 06:02:21 +0000
@@ -308,7 +308,7 @@
 static 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)
+# define fil_is_user_tablespace_id(i) ((i) > srv_undo_tablespaces_open && !trx_sys_sys_space(i))
 
 /** Determine if user has explicitly disabled fsync(). */
 #ifndef __WIN__
@@ -668,7 +668,7 @@
 
 	UT_LIST_ADD_LAST(chain, space->chain, node);
 
-	if (id < SRV_LOG_SPACE_FIRST_ID && fil_system->max_assigned_id < id) {
+	if (id < SRV_EXTRA_SYS_SPACE_FIRST_ID && fil_system->max_assigned_id < id) {
 
 		fil_system->max_assigned_id = id;
 	}
@@ -729,14 +729,14 @@
 		size_bytes = os_file_get_size(node->handle);
 		ut_a(size_bytes != (os_offset_t) -1);
 #ifdef UNIV_HOTBACKUP
-		if (space->id == 0) {
+		if (trx_sys_sys_space(space->id)) {
 			node->size = (ulint) (size_bytes / UNIV_PAGE_SIZE);
 			os_file_close(node->handle);
 			goto add_size;
 		}
 #endif /* UNIV_HOTBACKUP */
 		ut_a(space->purpose != FIL_LOG);
-		ut_a(fil_is_user_tablespace_id(space->id));
+		ut_a(!trx_sys_sys_space(space->id));
 
 		if (size_bytes < FIL_IBD_FILE_INITIAL_SIZE * UNIV_PAGE_SIZE) {
 			fprintf(stderr,
@@ -781,7 +781,7 @@
 		}
 
 		if (UNIV_UNLIKELY(space_id == ULINT_UNDEFINED
-				  || space_id == 0)) {
+				  || trx_sys_sys_space(space_id))) {
 			fprintf(stderr,
 				"InnoDB: Error: tablespace id %lu"
 				" in file %s is not sensible\n",
@@ -864,7 +864,6 @@
 	fil_n_file_opened++;
 
 	if (fil_space_belongs_in_lru(space)) {
-
 		/* Put the node to the LRU list */
 		UT_LIST_ADD_FIRST(LRU, system->LRU, node);
 	}
@@ -903,7 +902,6 @@
 	fil_n_file_opened--;
 
 	if (fil_space_belongs_in_lru(node->space)) {
-
 		ut_a(UT_LIST_GET_LEN(system->LRU) > 0);
 
 		/* The node is in the LRU list, remove it */
@@ -999,7 +997,7 @@
 retry:
 	mutex_enter(&fil_system->mutex);
 
-	if (space_id == 0 || space_id >= SRV_LOG_SPACE_FIRST_ID) {
+	if (trx_sys_sys_space(space_id) || space_id >= SRV_LOG_SPACE_FIRST_ID) {
 		/* We keep log files and system tablespace files always open;
 		this is important in preventing deadlocks in this module, as
 		a page read completion often performs another read from the
@@ -1276,9 +1274,9 @@
 	space->tablespace_version = fil_system->tablespace_version;
 	space->mark = FALSE;
 
-	if (purpose == FIL_TABLESPACE && !recv_recovery_on
-	    && id > fil_system->max_assigned_id) {
-
+	if (UNIV_LIKELY(purpose == FIL_TABLESPACE && !recv_recovery_on)
+	    && UNIV_UNLIKELY(id < SRV_EXTRA_SYS_SPACE_FIRST_ID)
+	    && UNIV_UNLIKELY(id > fil_system->max_assigned_id)) {
 		if (!fil_system->space_id_reuse_warned) {
 			fil_system->space_id_reuse_warned = TRUE;
 
@@ -1350,7 +1348,7 @@
 			(ulong) SRV_LOG_SPACE_FIRST_ID);
 	}
 
-	success = (id < SRV_LOG_SPACE_FIRST_ID);
+	success = (id < SRV_EXTRA_SYS_SPACE_FIRST_ID);
 
 	if (success) {
 		*space_id = fil_system->max_assigned_id = id;
@@ -1773,6 +1771,10 @@
 		ut_error;
 	}
 
+	if (max_id >= SRV_EXTRA_SYS_SPACE_FIRST_ID) {
+		return;
+	}
+
 	mutex_enter(&fil_system->mutex);
 
 	if (fil_system->max_assigned_id < max_id) {
@@ -4067,7 +4069,7 @@
 	}
 
 #ifdef UNIV_HOTBACKUP
-	if (fsp->id == ULINT_UNDEFINED || fsp->id == 0) {
+	if (fsp->id == ULINT_UNDEFINED || trx_sys_sys_space(fsp->id)) {
 		char*	new_path;
 
 		fprintf(stderr,
@@ -4967,7 +4969,6 @@
 	}
 
 	if (node->n_pending == 0 && fil_space_belongs_in_lru(node->space)) {
-
 		/* The node must be put back to the LRU list */
 		UT_LIST_ADD_FIRST(LRU, system->LRU, node);
 	}
 
=== modified file 'Percona-Server/storage/innobase/fsp/fsp0fsp.cc'
--- Percona-Server/storage/innobase/fsp/fsp0fsp.cc	2012-08-22 01:40:20 +0000
+++ Percona-Server/storage/innobase/fsp/fsp0fsp.cc	2012-11-13 06:02:21 +0000
@@ -49,7 +49,7 @@
 #endif /* UNIV_HOTBACKUP */
 #include "dict0mem.h"
 #include "srv0start.h"
-
+#include "trx0sys.h"
 
 #ifndef UNIV_HOTBACKUP
 /** Flag to indicate if we have printed the tablespace full error. */
@@ -832,10 +832,10 @@
 	flst_init(header + FSP_SEG_INODES_FREE, mtr);
 
 	mlog_write_ull(header + FSP_SEG_ID, 1, mtr);
-	if (space == 0) {
+	if (space == TRX_SYS_SPACE || space == TRX_DOUBLEWRITE_SPACE) {
 		fsp_fill_free_list(FALSE, space, header, mtr);
 		btr_create(DICT_CLUSTERED | DICT_UNIVERSAL | DICT_IBUF,
-			   0, 0, DICT_IBUF_ID_MIN + space,
+			   space, 0, DICT_IBUF_ID_MIN + space,
 			   dict_ind_redundant, mtr);
 	} else {
 		fsp_fill_free_list(TRUE, space, header, mtr);
 
=== modified file 'Percona-Server/storage/innobase/handler/ha_innodb.cc'
--- Percona-Server/storage/innobase/handler/ha_innodb.cc	2012-10-16 06:21:51 +0000
+++ Percona-Server/storage/innobase/handler/ha_innodb.cc	2012-11-13 06:02:21 +0000
@@ -159,6 +159,7 @@
 static char*	innobase_disable_monitor_counter	= NULL;
 static char*	innobase_reset_monitor_counter		= NULL;
 static char*	innobase_reset_all_monitor_counter	= NULL;
+static char*	innobase_doublewrite_file		= NULL;
 
 /* The highest file format being used in the database. The value can be
 set by user, however, it will be adjusted to the newer file format if
@@ -2920,6 +2921,8 @@
 		goto error;
 	}
 
+	srv_doublewrite_file = innobase_doublewrite_file;
+
 	/* -------------- All log files ---------------------------*/
 
 	/* The default dir for log files is the datadir of MySQL */
@@ -15799,6 +15802,11 @@
   1,			/* Minimum value */
   TRX_SYS_N_RSEGS, 0);	/* Maximum value */
 
+static MYSQL_SYSVAR_STR(doublewrite_file, innobase_doublewrite_file,
+  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+  "Path to special datafile for doublewrite buffer. (default is "": not used) ### ONLY FOR EXPERTS!!! ###",
+  NULL, NULL, NULL);
+
 static MYSQL_SYSVAR_LONG(autoinc_lock_mode, innobase_autoinc_lock_mode,
   PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
   "The AUTOINC lock modes supported by InnoDB:               "
@@ -15980,6 +15988,7 @@
   MYSQL_SYSVAR(concurrency_tickets),
   MYSQL_SYSVAR(compression_level),
   MYSQL_SYSVAR(data_file_path),
+  MYSQL_SYSVAR(doublewrite_file),
   MYSQL_SYSVAR(data_home_dir),
   MYSQL_SYSVAR(doublewrite),
   MYSQL_SYSVAR(api_enable_binlog),
 
=== modified file 'Percona-Server/storage/innobase/include/mtr0log.ic'
--- Percona-Server/storage/innobase/include/mtr0log.ic	2012-01-26 11:57:53 +0000
+++ Percona-Server/storage/innobase/include/mtr0log.ic	2012-11-13 06:02:21 +0000
@@ -28,8 +28,8 @@
 #include "buf0buf.h"
 #include "buf0dblwr.h"
 #include "fsp0types.h"
+#include "srv0srv.h"
 #include "trx0sys.h"
-
 /********************************************************//**
 Opens a buffer to mlog. It must be closed with mlog_close.
 @return	buffer, NULL if log mode MTR_LOG_NONE */
@@ -202,7 +202,8 @@
 	the doublewrite buffer is located in pages
 	FSP_EXTENT_SIZE, ..., 3 * FSP_EXTENT_SIZE - 1 in the
 	system tablespace */
-	if (space == TRX_SYS_SPACE
+	if ((space == TRX_SYS_SPACE
+	     || (srv_doublewrite_file && space == TRX_DOUBLEWRITE_SPACE))
 	    && offset >= FSP_EXTENT_SIZE && offset < 3 * FSP_EXTENT_SIZE) {
 		if (buf_dblwr_being_created) {
 			/* Do nothing: we only come to this branch in an
 
=== modified file 'Percona-Server/storage/innobase/include/srv0srv.h'
--- Percona-Server/storage/innobase/include/srv0srv.h	2012-10-16 06:21:51 +0000
+++ Percona-Server/storage/innobase/include/srv0srv.h	2012-11-13 06:02:21 +0000
@@ -235,6 +235,8 @@
 extern ulint*	srv_data_file_sizes;
 extern ulint*	srv_data_file_is_raw_partition;
 
+extern char*	srv_doublewrite_file;
+
 extern ibool	srv_auto_extend_last_data_file;
 extern ulint	srv_last_file_size_max;
 extern char**	srv_log_group_home_dirs;
 
=== modified file 'Percona-Server/storage/innobase/include/srv0start.h'
--- Percona-Server/storage/innobase/include/srv0start.h	2012-08-22 01:40:20 +0000
+++ Percona-Server/storage/innobase/include/srv0start.h	2012-11-13 06:02:21 +0000
@@ -173,4 +173,7 @@
 /** Log 'spaces' have id's >= this */
 #define SRV_LOG_SPACE_FIRST_ID		0xFFFFFFF0UL
 
+/** reserved for extra system tables */
+#define SRV_EXTRA_SYS_SPACE_FIRST_ID	0xFFFFFFE0UL
+
 #endif
 
=== modified file 'Percona-Server/storage/innobase/include/trx0sys.h'
--- Percona-Server/storage/innobase/include/trx0sys.h	2012-10-16 06:21:51 +0000
+++ Percona-Server/storage/innobase/include/trx0sys.h	2012-11-13 06:02:21 +0000
@@ -78,6 +78,22 @@
 /*=============*/
 	ulint	space,	/*!< in: space */
 	ulint	page_no);/*!< in: page number */
+/***************************************************************//**
+Checks if a space is the system tablespaces.
+@return TRUE if system tablespace */
+UNIV_INLINE
+ibool
+trx_sys_sys_space(
+/*==============*/
+	ulint	space);	/*!< in: space */
+/***************************************************************//**
+Checks if a space is the doublewrite tablespace.
+@return TRUE if doublewrite tablespace */
+UNIV_INLINE
+ibool
+trx_sys_doublewrite_space(
+/*======================*/
+	ulint	space);	/*!< in: space */
 /*****************************************************************//**
 Creates and initializes the central memory structures for the transaction
 system. This is called when the database is started.
@@ -463,6 +479,8 @@
 
 /* Space id and page no where the trx system file copy resides */
 #define	TRX_SYS_SPACE	0	/* the SYSTEM tablespace */
+#define	TRX_DOUBLEWRITE_SPACE	0xFFFFFFE0UL	/* the doublewrite buffer tablespace if used */
+#define	TRX_SYS_SPACE_MAX	9	/* reserved max space id for system tablespaces */
 #include "fsp0fsp.h"
 #define	TRX_SYS_PAGE_NO	FSP_TRX_SYS_PAGE_NO
 
@@ -660,3 +678,9 @@
 #endif
 
 #endif
+
+UNIV_INTERN
+void
+trx_sys_dummy_create(
+/*=================*/
+		     ulint	space);
 
=== modified file 'Percona-Server/storage/innobase/include/trx0sys.ic'
--- Percona-Server/storage/innobase/include/trx0sys.ic	2011-11-21 00:04:40 +0000
+++ Percona-Server/storage/innobase/include/trx0sys.ic	2012-11-13 06:02:21 +0000
@@ -25,6 +25,7 @@
 
 #include "trx0trx.h"
 #include "data0type.h"
+#include "srv0srv.h"
 #ifndef UNIV_HOTBACKUP
 # include "srv0srv.h"
 # include "mtr0log.h"
@@ -71,6 +72,40 @@
 }
 
 /***************************************************************//**
+Checks if a space is the system tablespaces.
+@return TRUE if system tablespace */
+UNIV_INLINE
+ibool
+trx_sys_sys_space(
+/*==============*/
+	ulint	space)	/*!< in: space */
+{
+	if (srv_doublewrite_file) {
+		/* several spaces are reserved */
+		return((ibool)(space == TRX_SYS_SPACE || space == TRX_DOUBLEWRITE_SPACE));
+	} else {
+		return((ibool)(space == TRX_SYS_SPACE));
+	}
+}
+
+/***************************************************************//**
+Checks if a space is the doublewrite tablespace.
+@return TRUE if doublewrite tablespace */
+UNIV_INLINE
+ibool
+trx_sys_doublewrite_space(
+/*======================*/
+	ulint	space)	/*!< in: space */
+{
+	if (srv_doublewrite_file) {
+		/* doublewrite buffer is separated */
+		return((ibool)(space == TRX_DOUBLEWRITE_SPACE));
+	} else {
+		return((ibool)(space == TRX_SYS_SPACE));
+	}
+}
+
+/***************************************************************//**
 Gets the pointer in the nth slot of the rseg array.
 @return	pointer to rseg object, NULL if slot not in use */
 UNIV_INLINE
 
=== modified file 'Percona-Server/storage/innobase/row/row0mysql.cc'
--- Percona-Server/storage/innobase/row/row0mysql.cc	2012-10-16 06:21:51 +0000
+++ Percona-Server/storage/innobase/row/row0mysql.cc	2012-11-13 06:02:21 +0000
@@ -4108,7 +4108,7 @@
 		a temp table or if the tablesace has been discarded. */
 		print_msg = !(is_temp || ibd_file_missing);
 
-		if (err == DB_SUCCESS && space_id > TRX_SYS_SPACE) {
+		if (err == DB_SUCCESS && !trx_sys_sys_space(space_id)) {
 			if (!is_temp
 			    && !fil_space_for_table_exists_in_mem(
 					space_id, tablename, FALSE, print_msg)) {
 
=== modified file 'Percona-Server/storage/innobase/srv/srv0srv.cc'
--- Percona-Server/storage/innobase/srv/srv0srv.cc	2012-10-16 06:21:51 +0000
+++ Percona-Server/storage/innobase/srv/srv0srv.cc	2012-11-13 06:02:21 +0000
@@ -161,6 +161,8 @@
 /* size in database pages */
 UNIV_INTERN ulint*	srv_data_file_sizes = NULL;
 
+UNIV_INTERN char*	srv_doublewrite_file = NULL;
+
 /* if TRUE, then we auto-extend the last data file */
 UNIV_INTERN ibool	srv_auto_extend_last_data_file	= FALSE;
 /* if != 0, this tells the max size auto-extending may increase the
 
=== modified file 'Percona-Server/storage/innobase/srv/srv0start.cc'
--- Percona-Server/storage/innobase/srv/srv0start.cc	2012-10-16 06:21:51 +0000
+++ Percona-Server/storage/innobase/srv/srv0start.cc	2012-11-13 06:02:21 +0000
@@ -761,6 +761,7 @@
 /*======================*/
 	ibool*		create_new_db,	/*!< out: TRUE if new database should be
 					created */
+	ibool*		create_new_doublewrite_file,
 #ifdef UNIV_LOG_ARCHIVE
 	ulint*		min_arch_log_no,/*!< out: min of archived log
 					numbers in data files */
@@ -796,6 +797,7 @@
 	*sum_of_new_sizes = 0;
 
 	*create_new_db = FALSE;
+	*create_new_doublewrite_file = FALSE;
 
 	srv_normalize_path_for_win(srv_data_home);
 
@@ -1066,6 +1068,139 @@
 				srv_data_file_is_raw_partition[i] != 0);
 	}
 
+	/* special file for doublewrite buffer */
+	if (srv_doublewrite_file)
+	{
+		srv_normalize_path_for_win(srv_doublewrite_file);
+
+		fprintf(stderr,
+			"InnoDB: Note: The innodb_doublewrite_file option has been specified.\n"
+			"InnoDB: This option is for experts only. Don't use it unless you understand WELL what it is.\n"
+			"InnoDB: ### Don't specify a file older than the last checkpoint. ###\n"
+			"InnoDB: Otherwise, the older doublewrite buffer will break your data during recovery!\n");
+
+		strcpy(name, srv_doublewrite_file);
+
+		/* First we try to create the file: if it already
+		exists, ret will get value FALSE */
+
+		files[i] = os_file_create(innodb_file_data_key, name, OS_FILE_CREATE,
+					  OS_FILE_NORMAL,
+					  OS_DATA_FILE, &ret);
+
+		if (ret == FALSE && os_file_get_last_error(FALSE)
+		    != OS_FILE_ALREADY_EXISTS
+#ifdef UNIV_AIX
+		    /* AIX 5.1 after security patch ML7 may have
+		    errno set to 0 here, which causes our function
+		    to return 100; work around that AIX problem */
+		    && os_file_get_last_error(FALSE) != 100
+#endif
+		    ) {
+			fprintf(stderr,
+				"InnoDB: Error in creating"
+				" or opening %s\n",
+				name);
+
+			return(DB_ERROR);
+		}
+
+		if (ret == FALSE) {
+			/* We open the data file */
+
+			files[i] = os_file_create(innodb_file_data_key,
+				name, OS_FILE_OPEN, OS_FILE_NORMAL,
+				OS_DATA_FILE, &ret);
+
+			if (!ret) {
+				fprintf(stderr,
+					"InnoDB: Error in opening %s\n", name);
+				os_file_get_last_error(TRUE);
+
+				return(DB_ERROR);
+			}
+
+			size = os_file_get_size(files[i]);
+			/* Round size downward to megabytes */
+
+			rounded_size_pages = (ulint)
+				(size >> UNIV_PAGE_SIZE_SHIFT);
+
+			if (rounded_size_pages != TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * 9) {
+
+				fprintf(stderr,
+					"InnoDB: Warning: doublewrite buffer file %s"
+					" is of a different size\n"
+					"InnoDB: %lu pages"
+					" (rounded down to MB)\n"
+					"InnoDB: than intended size"
+					" %lu pages...\n",
+					name,
+					(ulong) rounded_size_pages,
+					(ulong) TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * 9);
+			}
+
+			fil_read_first_page(files[i], one_opened, &flags,
+					    &space,
+#ifdef UNIV_LOG_ARCHIVE
+				min_arch_log_no, max_arch_log_no,
+#endif /* UNIV_LOG_ARCHIVE */
+				min_flushed_lsn, max_flushed_lsn);
+			one_opened = TRUE;
+		} else {
+			/* We created the data file and now write it full of
+			zeros */
+
+			*create_new_doublewrite_file = TRUE;
+
+			ut_print_timestamp(stderr);
+			fprintf(stderr,
+				"  InnoDB: Doublewrite buffer file %s did not"
+				" exist. It will be be created.\n",
+				name);
+
+			if (*create_new_db == FALSE) {
+				fprintf(stderr,
+					"InnoDB: Notice: Previous version's ibdata files may cause crash.\n"
+					"        If you use that, please use the ibdata files of this version.\n");
+			}
+
+			ut_print_timestamp(stderr);
+			fprintf(stderr,
+				"  InnoDB: Setting file %s size to %lu MB\n",
+				name,
+				(ulong) ((TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * 9)
+					 >> (20 - UNIV_PAGE_SIZE_SHIFT)));
+
+			fprintf(stderr,
+				"InnoDB: Database physically writes the"
+				" file full: wait...\n");
+
+			ret = os_file_set_size(
+				name, files[i],
+				(TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * 9)  << UNIV_PAGE_SIZE_SHIFT);
+
+			if (!ret) {
+				fprintf(stderr,
+					"InnoDB: Error in creating %s:"
+					" probably out of disk space\n", name);
+
+				return(DB_ERROR);
+			}
+		}
+
+		ret = os_file_close(files[i]);
+		ut_a(ret);
+
+		fil_space_create(name, TRX_DOUBLEWRITE_SPACE, 0, FIL_TABLESPACE);
+
+		ut_a(fil_validate());
+
+		fil_node_create(name, TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * 9, TRX_DOUBLEWRITE_SPACE, FALSE);
+
+		i++;
+	}
+
 	return(DB_SUCCESS);
 }
 
@@ -1448,6 +1583,7 @@
 /*====================================*/
 {
 	ibool		create_new_db;
+	ibool		create_new_doublewrite_file;
 	ibool		log_file_created;
 	ibool		log_created	= FALSE;
 	ibool		log_opened	= FALSE;
@@ -1940,6 +2076,7 @@
 	}
 
 	err = open_or_create_data_files(&create_new_db,
+					&create_new_doublewrite_file,
 #ifdef UNIV_LOG_ARCHIVE
 					&min_arch_log_no, &max_arch_log_no,
 #endif /* UNIV_LOG_ARCHIVE */
@@ -2112,6 +2249,14 @@
 
 		trx_purge_sys_create(srv_n_purge_threads, ib_bh);
 
+		if (create_new_doublewrite_file) {
+			mtr_start(&mtr);
+			fsp_header_init(TRX_DOUBLEWRITE_SPACE, TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * 9, &mtr);
+			mtr_commit(&mtr);
+
+			trx_sys_dummy_create(TRX_DOUBLEWRITE_SPACE);
+		}
+
 		dict_create();
 
 		srv_startup_is_before_trx_rollback_phase = FALSE;
@@ -2146,6 +2291,13 @@
 		recv_recovery_from_archive_finish();
 #endif /* UNIV_LOG_ARCHIVE */
 	} else {
+		char*	save_srv_doublewrite_file = NULL;
+
+		if (create_new_doublewrite_file) {
+			/* doublewrite_file cannot be used for recovery yet. */
+			save_srv_doublewrite_file = srv_doublewrite_file;
+			srv_doublewrite_file = NULL;
+		}
 
 		/* Check if we support the max format that is stamped
 		on the system tablespace.
@@ -2235,6 +2387,17 @@
 		we have finished the recovery process so that the
 		image of TRX_SYS_PAGE_NO is not stale. */
 		trx_sys_file_format_tag_init();
+
+		if (create_new_doublewrite_file) {
+			/* restore the value */
+			srv_doublewrite_file = save_srv_doublewrite_file;
+
+			mtr_start(&mtr);
+			fsp_header_init(TRX_DOUBLEWRITE_SPACE, TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * 9, &mtr);
+			mtr_commit(&mtr);
+
+			trx_sys_dummy_create(TRX_DOUBLEWRITE_SPACE);
+		}
 	}
 
 	if (!create_new_db && sum_of_new_sizes > 0) {
 
=== modified file 'Percona-Server/storage/innobase/trx/trx0sys.cc'
--- Percona-Server/storage/innobase/trx/trx0sys.cc	2012-10-16 06:21:51 +0000
+++ Percona-Server/storage/innobase/trx/trx0sys.cc	2012-11-13 06:02:21 +0000
@@ -385,7 +385,8 @@
 void
 trx_sysf_create(
 /*============*/
-	mtr_t*	mtr)	/*!< in: mtr */
+	mtr_t*	mtr,	/*!< in: mtr */
+	ulint	space_id)
 {
 	trx_sysf_t*	sys_header;
 	ulint		slot_no;
@@ -401,10 +402,10 @@
 	then enter the kernel: we must do it in this order to conform
 	to the latching order rules. */
 
-	mtr_x_lock(fil_space_get_latch(TRX_SYS_SPACE, NULL), mtr);
+	mtr_x_lock(fil_space_get_latch(space_id, NULL), mtr);
 
 	/* Create the trx sys file block in a new allocated file segment */
-	block = fseg_create(TRX_SYS_SPACE, 0, TRX_SYS + TRX_SYS_FSEG_HEADER,
+	block = fseg_create(space_id, 0, TRX_SYS + TRX_SYS_FSEG_HEADER,
 			    mtr);
 	buf_block_dbg_add_level(block, SYNC_TRX_SYS_HEADER);
 
@@ -422,6 +423,12 @@
 	mlog_write_ulint(page + TRX_SYS_DOUBLEWRITE
 			 + TRX_SYS_DOUBLEWRITE_MAGIC, 0, MLOG_4BYTES, mtr);
 
+	if (space_id != TRX_SYS_SPACE) {
+		/* That is all we need for doublewrite buffer file. */
+		ut_a(space_id == TRX_DOUBLEWRITE_SPACE);
+		return;
+	}
+
 	sys_header = trx_sysf_get(mtr);
 
 	/* Start counting transaction ids from number 1 up */
@@ -445,7 +452,7 @@
 
 	/* Create the first rollback segment in the SYSTEM tablespace */
 	slot_no = trx_sysf_rseg_find_free(mtr);
-	page_no = trx_rseg_header_create(TRX_SYS_SPACE, 0, ULINT_MAX, slot_no,
+	page_no = trx_rseg_header_create(space_id, 0, ULINT_MAX, slot_no,
 					 mtr);
 
 	ut_a(slot_no == TRX_SYS_SYSTEM_RSEG_ID);
@@ -599,7 +606,7 @@
 
 	mtr_start(&mtr);
 
-	trx_sysf_create(&mtr);
+	trx_sysf_create(&mtr, TRX_SYS_SPACE);
 
 	mtr_commit(&mtr);
 }
@@ -863,6 +870,26 @@
 	/* Does nothing at the moment */
 }
 
+/*****************************************************************//**
+Creates and initializes the dummy transaction system page for tablespace. */
+UNIV_INTERN
+void
+trx_sys_dummy_create(
+/*=================*/
+	ulint	space)
+{
+	mtr_t	mtr;
+
+	/* This function is only for doublewrite file for now */
+	ut_a(space == TRX_DOUBLEWRITE_SPACE);
+
+	mtr_start(&mtr);
+
+	trx_sysf_create(&mtr, space);
+
+	mtr_commit(&mtr);
+}
+
 /*********************************************************************
 Creates the rollback segments.
 @return number of rollback segments that are active. */