Merge lp:~laurynas-biveinis/percona-server/buf-mutex-split-fixes-5.1 into lp:percona-server/5.1

[Laurynas Biveinis]

http://jenkins.percona.com/job/percona-server-5.1-param/543/

Fix several buffer pool mutex split bugs:

- bug 1086680 (Valgrind: free in buf_page_get_gen (Invalid read in
  buf_flush_batch / buf_flush_list) + free in buf_page_get_gen
  (Invalid read in buf_flush_page_and_try_neighbors));

- bug 1103850 (InnoDB: Failing assertion:
  mutex_own(&buf_pool->LRU_list_mutex) in file buf0lru.c line 859);

- bug 1181269 (Unnecessary LRU list mutex acquisition in
  buf_page_io_complete()).

The Valgrind errors and crashes of bug 1086680 happen because of a
race condition involving a dirty compressed page block for which there
is uncompressed page image in the buffer pool.

First, a master thread (or possible another query thread) does a flush
list flush and for that acquires the flush list mutex, gets a pointer
to a page, releases the flush list mutex.

At this point another thread starts reading the same page into the
buffer. Since it is a dirty compressed page, it allocates an
uncompressed page, relocates the page on the flush list, frees the
compressed page descriptor.

At this point the flushing thread proceeds to use the pointer which is
now dangling, causing the issue.

Fix by adjusting buf_flush_batch() to hold the flush list mutex for
all the bpage pointer dereferences. This should not introduce any new
stalls because the mutex is released after checking a few fields
only. This also allows simplifying buf_flush_batch() to become closer
to the InnoDB version, by removing prev_bpage and remaining local
vars. However, this means that buf_flush_ready_for_flush() now
becomes callable with the flush list mutex both held and not held.
This requires additional handling because this function may call
buf_flush_remove() in XtraDB due to the lazy table drop feature. The
latter needs to acquire the flush list mutex, thus we introduce a
boolean have_flush_list_mutex for buf_flush_remove() and
buf_flush_ready_for_flush(), together with additional invariant
asserts.

Bug 1103850 is caused by buf_flush_remove() calling
buf_LRU_insert_zip_clean() for BUF_BLOCK_ZIP_DIRTY pages in debug
builds, which requires the LRU list mutex, which is not always held
here. Fixed by disabling the zip_clean list maintenance for debug
builds. The alternative would be to buffer-fix the block, release and
re-acquire all the mutexes, including the LRU list one. But since
buf_flush_remove() may be called from different contexts holding
different mutexes (also due to bug 1086680 fix), this seems to be very
impractical.

Bug 1181269 is a missed performance improvement opportunity due to
upstream fixing http://bugs.mysql.com/bug.php?id=61341, which made
that buf_LRU_insert_zip_clean() call in buf_flush_remove() confined to
debug builds only. But XtraDB still kept on acquiring the LRU list
mutex buf_flush_write_complete() for flush list flushes, which call
buf_flush_remove(). With the buf_LRU_insert_zip_clean() made
debug-only by upstream and removed by bug 1103850 fix,
buf_flush_write_complete() only has to acquire the LRU list mutex for
the LRU list flushes.

[George Ormond Lorch III (gl-az)]

Nice work, especially the fix for bug 1086680 and the changes in buf_flush_batch.

review: Approve (g2)

[Alexey Kopytov (akopytov)]

Laurynas,

Thanks for implementing my idea of a fix for bug #1086680.

Approving with a nitpick about a couple of lines not using the InnoDB coding conventions:

+ ut_ad (block_mutex);

and

+ mutex_exit (block_mutex);

review: Approve

[Laurynas Biveinis (laurynas-biveinis)]

Fixed, re-based, re-Jenkins-tested at http://jenkins.percona.com/job/percona-server-5.1-param/566/.

review: Approve

=== modified file 'Percona-Server/storage/innodb_plugin/buf/buf0buf.c'
--- Percona-Server/storage/innodb_plugin/buf/buf0buf.c	2013-08-05 13:11:52 +0000
+++ Percona-Server/storage/innodb_plugin/buf/buf0buf.c	2013-08-16 08:39:46 +0000
@@ -210,13 +210,6 @@
 but not written to disk yet. The block with the oldest modification
 which has not yet been written to disk is at the end of the chain.
 
