MDEV-15528 Punch holes when pages are freed

When a InnoDB data file page is freed, its contents becomes garbage,
and any storage allocated in the data file is wasted. So InnoDB does
write FREE_PAGE redo record and mark the page status as FREED when
page is being freed or extent is being freed.

If the variable innodb-immediate-scrub-data-uncompressed is true then
write zero out the page. If it is not then ignore the flushing of
the page from flush list.

11 files changed, 126 insertions, 178 deletions

diff --git a/storage/innobase/btr/btr0sea.cc b/storage/innobase/btr/btr0sea.cc
index 5522ba54b96..70cae35da97 100644
--- a/storage/innobase/btr/btr0sea.cc
+++ b/storage/innobase/btr/btr0sea.cc
@@ -962,7 +962,7 @@ fail:
 		}
 
 		ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
-		ut_ad(!block->page.file_page_was_freed);
+		DBUG_ASSERT(block->page.status != FREED);
 		buf_page_set_accessed(&block->page);
 		buf_block_buf_fix_inc(block, __FILE__, __LINE__);
 		mutex_exit(&block->mutex);
@@ -1313,7 +1313,7 @@ void btr_search_drop_page_hash_when_freed(const page_id_t page_id)
 
 		/* If AHI is still valid, page can't be in free state.
 		AHI is dropped when page is freed. */
-		ut_ad(!block->page.file_page_was_freed);
+		DBUG_ASSERT(block->page.status != FREED);
 
 		buf_block_dbg_add_level(block, SYNC_TREE_NODE_FROM_HASH);
 
diff --git a/storage/innobase/buf/buf0buf.cc b/storage/innobase/buf/buf0buf.cc
index 6e2c62a1e57..c4a9b1a8176 100644
--- a/storage/innobase/buf/buf0buf.cc
+++ b/storage/innobase/buf/buf0buf.cc
@@ -1356,14 +1356,12 @@ buf_block_init(buf_block_t* block, byte* frame)
 	block->page.state = BUF_BLOCK_NOT_USED;
 	block->page.buf_fix_count = 0;
 	block->page.io_fix = BUF_IO_NONE;
-	block->page.init_on_flush = false;
+	block->page.status = NORMAL;
 	block->page.real_size = 0;
 	block->page.write_size = 0;
 	block->modify_clock = 0;
 	block->page.slot = NULL;
 
-	ut_d(block->page.file_page_was_freed = FALSE);
-
 #ifdef BTR_CUR_HASH_ADAPT
 	block->index = NULL;
 #endif /* BTR_CUR_HASH_ADAPT */
@@ -3212,59 +3210,6 @@ void buf_page_make_young(buf_page_t* bpage)
 	mutex_exit(&buf_pool->mutex);
 }
 
-#ifdef UNIV_DEBUG
-/** Sets file_page_was_freed TRUE if the page is found in the buffer pool.
-This function should be called when we free a file page and want the
-debug version to check that it is not accessed any more unless
-reallocated.
-@param[in]	page_id	page id
-@return control block if found in page hash table, otherwise NULL */
-buf_page_t* buf_page_set_file_page_was_freed(const page_id_t page_id)
-{
-	buf_page_t*	bpage;
-	rw_lock_t*	hash_lock;
-
-	bpage = buf_page_hash_get_s_locked(page_id, &hash_lock);
-
-	if (bpage) {
-		BPageMutex*	block_mutex = buf_page_get_mutex(bpage);
-		ut_ad(!buf_pool_watch_is_sentinel(bpage));
-		mutex_enter(block_mutex);
-		rw_lock_s_unlock(hash_lock);
-		/* bpage->file_page_was_freed can already hold
-		when this code is invoked from dict_drop_index_tree() */
-		bpage->file_page_was_freed = TRUE;
-		mutex_exit(block_mutex);
-	}
-
-	return(bpage);
-}
-
-/** Sets file_page_was_freed FALSE if the page is found in the buffer pool.
-This function should be called when we free a file page and want the
-debug version to check that it is not accessed any more unless
-reallocated.
-@param[in]	page_id	page id
-@return control block if found in page hash table, otherwise NULL */
-buf_page_t* buf_page_reset_file_page_was_freed(const page_id_t page_id)
-{
-	buf_page_t*	bpage;
-	rw_lock_t*	hash_lock;
-
-	bpage = buf_page_hash_get_s_locked(page_id, &hash_lock);
-	if (bpage) {
-		BPageMutex*	block_mutex = buf_page_get_mutex(bpage);
-		ut_ad(!buf_pool_watch_is_sentinel(bpage));
-		mutex_enter(block_mutex);
-		rw_lock_s_unlock(hash_lock);
-		bpage->file_page_was_freed = FALSE;
-		mutex_exit(block_mutex);
-	}
-
-	return(bpage);
-}
-#endif /* UNIV_DEBUG */
-
 /** Attempts to discard the uncompressed frame of a compressed page.
 The caller should not be holding any mutexes when this function is called.
 @param[in]	page_id	page id */
