branches/zip: Eliminate many buf_block_align() calls.

Replace page_t* or page_zip_des_t* parameters in some functions with
buf_block_t*.

buf_frame_get_page_zip(): Disable unless #ifdef UNIV_DEBUG || UNIV_ZIP_DEBUG.

btr_cur_t: Add buf_block_t* page_block.

btr_pcur_get_block(), btr_cur_get_block(), btr_cur_get_page_zip():
New functions.

btr_cur_position(): Add the parameter block.

btr/btr0pcur.c

@@ -75,6 +75,7 @@ btr_pcur_store_position(
 	mtr_t*		mtr)	/* in: mtr */
 {
 	page_cur_t*	page_cursor;
+	buf_block_t*	block;
 	rec_t*		rec;
 	dict_index_t*	index;
 	page_t*		page;
@@ -83,6 +84,7 @@ btr_pcur_store_position(
 	ut_a(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 	ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
 
+	block = btr_pcur_get_block(cursor);
 	index = btr_cur_get_index(btr_pcur_get_btr_cur(cursor));
 
 	page_cursor = btr_pcur_get_page_cur(cursor);
@@ -91,8 +93,8 @@ btr_pcur_store_position(
 	page = page_align(rec);
 	offs = page_offset(rec);
 
-	ut_ad(mtr_memo_contains_page(mtr, page, MTR_MEMO_PAGE_S_FIX)
-	      || mtr_memo_contains_page(mtr, page, MTR_MEMO_PAGE_X_FIX));
+	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_S_FIX)
+	      || mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
 	ut_a(cursor->latch_mode != BTR_NO_LATCHES);
 
 	if (UNIV_UNLIKELY(page_get_n_recs(page) == 0)) {
@@ -135,9 +137,8 @@ btr_pcur_store_position(
 		index, rec, &cursor->old_n_fields,
 		&cursor->old_rec_buf, &cursor->buf_size);
 
-	cursor->block_when_stored = buf_block_align(page);
-	cursor->modify_clock = buf_block_get_modify_clock(
-		cursor->block_when_stored);
+	cursor->block_when_stored = block;
+	cursor->modify_clock = buf_block_get_modify_clock(block);
 }
 
 /******************************************************************
@@ -215,9 +216,9 @@ btr_pcur_restore_position(
 		ut_error;
 	}
 
-	if (UNIV_UNLIKELY(
-		    cursor->rel_pos == BTR_PCUR_AFTER_LAST_IN_TREE
-		    || cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE)) {
+	if (UNIV_UNLIKELY
+	    (cursor->rel_pos == BTR_PCUR_AFTER_LAST_IN_TREE
+	     || cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE)) {
 
 		/* In these cases we do not try an optimistic restoration,
 		but always do a search */
@@ -226,8 +227,7 @@ btr_pcur_restore_position(
 			cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE,
 			index, latch_mode, btr_pcur_get_btr_cur(cursor), mtr);
 
-		cursor->block_when_stored
-			= buf_block_align(btr_pcur_get_page(cursor));
+		cursor->block_when_stored = btr_pcur_get_block(cursor);
 
 		return(FALSE);
 	}
@@ -235,7 +235,7 @@ btr_pcur_restore_position(
 	ut_a(cursor->old_rec);
 	ut_a(cursor->old_n_fields);
 
-	page = btr_cur_get_page(btr_pcur_get_btr_cur(cursor));
+	page = btr_pcur_get_page(cursor);
 
 	if (UNIV_LIKELY(latch_mode == BTR_SEARCH_LEAF)
 	    || UNIV_LIKELY(latch_mode == BTR_MODIFY_LEAF)) {
@@ -247,7 +247,7 @@ btr_pcur_restore_position(
 					cursor->modify_clock, mtr))) {
 			cursor->pos_state = BTR_PCUR_IS_POSITIONED;
 #ifdef UNIV_SYNC_DEBUG
-			buf_block_dbg_add_level(buf_block_align(page),
+			buf_block_dbg_add_level(btr_pcur_get_block(cursor),
 						SYNC_TREE_NODE);
 #endif /* UNIV_SYNC_DEBUG */
 			if (cursor->rel_pos == BTR_PCUR_ON) {
@@ -316,8 +316,7 @@ btr_pcur_restore_position(
 		the cursor can now be on a different page! But we can retain
 		the value of old_rec */
 
-		cursor->block_when_stored = buf_block_align(
-			btr_pcur_get_page(cursor));
+		cursor->block_when_stored = btr_pcur_get_block(cursor);
 		cursor->modify_clock = buf_block_get_modify_clock(
 			cursor->block_when_stored);
 		cursor->old_stored = BTR_PCUR_OLD_STORED;
@@ -356,7 +355,7 @@ btr_pcur_release_leaf(
 	ut_a(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 	ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
 
-	block = buf_block_align(btr_cur_get_rec(btr_pcur_get_btr_cur(cursor)));
+	block = btr_pcur_get_block(cursor);
 
 	btr_leaf_page_release(block, cursor->latch_mode, mtr);
 
@@ -391,9 +390,8 @@ btr_pcur_move_to_next_page(
 	cursor->old_stored = BTR_PCUR_OLD_NOT_STORED;
 
 	page = btr_pcur_get_page(cursor);
-
 	next_page_no = btr_page_get_next(page, mtr);
-	space = page_get_space_id(page);
+	space = buf_block_get_space(btr_pcur_get_block(cursor));
 
 	ut_ad(next_page_no != FIL_NULL);
 
@@ -402,12 +400,15 @@ btr_pcur_move_to_next_page(
 	next_page = buf_block_get_frame(next_block);
 #ifdef UNIV_BTR_DEBUG
 	ut_a(page_is_comp(next_page) == page_is_comp(page));
-	ut_a(btr_page_get_prev(next_page, mtr) == page_get_page_no(page));
+	ut_a(btr_page_get_prev(next_page, mtr)
+	     == buf_block_get_page_no(btr_pcur_get_block(cursor)));
 #endif /* UNIV_BTR_DEBUG */
 	next_block->check_index_page_at_flush = TRUE;
 
-	btr_leaf_page_release(buf_block_align(page), cursor->latch_mode, mtr);
+	btr_leaf_page_release(btr_pcur_get_block(cursor),
+			      cursor->latch_mode, mtr);
 
+	btr_pcur_get_btr_cur(cursor)->page_block = next_block;
 	page_cur_set_before_first(next_page, btr_pcur_get_page_cur(cursor));
 
 	page_check_dir(next_page);
@@ -467,18 +468,21 @@ btr_pcur_move_backward_from_page(
 	page = btr_pcur_get_page(cursor);
 
 	prev_page_no = btr_page_get_prev(page, mtr);
-	space = page_get_space_id(page);
+	space = buf_block_get_space(btr_pcur_get_block(cursor));
 
-	if (btr_pcur_is_before_first_on_page(cursor, mtr)
-	    && (prev_page_no != FIL_NULL)) {
+	if (prev_page_no == FIL_NULL) {
+	} else if (btr_pcur_is_before_first_on_page(cursor, mtr)) {
 
 		prev_page = btr_pcur_get_btr_cur(cursor)->left_page;
 
-		btr_leaf_page_release(buf_block_align(page), latch_mode, mtr);
+		btr_leaf_page_release(btr_pcur_get_block(cursor),
+				      latch_mode, mtr);
 
+		btr_pcur_get_btr_cur(cursor)->page_block
+			= buf_block_align(prev_page);
 		page_cur_set_after_last(prev_page,
 					btr_pcur_get_page_cur(cursor));
-	} else if (prev_page_no != FIL_NULL) {
+	} else {
 
 		/* The repositioned cursor did not end on an infimum record on
 		a page. Cursor repositioning acquired a latch also on the

btr/btr0sea.c

@@ -464,7 +464,7 @@ btr_search_info_update_slow(
 	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
-	block = buf_block_align(btr_cur_get_rec(cursor));
+	block = btr_cur_get_block(cursor);
 
 	/* NOTE that the following two function calls do NOT protect
 	info or block->n_fields etc. with any semaphore, to save CPU time!
@@ -789,7 +789,7 @@ btr_search_guess_on_hash(
 	ut_ad(block->state == BUF_BLOCK_FILE_PAGE);
 	ut_ad(page_rec_is_user_rec(rec));
 
-	btr_cur_position(index, rec, cursor);
+	btr_cur_position(index, rec, block, cursor);
 
 	/* Check the validity of the guess within the page */
 

ibuf/ibuf0ibuf.c

@@ -2875,14 +2875,14 @@ void
 ibuf_insert_to_index_page(
 /*======================*/
 	dtuple_t*	entry,	/* in: buffered entry to insert */
-	page_t*		page,	/* in/out: index page where the buffered entry
+	buf_block_t*	block,	/* in/out: index page where the buffered entry
 				should be placed */
-	page_zip_des_t*	page_zip,/* in/out: compressed page, or NULL */
 	dict_index_t*	index,	/* in: record descriptor */
 	mtr_t*		mtr)	/* in: mtr */
 {
 	page_cur_t	page_cur;
 	ulint		low_match;
+	page_t*		page		= buf_block_get_frame(block);
 	rec_t*		rec;
 	page_t*		bitmap_page;
 	ulint		old_bits;
@@ -2931,21 +2931,23 @@ dump:
 
 		btr_cur_del_unmark_for_ibuf(rec, mtr);
 	} else {
-		rec = page_cur_tuple_insert(&page_cur, page_zip,
+		rec = page_cur_tuple_insert(&page_cur,
+					    buf_block_get_page_zip(block),
 					    entry, index, NULL, 0, mtr);
 
 		if (UNIV_UNLIKELY(rec == NULL)) {
 			/* If the record did not fit, reorganize */
 
-			btr_page_reorganize(page, index, mtr);
+			btr_page_reorganize(block, index, mtr);
 
 			page_cur_search(page, index, entry,
 					PAGE_CUR_LE, &page_cur);
 
 			/* This time the record must fit */
 			if (UNIV_UNLIKELY
-			    (!page_cur_tuple_insert(&page_cur, page_zip, entry,
-						    index, NULL, 0, mtr))) {
+			    (!page_cur_tuple_insert(
+				    &page_cur, buf_block_get_page_zip(block),
+				    entry, index, NULL, 0, mtr))) {
 
 				ulint	space;
 				ulint	page_no;
@@ -3345,7 +3347,7 @@ loop:
 			ut_a(volume <= 4 * UNIV_PAGE_SIZE
 			     / IBUF_PAGE_SIZE_PER_FREE_SPACE);
 #endif
-			ibuf_insert_to_index_page(entry, page, page_zip,
+			ibuf_insert_to_index_page(entry, block,
 						  dummy_index, &mtr);
 			ibuf_dummy_index_free(dummy_index);
 		}

include/btr0btr.h

@@ -156,7 +156,7 @@ ulint
 btr_node_ptr_get_child_page_no(
 /*===========================*/
 				/* out: child node address */
-	rec_t*		rec,	/* in: node pointer record */
+	const rec_t*	rec,	/* in: node pointer record */
 	const ulint*	offsets);/* in: array returned by rec_get_offsets() */
 /****************************************************************
 Creates the root node for a new index tree. */
@@ -216,7 +216,7 @@ ibool
 btr_page_reorganize(
 /*================*/
 				/* out: TRUE on success, FALSE on failure */
-	page_t*		page,	/* in: page to be reorganized */
+	buf_block_t*	block,	/* in: page to be reorganized */
 	dict_index_t*	index,	/* in: record descriptor */
 	mtr_t*		mtr);	/* in: mtr */
 /*****************************************************************
@@ -290,7 +290,7 @@ void
 btr_node_ptr_delete(
 /*================*/
 	dict_index_t*	index,	/* in: index tree */
-	page_t*		page,	/* in: page whose node pointer is deleted */
+	buf_block_t*	block,	/* in: page whose node pointer is deleted */
 	mtr_t*		mtr);	/* in: mtr */
 #ifdef UNIV_DEBUG
 /****************************************************************
@@ -357,8 +357,7 @@ btr_parse_page_reorganize(
 	byte*		ptr,	/* in: buffer */
 	byte*		end_ptr,/* in: buffer end */
 	dict_index_t*	index,	/* in: record descriptor */
-	page_t*		page,	/* in/out: page to be reorganized, or NULL */
-	page_zip_des_t*	page_zip,/* in/out: compressed page, or NULL */
+	buf_block_t*	block,	/* in: page to be reorganized, or NULL */
 	mtr_t*		mtr);	/* in: mtr or NULL */
 /******************************************************************
 Gets the number of pages in a B-tree. */

include/btr0btr.ic

@@ -229,17 +229,17 @@ ulint
 btr_node_ptr_get_child_page_no(
 /*===========================*/
 				/* out: child node address */
-	rec_t*		rec,	/* in: node pointer record */
+	const rec_t*	rec,	/* in: node pointer record */
 	const ulint*	offsets)/* in: array returned by rec_get_offsets() */
 {
-	byte*	field;
-	ulint	len;
-	ulint	page_no;
+	const byte*	field;
+	ulint		len;
+	ulint		page_no;
 
 	ut_ad(!rec_offs_comp(offsets) || rec_get_node_ptr_flag(rec));
 
 	/* The child address is in the last field */
-	field = rec_get_nth_field(rec, offsets,
+	field = rec_get_nth_field((rec_t*) rec, offsets,
 				  rec_offs_n_fields(offsets) - 1, &len);
 
 	ut_ad(len == 4);
@@ -251,7 +251,7 @@ btr_node_ptr_get_child_page_no(
 			"InnoDB: a nonsensical page number 0"
 			" in a node ptr record at offset %lu\n",
 			(ulong) page_offset(rec));
-		buf_page_print(page_align(rec), 0);
+		buf_page_print(page_align((rec_t*) rec), 0);
 	}
 
 	return(page_no);

include/btr0cur.h

@@ -36,6 +36,14 @@ btr_cur_get_page_cur(
 				/* out: pointer to page cursor component */
 	btr_cur_t*	cursor);/* in: tree cursor */
 /*************************************************************
+Returns the buffer block on which the tree cursor is positioned. */
+UNIV_INLINE
+buf_block_t*
+btr_cur_get_block(
+/*==============*/
+				/* out: pointer to buffer block */
+	btr_cur_t*	cursor);/* in: tree cursor */
+/*************************************************************
 Returns the record pointer of a tree cursor. */
 UNIV_INLINE
 rec_t*
@@ -44,6 +52,15 @@ btr_cur_get_rec(
 				/* out: pointer to record */
 	btr_cur_t*	cursor);/* in: tree cursor */
 /*************************************************************
+Returns the compressed page on which the tree cursor is positioned. */
+UNIV_INLINE
+page_zip_des_t*
+btr_cur_get_page_zip(
+/*=================*/
+				/* out: pointer to compressed page,
+				or NULL if the page is not compressed */
+	btr_cur_t*	cursor);/* in: tree cursor */
+/*************************************************************
 Invalidates a tree cursor by setting record pointer to NULL. */
 UNIV_INLINE
 void
@@ -74,6 +91,7 @@ btr_cur_position(
 /*=============*/
 	dict_index_t*	index,	/* in: index */
 	rec_t*		rec,	/* in: record in tree */
+	buf_block_t*	block,	/* in: buffer block of rec */
 	btr_cur_t*	cursor);/* in: cursor */
 /************************************************************************
 Searches an index tree and positions a tree cursor on a given level.
@@ -577,6 +595,9 @@ to know struct size! */
 struct btr_cur_struct {
 	dict_index_t*	index;		/* index where positioned */
 	page_cur_t	page_cur;	/* page cursor */
+	buf_block_t*	page_block;	/* buffer pool block were
+					cursor is positioned; needed
+					to avoid buf_block_align() */
 	page_t*		left_page;	/* this field is used to store
 					a pointer to the left neighbor
 					page, in the cases

include/btr0cur.ic

@@ -19,6 +19,18 @@ btr_cur_get_page_cur(
 {
 	return(&(cursor->page_cur));
 }
+/*************************************************************
+Returns the buffer block on which the tree cursor is positioned. */
+UNIV_INLINE
+buf_block_t*
+btr_cur_get_block(
+/*==============*/
+				/* out: pointer to buffer block */
+	btr_cur_t*	cursor)	/* in: tree cursor */
+{
+	ut_ad(page_align(cursor->page_cur.rec) == cursor->page_block->frame);
+	return(cursor->page_block);
+}
 
 /*************************************************************
 Returns the record pointer of a tree cursor. */
@@ -29,9 +41,23 @@ btr_cur_get_rec(
 				/* out: pointer to record */
 	btr_cur_t*	cursor)	/* in: tree cursor */
 {
+	ut_ad(page_align(cursor->page_cur.rec) == cursor->page_block->frame);
 	return(page_cur_get_rec(&(cursor->page_cur)));
 }
 
+/*************************************************************
+Returns the compressed page on which the tree cursor is positioned. */
+UNIV_INLINE
+page_zip_des_t*
+btr_cur_get_page_zip(
+/*=================*/
+				/* out: pointer to compressed page,
+				or NULL if the page is not compressed */
+	btr_cur_t*	cursor)	/* in: tree cursor */
+{
+	return(buf_block_get_page_zip(btr_cur_get_block(cursor)));
+}
+
 /*************************************************************
 Invalidates a tree cursor by setting record pointer to NULL. */
 UNIV_INLINE
@@ -41,6 +67,7 @@ btr_cur_invalidate(
 	btr_cur_t*	cursor)	/* in: tree cursor */
 {
 	page_cur_invalidate(&(cursor->page_cur));
+	cursor->page_block = NULL;
 }
 
 /*************************************************************
@@ -75,9 +102,13 @@ btr_cur_position(
 /*=============*/
 	dict_index_t*	index,	/* in: index */
 	rec_t*		rec,	/* in: record in tree */
-	btr_cur_t*	cursor)	/* in: cursor */
+	buf_block_t*	block,	/* in: buffer block of rec */
+	btr_cur_t*	cursor)	/* out: cursor */
 {
+	ut_ad(page_align(rec) == buf_block_get_frame(block));
+
 	page_cur_position(rec, btr_cur_get_page_cur(cursor));
+	cursor->page_block = block;
 
 	cursor->index = index;
 }

include/btr0pcur.h

@@ -371,6 +371,14 @@ btr_pcur_get_page(
 				/* out: pointer to the page */
 	btr_pcur_t*	cursor);/* in: persistent cursor */
 /*************************************************************
+Returns the buffer block of a persistent cursor. */
+UNIV_INLINE
+buf_block_t*
+btr_pcur_get_block(
+/*===============*/
+				/* out: pointer to the block */
+	btr_pcur_t*	cursor);/* in: persistent cursor */
+/*************************************************************
 Returns the record of a persistent cursor. */
 UNIV_INLINE
 rec_t*

include/btr0pcur.ic

@@ -88,7 +88,21 @@ btr_pcur_get_page(
 {
 	ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 
-	return(page_cur_get_page(btr_pcur_get_page_cur(cursor)));
+	return(btr_cur_get_page(btr_pcur_get_btr_cur(cursor)));
+}
+
+/*************************************************************
+Returns the buffer block of a persistent cursor. */
+UNIV_INLINE
+buf_block_t*
+btr_pcur_get_block(
+/*===============*/
+				/* out: pointer to the block */
+	btr_pcur_t*	cursor)	/* in: persistent cursor */
+{
+	ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
+
+	return(btr_cur_get_block(btr_pcur_get_btr_cur(cursor)));
 }
 
 /*************************************************************
@@ -103,7 +117,7 @@ btr_pcur_get_rec(
 	ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 	ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
 
-	return(page_cur_get_rec(btr_pcur_get_page_cur(cursor)));
+	return(btr_cur_get_rec(btr_pcur_get_btr_cur(cursor)));
 }
 
 /******************************************************************
@@ -296,7 +310,7 @@ btr_pcur_move_to_last_on_page(
 	UT_NOT_USED(mtr);
 	ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
 
-	page_cur_set_after_last(page_align(btr_pcur_get_rec(cursor)),
+	page_cur_set_after_last(btr_pcur_get_page(cursor),
 				btr_pcur_get_page_cur(cursor));
 
 	cursor->old_stored = BTR_PCUR_OLD_NOT_STORED;
@@ -619,6 +633,7 @@ btr_pcur_close(
 		cursor->old_rec_buf = NULL;
 	}
 
+	cursor->btr_cur.page_block = NULL;
 	cursor->btr_cur.page_cur.rec = NULL;
 	cursor->old_rec = NULL;
 	cursor->old_stored = BTR_PCUR_OLD_NOT_STORED;

include/buf0buf.h

@@ -132,9 +132,9 @@ UNIV_INLINE
 byte*
 buf_frame_copy(
 /*===========*/
-				/* out: buf */
-	byte*		buf,	/* in: buffer to copy to */
-	buf_frame_t*	frame);	/* in: buffer frame */
+					/* out: buf */
+	byte*			buf,	/* in: buffer to copy to */
+	const buf_frame_t*	frame);	/* in: buffer frame */
 /******************************************************************
 NOTE! The following macros should be used instead of buf_page_get_gen,
 to improve debugging. Only values RW_S_LATCH and RW_X_LATCH are allowed
@@ -618,6 +618,7 @@ buf_block_align(
 /*============*/
 			/* out: pointer to block */
 	byte*	ptr);	/* in: pointer to a frame */
+#if defined UNIV_DEBUG || defined UNIV_ZIP_DEBUG
 /*************************************************************************
 Gets the compressed page descriptor corresponding to an uncompressed page
 if applicable. */
@@ -628,6 +629,7 @@ buf_frame_get_page_zip(
 			/* out: compressed page descriptor, or NULL */
 	byte*	ptr)	/* in: pointer to the page */
 	__attribute((const));
+#endif /* UNIV_DEBUG || UNIV_ZIP_DEBUG */
 /************************************************************************
 This function is used to get info if there is an io operation
 going on on a buffer page. */

include/buf0buf.ic

@@ -261,6 +261,7 @@ buf_block_align(
 	return(block);
 }
 
+#if defined UNIV_DEBUG || defined UNIV_ZIP_DEBUG
 /*************************************************************************
 Gets the compressed page descriptor corresponding to an uncompressed page
 if applicable. */
@@ -273,6 +274,7 @@ buf_frame_get_page_zip(
 {
 	return(buf_block_get_page_zip(buf_block_align(ptr)));
 }
+#endif /* UNIV_DEBUG || UNIV_ZIP_DEBUG */
 
 /**************************************************************************
 Gets the space id, page offset, and byte offset within page of a
@@ -286,7 +288,7 @@ buf_ptr_get_fsp_addr(
 	fil_addr_t*	addr)	/* out: page offset and byte offset */
 {
 	const page_t*	page = ut_align_down((void*) ptr, UNIV_PAGE_SIZE);
-	ut_ad(buf_block_align(ptr));
+	ut_ad(buf_block_align((byte*) ptr));
 
 	*space = mach_read_from_4(page + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID);
 	addr->page = mach_read_from_4(page + FIL_PAGE_OFFSET);
@@ -361,9 +363,9 @@ UNIV_INLINE
 byte*
 buf_frame_copy(
 /*===========*/
-				/* out: buf */
-	byte*		buf,	/* in: buffer to copy to */
-	buf_frame_t*	frame)	/* in: buffer frame */
+					/* out: buf */
+	byte*			buf,	/* in: buffer to copy to */
+	const buf_frame_t*	frame)	/* in: buffer frame */
 {
 	ut_ad(buf && frame);
 

include/lock0lock.h

@@ -10,6 +10,7 @@ Created 5/7/1996 Heikki Tuuri
 #define lock0lock_h
 
 #include "univ.i"
+#include "buf0types.h"
 #include "trx0types.h"
 #include "rem0types.h"
 #include "dict0types.h"
@@ -250,6 +251,7 @@ lock_rec_insert_check_and_lock(
 	ulint		flags,	/* in: if BTR_NO_LOCKING_FLAG bit is set,
 				does nothing */
 	rec_t*		rec,	/* in: record after which to insert */
+	buf_block_t*	block,	/* in: buffer block of rec */
 	dict_index_t*	index,	/* in: index */
 	que_thr_t*	thr,	/* in: query thread */
 	ibool*		inherit);/* out: set to TRUE if the new inserted
@@ -289,6 +291,7 @@ lock_sec_rec_modify_check_and_lock(
 				NOTE: as this is a secondary index, we
 				always have to modify the clustered index
 				record first: see the comment below */
+	buf_block_t*	block,	/* in: buffer block of rec */
 	dict_index_t*	index,	/* in: secondary index */
 	que_thr_t*	thr);	/* in: query thread */
 /*************************************************************************

include/page0page.h

@@ -698,12 +698,11 @@ page_copy_rec_list_end(
 					on new_page, or NULL on zip overflow
 					(new_page will be decompressed
 					from new_page_zip) */
-	page_t*		new_page,	/* in/out: index page to copy to */
-	page_zip_des_t*	new_page_zip,	/* in/out: compressed page, or NULL */
+	buf_block_t*	new_block,	/* in/out: index page to copy to */
 	rec_t*		rec,		/* in: record on page */
 	dict_index_t*	index,		/* in: record descriptor */
 	mtr_t*		mtr)		/* in: mtr */
-	__attribute__((warn_unused_result, nonnull(1, 3, 4, 5)));
+	__attribute__((warn_unused_result, nonnull));
 /*****************************************************************
 Copies records from page to new_page, up to the given record, NOT
 including that record. Infimum and supremum records are not copied.
@@ -717,12 +716,11 @@ page_copy_rec_list_start(
 					on new_page, or NULL on zip overflow
 					(new_page will be decompressed
 					from new_page_zip) */
-	page_t*		new_page,	/* in/out: index page to copy to */
-	page_zip_des_t*	new_page_zip,	/* in/out: compressed page, or NULL */
+	buf_block_t*	new_block,	/* in/out: index page to copy to */
 	rec_t*		rec,		/* in: record on page */
 	dict_index_t*	index,		/* in: record descriptor */
 	mtr_t*		mtr)		/* in: mtr */
-	__attribute__((warn_unused_result, nonnull(1, 3, 4, 5)));
+	__attribute__((warn_unused_result, nonnull));
 /*****************************************************************
 Deletes records from a page from a given record onward, including that record.
 The infimum and supremum records are not deleted. */
@@ -762,15 +760,13 @@ page_move_rec_list_end(
 					/* out: TRUE on success; FALSE on
 					compression failure (new_page will
 					be decompressed from new_page_zip) */
-	page_t*		new_page,	/* in: index page where to move */
-	page_zip_des_t*	new_page_zip,	/* in/out: compressed page of
-					new_page, or NULL */
+	buf_block_t*	new_block,	/* in/out: index page where to move */
 	rec_t*		split_rec,	/* in: first record to move */
 	page_zip_des_t*	page_zip,	/* in/out: compressed page of
 					split_rec, or NULL */
 	dict_index_t*	index,		/* in: record descriptor */
 	mtr_t*		mtr)		/* in: mtr */
-	__attribute__((nonnull(1, 3, 5, 6)));
+	__attribute__((nonnull(1, 2, 4, 5)));
 /*****************************************************************
 Moves record list start to another page. Moved records do not include
 split_rec. */
@@ -780,15 +776,13 @@ page_move_rec_list_start(
 /*=====================*/
 					/* out: TRUE on success; FALSE on
 					compression failure */
-	page_t*		new_page,	/* in: index page where to move */
-	page_zip_des_t*	new_page_zip,	/* in/out: compressed page of
-					new_page, or NULL */
+	buf_block_t*	new_block,	/* in/out: index page where to move */
 	rec_t*		split_rec,	/* in: first record not to move */
 	page_zip_des_t*	page_zip,	/* in/out: compressed page of
 					split_rec, or NULL */
 	dict_index_t*	index,		/* in: record descriptor */
 	mtr_t*		mtr)		/* in: mtr */
-	__attribute__((nonnull(1, 3, 5, 6)));
+	__attribute__((nonnull(1, 2, 4, 5)));
 /********************************************************************
 Splits a directory slot which owns too many records. */
 

include/page0zip.h

@@ -16,6 +16,7 @@ Created June 2005 by Marko Makela
 
 #include "mtr0types.h"
 #include "page0types.h"
+#include "buf0types.h"
 #include "dict0types.h"
 #include "ut0byte.h"
 
@@ -335,9 +336,9 @@ page_zip_reorganize(
 				/* out: TRUE on success, FALSE on failure;
 				page and page_zip will be left intact
 				on failure. */
-	page_zip_des_t*	page_zip,/* in: size; out: data, n_blobs,
-				m_start, m_end */
-	page_t*		page,	/* in/out: uncompressed page */
+	buf_block_t*	block,	/* in/out: page with compressed page;
+				on the compressed page, in: size;
+				out: data, n_blobs, m_start, m_end */
 	dict_index_t*	index,	/* in: index of the B-tree node */
 	mtr_t*		mtr)	/* in: mini-transaction */
 	__attribute__((warn_unused_result, nonnull));

lock/lock0lock.c

@@ -4926,6 +4926,7 @@ lock_rec_insert_check_and_lock(
 	ulint		flags,	/* in: if BTR_NO_LOCKING_FLAG bit is set,
 				does nothing */
 	rec_t*		rec,	/* in: record after which to insert */
+	buf_block_t*	block,	/* in: buffer block of rec */
 	dict_index_t*	index,	/* in: index */
 	que_thr_t*	thr,	/* in: query thread */
 	ibool*		inherit)/* out: set to TRUE if the new inserted
@@ -4968,7 +4969,7 @@ lock_rec_insert_check_and_lock(
 		if (!dict_index_is_clust(index)) {
 			/* Update the page max trx id field */
 			page_update_max_trx_id(page_align(rec),
-					       buf_frame_get_page_zip(rec),
+					       buf_block_get_page_zip(block),
 					       thr_get_trx(thr)->id);
 		}
 
@@ -5006,7 +5007,7 @@ lock_rec_insert_check_and_lock(
 	if ((err == DB_SUCCESS) && !dict_index_is_clust(index)) {
 		/* Update the page max trx id field */
 		page_update_max_trx_id(page_align(rec),
-				       buf_frame_get_page_zip(rec),
+				       buf_block_get_page_zip(block),
 				       thr_get_trx(thr)->id);
 	}
 
@@ -5142,6 +5143,7 @@ lock_sec_rec_modify_check_and_lock(
 				NOTE: as this is a secondary index, we
 				always have to modify the clustered index
 				record first: see the comment below */
+	buf_block_t*	block,	/* in: buffer block of rec */
 	dict_index_t*	index,	/* in: secondary index */
 	que_thr_t*	thr)	/* in: query thread */
 {
@@ -5186,7 +5188,7 @@ lock_sec_rec_modify_check_and_lock(
 	if (err == DB_SUCCESS) {
 		/* Update the page max trx id field */
 		page_update_max_trx_id(page_align(rec),
-				       buf_frame_get_page_zip(rec),
+				       buf_block_get_page_zip(block),
 				       thr_get_trx(thr)->id);
 	}
 

log/log0recv.c

@@ -881,7 +881,7 @@ recv_parse_or_apply_log_rec_body(
 			     || (ibool)!!page_is_comp(page)
 			     == dict_table_is_comp(index->table));
 			ptr = btr_parse_page_reorganize(ptr, end_ptr, index,
-							page, page_zip, mtr);
+							block, mtr);
 		}
 		break;
 	case MLOG_PAGE_CREATE: case MLOG_COMP_PAGE_CREATE:

page/page0cur.c

@@ -1130,11 +1130,14 @@ use_heap:
 		    (!page_zip_compress(page_zip_orig, page, index, mtr))) {
 			/* Before trying to reorganize the page,
 			store the number of preceding records on the page. */
-			ulint	insert_pos
+			ulint		insert_pos
 				= page_rec_get_n_recs_before(insert_rec);
+			buf_block_t*	block
+				= buf_block_align(page);
 
-			if (page_zip_reorganize(page_zip_orig, page,
-						index, mtr)) {
+			ut_ad(buf_block_get_page_zip(block) == page_zip_orig);
+
+			if (page_zip_reorganize(block, index, mtr)) {
 				/* The page was reorganized:
 				Seek to insert_pos to find insert_rec. */
 				insert_rec = page + PAGE_NEW_INFIMUM;

page/page0page.c

@@ -579,15 +579,17 @@ page_copy_rec_list_end(
 					on new_page, or NULL on zip overflow
 					(new_page will be decompressed
 					from new_page_zip) */
-	page_t*		new_page,	/* in/out: index page to copy to */
-	page_zip_des_t*	new_page_zip,	/* in/out: compressed page, or NULL */
+	buf_block_t*	new_block,	/* in/out: index page to copy to */
 	rec_t*		rec,		/* in: record on page */
 	dict_index_t*	index,		/* in: record descriptor */
 	mtr_t*		mtr)		/* in: mtr */
 {
-	page_t*	page	= page_align(rec);
-	rec_t*	ret	= page_rec_get_next(page_get_infimum_rec(new_page));
-	ulint	log_mode= 0; /* remove warning */
+	page_t*		new_page	= buf_block_get_frame(new_block);
+	page_zip_des_t*	new_page_zip	= buf_block_get_page_zip(new_block);
+	page_t*		page		= page_align(rec);
+	rec_t*		ret		= page_rec_get_next(
+		page_get_infimum_rec(new_page));
+	ulint		log_mode	= 0; /* remove warning */
 
 	/* page_zip_validate() will fail here if btr_compress()
 	sets FIL_PAGE_PREV to FIL_NULL */
@@ -616,8 +618,7 @@ page_copy_rec_list_end(
 				= page_rec_get_n_recs_before(ret);
 
 			if (UNIV_UNLIKELY
-			    (!page_zip_reorganize(new_page_zip, new_page,
-						  index, mtr))) {
+			    (!page_zip_reorganize(new_block, index, mtr))) {
 
 				if (UNIV_UNLIKELY
 				    (!page_zip_decompress(new_page_zip,
@@ -663,12 +664,13 @@ page_copy_rec_list_start(
 					on new_page, or NULL on zip overflow
 					(new_page will be decompressed
 					from new_page_zip) */
-	page_t*		new_page,	/* in/out: index page to copy to */
-	page_zip_des_t*	new_page_zip,	/* in/out: compressed page, or NULL */
+	buf_block_t*	new_block,	/* in/out: index page to copy to */
 	rec_t*		rec,		/* in: record on page */
 	dict_index_t*	index,		/* in: record descriptor */
 	mtr_t*		mtr)		/* in: mtr */
 {
+	page_t*		new_page	= buf_block_get_frame(new_block);
+	page_zip_des_t*	new_page_zip	= buf_block_get_page_zip(new_block);
 	page_cur_t	cur1;
 	page_cur_t	cur2;
 	page_t*		page;
@@ -726,8 +728,7 @@ page_copy_rec_list_start(
 				= page_rec_get_n_recs_before(ret);
 
 			if (UNIV_UNLIKELY
-			    (!page_zip_reorganize(new_page_zip, new_page,
-						  index, mtr))) {
+			    (!page_zip_reorganize(new_block, index, mtr))) {
 
 				if (UNIV_UNLIKELY
 				    (!page_zip_decompress(new_page_zip,
@@ -1090,19 +1091,21 @@ page_move_rec_list_end(
 					/* out: TRUE on success; FALSE on
 					compression failure (new_page will
 					be decompressed from new_page_zip) */
-	page_t*		new_page,	/* in: index page where to move */
-	page_zip_des_t*	new_page_zip,	/* in/out: compressed page of
-					new_page, or NULL */
+	buf_block_t*	new_block,	/* in/out: index page where to move */
 	rec_t*		split_rec,	/* in: first record to move */
 	page_zip_des_t*	page_zip,	/* in/out: compressed page of
 					split_rec, or NULL */
 	dict_index_t*	index,		/* in: record descriptor */
 	mtr_t*		mtr)		/* in: mtr */
 {
-	ulint	old_data_size;
-	ulint	new_data_size;
-	ulint	old_n_recs;
-	ulint	new_n_recs;
+	page_t*		new_page	= buf_block_get_frame(new_block);
+#ifdef UNIV_ZIP_DEBUG
+	page_zip_des_t*	new_page_zip	= buf_block_get_page_zip(new_block);
+#endif /* UNIV_ZIP_DEBUG */
+	ulint		old_data_size;
+	ulint		new_data_size;
+	ulint		old_n_recs;
+	ulint		new_n_recs;
 
 	old_data_size = page_get_data_size(new_page);
 	old_n_recs = page_get_n_recs(new_page);
@@ -1111,8 +1114,8 @@ page_move_rec_list_end(
 	ut_a(!page_zip || page_zip_validate(page_zip, page_align(split_rec)));
 #endif /* UNIV_ZIP_DEBUG */
 
-	if (UNIV_UNLIKELY(!page_copy_rec_list_end(new_page, new_page_zip,
-						  split_rec, index, mtr))) {
+	if (UNIV_UNLIKELY(!page_copy_rec_list_end(new_block, split_rec,
+						  index, mtr))) {
 		return(FALSE);
 	}
 
@@ -1138,17 +1141,15 @@ page_move_rec_list_start(
 /*=====================*/
 					/* out: TRUE on success; FALSE on
 					compression failure */
-	page_t*		new_page,	/* in: index page where to move */
-	page_zip_des_t*	new_page_zip,	/* in/out: compressed page of
-					new_page, or NULL */
+	buf_block_t*	new_block,	/* in/out: index page where to move */
 	rec_t*		split_rec,	/* in: first record not to move */
 	page_zip_des_t*	page_zip,	/* in/out: compressed page of
 					split_rec, or NULL */
 	dict_index_t*	index,		/* in: record descriptor */
 	mtr_t*		mtr)		/* in: mtr */
 {
-	if (UNIV_UNLIKELY(!page_copy_rec_list_start(new_page, new_page_zip,
-						    split_rec, index, mtr))) {
+	if (UNIV_UNLIKELY(!page_copy_rec_list_start(new_block, split_rec,
+						    index, mtr))) {
 		return(FALSE);
 	}
 

page/page0zip.c

@@ -3504,13 +3504,14 @@ page_zip_reorganize(
 				/* out: TRUE on success, FALSE on failure;
 				page and page_zip will be left intact
 				on failure. */
-	page_zip_des_t*	page_zip,/* in: size; out: data, n_blobs,
-				m_start, m_end */
-	page_t*		page,	/* in/out: uncompressed page */
+	buf_block_t*	block,	/* in/out: page with compressed page;
+				on the compressed page, in: size;
+				out: data, n_blobs, m_start, m_end */
 	dict_index_t*	index,	/* in: index of the B-tree node */
 	mtr_t*		mtr)	/* in: mini-transaction */
 {
-	buf_block_t*	block;
+	page_zip_des_t*	page_zip	= buf_block_get_page_zip(block);
+	page_t*		page		= buf_block_get_frame(block);
 	buf_block_t*	temp_block;
 	page_t*		temp_page;
 	ulint		log_mode;
@@ -3531,7 +3532,6 @@ page_zip_reorganize(
 	/* Recreate the page: note that global data on page (possible
 	segment headers, next page-field, etc.) is preserved intact */
 
-	block = buf_block_align(page);
 	page_create(block, mtr, dict_table_is_comp(index->table));
 	block->check_index_page_at_flush = TRUE;
 

row/row0ins.c

@@ -2084,7 +2084,8 @@ row_ins_index_entry_low(
 		if (modify == ROW_INS_NEXT) {
 			rec = page_rec_get_next(btr_cur_get_rec(&cursor));
 
-			btr_cur_position(index, rec, &cursor);
+			btr_cur_position(index, rec,
+					 btr_cur_get_block(&cursor),&cursor);
 		}
 
 		if (dict_index_is_clust(index)) {

row/row0sel.c

@@ -3793,7 +3793,9 @@ wrong_offs:
 				" buf block fix count %lu\n",
 				(void*) rec, (void*) buf_pool->frame_zero,
 				(void*) buf_pool->high_end,
-				(ulong)buf_block_align(rec)->buf_fix_count);
+				(ulong)
+				btr_cur_get_block(btr_pcur_get_btr_cur(pcur))
+				->buf_fix_count);
 			fprintf(stderr,
 				"InnoDB: Index corruption: rec offs %lu"
 				" next offs %lu, page no %lu,\n"

row/row0upd.c

@@ -1470,7 +1470,7 @@ row_upd_clust_rec_by_insert(
 		index = dict_table_get_first_index(table);
 
 		btr_cur_mark_extern_inherited_fields(
-			buf_frame_get_page_zip(rec),
+			btr_cur_get_page_zip(btr_cur),
 			rec, index,
 			rec_get_offsets(rec, index, offsets_,
 					ULINT_UNDEFINED, &heap),