-The chain of unmodified compressed blocks (buf_pool->zip_clean)
-contains the control blocks (buf_page_t) of those compressed pages
-that are not in buf_pool->flush_list and for which no uncompressed
-page has been allocated in the buffer pool.  The control blocks for
-uncompressed pages are accessible via buf_block_t objects that are
-reachable via buf_pool->chunks[].
-
 The chains of free memory blocks (buf_pool->zip_free[]) are used by
 the buddy allocator (buf0buddy.c) to keep track of currently unused
 memory blocks of size sizeof(buf_page_t)..UNIV_PAGE_SIZE / 2.  These
@@ -2031,10 +2024,11 @@
 
 		if (buf_page_get_state(&block->page)
 		    == BUF_BLOCK_ZIP_PAGE) {
-#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
+#if 0
+			/* Disabled for XtraDB, see buf_flush_remove(). */
 			UT_LIST_REMOVE(zip_list, buf_pool->zip_clean,
 				       &block->page);
-#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
+#endif
 			ut_ad(!block->page.in_flush_list);
 		} else {
 			/* Relocate buf_pool->flush_list. */
@@ -2858,11 +2852,12 @@
 
 		/* The block must be put to the LRU list, to the old blocks */
 		buf_LRU_add_block(bpage, TRUE/* to old blocks */);
-#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
+#if 0
+		/* Disabled for XtraDB, see buf_flush_remove(). */
 		mutex_enter(&flush_list_mutex);
 		buf_LRU_insert_zip_clean(bpage);
 		mutex_exit(&flush_list_mutex);
-#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
+#endif
 
 		mutex_exit(&LRU_list_mutex);
 
@@ -3063,6 +3058,7 @@
 	const ibool	uncompressed = (buf_page_get_state(bpage)
 					== BUF_BLOCK_FILE_PAGE);
 	mutex_t*	block_mutex;
+	enum buf_flush	flush_type	= BUF_FLUSH_N_TYPES;
 
 	ut_a(buf_page_in_file(bpage));
 
@@ -3219,9 +3215,12 @@
 		}
 	}
 
-	//buf_pool_mutex_enter();
 	if (io_type == BUF_IO_WRITE) {
-		mutex_enter(&LRU_list_mutex);
+
+		flush_type = buf_page_get_flush_type(bpage);
+		if (flush_type == BUF_FLUSH_LRU) {
+			mutex_enter(&LRU_list_mutex);
+		}
 	}
 	block_mutex = buf_page_get_mutex_enter(bpage);
 	ut_a(block_mutex);
@@ -3265,10 +3264,9 @@
 
 		buf_flush_write_complete(bpage);
 
-		/* to keep consistency at buf_LRU_insert_zip_clean() */
-		//if (flush_type == BUF_FLUSH_LRU) { /* optimistic! */
+		if (flush_type == BUF_FLUSH_LRU) {
 			mutex_exit(&LRU_list_mutex);
-		//}
+		}
 
 		if (uncompressed) {
 			rw_lock_s_unlock_gen(&((buf_block_t*) bpage)->lock,
@@ -3404,7 +3402,7 @@
 			case BUF_BLOCK_ZIP_PAGE:
 			case BUF_BLOCK_ZIP_DIRTY:
 				/* These should only occur on
-				zip_clean, zip_free[], or flush_list. */
+				zip_free[], or flush_list. */
 				ut_error;
 				break;
 
@@ -3480,6 +3478,9 @@
 
 	mutex_enter(&buf_pool_zip_mutex);
 
+#if 0
+	/* Disabled for XtraDB, see buf_flush_remove(). */
+
 	/* Check clean compressed-only blocks. */
 
 	for (b = UT_LIST_GET_FIRST(buf_pool->zip_clean); b;
@@ -3505,6 +3506,7 @@
 		n_lru++;
 		n_zip++;
 	}
+#endif
 
 	/* Check dirty compressed-only blocks. */
 
@@ -3566,7 +3568,7 @@
 		ut_error;
 	}
 
-	ut_a(UT_LIST_GET_LEN(buf_pool->LRU) == n_lru);
+	ut_a(UT_LIST_GET_LEN(buf_pool->LRU) >= n_lru);
 	/* because of latching order with block->mutex, we cannot get free_list_mutex before that */
 /*
 	if (UT_LIST_GET_LEN(buf_pool->free) != n_free) {
@@ -3766,6 +3768,9 @@
 
 	/* Traverse the lists of clean and dirty compressed-only blocks. */
 
+#if 0
+	/* Disabled for XtraDB, see buf_flush_remove(). */
+
 	for (b = UT_LIST_GET_FIRST(buf_pool->zip_clean); b;
 	     b = UT_LIST_GET_NEXT(zip_list, b)) {
 		ut_a(buf_page_get_state(b) == BUF_BLOCK_ZIP_PAGE);
@@ -3776,6 +3781,7 @@
 			fixed_pages_number++;
 		}
 	}