@@ -3383,7 +3328,7 @@ got_block:
 
 	rw_lock_s_unlock(hash_lock);
 
-	ut_ad(!bpage->file_page_was_freed);
+	DBUG_ASSERT(bpage->status != FREED);
 
 	buf_page_set_accessed(bpage);
 
@@ -4283,7 +4228,7 @@ evict_from_pool:
 	"btr_search_drop_page_hash_when_freed". */
 	ut_ad(mode == BUF_GET_POSSIBLY_FREED
 	      || mode == BUF_PEEK_IF_IN_POOL
-	      || !fix_block->page.file_page_was_freed);
+	      || fix_block->page.status != FREED);
 
 	/* Check if this is the first access to the page */
 	access_time = buf_page_is_accessed(&fix_block->page);
@@ -4473,10 +4418,6 @@ buf_page_optimistic_get(
 	ut_a(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
-	ut_d(buf_page_mutex_enter(block));
-	ut_ad(!block->page.file_page_was_freed);
-	ut_d(buf_page_mutex_exit(block));
-
 	if (!access_time) {
 		/* In the case of a first access, try to apply linear
 		read-ahead */
@@ -4559,10 +4500,6 @@ buf_page_try_get_func(
 	ut_a(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
-	ut_d(buf_page_mutex_enter(block));
-	ut_d(ut_a(!block->page.file_page_was_freed));
-	ut_d(buf_page_mutex_exit(block));
-
 	buf_block_dbg_add_level(block, SYNC_NO_ORDER_CHECK);
 
 	buf_pool->stat.n_page_gets++;
@@ -4589,10 +4526,9 @@ buf_page_init_low(
 	bpage->real_size = 0;
 	bpage->slot = NULL;
 	bpage->ibuf_exist = false;
+	bpage->status = NORMAL;
 
 	HASH_INVALIDATE(bpage, hash);
-
-	ut_d(bpage->file_page_was_freed = FALSE);
 }
 
 /** Inits a page to the buffer buf_pool.
@@ -4845,7 +4781,7 @@ buf_page_init_for_read(
 
 		bpage->state = BUF_BLOCK_ZIP_PAGE;
 		bpage->id = page_id;
-		bpage->init_on_flush = false;
+		bpage->status = NORMAL;
 
 		ut_d(bpage->in_page_hash = FALSE);
 		ut_d(bpage->in_zip_hash = FALSE);
@@ -4937,7 +4873,7 @@ buf_page_create(
 	if (block
 	    && buf_page_in_file(&block->page)
 	    && !buf_pool_watch_is_sentinel(&block->page)) {
-		ut_d(block->page.file_page_was_freed = FALSE);
+		block->page.status = NORMAL;
 
 		/* Page can be found in buf_pool */
 		mutex_exit(&buf_pool->mutex);
diff --git a/storage/innobase/buf/buf0flu.cc b/storage/innobase/buf/buf0flu.cc
index d74b41b0e8e..8c929c44a94 100644
--- a/storage/innobase/buf/buf0flu.cc
+++ b/storage/innobase/buf/buf0flu.cc
@@ -1086,6 +1086,10 @@ buf_flush_write_block_low(
 
 		byte* page = reinterpret_cast<const buf_block_t*>(bpage)->frame;
 
+		if (bpage->status == FREED) {
+			break;
+		}
+
 		if (full_crc32) {
 			page = buf_page_encrypt(space, bpage, page);
 			frame = page;
@@ -1097,7 +1101,7 @@ buf_flush_write_block_low(
 		break;
 	}
 
-	if (!full_crc32) {
+	if (!full_crc32 && bpage->status != FREED) {
 		frame = buf_page_encrypt(space, bpage, frame);
 	}
 
@@ -1111,13 +1115,17 @@ buf_flush_write_block_low(
 		ut_ad(space->atomic_write_supported);
 	}
 
-	const bool use_doublewrite = !bpage->init_on_flush
+	if (bpage->status == FREED) {
+		/** Zero out the page if the page is freed */
+		memset(frame, 0, bpage->physical_size());
+	}
+
+	const bool use_doublewrite = (bpage->status == NORMAL)
 		&& space->use_doublewrite();
 
 	if (!use_doublewrite) {
 		ulint	type = IORequest::WRITE;
-
-		IORequest	request(type, bpage);
+		IORequest request(type, bpage);
 
 		/* TODO: pass the tablespace to fil_io() */
 		fil_io(request,
@@ -1191,17 +1199,31 @@ bool buf_flush_page(buf_page_t* bpage, buf_flush_t flush_type, bool sync)
 
 	ut_ad(buf_flush_ready_for_flush(bpage, flush_type));
 
-	bool	is_uncompressed;
+	/* Ignore the flushing of temporary tablespace pages while
+	shutting down */
+	if (!srv_undo_sources
+	    && fsp_is_system_temporary(bpage->id.space())) {
+		buf_flush_remove(bpage);
+		return false;
+	}
+
+	/* Ignore the flushing of freed page */
+	if (bpage->status == FREED) {
+		if (!srv_immediate_scrub_data_uncompressed) {
+			buf_flush_remove(bpage);
+			return false;
+		}
+	}
+
+	bool	is_uncompressed = (buf_page_get_state(bpage)
+				   == BUF_BLOCK_FILE_PAGE);
 
-	is_uncompressed = (buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE);
 	ut_ad(is_uncompressed == (block_mutex != &buf_pool->zip_mutex));
 
-	ibool		flush;
 	rw_lock_t*	rw_lock;
 	bool		no_fix_count = bpage->buf_fix_count == 0;
 
 	if (!is_uncompressed) {
-		flush = TRUE;
 		rw_lock = NULL;
 	} else if (!(no_fix_count || flush_type == BUF_FLUSH_LIST)
 		   || (!no_fix_count
@@ -1211,61 +1233,55 @@ bool buf_flush_page(buf_page_t* bpage, buf_flush_t flush_type, bool sync)
 		/* For table residing in temporary tablespace sync is done
 		using IO_FIX and so before scheduling for flush ensure that
 		page is not fixed. */
-		flush = FALSE;
+		return false;
 	} else {
 		rw_lock = &reinterpret_cast<buf_block_t*>(bpage)->lock;
-		if (flush_type != BUF_FLUSH_LIST) {
-			flush = rw_lock_sx_lock_nowait(rw_lock, BUF_IO_WRITE);
-		} else {
-			/* Will SX lock later */
-			flush = TRUE;
+		if (flush_type != BUF_FLUSH_LIST
+		    && !rw_lock_sx_lock_nowait(rw_lock, BUF_IO_WRITE)) {
+			return false;
 		}
 	}
 
-	if (flush) {
+	/* We are committed to flushing by the time we get here */
 
-		/* We are committed to flushing by the time we get here */
+	buf_page_set_io_fix(bpage, BUF_IO_WRITE);
 
-		buf_page_set_io_fix(bpage, BUF_IO_WRITE);
+	buf_page_set_flush_type(bpage, flush_type);
 
-		buf_page_set_flush_type(bpage, flush_type);
-
-		if (buf_pool->n_flush[flush_type] == 0) {
-			os_event_reset(buf_pool->no_flush[flush_type]);
-		}
-
-		++buf_pool->n_flush[flush_type];
-		ut_ad(buf_pool->n_flush[flush_type] != 0);
+	if (buf_pool->n_flush[flush_type] == 0) {
+		os_event_reset(buf_pool->no_flush[flush_type]);
+	}
 
-		mutex_exit(block_mutex);
+	++buf_pool->n_flush[flush_type];
+	ut_ad(buf_pool->n_flush[flush_type] != 0);
 
-		mutex_exit(&buf_pool->mutex);
+	mutex_exit(block_mutex);
 
-		if (flush_type == BUF_FLUSH_LIST
-		    && is_uncompressed
-		    && !rw_lock_sx_lock_nowait(rw_lock, BUF_IO_WRITE)) {
+	mutex_exit(&buf_pool->mutex);
 
-			if (!fsp_is_system_temporary(bpage->id.space())) {
-				/* avoiding deadlock possibility involves
-				doublewrite buffer, should flush it, because
-				it might hold the another block->lock. */
-				buf_dblwr_flush_buffered_writes();
-			} else {
-				buf_dblwr_sync_datafiles();
-			}
+	if (flush_type == BUF_FLUSH_LIST
+	    && is_uncompressed
+	    && !rw_lock_sx_lock_nowait(rw_lock, BUF_IO_WRITE)) {
 
-			rw_lock_sx_lock_gen(rw_lock, BUF_IO_WRITE);
+		if (!fsp_is_system_temporary(bpage->id.space())) {
+			/* avoiding deadlock possibility involves
+			doublewrite buffer, should flush it, because
+			it might hold the another block->lock. */
+			buf_dblwr_flush_buffered_writes();
+		} else {
+			buf_dblwr_sync_datafiles();
 		}
 
-		/* Even though bpage is not protected by any mutex at this
-		point, it is safe to access bpage, because it is io_fixed and
-		oldest_modification != 0.  Thus, it cannot be relocated in the
-		buffer pool or removed from flush_list or LRU_list. */
-
-		buf_flush_write_block_low(bpage, flush_type, sync);
+		rw_lock_sx_lock_gen(rw_lock, BUF_IO_WRITE);
 	}
 
-	return(flush);
+	/* Even though bpage is not protected by any mutex at this
+	point, it is safe to access bpage, because it is io_fixed and
+	oldest_modification != 0.  Thus, it cannot be relocated in the
+	buffer pool or removed from flush_list or LRU_list. */
+
+	buf_flush_write_block_low(bpage, flush_type, sync);
+	return true;
 }
 
 # if defined UNIV_DEBUG || defined UNIV_IBUF_DEBUG
diff --git a/storage/innobase/fil/fil0fil.cc b/storage/innobase/fil/fil0fil.cc
index d9c35afd001..8a679f51b76 100644
--- a/storage/innobase/fil/fil0fil.cc
+++ b/storage/innobase/fil/fil0fil.cc
@@ -4192,8 +4192,8 @@ void fil_aio_callback(os_aio_userdata_t *data)
 	}
 
 	ulint offset = bpage->id.page_no();
-	if (dblwr && bpage->init_on_flush) {
-		bpage->init_on_flush = false;
+	if (dblwr && bpage->status != NORMAL) {
+		bpage->status = NORMAL;
 		dblwr = false;
 	}
 	dberr_t err = buf_page_io_complete(bpage, dblwr);
diff --git a/storage/innobase/fsp/fsp0fsp.cc b/storage/innobase/fsp/fsp0fsp.cc
index 6eefabdfe52..bcf76cc1f84 100644
--- a/storage/innobase/fsp/fsp0fsp.cc
+++ b/storage/innobase/fsp/fsp0fsp.cc
@@ -1262,7 +1262,14 @@ static void fsp_free_page(fil_space_t* space, page_no_t offset, mtr_t* mtr)
 		return;
 	}
 
-	mtr->free(page_id_t(space->id, offset));
+	page_id_t drop_page_id(space->id, offset);
+
+	buf_block_t* block = buf_page_get_gen(
+			drop_page_id, 0, RW_X_LATCH, NULL,
+			BUF_GET_IF_IN_POOL, __FILE__, __LINE__,
+			mtr, NULL);
+
+	mtr->free(drop_page_id, block);
 
 	const ulint	bit = offset % FSP_EXTENT_SIZE;
 
@@ -2642,8 +2649,6 @@ fseg_free_page_func(
 
 	fseg_free_page_low(seg_inode, iblock, space, offset, ahi, mtr);
 
-	ut_d(buf_page_set_file_page_was_freed(page_id_t(space->id, offset)));
-
 	DBUG_VOID_RETURN;
 }
 
@@ -2726,6 +2731,19 @@ fseg_free_extent(
 	}
 #endif /* BTR_CUR_HASH_ADAPT */
 
+	for (ulint i = 0; i < FSP_EXTENT_SIZE; i++) {
+		if (!xdes_is_free(descr, i)) {
+			const page_id_t drop_page_id(
+				space->id, first_page_in_extent + i);
+
+			buf_block_t* block = buf_page_get_gen(
+				drop_page_id, 0, RW_X_LATCH, NULL,
+				BUF_GET_IF_IN_POOL, __FILE__, __LINE__,
+				mtr, NULL);
+			mtr->free(drop_page_id, block);
+		}
+	}
+
 	const uint16_t xoffset= XDES_FLST_NODE + uint16_t(descr - xdes->frame);
 	const uint16_t ioffset= uint16_t(seg_inode - iblock->frame);
 
@@ -2746,14 +2764,6 @@ fseg_free_extent(
 	}
 
 	fsp_free_extent(space, page, mtr);
-
-#ifdef UNIV_DEBUG
-	for (ulint i = 0; i < FSP_EXTENT_SIZE; i++) {
-
-		buf_page_set_file_page_was_freed(
-			page_id_t(space->id, first_page_in_extent + i));
-	}
-#endif /* UNIV_DEBUG */
 }
 
 #ifndef BTR_CUR_HASH_ADAPT
@@ -2830,10 +2840,10 @@ fseg_free_step_func(
 		DBUG_RETURN(true);
 	}
 
+	ulint offset = fseg_get_nth_frag_page_no(inode, n, mtr);
+
 	fseg_free_page_low(
-		inode, iblock, space,
-		fseg_get_nth_frag_page_no(inode, n, mtr),
-		ahi, mtr);
+		inode, iblock, space, offset, ahi, mtr);
 
 	n = fseg_find_last_used_frag_page_slot(inode, mtr);
 
diff --git a/storage/innobase/ibuf/ibuf0ibuf.cc b/storage/innobase/ibuf/ibuf0ibuf.cc
index 94a5af0015c..0fd0c40ddb0 100644
--- a/storage/innobase/ibuf/ibuf0ibuf.cc
+++ b/storage/innobase/ibuf/ibuf0ibuf.cc
@@ -1948,8 +1948,6 @@ ibuf_remove_free_page(void)
 
 	const page_id_t	page_id(IBUF_SPACE_ID, page_no);
 
-	ut_d(buf_page_reset_file_page_was_freed(page_id));
-
 	ibuf_enter(&mtr);
 
 	mutex_enter(&ibuf_mutex);
@@ -1982,8 +1980,6 @@ ibuf_remove_free_page(void)
 	ibuf_bitmap_page_set_bits<IBUF_BITMAP_IBUF>(
 		bitmap_page, page_id, srv_page_size, false, &mtr);
 
-	ut_d(buf_page_set_file_page_was_freed(page_id));
-
 	ibuf_mtr_commit(&mtr);
 }
 
diff --git a/storage/innobase/include/buf0buf.h b/storage/innobase/include/buf0buf.h
index 3432ef12df9..a8968259bfd 100644
--- a/storage/innobase/include/buf0buf.h
+++ b/storage/innobase/include/buf0buf.h
@@ -402,24 +402,6 @@ buf_page_make_young(
 /*================*/
 	buf_page_t*	bpage);	/*!< in: buffer block of a file page */
 
-#ifdef UNIV_DEBUG
-/** Sets file_page_was_freed TRUE if the page is found in the buffer pool.
-This function should be called when we free a file page and want the
-debug version to check that it is not accessed any more unless
-reallocated.
-@param[in]	page_id	page id
-@return control block if found in page hash table, otherwise NULL */
-buf_page_t* buf_page_set_file_page_was_freed(const page_id_t page_id);
-
-/** Sets file_page_was_freed FALSE if the page is found in the buffer pool.
-This function should be called when we free a file page and want the
-debug version to check that it is not accessed any more unless
-reallocated.
-@param[in]	page_id	page id
-@return control block if found in page hash table, otherwise NULL */
-buf_page_t* buf_page_reset_file_page_was_freed(const page_id_t page_id);
-
-#endif /* UNIV_DEBUG */
 /********************************************************************//**
 Reads the freed_page_clock of a buffer block.
 @return freed_page_clock */
@@ -1201,6 +1183,19 @@ for compressed and uncompressed frames */
 /** Number of bits used for buffer page states. */
 #define BUF_PAGE_STATE_BITS	3
 
+enum page_status_t {
+	NORMAL,
+	/** whether the page will be (re)initialized at the time it will
+	be written to the file, that is, whether the doublewrite buffer
+	can be safely skipped. Protected under similar conditions as
+	buf_block_t::frame. Can be set while holding buf_block_t::lock
+	X-latch and reset during page flush, while io_fix is in effect. */
+	INIT_ON_FLUSH,
+	/** FSP frees a page in buffer pool. protected by
+	buf_pool->zip_mutex or buf_block_t::mutex */
+	FREED
+};
+
 class buf_page_t {
 public:
 	/** @name General fields
@@ -1244,12 +1239,7 @@ public:
 					if written again we check is TRIM
 					operation needed. */
 
-	/** whether the page will be (re)initialized at the time it will
-	be written to the file, that is, whether the doublewrite buffer
-	can be safely skipped. Protected under similar conditions as
-	buf_block_t::frame. Can be set while holding buf_block_t::lock
-	X-latch and reset during page flush, while io_fix is in effect. */
-	bool		init_on_flush;
+	page_status_t	status;
 
 	ulint           real_size;	/*!< Real size of the page
 					Normal pages == srv_page_size
@@ -1365,13 +1355,6 @@ public:
 					and bytes allocated for recv_sys.pages,
 					the field is protected by
 					recv_sys_t::mutex. */
-# ifdef UNIV_DEBUG
-	ibool		file_page_was_freed;
-					/*!< this is set to TRUE when
-					fsp frees a page in buffer pool;
-					protected by buf_pool->zip_mutex
-					or buf_block_t::mutex. */
-# endif /* UNIV_DEBUG */
   /** Change buffer entries for the page exist.
   Protected by io_fix==BUF_IO_READ or by buf_block_t::lock. */
   bool ibuf_exist;
diff --git a/storage/innobase/include/mtr0log.h b/storage/innobase/include/mtr0log.h
index 05c92df3e03..fffe776327b 100644
--- a/storage/innobase/include/mtr0log.h
+++ b/storage/innobase/include/mtr0log.h
@@ -510,15 +510,22 @@ inline void mtr_t::init(buf_block_t *b)
 
   m_log.close(log_write<INIT_PAGE>(b->page.id, &b->page));
   m_last_offset= FIL_PAGE_TYPE;
-  b->page.init_on_flush= true;
+  b->page.status = INIT_ON_FLUSH;
 }
 
 /** Free a page.
-@param id      page identifier */
-inline void mtr_t::free(const page_id_t id)
+@param id      page identifier
+@param block   block descriptor or NULL if drop page
+	       doesn't exist in buffer pool */
+inline void mtr_t::free(const page_id_t id, buf_block_t* block)
 {
   if (m_log_mode == MTR_LOG_ALL)
     m_log.close(log_write<FREE_PAGE>(id, nullptr));
+
+  fprintf(stderr, "freeing id %d:%d block %p\n",
+	  id.space(), id.page_no(), block);
+  if (block)
+    block->page.status = FREED;
 }
 
 /** Write an EXTENDED log record.
diff --git a/storage/innobase/include/mtr0mtr.h b/storage/innobase/include/mtr0mtr.h
index 1a270ebb975..245fa974608 100644
--- a/storage/innobase/include/mtr0mtr.h
+++ b/storage/innobase/include/mtr0mtr.h
@@ -488,10 +488,11 @@ struct mtr_t {
   @param[in,out]        b       buffer page */
   void init(buf_block_t *b);
   /** Free a page.
-  @param id      page identifier */
-  inline void free(const page_id_t id);
-  /** Write log for partly initializing a B-tree or R-tree page.
-  @param block    B-tree or R-tree page
+  @param id      page identifier
+  @param block	 buffer block */
+  inline void free(const page_id_t id, buf_block_t *block);
+  /** Partly initialize a B-tree page.
+  @param block    B-tree page
   @param comp     false=ROW_FORMAT=REDUNDANT, true=COMPACT or DYNAMIC */
   inline void page_create(const buf_block_t &block, bool comp);
 
diff --git a/storage/innobase/lock/lock0lock.cc b/storage/innobase/lock/lock0lock.cc
index 525c81af488..979ec132d13 100644
--- a/storage/innobase/lock/lock0lock.cc
+++ b/storage/innobase/lock/lock0lock.cc
@@ -4984,7 +4984,7 @@ loop:
 		goto function_exit;
 	}
 
-	ut_ad(!block->page.file_page_was_freed);
+	DBUG_ASSERT(block->page.status != FREED);
 
 	for (i = 0; i < nth_lock; i++) {
 
diff --git a/storage/innobase/page/page0zip.cc b/storage/innobase/page/page0zip.cc
index fa72090d651..dd54e95b990 100644
--- a/storage/innobase/page/page0zip.cc
+++ b/storage/innobase/page/page0zip.cc
@@ -450,7 +450,6 @@ static void page_zip_compress_write_log(buf_block_t *block,
   if (trailer_size)
     mtr->zmemcpy(block->page, page_zip_get_size(page_zip) - trailer_size,
                  trailer_size);
-  block->page.init_on_flush= true; /* because of mtr_t::init() */
 }
 
 /******************************************************//**