+#endif
 
 	mutex_enter(&flush_list_mutex);
 	for (b = UT_LIST_GET_FIRST(buf_pool->flush_list); b;
 
=== modified file 'Percona-Server/storage/innodb_plugin/buf/buf0flu.c'
--- Percona-Server/storage/innodb_plugin/buf/buf0flu.c	2013-08-05 13:11:52 +0000
+++ Percona-Server/storage/innodb_plugin/buf/buf0flu.c	2013-08-16 08:39:46 +0000
@@ -395,12 +395,18 @@
 /*======================*/
 	buf_page_t*	bpage,	/*!< in: buffer control block, must be
 				buf_page_in_file(bpage) */
-	enum buf_flush	flush_type)/*!< in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */
+	enum buf_flush	flush_type,/*!< in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */
+	ibool		have_flush_list_mutex)/*!< in: TRUE if flush list mutex
+					      is being held */
 {
-	//ut_a(buf_page_in_file(bpage));
-	//ut_ad(buf_pool_mutex_own()); /*optimistic...*/
-	ut_ad(mutex_own(buf_page_get_mutex(bpage)));
-	ut_ad(flush_type == BUF_FLUSH_LRU || BUF_FLUSH_LIST);
+	ut_a(buf_page_in_file(bpage));
+
+	ut_ad(have_flush_list_mutex == mutex_own(&flush_list_mutex));
+	ut_ad(((flush_type == BUF_FLUSH_LRU
+		&& mutex_own(buf_page_get_mutex(bpage)))
+	       || (flush_type == BUF_FLUSH_LIST
+		   && (mutex_own(buf_page_get_mutex(bpage))
+		       || mutex_own(&flush_list_mutex)))));
 
 	if (buf_page_in_file(bpage) && bpage->oldest_modification != 0
 	    && buf_page_get_io_fix(bpage) == BUF_IO_NONE) {
@@ -409,7 +415,7 @@
 		if (bpage->space_was_being_deleted) {
 			/* should be removed from flush_list here */
 			/* because buf_flush_try_neighbors() cannot flush without fil_space_get_size(space) */
-			buf_flush_remove(bpage);
+			buf_flush_remove(bpage, have_flush_list_mutex);
 			return(FALSE);
 		}
 
@@ -436,12 +442,16 @@
 void
 buf_flush_remove(
 /*=============*/
-	buf_page_t*	bpage)	/*!< in: pointer to the block in question */
+	buf_page_t*	bpage,	/*!< in: pointer to the block in question */
+	ibool		have_flush_list_mutex)	/*!< in: TRUE if
+						flush_list_mutex is held */
 {
-	//ut_ad(buf_pool_mutex_own());
-	ut_ad(mutex_own(buf_page_get_mutex(bpage)));
-
-	mutex_enter(&flush_list_mutex);
+	if (!have_flush_list_mutex) {
+		mutex_enter(&flush_list_mutex);
+	} else {
+		ut_ad(mutex_own(&flush_list_mutex));
+		ut_ad(!mutex_own(buf_page_get_mutex(bpage)));
+	}
 
 	ut_ad(bpage->in_flush_list);
 
@@ -453,15 +463,17 @@
 	case BUF_BLOCK_READY_FOR_USE:
 	case BUF_BLOCK_MEMORY:
 	case BUF_BLOCK_REMOVE_HASH:
-		mutex_exit(&flush_list_mutex);
 		ut_error;
 		return;
 	case BUF_BLOCK_ZIP_DIRTY:
 		buf_page_set_state(bpage, BUF_BLOCK_ZIP_PAGE);
 		UT_LIST_REMOVE(flush_list, buf_pool->flush_list, bpage);
-#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
+#if 0
+		/* Disabled for XtraDB.  The cost of acquiring LRU mutex here
+		seems to be higher than the benefit of zip_clean list
+		maintenance. */
 		buf_LRU_insert_zip_clean(bpage);
-#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
+#endif
 		break;
 	case BUF_BLOCK_FILE_PAGE:
 		UT_LIST_REMOVE(flush_list, buf_pool->flush_list, bpage);
@@ -481,7 +493,9 @@
 
 	ut_d(UT_LIST_VALIDATE(flush_list, buf_page_t, buf_pool->flush_list,
 			      ut_ad(ut_list_node_313->in_flush_list)));
-	mutex_exit(&flush_list_mutex);
+	if (!have_flush_list_mutex) {
+		mutex_exit(&flush_list_mutex);
+	}
 }
 
 /********************************************************************//**
@@ -554,7 +568,7 @@
 
 	ut_ad(bpage);
 
-	buf_flush_remove(bpage);
+	buf_flush_remove(bpage, FALSE);
 
 	flush_type = buf_page_get_flush_type(bpage);
 	buf_pool->n_flush[flush_type]--;
@@ -1089,8 +1103,9 @@
 	//ut_ad(buf_pool_mutex_own());
 	ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
 	ut_ad(mutex_own(&block->mutex));
+	ut_ad(!mutex_own(&flush_list_mutex));
 
-	if (!buf_flush_ready_for_flush(&block->page, BUF_FLUSH_LRU)) {
+	if (!buf_flush_ready_for_flush(&block->page, BUF_FLUSH_LRU, FALSE)) {
 		return(FALSE);
 	}
 
@@ -1171,6 +1186,7 @@
 	ibool		is_uncompressed;
 
 	ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
+	ut_ad(!mutex_own(&flush_list_mutex));
 	//ut_ad(buf_pool_mutex_own());
 #ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&page_hash_latch, RW_LOCK_EX)
@@ -1184,7 +1200,7 @@
 	mutex_enter(&buf_pool_mutex);
 	rw_lock_s_unlock(&page_hash_latch);
 
-	ut_ad(buf_flush_ready_for_flush(bpage, flush_type));
+	ut_ad(buf_flush_ready_for_flush(bpage, flush_type, FALSE));
 
 	buf_page_set_io_fix(bpage, BUF_IO_WRITE);
 
@@ -1294,6 +1310,7 @@
 	ulint		i;
 
 	ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
+	ut_ad(!mutex_own(&flush_list_mutex));
 
 	if (UT_LIST_GET_LEN(buf_pool->LRU) < BUF_LRU_OLD_MIN_LEN || !flush_neighbors) {
 		/* If there is little space, it is better not to flush any
@@ -1340,7 +1357,9 @@
 		    || buf_page_is_old(bpage)) {
 			mutex_t* block_mutex = buf_page_get_mutex_enter(bpage);
 
-			if (block_mutex && buf_flush_ready_for_flush(bpage, flush_type)
+			if (block_mutex
+			    && buf_flush_ready_for_flush(bpage, flush_type,
+							 FALSE)
 			    && (i == offset || !bpage->buf_fix_count)) {
 				/* We only try to flush those
 				neighbors != offset where the buf fix count is
@@ -1394,11 +1413,9 @@
 					min_n), otherwise ignored */
 {
 	buf_page_t*	bpage;
-	buf_page_t*	prev_bpage	= NULL;
 	ulint		page_count	= 0;
 	ulint		space;
 	ulint		offset;
-	ulint		remaining	= 0;
 
 	ut_ad((flush_type == BUF_FLUSH_LRU)
 	      || (flush_type == BUF_FLUSH_LIST));
@@ -1445,16 +1462,12 @@
 			ut_ad(flush_type == BUF_FLUSH_LIST);
 
 			mutex_enter(&flush_list_mutex);
-			remaining = UT_LIST_GET_LEN(buf_pool->flush_list);
 			bpage = UT_LIST_GET_LAST(buf_pool->flush_list);
-			if (bpage) {
-				prev_bpage = UT_LIST_GET_PREV(flush_list, bpage);
-			}
-			mutex_exit(&flush_list_mutex);
 			if (!bpage
 			    || bpage->oldest_modification >= lsn_limit) {
 				/* We have flushed enough */
 
+				mutex_exit(&flush_list_mutex);
 				break;
 			}
 			ut_ad(bpage->in_flush_list);
@@ -1467,24 +1480,29 @@
 		function a pointer to a block in the list! */
 
 		do {
-			mutex_t*block_mutex = buf_page_get_mutex_enter(bpage);
+			mutex_t*block_mutex = NULL;
 			ibool	ready;
 
-			//ut_a(buf_page_in_file(bpage));
+			ut_a(buf_page_in_file(bpage));
 
+			if (flush_type == BUF_FLUSH_LRU) {
+				block_mutex = buf_page_get_mutex_enter(bpage);
+				ut_ad(block_mutex);
+			}
+			ready = buf_flush_ready_for_flush(bpage, flush_type,
+							  (flush_type
+							   == BUF_FLUSH_LIST));
 			if (block_mutex) {
-				ready = buf_flush_ready_for_flush(bpage, flush_type);
 				mutex_exit(block_mutex);
-			} else {
-				ready = FALSE;
 			}
 
 			if (ready) {
 				space = buf_page_get_space(bpage);
 				offset = buf_page_get_page_no(bpage);
 
-				//buf_pool_mutex_exit();
-				if (flush_type == BUF_FLUSH_LRU) {
+				if (flush_type == BUF_FLUSH_LIST) {
+					mutex_exit(&flush_list_mutex);
+				} else if (flush_type == BUF_FLUSH_LRU) {
 					mutex_exit(&LRU_list_mutex);
 				}
 
@@ -1503,26 +1521,17 @@
 			} else {
 				ut_ad(flush_type == BUF_FLUSH_LIST);
 
-				mutex_enter(&flush_list_mutex);
 				bpage = UT_LIST_GET_PREV(flush_list, bpage);
-				//ut_ad(!bpage || bpage->in_flush_list); /* optimistic */
-				if (bpage != prev_bpage) {
-					/* the search may warp.. retrying */
-					bpage = NULL;
-				}
-				if (bpage) {
-					prev_bpage = UT_LIST_GET_PREV(flush_list, bpage);
-				}
-				mutex_exit(&flush_list_mutex);
-				remaining--;
+				ut_ad(!bpage || bpage->in_flush_list);
 			}
 		} while (bpage != NULL);
 
-		if (remaining)
-			goto flush_next;
-
 		/* If we could not find anything to flush, leave the loop */
 
+		if (flush_type == BUF_FLUSH_LIST) {
+			mutex_exit(&flush_list_mutex);
+		}
+
 		break;
 	}
 
 
=== modified file 'Percona-Server/storage/innodb_plugin/buf/buf0lru.c'
--- Percona-Server/storage/innodb_plugin/buf/buf0lru.c	2013-08-05 13:11:52 +0000
+++ Percona-Server/storage/innodb_plugin/buf/buf0lru.c	2013-08-16 08:39:46 +0000
@@ -481,7 +481,7 @@
 
 		if (bpage->oldest_modification != 0) {
 
-			buf_flush_remove(bpage);
+			buf_flush_remove(bpage, FALSE);
 		}
 
 		/* Remove from the LRU list. */
@@ -540,7 +540,8 @@
 	ut_ad(buf_LRU_drop_page_hash_for_tablespace(id) == 0);
 }
 
-#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
+#if 0
+/* Disabled for XtraDB, see buf_flush_remove(). */
 /********************************************************************//**
 Insert a compressed block into buf_pool->zip_clean in the LRU order. */
 UNIV_INTERN
@@ -1452,7 +1453,7 @@
 	}
 
 	if (bpage->space_was_being_deleted && bpage->oldest_modification != 0) {
-		buf_flush_remove(bpage);
+		buf_flush_remove(bpage, FALSE);
 	}
 
 #ifdef UNIV_IBUF_COUNT_DEBUG
@@ -1619,9 +1620,11 @@
 
 			mutex_enter(&flush_list_mutex);
 			if (b->state == BUF_BLOCK_ZIP_PAGE) {
-#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
+#if 0
+				/* Disabled for XtraDB, see
+				buf_flush_remove(). */
 				buf_LRU_insert_zip_clean(b);
-#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
+#endif
 			} else {
 				/* Relocate on buf_pool->flush_list. */
 				buf_flush_relocate_on_flush_list(bpage, b);
@@ -1920,9 +1923,10 @@
 		ut_a(bpage->zip.data);
 		ut_a(buf_page_get_zip_size(bpage));
 
-#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
+#if 0
+		/* Disabled for XtraDB, see buf_flush_remove(). */
 		UT_LIST_REMOVE(zip_list, buf_pool->zip_clean, bpage);
-#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
+#endif
 
 		mutex_exit(&buf_pool_zip_mutex);
 		//buf_pool_mutex_exit_forbid();
 
=== modified file 'Percona-Server/storage/innodb_plugin/include/buf0buf.h'
--- Percona-Server/storage/innodb_plugin/include/buf0buf.h	2013-03-06 11:10:14 +0000
+++ Percona-Server/storage/innodb_plugin/include/buf0buf.h	2013-08-16 08:39:46 +0000
@@ -1219,7 +1219,6 @@
 					- BUF_BLOCK_NOT_USED:	free
 					- BUF_BLOCK_FILE_PAGE:	flush_list
 					- BUF_BLOCK_ZIP_DIRTY:	flush_list
-					- BUF_BLOCK_ZIP_PAGE:	zip_clean
 					- BUF_BLOCK_ZIP_FREE:	zip_free[]
 
 					The contents of the list node
@@ -1233,7 +1232,7 @@
 	/* resplit for optimistic use */
 	UT_LIST_NODE_T(buf_page_t) free;
 	UT_LIST_NODE_T(buf_page_t) flush_list;
-	UT_LIST_NODE_T(buf_page_t) zip_list; /* zip_clean or zip_free[] */
+	UT_LIST_NODE_T(buf_page_t) zip_list; /* zip_free[] */
 #ifdef UNIV_DEBUG
 	ibool		in_flush_list;	/*!< TRUE if in buf_pool->flush_list;
 					when buf_pool_mutex is free, the
@@ -1587,10 +1586,11 @@
 	frames and buf_page_t descriptors of blocks that exist
 	in the buffer pool only in compressed form. */
 	/* @{ */
-#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
+#if 0
+	/* Disabled for XtraDB, see buf_flush_remove(). */
 	UT_LIST_BASE_NODE_T(buf_page_t)	zip_clean;
 					/*!< unmodified compressed pages */
-#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
+#endif
 	UT_LIST_BASE_NODE_T(buf_page_t) zip_free[BUF_BUDDY_SIZES_MAX];
 					/*!< buddy free lists */
 //#if BUF_BUDDY_HIGH != UNIV_PAGE_SIZE
 
=== modified file 'Percona-Server/storage/innodb_plugin/include/buf0flu.h'
--- Percona-Server/storage/innodb_plugin/include/buf0flu.h	2013-08-05 13:11:52 +0000
+++ Percona-Server/storage/innodb_plugin/include/buf0flu.h	2013-08-16 08:39:46 +0000
@@ -38,7 +38,10 @@
 void
 buf_flush_remove(
 /*=============*/
-	buf_page_t*	bpage);	/*!< in: pointer to the block in question */
+	buf_page_t*	bpage,	/*!< in: pointer to the block in question */
+	ibool		have_flush_list_mutex);	/*!< in: TRUE if
+						flush_list_mutex is held */
+
 /********************************************************************//**
 Relocates a buffer control block on the flush_list.
 Note that it is assumed that the contents of bpage has already been
 
=== modified file 'Percona-Server/storage/innodb_plugin/include/buf0lru.h'
--- Percona-Server/storage/innodb_plugin/include/buf0lru.h	2013-08-05 13:11:52 +0000
+++ Percona-Server/storage/innodb_plugin/include/buf0lru.h	2013-08-16 08:39:46 +0000
@@ -79,7 +79,8 @@
 buf_LRU_mark_space_was_deleted(
 /*===========================*/
 	ulint	id);	/*!< in: space id */
-#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
+#if 0
+/* Disabled for XtraDB, see buf_flush_remove(). */
 /********************************************************************//**
 Insert a compressed block into buf_pool->zip_clean in the LRU order. */
 UNIV_INTERN
@@ -87,7 +88,7 @@
 buf_LRU_insert_zip_clean(
 /*=====================*/
 	buf_page_t*	bpage);	/*!< in: pointer to the block in question */
-#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
+#endif
 
 /******************************************************************//**
 Try to free a block.  If bpage is a descriptor of a compressed-only