Merge lp:~sergei.glushchenko/percona-xtrabackup/xb-tools into lp:percona-xtrabackup/2.1

[Stewart Smith]

Log and printers are build inside XtraBackup tree. Following are how it been done:
innodb51-utils.patch - patch needed for utils to work inside XtraBackup
innodb51-utils-init.patch - patch needed for utils to work standalone (in addition to innodb-utils.patch)
api0internal.h - some innodb internals exposed
api0log.c - log printer code
api0page.c - page printer code
innodb_init.c - innodb initialization code needed for standalone utils
percona-pprint.cc - standalone page printer main function
percona-redo.cc - standalone log printer main function

to build standalone tools utils/build.sh utils
utils are also linked to xtrabackup_plugin

[Alexey Kopytov (akopytov)]

Sergei,

I didn't review the actual code, just want to comment on a number of basic things that caught my eye:

   - large blocks of empty lines, i.e. after ib_page_page_print_list()
     declaration (and what does that "SOME IBUF STUFF" comment mean?),
     and after ib_page_ibuf_rec_get_size()
   - lots of lines breaking the 80 chars limit
   - I see absolutely no reasons to use C++ and Boost in percona-redo.cc
     and percona-pprint.cc. Option parsing is available in my_getopt.c,
     which is already used in xtrabackup.c and xbstream.c. And
     pprint/reado are very small utilities.
   - large block of "#if 0"ed code in percona-redo.cc. If it's a
     debug-only code, create appropriately named #defines and some way
     to compile a debug binary. If that code is not supposed to be used
     by anyone, remove it.
   - some commented out code in percona-pprint.c. Same comments as in
     the previous item.
   - what are those "BEGIN LICENSE" / "END LICENSE" for?
   - can innodb_init_param() be moved to innodb_int.[ch] so we don't
     create separate files for it, which are also confusingly similar to
     innodb_int*?

review: Needs Fixing

[Alexey Kopytov (akopytov)]

In addition to the above, I think api0internal.h has to be merged with
innodb_int.h, since the latter has the same purpose.

And api0log.c and api0print.c should have better name, I don't see a
point in following the InnoDB file naming conventions. Especially
because no one except Heikki knows the reason to name files like
xxx0yyy.c :)

review: Needs Fixing

[Laurynas Biveinis (laurynas-biveinis)]

Alexey -

I guess we want to minimize differences between the HailDB and XB versions of the utilities, and IMHO api0internal.h makes more sense in the former where there is no innodb_int.h. I agree we could name files better for XB, but for the HailDB modifications it makes sense to stick with foo0bar naming convention. But this is not a very strong opinion.

[Alexey Kopytov (akopytov)]

Laurynas,

On 07/05/2012 09:26 AM, Laurynas Biveinis wrote:
> I guess we want to minimize differences between the HailDB and XB versions of the utilities, and IMHO api0internal.h makes more sense in the former where there is no innodb_int.h. I agree we could name files better for XB, but for the HailDB modifications it makes sense to stick with foo0bar naming convention. But this is not a very strong opinion.
>

I remember we were discussing this, but I'm not sure about our current
plans about the HailDB version of the utilities. Do we have anything
specific set?

[Sergei Glushchenko (sergei.glushchenko)]

Following been done:

Formatted to meet 80 chars limitation.
C++ parts rewritten in C.
Some code cleanup, removed commented and #if 0'ed parts.
innodb_init_param moved to innodb_int.c
api0* files were renamed to api_*
api0internal.h was merged with innodb_int.h

I consider that it is ready for the next iteration.

[Laurynas Biveinis (laurynas-biveinis)]

This is a partial review only, I will continue later.

    Please create and link a blueprint for this work.

    Is it possible to merge the tools InnoDB patch with some existing
    patch? I guess for that some more effort would be required: to
    uncomment but conditionally skip the commented
    innobase_rec_to_mysql(), trx_i_s_cache_init() etc. calls. I don't
    know if this additional effort is justifiable or not.

    Instead of open_or_create_log_file_ex() perhaps better to have
    just open_log_file() that always sets the proposed log file from
    the actual file size? In general I don't like the _ex naming
    convention, because as time passes it is never apparent what is
    meant by it.

    What is the purpose of rec_get_offsets_old()? Its implementation
    does not have a header comment, and the one next to its
    declaration does not tell why "new" function is not good enough.

    Why there are separate rules for the utility functions in XB? I
    think we should just link them in the relevant xb configurations
    by default. If they are needed then the Makefile diff at lines
    591--599 contains $(CFLAGS), $(CXXFLAGS), $(CCFLAGS). I think
    only the first is correct, and then the rules can be merged.

    Makefile "utils" target should be marked as phony and IMHO it
    should be included in the default build.

    Can the INNODBOBJS definition for utils be reused from some other
    target instead of copy-paste?

    Line 677: please define MLOG_LSN conditionally with #ifndef
    MLOG_LSN

    The ib_log_rec_*, ib_log_sys_* structs and functions need
    comments. This was my work, please ping me on IRC and we will
    coordinate.

    The #if 0 blocks in fill_parse_buffer should go away. Likewise in
    ib_log_sys_g et_next_rec().

    The untested log record types still need testing. That's a non
    trivial task, need coordination with QA.

review: Needs Fixing

[Stewart Smith (stewart)]

Alexey Kopytov <email address hidden> writes:
> I remember we were discussing this, but I'm not sure about our current
> plans about the HailDB version of the utilities. Do we have anything
> specific set?

No, nothing solid. Although api0internal.h is more innodb-like naming.

--
Stewart Smith

[Laurynas Biveinis (laurynas-biveinis)]

Couple more comments:

The page printer utility starts & commits MTRs, for example i ib_page_load_table_for_id(). How does that work since we are not allowed to write to the log in the utility?

How do you plan automating testing this, both as standalone utility and GDB entry points in the XB binary?

review: Needs Fixing

[Sergei Glushchenko (sergei.glushchenko)]

Laurynas,

>
> Please create and link a blueprint for this work.
>

https://blueprints.launchpad.net/percona-xtrabackup/+spec/log-and-page-printers-for-xtrabackup
Please look at the BP above and tells whether it good or must be rewritten.

> Is it possible to merge the tools InnoDB patch with some existing
> patch? I guess for that some more effort would be required: to
> uncomment but conditionally skip the commented
> innobase_rec_to_mysql(), trx_i_s_cache_init() etc. calls. I don't
> know if this additional effort is justifiable or not.
>

Yep, there is nothing hard in merging utils patch with innodb51.patch.
innobase_rec_to_mysql(), trx_i_s_cache_init() etc. calls should be commented
for both xtrabackup and utils so there is no problem.
Patches been merged.

> Instead of open_or_create_log_file_ex() perhaps better to have
> just open_log_file() that always sets the proposed log file from
> the actual file size? In general I don't like the _ex naming
> convention, because as time passes it is never apparent what is
> meant by it.
>
Yep. I tend to agree with you.

> What is the purpose of rec_get_offsets_old()? Its implementation
> does not have a header comment, and the one next to its
> declaration does not tell why "new" function is not good enough.
>

In case when we deal with redundant page format we don't need to have
dict_index_t* for this page. However rec_get_offsets_new always require
this, so I made separate function rec_get_offsets_old. Another way is
to replace
ut_ad(index);
with something like
ut_ad(!page_is_comp(page_align(rec))||index);

> Why there are separate rules for the utility functions in XB? I
> think we should just link them in the relevant xb configurations
> by default. If they are needed then the Makefile diff at lines
> 591--599 contains $(CFLAGS), $(CXXFLAGS), $(CCFLAGS). I think
> only the first is correct, and then the rules can be merged.
>
> Makefile "utils" target should be marked as phony and IMHO it
> should be included in the default build.
>
> Can the INNODBOBJS definition for utils be reused from some other
> target instead of copy-paste?
>

I've removed target 'utils'. Now utils are build with 'innodb51' target.

> Line 677: please define MLOG_LSN conditionally with #ifndef
> MLOG_LSN
>

done

> The #if 0 blocks in fill_parse_buffer should go away. Likewise in
> ib_log_sys_g et_next_rec().
>

done

> The ib_log_rec_*, ib_log_sys_* structs and functions need
> comments. This was my work, please ping me on IRC and we will
> coordinate.
>

I'll try to write comments by myself first (it's useful as I will get more familiar with code) and
will send you email my version. Then you will correct them and reply back to me. Will this work?

[Sergei Glushchenko (sergei.glushchenko)]

> Couple more comments:
>
> The page printer utility starts & commits MTRs, for example i
> ib_page_load_table_for_id(). How does that work since we are not allowed to
> write to the log in the utility?
>

As long as page printer doesn't make changes to buffer pool pages, mtr_commit doesn't write to log.

> How do you plan automating testing this, both as standalone utility and GDB
> entry points in the XB binary?

We should think about it:)

[Laurynas Biveinis (laurynas-biveinis)]

> https://blueprints.launchpad.net/percona-xtrabackup/+spec/log-and-page-
> printers-for-xtrabackup
> Please look at the BP above and tells whether it good or must be rewritten.

Thanks, I commented on its whiteboard.

> > The ib_log_rec_*, ib_log_sys_* structs and functions need
> > comments. This was my work, please ping me on IRC and we will
> > coordinate.
> >
>
> I'll try to write comments by myself first (it's useful as I will get more
> familiar with code) and
> will send you email my version. Then you will correct them and reply back to
> me. Will this work?

Yes.

[Laurynas Biveinis (laurynas-biveinis)]

> > Couple more comments:
> >
> > The page printer utility starts & commits MTRs, for example i
> > ib_page_load_table_for_id(). How does that work since we are not allowed to
> > write to the log in the utility?
> >
>
> As long as page printer doesn't make changes to buffer pool pages, mtr_commit
> doesn't write to log.

No way to avoid creating those MTRs and passing NULL MTRs around? Or asserting that MTR did not write anything?

> > How do you plan automating testing this, both as standalone utility and GDB
> > entry points in the XB binary?
>
> We should think about it:)

I see two ways, with distinct advantages and disadvantages:
1) Provide entry to those functions through some new XB command-line options. Then test those options.
2) Script gdb to call these functions.

The latter is closer to the actual use case but the former might be enough perhaps?

[Vlad Lesin (vlad-lesin)]

1) Building:
AUTO_DOWNLOAD=yes utils/build.sh innodb51
...
Building XtraBackup
Makefile:190: target `innodb_int.o' given more than once in the same rule.
...
api_page.c: In function ‘ib_page_rec_print_old’:
api_page.c:2715:24: warning: variable ‘ifield’ set but not used [-Wunused-but-set-variable]
api_page.c: In function ‘ib_page_page_print_list’:
api_page.c:2880:9: warning: variable ‘n_recs’ set but not used [-Wunused-but-set-variable]
api_log.c: In function ‘ib_log_sys_parse_rec_body’:
api_log.c:816:8: warning: variable ‘ret’ set but not used [-Wunused-but-set-variable]
innodb_int.c: In function ‘innodb_init_param_for_util’:
innodb_int.c:65:16: warning: assignment discards ‘const’ qualifier from pointer target type [enabled by default]
innodb_int.c:82:2: warning: passing argument 1 of ‘srv_parse_log_group_home_dirs’ discards ‘const’ qualifier from pointer target type [enabled by default]
/home/vlesin/src/work/xb-tools-sergey_gl/mysql-5.1/storage/innodb_plugin/include/srv0start.h:54:1: note: expected ‘char *’ but argument is of type ‘const char *’
api_log.c: In function ‘ib_log_sys_print’:
api_log.c:1449:1: warning: control reaches end of non-void function [-Wreturn-type]
...
cc: error: percona-pprint.o: No such file or directory

2) Code style:
a) 16, 35, 93 - innodb code style requires comment which underlines function name the same length as underlined function name;
b) 100, 251 - unaligned comment;
c) 150, 151, 243- function description is absent;
d) 14-15, 33-34, 60-61, 67-68, 2427, 2444, 2468 and other functions in api_page.c containing page pointer as an argument, - function argument description is absent;
e) I don't think _old and _new function names postfixes is a good idea. What if there is one more new format? As I see there are two variants of code for calculating record offsets. One is for "compact" and another is for "external" formats. We could just use _cmp_fmt and _ext_fmt postfixes for that functions instead of _old and _new.
f) I think api_page.c should correspond to innodb code style as api_log.c does to have some uniformity in api_* files. If so there should be explaining comments for function declarations and definitions. And the same remark as 2a.

3) Possible errors:
a) 330-338 - if "create_new_db" is false then "ret" is not initialized but it is compared with "FALSE" in 338. This comparison is unneeded because "ret" is initialized only if "create_new_db" is true. Otherwise the first argument of "or" operator is true and there is not need to check the second one.
339-340 - the "if" block will never work because if we are at this line the "create_new_db" is false. I think this block should be under "if (create_new_db)" condition.
It would be great if you comment your changes in open_or_create_log_file() function.
b) 2567-2569 it would be good if we checked "create_new_db" for false.

[Sergei Glushchenko (sergei.glushchenko)]

Vlad,

> a) 330-338 - if "create_new_db" is false then "ret" is not initialized but it is compared with "FALSE" in 338. This comparison is unneeded because "ret" is initialized only if "create_new_db" is true. Otherwise the first argument of "or" operator is true and there is not need to check the second one.

Just a little comment. I put the code below to not move eyes up and down while writing this.
 if (create_new_db) {

  files[i]
   = os_file_create(name, OS_FILE_CREATE, OS_FILE_NORMAL,
      OS_LOG_FILE, &ret);
 }
 if (!create_new_db || ret == FALSE) {
  if (create_new_db
      && os_file_get_last_error(FALSE) != OS_FILE_ALREADY_EXISTS
...
      ) {
...
   return(DB_ERROR);
  }

  files[i] = os_file_create(name, OS_FILE_OPEN, OS_FILE_AIO,
       OS_LOG_FILE, &ret);

I can't see any mistake in this lines.
Indeed, consider create_new_db is TRUE and we are trying to create new file. We have two options here. Creation succeeded and ret is set to TRUE, or creation failed and ret is set to FALSE.
Next we check whether we created file or not by using this condition (!create_new_db || ret == FALSE). Obviously if create_new_db is TRUE, the result depends only on the ret value. And we should report error (last error was not OS_FILE_ALREADY_EXISTS) or try to open existing file.

Now lets consider create_new_db is FALSE. In this case we go straight to opening file with OS_FILE_OPEN. Because all conditions in this case not depend on ret value, which is not set as you noticed before.

[Sergei Glushchenko (sergei.glushchenko)]

Vlad,
> e) I don't think _old and _new function names postfixes is a good idea. What if there is one more new format? As I see there are two variants of code for calculating record offsets. One is for "compact" and another is for "external" formats. We could just use _cmp_fmt and _ext_fmt postfixes for that functions instead of _old and _new.

Yes. There are two major physical row formats in InnoDB http://dev.mysql.com/doc/refman/5.0/en/innodb-physical-record.html. Redundant page keeps much more information inside the record itself, which allow us to print fields even if we have no information about the index which occupied this page. While compact page needs less space to store records. I don't like _old and _new suffixes as much as you do. But it is common practice to use these suffixes. Just look at rem0rec.h and you will see it. So I think we should use this convention too.

[Sergei Glushchenko (sergei.glushchenko)]

I did some testing of entry points in xtrabackup and here are my findings:

In 'backup' mode:
Page printer fails. In order for it to work following initialization should be done first:
 buf_pool_init();
 dict_ind_init();
 dict_boot(FALSE);
 dict_check_tablespaces_and_store_max_id(FALSE);
and IBUF should initialized in order to print IBUF pages
Log printer also fails.
 recv_sys_create()
is needed.

In 'prepare' mode:
For page printer to work:
 dict_ind_init();
 dict_boot(FALSE);
 dict_check_tablespaces_and_store_max_id(FALSE);
Log printer work just fine

In 'stats' mode:
Both page and log printers work OK.

I don't think we should initialize all these systems every time when running xtrabackup. However it would be nice to make log and page printers more useable inside xtrabackup. Maybe we should make some initialization function for these tools which used could call from gdb before using log or page printer.

I also found that by making create_new_db flag meaningful breaks second '--prepare' run (in open_or_create_log_file). XtraBackup doesn't create new log files because of when datafiles been found, create_new_db=FALSE is passed. So I reverted a change with create_new_db.

[Laurynas Biveinis (laurynas-biveinis)]

I think all required subsystems must be initialized on startup then, unless something precludes this.

[Sergei Glushchenko (sergei.glushchenko)]

Couple more bugs been found in initialization of log printer.
1. When compiled with debug, several failures occurred on ut_a(&(log_sys->mutex))
2. mem_init() call needed for debug builds
3. ib_log_sys_start opens only one log file from group.

[Sergei Glushchenko (sergei.glushchenko)]

Also it would be nice to have commandline argument --log-file-size

[Sergei Glushchenko (sergei.glushchenko)]

Comments for ib_page_* and ib_log_* fucntions, more InnoDB code conventions fixes.
Two testcases added for standalone tools.
Fixed number of initialization and locking errors.

[Sergei Glushchenko (sergei.glushchenko)]

Hey, guys!
Many of your comments were taken into account, many other things were spotted and fixed. Could you please review this once more.

[Laurynas Biveinis (laurynas-biveinis)]

Diff has conflicts.

review: Needs Fixing

Unmerged revisions

417. By Sergei Glushchenko on 2012-10-04

made extra initialization for innodb51 only

416. By Sergei Glushchenko on 2012-10-01

Additional initialization in xtrabackup in order to be able to run printers entry points.

415. By Sergei Glushchenko on 2012-09-26

Buffer overrun. Fix bug in release build

414. By Sergei Glushchenko on 2012-09-24

Fix percona*.sh tests

413. By Sergei Glushchenko on 2012-09-24

Fix build with builtin innodb. Missing percona-*.o deps in Makefile. Added missing .sql for tests

412. By Sergei Glushchenko on 2012-09-23

2 basic tests

411. By Sergei Glushchenko on 2012-09-23

Merge trunk

410. By Sergei Glushchenko on 2012-09-23

Debug build tested. Some initialization errors fixed. Some locking errors fixed.

409. By Sergei Glushchenko on 2012-09-17

Fixes after entry points testing. Do not use create_new_db flag in open_or_create_log_file_ex

408. By Sergei Glushchenko on 2012-09-13

InnoDB coding conventions, comments for functions and arguments.
Fixed some warnings.

=== modified file 'patches/innodb51.patch'
--- patches/innodb51.patch	2012-11-14 04:46:11 +0000
+++ patches/innodb51.patch	2012-12-05 22:33:23 +0000
@@ -50,7 +50,26 @@
  #endif
  	buf_pool->stat.n_page_gets++;
  loop:
-@@ -2894,7 +2896,7 @@
+@@ -2075,7 +2077,8 @@
+ 	access_time = buf_page_is_accessed(&block->page);
+ 	buf_page_set_accessed_make_young(&block->page, access_time);
+ 
+-	ut_ad(!ibuf_inside()
++	ut_ad(srv_fake_write
++	      || !ibuf_inside()
+ 	      || ibuf_page(buf_block_get_space(block),
+ 			   buf_block_get_zip_size(block),
+ 			   buf_block_get_page_no(block), NULL));
+@@ -2203,7 +2206,7 @@
+ 		buf_pool_mutex_exit();
+ 	}
+ 
+-	ut_ad(!ibuf_inside() || (mode == BUF_KEEP_OLD));
++	ut_ad(srv_fake_write || !ibuf_inside() || (mode == BUF_KEEP_OLD));
+ 
+ 	if (rw_latch == RW_S_LATCH) {
+ 		success = rw_lock_s_lock_nowait(&(block->lock),
+@@ -2894,7 +2897,7 @@
  			recv_recover_page(TRUE, (buf_block_t*) bpage);
  		}
  
@@ -158,6 +177,49 @@
  		return;
  	}
  
+--- a/storage/innodb_plugin/dict/dict0boot.c
++++ b/storage/innodb_plugin/dict/dict0boot.c
+@@ -241,8 +241,8 @@
+ started. This function is also called when the data dictionary is created. */
+ UNIV_INTERN
+ void
+-dict_boot(void)
+-/*===========*/
++dict_boot(ibool ibuf_init)
++/*======================*/
+ {
+ 	dict_table_t*	table;
+	dict_index_t*	index;
+@@ -442,7 +442,8 @@
+ 
+ 	/* Initialize the insert buffer table and index for each tablespace */
+ 
+-	ibuf_init_at_db_start();
++	if (ibuf_init)
++		ibuf_init_at_db_start();
+ 
+ 	/* Load definitions of other indexes on system tables */
+ 
+@@ -469,8 +470,8 @@
+ Creates and initializes the data dictionary at the database creation. */
+ UNIV_INTERN
+ void
+-dict_create(void)
+-/*=============*/
++dict_create(ibool ibuf_init)
++/*========================*/
+ {
+ 	mtr_t	mtr;
+
+@@ -480,7 +481,7 @@
+ 
+ 	mtr_commit(&mtr);
+ 
+-	dict_boot();
++	dict_boot(ibuf_init);
+ 
+ 	dict_insert_initial_data();
+ }
 --- a/storage/innodb_plugin/fil/fil0fil.c
 +++ b/storage/innodb_plugin/fil/fil0fil.c
 @@ -48,6 +48,8 @@
@@ -642,6 +704,27 @@
  	while (sum_pages < n_pages) {
  		n_bytes = ibuf_contract_ext(&n_pag2, sync);
  
+--- a/storage/innodb_plugin/include/dict0boot.h
++++ b/storage/innodb_plugin/include/dict0boot.h
+@@ -82,14 +82,14 @@
+ started. This function is also called when the data dictionary is created. */
+ UNIV_INTERN
+ void
+-dict_boot(void);
+-/*===========*/
++dict_boot(ibool ibuf_init);
++/*=======================*/
+ /*****************************************************************//**
+ Creates and initializes the data dictionary at the database creation. */
+ UNIV_INTERN
+ void
+-dict_create(void);
+-/*=============*/
++dict_create(ibool ibuf_init);
++/*=========================*/
+ 
+ 
+ /* Space id and page no where the dictionary header resides */
 --- a/storage/innodb_plugin/include/mem0mem.ic
 +++ b/storage/innodb_plugin/include/mem0mem.ic
 @@ -367,7 +367,7 @@
@@ -664,6 +747,41 @@
  
  		if ((object == slot->object) && (type == slot->type)) {
  
+--- a/storage/innodb_plugin/include/rem0rec.h
++++ b/storage/innodb_plugin/include/rem0rec.h
+@@ -361,6 +361,32 @@
+ #define rec_get_offsets(rec,index,offsets,n,heap)	\
+ 	rec_get_offsets_func(rec,index,offsets,n,heap,__FILE__,__LINE__)
+ 
++
++/******************************************************//**
++The following function determines the offsets to each field
++in the record.	Function can only calculate offsets for
++redundant row format records.
++It can reuse a previously allocated array.
++@return	the new offsets */
++UNIV_INTERN
++ulint*
++rec_get_offsets_old_func(
++/*=====================*/
++	const rec_t*		rec,	/*!< in: physical record */
++	ulint*			offsets,/*!< in/out: array consisting of
++					offsets[0] allocated elements,
++					or an array from rec_get_offsets(),
++					or NULL */
++	ulint			n_fields,/*!< in: maximum number of
++					initialized fields
++					 (ULINT_UNDEFINED if all fields) */
++	mem_heap_t**		heap,	/*!< in/out: memory heap */
++	const char*		file,	/*!< in: file name where called */
++	ulint			line);	/*!< in: line number where called */
++
++#define rec_get_offsets_old(rec,offsets,n,heap)	\
++	rec_get_offsets_old_func(rec,offsets,n,heap,__FILE__,__LINE__)
++
+ /******************************************************//**
+ Determine the offset to each field in a leaf-page record
+ in ROW_FORMAT=COMPACT.  This is a special case of
 --- a/storage/innodb_plugin/include/srv0srv.h
 +++ b/storage/innodb_plugin/include/srv0srv.h
 @@ -202,6 +202,10 @@
@@ -868,6 +986,24 @@
  	    || (recv_addr->state == RECV_BEING_PROCESSED)
  	    || (recv_addr->state == RECV_PROCESSED)) {
  
+@@ -2012,7 +2013,7 @@
+ /*******************************************************************//**
+ Tries to parse a single log record and returns its length.
+ @return	length of the record, or 0 if the record was not complete */
+-static
++UNIV_INTERN
+ ulint
+ recv_parse_log_rec(
+ /*===============*/
+@@ -2083,7 +2084,7 @@
+ 
+ /*******************************************************//**
+ Calculates the new value for lsn when more data is added to the log. */
+-static
++UNIV_INTERN
+ ib_uint64_t
+ recv_calc_lsn_on_data_add(
+ /*======================*/
 @@ -2297,7 +2298,7 @@
  			   || type == MLOG_FILE_RENAME
  			   || type == MLOG_FILE_DELETE) {
@@ -1007,6 +1143,158 @@
  #endif
  }
  
+--- a/storage/innodb_plugin/rem/rem0rec.c
++++ b/storage/innodb_plugin/rem/rem0rec.c
+@@ -344,6 +344,50 @@
+ 		= (rec - (lens + 1)) | REC_OFFS_COMPACT | any_ext;
+ }
+ 
++static void
++rec_init_offsets_old(
++/*=================*/
++	const rec_t*		rec,	/*!< in: physical record */
++	ulint*			offsets)/*!< in/out: array of offsets;
++					in: n=rec_offs_n_fields(offsets) */
++{
++	ulint	i	= 0;
++	ulint	offs;
++
++	/* Old-style record: determine extra size and end offsets */
++	offs = REC_N_OLD_EXTRA_BYTES;
++	if (rec_get_1byte_offs_flag(rec)) {
++		offs += rec_offs_n_fields(offsets);
++		*rec_offs_base(offsets) = offs;
++		/* Determine offsets to fields */
++		do {
++			offs = rec_1_get_field_end_info(rec, i);
++			if (offs & REC_1BYTE_SQL_NULL_MASK) {
++				offs &= ~REC_1BYTE_SQL_NULL_MASK;
++				offs |= REC_OFFS_SQL_NULL;
++			}
++			rec_offs_base(offsets)[1 + i] = offs;
++		} while (++i < rec_offs_n_fields(offsets));
++	} else {
++		offs += 2 * rec_offs_n_fields(offsets);
++		*rec_offs_base(offsets) = offs;
++		/* Determine offsets to fields */
++		do {
++			offs = rec_2_get_field_end_info(rec, i);
++			if (offs & REC_2BYTE_SQL_NULL_MASK) {
++				offs &= ~REC_2BYTE_SQL_NULL_MASK;
++				offs |= REC_OFFS_SQL_NULL;
++			}
++			if (offs & REC_2BYTE_EXTERN_MASK) {
++				offs &= ~REC_2BYTE_EXTERN_MASK;
++				offs |= REC_OFFS_EXTERNAL;
++				*rec_offs_base(offsets) |= REC_OFFS_EXTERNAL;
++			}
++			rec_offs_base(offsets)[1 + i] = offs;
++		} while (++i < rec_offs_n_fields(offsets));
++	}
++}
++
+ /******************************************************//**
+ The following function determines the offsets to each field in the
+ record.	 The offsets are written to a previously allocated array of
+@@ -480,38 +524,7 @@
+ 		*rec_offs_base(offsets)
+ 			= (rec - (lens + 1)) | REC_OFFS_COMPACT;
+ 	} else {
+-		/* Old-style record: determine extra size and end offsets */
+-		offs = REC_N_OLD_EXTRA_BYTES;
+-		if (rec_get_1byte_offs_flag(rec)) {
+-			offs += rec_offs_n_fields(offsets);
+-			*rec_offs_base(offsets) = offs;
+-			/* Determine offsets to fields */
+-			do {
+-				offs = rec_1_get_field_end_info(rec, i);
+-				if (offs & REC_1BYTE_SQL_NULL_MASK) {
+-					offs &= ~REC_1BYTE_SQL_NULL_MASK;
+-					offs |= REC_OFFS_SQL_NULL;
+-				}
+-				rec_offs_base(offsets)[1 + i] = offs;
+-			} while (++i < rec_offs_n_fields(offsets));
+-		} else {
+-			offs += 2 * rec_offs_n_fields(offsets);
+-			*rec_offs_base(offsets) = offs;
+-			/* Determine offsets to fields */
+-			do {
+-				offs = rec_2_get_field_end_info(rec, i);
+-				if (offs & REC_2BYTE_SQL_NULL_MASK) {
+-					offs &= ~REC_2BYTE_SQL_NULL_MASK;
+-					offs |= REC_OFFS_SQL_NULL;
+-				}
+-				if (offs & REC_2BYTE_EXTERN_MASK) {
+-					offs &= ~REC_2BYTE_EXTERN_MASK;
+-					offs |= REC_OFFS_EXTERNAL;
+-					*rec_offs_base(offsets) |= REC_OFFS_EXTERNAL;
+-				}
+-				rec_offs_base(offsets)[1 + i] = offs;
+-			} while (++i < rec_offs_n_fields(offsets));
+-		}
++		rec_init_offsets_old(rec, offsets);
+ 	}
+ }
+ 
+@@ -587,6 +600,58 @@
+ 	return(offsets);
+ }
+ 
++/******************************************************//**
++The following function determines the offsets to each field
++in the record.	Function can only calculate offsets for
++redundant row format records.
++It can reuse a previously allocated array.
++@return	the new offsets */
++UNIV_INTERN
++ulint*
++rec_get_offsets_old_func(
++/*=====================*/
++	const rec_t*		rec,	/*!< in: physical record */
++	ulint*			offsets,/*!< in/out: array consisting of
++					offsets[0] allocated elements,
++					or an array from rec_get_offsets(),
++					or NULL */
++	ulint			n_fields,/*!< in: maximum number of
++					initialized fields
++					 (ULINT_UNDEFINED if all fields) */
++	mem_heap_t**		heap,	/*!< in/out: memory heap */
++	const char*		file,	/*!< in: file name where called */
++	ulint			line)	/*!< in: line number where called */
++{
++	ulint	n;
++	ulint	size;
++
++	ut_ad(rec);
++	ut_ad(heap);
++
++	n = rec_get_n_fields_old(rec);
++
++	if (UNIV_UNLIKELY(n_fields < n)) {
++		n = n_fields;
++	}
++
++	size = n + (1 + REC_OFFS_HEADER_SIZE);
++
++	if (UNIV_UNLIKELY(!offsets)
++	    || UNIV_UNLIKELY(rec_offs_get_n_alloc(offsets) < size)) {
++		if (UNIV_UNLIKELY(!*heap)) {
++			*heap = mem_heap_create_func(size * sizeof(ulint),
++						     MEM_HEAP_DYNAMIC,
++						     file, line);
++		}
++		offsets = mem_heap_alloc(*heap, size * sizeof(ulint));
++		rec_offs_set_n_alloc(offsets, size);
++	}
++
++	rec_offs_set_n_fields(offsets, n);
++	rec_init_offsets_old(rec, offsets);
++	return(offsets);
++}
++
+ /******************************************************//**
+ The following function determines the offsets to each field
+ in the record.  It can reuse a previously allocated array. */
 --- a/storage/innodb_plugin/row/row0merge.c
 +++ b/storage/innodb_plugin/row/row0merge.c
 @@ -453,7 +453,9 @@
@@ -1084,6 +1372,15 @@
  }
  
  /*********************************************************************//**
+@@ -1321,7 +1326,7 @@
+ /*********************************************************************//**
+ Normalizes init parameter values to use units we use inside InnoDB.
+ @return	DB_SUCCESS or error code */
+-static
++UNIV_INTERN
+ ulint
+ srv_normalize_init_values(void)
+ /*===========================*/
 --- a/storage/innodb_plugin/srv/srv0start.c
 +++ b/storage/innodb_plugin/srv/srv0start.c
 @@ -94,6 +94,8 @@
@@ -1104,7 +1401,18 @@
  ulint
  open_or_create_log_file(
  /*====================*/
-@@ -702,7 +704,7 @@
+@@ -611,6 +619,10 @@
+ 		ret = os_file_get_size(files[i], &size, &size_high);
+ 		ut_a(ret);
+ 
++		srv_log_file_size =
++			((ib_uint64_t)size_high << 32 | size)
++			>> UNIV_PAGE_SIZE_SHIFT;
++
+ 		if (size != srv_calc_low32(srv_log_file_size)
+ 		    || size_high != srv_calc_high32(srv_log_file_size)) {
+ 
+@@ -702,7 +714,7 @@
  /*********************************************************************//**
  Creates or opens database data files and closes them.
  @return	DB_SUCCESS or error code */
@@ -1113,7 +1421,7 @@
  ulint
  open_or_create_data_files(
  /*======================*/
-@@ -1359,7 +1361,7 @@
+@@ -1359,7 +1371,7 @@
  	}
  #endif /* UNIV_LOG_ARCHIVE */
  
@@ -1122,7 +1430,34 @@
  		fprintf(stderr,
  			"InnoDB: Error: combined size of log files"
  			" must be < 4 GB\n");
-@@ -1601,6 +1603,10 @@
+@@ -1516,7 +1528,7 @@
+ 		mtr_commit(&mtr);
+ 
+ 		trx_sys_create();
+-		dict_create();
++		dict_create(TRUE);
+ 		srv_startup_is_before_trx_rollback_phase = FALSE;
+ 
+ #ifdef UNIV_LOG_ARCHIVE
+@@ -1534,7 +1546,7 @@
+ 		/* Since ibuf init is in dict_boot, and ibuf is needed
+ 		in any disk i/o, first call dict_boot */
+ 
+-		dict_boot();
++		dict_boot(TRUE);
+ 		trx_sys_init_at_db_start();
+ 		srv_startup_is_before_trx_rollback_phase = FALSE;
+ 
+@@ -1590,7 +1602,7 @@
+ 		to access space 0, and the insert buffer at this stage already
+ 		works for space 0. */
+ 
+-		dict_boot();
++		dict_boot(TRUE);
+ 		trx_sys_init_at_db_start();
+ 
+ 		/* Initialize the fsp free limit global variable in the log
+@@ -1601,6 +1613,10 @@
  		are initialized in trx_sys_init_at_db_start(). */
  
  		recv_recovery_from_checkpoint_finish();
@@ -1133,7 +1468,7 @@
  		if (srv_force_recovery < SRV_FORCE_NO_IBUF_MERGE) {
  			/* The following call is necessary for the insert
  			buffer to work with multiple tablespaces. We must
-@@ -1747,7 +1753,18 @@
+@@ -1747,7 +1763,18 @@
  
  	if (srv_auto_extend_last_data_file
  	    && sum_of_data_file_sizes < tablespace_size_in_header) {
@@ -1152,7 +1487,7 @@
  		fprintf(stderr,
  			"InnoDB: Error: tablespace size stored in header"
  			" is %lu pages, but\n"
-@@ -1772,6 +1789,7 @@
+@@ -1772,6 +1799,7 @@
  
  			return(DB_ERROR);
  		}
@@ -1160,7 +1495,7 @@
  	}
  
  	/* Check that os_fast_mutexes work as expected */
-@@ -1867,6 +1885,7 @@
+@@ -1867,6 +1895,7 @@
  		ibuf_update_max_tablespace_id();
  	}
  
 
=== modified file 'src/Makefile'
--- src/Makefile	2012-05-25 11:38:15 +0000
+++ src/Makefile	2012-12-05 22:33:23 +0000
@@ -35,6 +35,10 @@
 	xbstream_write.o \
 	quicklz/quicklz.o
 XBSTREAMOBJS = xbstream.o xbstream_write.o xbstream_read.o
+UTILSCOREOBJS = api_page.o api_log.o
+UTILSCOBJS = innodb_int.o $(UTILSCOREOBJS)
+REDOCOBJS = percona-redo.o
+PAGECOBJS = percona-pprint.o
 
 LIBARCHIVE_A = libarchive/libarchive/libarchive.a
 
@@ -86,8 +90,9 @@
 
 plugin: MYSQLOBJS = $(addprefix $(MYSQL_ROOT_DIR)/, mysys/libmysys.a \
 	strings/libmystrings.a zlib/.libs/libzlt.a dbug/libdbug.a)
+plugin: EXTLINKOBJS := $(UTILSCOREOBJS)
 plugin: TARGET := xtrabackup_plugin
-plugin: $(TARGET) xbstream
+plugin: utils $(TARGET) xbstream
 
 # XtraBackup for MySQL 5.5
 5.5: INC = $(COMMON_INC) $(addprefix -isystem$(MYSQL_ROOT_DIR)/, \
@@ -179,7 +184,7 @@
 xtradb55: TARGET := xtrabackup_55
 xtradb55: $(TARGET) xbstream
 
-$(XTRABACKUPOBJS): %.o: %.c
+$(XTRABACKUPOBJS) $(UTILSCOREOBJS) $(REDOCOBJS) $(PAGECOBJS): %.o: %.c
 	$(CC) $(CFLAGS) $(INC) $(DEFS) -c $< -o $@
 
 xbstream.o xbstream_read.o: %.o: %.c
@@ -190,9 +195,13 @@
 
 xtrabackup.o: xtrabackup.c xb_regex.h write_filt.h fil_cur.h xtrabackup.h
 
-$(TARGET): $(XTRABACKUPOBJS) $(INNODBOBJS) $(MYSQLOBJS) $(LIBARCHIVE_A)
-	$(CC) $(CFLAGS) $(XTRABACKUPOBJS) $(INNODBOBJS) $(MYSQLOBJS) $(LIBS) \
+$(TARGET): $(EXTLINKOBJS) $(XTRABACKUPOBJS) $(INNODBOBJS) $(MYSQLOBJS) $(LIBARCHIVE_A)
+	$(CC) $(CFLAGS) $(EXTLINKOBJS) $(XTRABACKUPOBJS) $(INNODBOBJS) $(MYSQLOBJS) $(LIBS) \
 	$(LIBARCHIVE_A) -o $(TARGET)
 
+utils: $(UTILSCOBJS) $(INNODBOBJS) $(MYSQLOBJS) $(REDOCOBJS) $(PAGECOBJS)
+	$(CC) $(UTILSCOBJS) $(REDOCOBJS) $(INNODBOBJS) $(MYSQLOBJS) $(LIBS) -o percona-redo
+	$(CC) $(UTILSCOBJS) $(PAGECOBJS) $(INNODBOBJS) $(MYSQLOBJS) $(LIBS) -o percona-pprint
+
 clean:
-	rm -f $(XTRABACKUPOBJS) $(XBSTREAMOBJS) xtrabackup xtrabackup_* 
+	rm -f $(UTILSCOBJS) $(XTRABACKUPOBJS) $(XBSTREAMOBJS) xtrabackup xtrabackup_* 
 
=== added file 'src/api_log.c'
--- src/api_log.c	1970-01-01 00:00:00 +0000
+++ src/api_log.c	2012-12-05 22:33:23 +0000
@@ -0,0 +1,1493 @@
+/*
+ * Copyright (C) 2012 Percona Inc.
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define DULINT_STANDARD
+
+#include "api_log.h"
+#include "fil0fil.h"
+#include "log0log.h"
+#include "log0recv.h"
+#include "rem0rec.h"
+#include "os0file.h"
+#include "os0sync.h"
+#include "sync0sync.h"
+#include "srv0srv.h"
+
+#include "innodb_int.h"
+
+#define SRV_N_PENDING_IOS_PER_THREAD 	OS_AIO_N_PENDING_IOS_PER_THREAD
+#define SRV_MAX_N_PENDING_SYNC_IOS	100
+
+#ifndef MLOG_LSN
+ #define MLOG_LSN ((byte)28)
+#endif
+
+static const char* mlog_type_names[] = {
+	"undefined (0)",
+	"MLOG_1BYTE",
+	"MLOG_2BYTES",
+	"undefined (3)",
+	"MLOG_4BYTES",
+	"undefined (5)",
+	"undefined (6)",
+	"undefined (7)",
+	"MLOG_8BYTES",
+	"MLOG_REC_INSERT",
+	"MLOG_REC_CLUST_DELETE_MARK", /* 10 */
+	"MLOG_REC_SEC_DELETE_MARK",
+	"undefined (12)",
+	"MLOG_REC_UPDATE_IN_PLACE",
+	"MLOG_REC_DELETE",
+	"MLOG_LIST_END_DELETE",
+	"MLOG_LIST_START_DELETE",
+	"MLOG_LIST_END_COPY_CREATED",
+	"MLOG_PAGE_REORGANIZE",
+	"MLOG_PAGE_CREATE",
+	"MLOG_UNDO_INSERT",	      /* 20 */
+	"MLOG_UNDO_ERASE_END",
+	"MLOG_UNDO_INIT",
+	"MLOG_UNDO_HDR_DISCARD",
+	"MLOG_UNDO_HDR_REUSE",
+	"MLOG_UNDO_HDR_CREATE",
+	"MLOG_REC_MIN_MARK",
+	"MLOG_IBUF_BITMAP_INIT",
+	"MLOG_LSN",
+	"MLOG_INIT_FILE_PAGE",
+	"MLOG_WRITE_STRING",	      /* 30 */
+	"MLOG_MULTI_REC_END",
+	"MLOG_DUMMY_RECORD",
+	"MLOG_FILE_CREATE",
+	"MLOG_FILE_RENAME",
+	"MLOG_FILE_DELETE",
+	"MLOG_COMP_REC_MIN_MARK",
+	"MLOG_COMP_PAGE_CREATE",
+	"MLOG_COMP_REC_INSERT",
+	"MLOG_COMP_REC_CLUST_DELETE_MARK",
+	"MLOG_COMP_REC_SEC_DELETE_MARK", /* 40 */
+	"MLOG_COMP_REC_UPDATE_IN_PLACE",
+	"MLOG_COMP_REC_DELETE",
+	"MLOG_COMP_LIST_END_DELETE",
+	"MLOG_COMP_LIST_START_DELETE",
+	"MLOG_COMP_LIST_END_COPY_CREATED",
+	"MLOG_COMP_PAGE_REORGANIZE",
+	"MLOG_FILE_CREATE2",
+	"MLOG_ZIP_WRITE_NODE_PTR",
+	"MLOG_ZIP_WRITE_BLOB_PTR",
+	"MLOG_ZIP_WRITE_HEADER",     /* 50 */
+	"MLOG_ZIP_PAGE_COMPRESS"
+};
+
+/* Informaton about single log record */
+struct ib_log_rec_struct
+{
+	ib_uint64_t	lsn;		/* record's LSN */
+	ulint		len;		/* length */
+	byte		type;		/* type MLOG_* */
+	ulint		space;		/* space id or ULINT_UNDEFINED */
+	ulint		page_no;	/* page number or ULINT_UNDEFINED */
+	char*		body_str;	/* log record's body as string */
+	unsigned	single_rec:1;	/* set if MLOG_SINGLE_REC_FLAG
+					is set for record */
+};
+
+/* log iterator */
+struct ib_log_rec_itr_struct
+{
+	ib_uint64_t		 start_lsn;		/* starting LSN */
+	ib_uint64_t		 end_lsn;		/* end LSN */
+	ib_uint64_t		 block_start_lsn;	/* OS_FILE_LOG_BLOCK_SIZE aligned LSN */
+	byte*			 read_buf;		/* read buffer */
+	byte*			 read_buf_ptr;		/* pointer to current record in read buffer */
+	byte*			 parse_buf;		/* parse buffer */
+	byte*			 parse_buf_ptr;		/* pointer to current record in parse buffer */
+	byte*			 parse_buf_end;		/* end of parse buffer */
+	ulint			 scanned_checkpoint_no; /* last checkpoint stored in the log data */
+	ibool			 eof;			/* TRUE if end of scanned interval reached */
+	ib_uint64_t		 next_parse_lsn;	/* LSN of next record to be parsed */
+	struct ib_log_rec_struct current_rec;		/* current log record */
+};
+
+/*********************************************************************//**
+Initialize InnoDB systems needed for the log printer
+@return DB_SUCCESS if successfull */
+HAILDB_API
+ib_err_t
+ib_log_sys_start(
+/*=============*/
+	ib_ulint_t	log_buf_size,	/*!< in: the size of the buffer */
+	const char*	log_dir)	/*!< in: path to InnoDB log files. */
+{
+	ibool log_file_created = TRUE;
+	ib_err_t err;
+	ulint i;
+
+	innodb_init_param_for_util("./", log_dir, 1024*1024, log_buf_size, TRUE);
+
+	srv_max_n_threads = 1;
+	srv_normalize_init_values();
+	ut_mem_init();
+
+	srv_n_read_io_threads = srv_n_write_io_threads = 1;
+	srv_n_file_io_threads = 2 + srv_n_read_io_threads +
+		srv_n_write_io_threads;
+	os_sync_init();
+	sync_init();
+	// os_io_init_simple();
+	os_aio_init(8 * SRV_N_PENDING_IOS_PER_THREAD,
+		    srv_n_read_io_threads,
+		    srv_n_write_io_threads,
+		    SRV_MAX_N_PENDING_SYNC_IOS);
+
+	mem_init(1);
+	fil_init(10, 10);
+	log_init();
+	recv_sys_create();
+
+	for (i = 0; i < srv_n_log_files; i++) {
+		err = open_or_create_log_file(FALSE, &log_file_created, TRUE, 0, 0);
+		if (err != DB_SUCCESS) {
+			ib_log_sys_stop();
+			return err;
+		}
+
+		if (log_file_created) {
+			ib_logger(ib_stream,
+				"Something wrong with source files...\n");
+			return DB_ERROR;
+		}
+	}
+
+	/* open_or_create_log_file will set srv_log_file_size.  Normalize the
+	init values again to get srv_log_file_size/srv_log_file_curr_size in
+	sync.  */
+	srv_normalize_init_values();
+
+	return DB_SUCCESS;
+}
+
+/*********************************************************************//**
+Uninitialize InnoDB systems needed for the log printer */
+HAILDB_API
+void
+ib_log_sys_stop(void)
+{
+	recv_sys_close();
+	recv_sys_mem_free();
+	fil_close_all_files();
+	log_shutdown();
+	log_mem_free();
+	sync_close();
+	os_sync_free();
+	fil_close();
+	mem_close();
+	ut_free_all_mem();
+}
+
+/*********************************************************************//**
+Find last consistent checkpoint LSN in log groups */
+HAILDB_API
+ib_err_t
+ib_log_sys_find_last_checkpoint_lsn(
+/*================================*/
+	ib_u64_t*	last_checkpoint_lsn)	/*!< out: last checkpoint LSN */
+{
+	log_group_t*	max_cp_group;
+	ulint		max_cp_field;
+
+	mutex_enter(&log_sys->mutex);
+
+	uint err = recv_find_max_checkpoint(&max_cp_group, &max_cp_field);
+	if (err != DB_SUCCESS)
+		return err;
+
+	log_group_read_checkpoint_info(max_cp_group, max_cp_field);
+	*last_checkpoint_lsn
+		= mach_read_ull(log_sys->checkpoint_buf + LOG_CHECKPOINT_LSN);
+
+	mutex_exit(&log_sys->mutex);
+
+	return DB_SUCCESS;
+}
+
+/*********************************************************************//**
+Create iterator through log records */
+HAILDB_API
+ib_log_rec_itr_t
+ib_log_sys_create_iterator(
+/*=======================*/
+	ib_u64_t	start_lsn,	/*!< in: starting LSN */
+	ib_u64_t	end_lsn)	/*!< in: last LSN */
+{
+	ib_log_rec_itr_t result = mem_alloc(sizeof(*result));
+
+	result->start_lsn = start_lsn;
+	result->end_lsn = end_lsn;
+	result->block_start_lsn = ut_uint64_align_down(start_lsn,
+						       OS_FILE_LOG_BLOCK_SIZE);
+	result->read_buf = mem_alloc(RECV_SCAN_SIZE);
+	/* Pointing to the end of buffer will trigger the first read */
+	result->read_buf_ptr = result->read_buf + RECV_SCAN_SIZE;
+	result->parse_buf = mem_alloc(RECV_PARSING_BUF_SIZE);
+	result->parse_buf_ptr = result->parse_buf;
+	result->parse_buf_end = result->parse_buf;
+	result->scanned_checkpoint_no = 0;
+	result->eof = FALSE;
+	result->next_parse_lsn = result->block_start_lsn;
+
+	result->current_rec.lsn = IB_ULONGLONG_MAX;
+	result->current_rec.len = ULINT_UNDEFINED;
+	result->current_rec.type = MLOG_BIGGEST_TYPE + 1;
+	result->current_rec.space = ULINT_UNDEFINED;
+	result->current_rec.page_no = ULINT_UNDEFINED;
+	result->current_rec.body_str = NULL;
+	return result;
+}
+
+/*********************************************************************//**
+For the given minilog record type determines if the record has (space; page)
+associated with it.
+@return TRUE if the record has (space; page) in it */
+static
+ibool
+log_online_rec_has_page(
+/*====================*/
+	byte	type)	/*!<in: the minilog record type */
+{
+	return type != MLOG_MULTI_REC_END && type != MLOG_DUMMY_RECORD;
+}
+
+
+
+/*********************************************************************//**
+Copies new log data to the parse buffer while skipping log block header,
+and trailer.  The decision how much to copy here is taken from
+recv_sys_add_to_parsing_buf but simplified. */
+static
+void
+log_online_add_to_parse_buf(
+/*========================*/
+	const byte*	log_block,	/*!< in: read log data */
+	ulint		start_offset,	/*!< in: data start offset */
+	ulint		data_len,	/*!< in: length of read log data */
+	byte*		parse_buf,      /*!< in: the parse buffer */
+	byte**		parse_buf_end)	/*!< in/out: end of parse buffer */
+{
+	ulint end_offset
+		= (data_len == OS_FILE_LOG_BLOCK_SIZE)
+		? data_len - LOG_BLOCK_TRL_SIZE
+		: data_len;
+	ulint actual_data_len = (end_offset >= start_offset)
+		? end_offset - start_offset : 0;
+
+	ut_a (start_offset >= LOG_BLOCK_HDR_SIZE);
+
+	if ((*parse_buf_end + actual_data_len - parse_buf)
+	    > RECV_PARSING_BUF_SIZE) {
+
+		ib_logger(ib_stream, "Parse buffer overflow!  Most likely "
+			  "caused by corrupt log data.  In the case of "
+			  "correct log increase RECV_PARSING_BUF_SIZE\n");
+		ib_logger(ib_stream, "Discarding the overflowing data, some "
+			  "records will be skipped\n");
+		actual_data_len
+			= RECV_PARSING_BUF_SIZE - (*parse_buf_end - parse_buf);
+	}
+
+	ut_memcpy(*parse_buf_end, log_block + start_offset, actual_data_len);
+	*parse_buf_end += actual_data_len;
+	ut_ad (*parse_buf_end - parse_buf <= RECV_PARSING_BUF_SIZE);
+}
+
+/*********************************************************************//**
+Checks if the log block checksum is OK.  TODO: with comparisson to log0recv
+checks, this one drops the scanned no vs. no in the log check.
+TODO: copy-paste with innodb-changed-page-tracking log0online.c
+@return TRUE if the log block checksum is OK, FALSE otherwise.  */
+static
+ibool
+log_online_is_valid_log_seg(
+/*========================*/
+	const byte*	log_block)	/*!< in: read log data */
+{
+	ibool checksum_is_ok
+		= log_block_checksum_is_ok_or_old_format(log_block);
+
+	if (!checksum_is_ok) {
+		/* Garbage or an incompletely written log block */
+
+		ib_logger(ib_stream,
+			  "Log block checksum mismatch: "
+			  "expected %lu, calculated checksum %lu\n",
+			  (ulong) log_block_get_checksum(log_block),
+			  (ulong) log_block_calc_checksum(log_block));
+	}
+
+	return checksum_is_ok;
+}
+
+/*********************************************************************//**
+Checks if the log block is in fact garbage from a log buffer flush which was
+made before the most recent database recovery.
+@return TRUE if log block is garbage from the flush */
+static
+ibool
+log_online_is_garbage_log_seg(
+/*==========================*/
+	const byte*	log_block,	       /*!< in: read log data */
+	ulint		scanned_checkpoint_no) /*!< in: last checkpoint
+					       stored in the log data */
+{
+	return (scanned_checkpoint_no > 0)
+		&& (log_block_get_checkpoint_no(log_block)
+		    < scanned_checkpoint_no)
+		&& (scanned_checkpoint_no
+		    - log_block_get_checkpoint_no(log_block)
+		    > 0x80000000UL);
+}
+
+/*********************************************************************//**
+Copy consistent piece of data from the read buffer to the parse buffer.
+@return TRUE if data been copied */
+static
+ibool
+fill_parse_buffer(
+/*==============*/
+	ib_log_rec_itr_t	itr)	/*!< in: log records iterator */
+{
+	ulint block_data_len;
+	ulint data_start_offset = LOG_BLOCK_HDR_SIZE;
+
+	if (itr->eof)
+		return FALSE;
+
+	if (itr->read_buf_ptr == itr->read_buf + RECV_SCAN_SIZE) {
+
+		ib_uint64_t read_end_lsn;
+		log_group_t* group;
+
+		/* Read buf empty, read more recs if there are any */
+		read_end_lsn = itr->block_start_lsn + RECV_SCAN_SIZE;
+		group = UT_LIST_GET_FIRST(log_sys->log_groups);
+		ut_a(group);
+
+		/* Single-threaded operation, no mutexes */
+		mutex_enter(&log_sys->mutex);
+		log_group_read_log_seg(LOG_RECOVER, itr->read_buf, group,
+				       itr->block_start_lsn, read_end_lsn);
+		mutex_exit(&log_sys->mutex);
+		itr->read_buf_ptr = itr->read_buf;
+	}
+
+	/* Read buffer has some data, process and move one block to the parse
+	* buffer.  */
+	if (!log_online_is_valid_log_seg(itr->read_buf_ptr)) {
+		return FALSE;
+	}
+
+	if (log_online_is_garbage_log_seg(itr->read_buf_ptr,
+					  itr->scanned_checkpoint_no)) {
+		return FALSE;
+	}
+
+	block_data_len = log_block_get_data_len(itr->read_buf_ptr);
+
+	if (itr->next_parse_lsn == itr->block_start_lsn) {
+
+		/* First read, find the start of the first complete record
+		group in this block */
+		ut_a (itr->start_lsn
+		      < (itr->block_start_lsn + OS_FILE_LOG_BLOCK_SIZE));
+		data_start_offset
+			= log_block_get_first_rec_group(itr->read_buf_ptr);
+		/* TODO: is this the correct way to handle 0 return value? */
+		if (data_start_offset == 0)
+			data_start_offset = LOG_BLOCK_HDR_SIZE;
+		itr->next_parse_lsn += data_start_offset;
+	}
+	ut_ad (block_data_len % OS_FILE_LOG_BLOCK_SIZE == 0
+	       || block_data_len < OS_FILE_LOG_BLOCK_SIZE);
+
+	log_online_add_to_parse_buf(itr->read_buf_ptr, data_start_offset,
+				    block_data_len, itr->parse_buf,
+				    &itr->parse_buf_end);
+
+	/* TODO: check itr->scanned_checkpoint_no */
+	itr->scanned_checkpoint_no
+		= log_block_get_checkpoint_no(itr->read_buf_ptr);
+
+	if (block_data_len < OS_FILE_LOG_BLOCK_SIZE)
+		itr->eof = TRUE;
+
+	if (!itr->eof) {
+		itr->block_start_lsn += OS_FILE_LOG_BLOCK_SIZE;
+		itr->read_buf_ptr += OS_FILE_LOG_BLOCK_SIZE;
+	}
+
+	return TRUE;
+}
+
+static char buf[RECV_SCAN_SIZE];
+
+/*********************************************************************//**
+Parse index data and format it in human-readable form to static buffer.
+@return end of data copied to buffer */
+static
+char *
+ib_log_sys_parse_index(
+/*===================*/
+	byte**	ptr)	/*!< in/out: pointer to log data */
+{
+	char* buf_end = buf;
+	ulint n_uniq;
+	ulint n = mach_read_from_2(*ptr);
+	unsigned i;
+	*ptr += 2;
+	n_uniq = mach_read_from_2(*ptr);
+	*ptr += 2;
+	buf_end += snprintf(buf, RECV_SCAN_SIZE, "n: %lu, n_unique: %lu",
+			    n, n_uniq);
+	for (i = 0; i < n; i++) {
+		ulint len = mach_read_from_2(*ptr);
+		*ptr += 2;
+		buf_end += snprintf(buf_end, RECV_SCAN_SIZE - (buf_end - buf),
+				    ", len%u: %lu", i, len);
+	}
+	return buf_end;
+}
+
+/*********************************************************************//**
+Parse system fields of log record. */
+static
+void
+ib_log_sys_parse_sys_fields(
+/*========================*/
+	byte**		ptr,		/*!< in/out: pointer to log data */
+	byte*		body_end,	/*!< in: pointer to end of
+					a log record body */
+	ulint*		pos,		/*!< out: position */
+	trx_id_t*	trx_id,		/*!< out: trx id */
+	roll_ptr_t*	roll_ptr)	/*!< out: roll pointer */
+{
+	*ptr = mach_parse_compressed(*ptr, body_end, pos);
+	*roll_ptr = mach_read_from_7(*ptr);
+	*ptr += 7;
+	*ptr = mach_dulint_parse_compressed(*ptr, body_end, trx_id);
+}
+
+/*********************************************************************//**
+Parse the redo log record for delete marking or unmarking of a clustered
+index record. */
+static
+void
+ib_log_sys_parse_del_mark_set_clust_rec(
+/*====================================*/
+	ib_log_rec_itr_t	itr,		/*!< in/out: log iterator */
+	byte**			ptr,		/*!< in/out: pointer to
+						log data */
+	byte*			body_end)	/*!< in: pointer to end of a
+						log record body */
+{
+	ulint val;
+	ulint pos;
+	roll_ptr_t roll_ptr;
+	trx_id_t   trx_id;
+	ulint offset;
+	int ret;
+	ulint flags = mach_read_from_1(*ptr);
+	(*ptr)++;
+	val = mach_read_from_1(*ptr);
+	(*ptr)++;
+	ib_log_sys_parse_sys_fields(ptr, body_end, &pos, &trx_id, &roll_ptr);
+	offset = mach_read_from_2(*ptr);
+	*ptr += 2;
+	ret = asprintf(&itr->current_rec.body_str,
+		       "%sflags: 0x%lX, value: 0x%lX, position: 0x%lX, "
+		       "roll_ptr: 0x%llX, trx_id: 0x%llX, offset: 0x%lX",
+		       buf, flags, val, pos,
+		       ut_conv_dulint_to_longlong(roll_ptr),
+		       ut_conv_dulint_to_longlong(trx_id), offset);
+	ut_a (ret > 0);
+}
+
+/*********************************************************************//**
+Dump a log record as a hex string */
+static
+void
+ib_log_sys_output_raw(
+/*==================*/
+	byte**	ptr,		/*!< in/out: pointer to log data */
+	byte*	body_end,	/*!< in: pointer to end of a log record body */
+	char**	buf_end)	/*!< in/out: pointer to end of output buffer */
+{
+	while (*ptr != body_end) {
+		*buf_end += snprintf(*buf_end,
+				     RECV_SCAN_SIZE - (*buf_end - buf),
+				     " %02X", **ptr);
+		(*ptr)++;
+	}
+}
+
+/*********************************************************************//**
+Parse update of a compact record */
+static
+void
+ib_log_sys_parse_update_in_place(
+/*=============================*/
+	ib_log_rec_itr_t	itr,		/*!< in/out: log iterator */
+	byte**			ptr,		/*!< in/out: pointer to
+						log data */
+	byte*			body_end)	/*!< in: pointer to end of
+						a log record body */
+{
+	char *buf_end = buf + strlen(buf);
+	ulint pos;
+	roll_ptr_t roll_ptr;
+	trx_id_t   trx_id;
+	ulint offset;
+	ulint info_bits;
+	ulint n_fields;
+	unsigned i;
+	ulint flags = mach_read_from_1(*ptr);
+	(*ptr)++;
+	ib_log_sys_parse_sys_fields(ptr, body_end, &pos, &trx_id, &roll_ptr);
+	offset = mach_read_from_2(*ptr);
+	*ptr += 2;
+	info_bits = mach_read_from_1(*ptr);
+	(*ptr)++;
+	*ptr = mach_parse_compressed(*ptr, body_end, &n_fields);
+	buf_end += snprintf(buf_end, RECV_SCAN_SIZE - (buf_end - buf),
+			    "flags: 0x%lX, position: 0x%lX, roll_ptr: 0x%llX, "
+			    "trx_id: 0x%llX, offset: 0x%lX, info_bits: 0x%lX, "
+			    "n_fields: %lu", flags, pos,
+			    ut_conv_dulint_to_longlong(roll_ptr),
+			    ut_conv_dulint_to_longlong(trx_id), offset,
+			    info_bits, n_fields);
+	for (i = 0; i < n_fields; i++) {
+		ulint field_no;
+		ulint len;
+		*ptr = mach_parse_compressed(*ptr, body_end, &field_no);
+		buf_end += snprintf(buf_end, RECV_SCAN_SIZE - (buf_end - buf),
+				    ", field_no_%d: %lu", i, field_no);
+		*ptr = mach_parse_compressed(*ptr, body_end, &len);
+		if (len != UNIV_SQL_NULL) {
+			buf_end += snprintf(buf_end,
+					    RECV_SCAN_SIZE - (buf_end - buf),
+					    ", data_len_%d: %lu, data:", i,
+					    len);
+			ib_log_sys_output_raw(ptr, *ptr + len, &buf_end);
+		}
+		else {
+			buf_end += snprintf(buf_end,
+					    RECV_SCAN_SIZE - (buf_end - buf),
+					    ", data_len_%d: UNIV_SQL_NULL", i);
+		}
+	}
+	itr->current_rec.body_str = strdup(buf);
+}
+
+/*********************************************************************//**
+Parse delete record list */
+static
+void
+ib_log_sys_parse_delete_rec_list(
+/*=============================*/
+	ib_log_rec_itr_t	itr,	/*!< in/out: log iterator */
+	byte**			ptr)	/*!< in/out: pointer to log data */
+{
+	ulint offset = mach_read_from_2(*ptr);
+	char *buf_end = buf + strlen(buf);
+	*ptr += 2;
+	buf_end += snprintf(buf_end, RECV_SCAN_SIZE - (buf_end - buf),
+			    "offset: %lu", offset);
+	itr->current_rec.body_str = strdup(buf);
+}
+
+/*********************************************************************//**
+Read info bits of insert record */
+static
+void
+ib_log_sys_parse_info_origin_mismatch(
+/*==================================*/
+	byte**	ptr,		/*!< in/out: pointer to log data */
+	byte*	body_end,	/*!< in: pointer to end of a log record body */
+	char**	buf_end)	/*!< in/out: pointer to end of output buffer */
+{
+	ulint origin_offset;
+	ulint mismatch_index;
+	ulint info_and_status_bits = mach_read_from_1(*ptr);
+	(*ptr)++;
+	*ptr = mach_parse_compressed(*ptr, body_end, &origin_offset);
+	*ptr = mach_parse_compressed(*ptr, body_end, &mismatch_index);
+	*buf_end += snprintf(*buf_end, RECV_SCAN_SIZE - (*buf_end - buf),
+			    ", info_status_bits: 0x%lX, origin_offset: %lu, "
+			    "mismatch_index: %lu",
+			    info_and_status_bits, origin_offset,
+			    mismatch_index);
+}
+
+/*********************************************************************//**
+Parse compact record insert */
+static
+void
+ib_log_sys_parse_rec_insert(
+/*========================*/
+	ib_log_rec_itr_t	itr,		/*!< in/out: log iterator */
+	byte**			ptr,		/*!< in/out: pointer to
+						log data */
+	byte*			body_end)	/*!< in: pointer to end of a log
+						record body */
+{
+	char* buf_end = buf;
+	ulint end_seg_len;
+	ulint offset = mach_read_from_2(*ptr);
+	*ptr += 2;
+	*ptr = mach_parse_compressed(*ptr, body_end, &end_seg_len);
+	buf_end += snprintf(buf_end, RECV_SCAN_SIZE - (buf_end - buf),
+			    "offset: %lu, end_seg_len: %lu", offset,
+			    end_seg_len);
+	if (end_seg_len & 0x1UL) {
+
+		ib_log_sys_parse_info_origin_mismatch(ptr, body_end,
+						      &buf_end);
+	}
+	strcpy(buf_end, ", data:");
+	buf_end += strlen(", data:");
+	ib_log_sys_output_raw(ptr, *ptr + (end_seg_len >> 1), &buf_end);
+	itr->current_rec.body_str = strdup(buf);
+}
+
+/*********************************************************************//**
+Parse copy record list end to a new created index page */
+static
+void
+ib_log_sys_parse_end_list_copy(
+/*===========================*/
+	ib_log_rec_itr_t	itr,		/*!< in/out: log iterator */
+	byte**			ptr,		/*!< in/out: pointer to
+						log data */
+	byte*			body_end)	/*!< in: pointer to end of a
+						log record body */
+{
+	char *buf_end = buf + strlen(buf);
+	ulint data_len = mach_read_from_4(*ptr);
+	*ptr += 4;
+	buf_end += snprintf(buf_end, RECV_SCAN_SIZE - (buf_end - buf),
+			    "len: %lu", data_len);
+	while (*ptr < body_end) {
+		ulint end_seg_len;
+		*ptr = mach_parse_compressed(*ptr, body_end, &end_seg_len);
+		buf_end += snprintf(buf_end, RECV_SCAN_SIZE - (buf_end - buf),
+				    ", end_seg_len: %lu", end_seg_len);
+		if (end_seg_len & 0x1UL) {
+
+			ib_log_sys_parse_info_origin_mismatch(ptr, body_end,
+							      &buf_end);
+		}
+		strcpy(buf_end, ", data:");
+		buf_end += strlen(", data:");
+		ib_log_sys_output_raw(ptr, *ptr + (end_seg_len >> 1),
+				      &buf_end);
+	}
+	itr->current_rec.body_str = strdup(buf);
+}
+
+/*********************************************************************//**
+Parse delete record from the page */
+static
+void
+ib_log_sys_parse_delete_rec(
+/*========================*/
+	ib_log_rec_itr_t	itr,	/*!< in/out: log iterator */
+	byte**			ptr)	/*!< in/out: pointer to log data */
+{
+	char* buf_end = buf + strlen(buf);
+	ulint offset = mach_read_from_2(*ptr);
+	*ptr += 2;
+	buf_end += snprintf(buf, RECV_SCAN_SIZE, "offset: %lu", offset);
+	itr->current_rec.body_str = strdup(buf);
+}
+
+/*********************************************************************//**
+Parse a file operation record */
+static
+void
+ib_log_sys_parse_fil_op(
+/*====================*/
+	ib_log_rec_itr_t	itr,		/*!< in/out: log iterator */
+	byte**			ptr,		/*!< in/out: pointer to
+						log data */
+	char**			buf_end)	/*!< in: pointer to end of a
+						log record body */
+{
+	const char* name;
+	ulint name_len = mach_read_from_2(*ptr);
+	*ptr += 2;
+	name = (const char *)(*ptr);
+	*ptr += name_len;
+	*buf_end += snprintf(*buf_end, RECV_SCAN_SIZE - (*buf_end - buf),
+			    "name_len: %lu, name: \"%s\"", name_len, name);
+	if (itr->current_rec.type == MLOG_FILE_RENAME) {
+		const char* new_name;
+		ulint new_name_len = mach_read_from_2(*ptr);
+		*ptr += 2;
+		new_name = (const char *)(*ptr);
+		*ptr += new_name_len;
+		*buf_end += snprintf(*buf_end,
+				    RECV_SCAN_SIZE - (*buf_end - buf),
+				    ", new_name_len: %lu, new_name: \"%s\"",
+				    new_name_len,  new_name);
+	}
+	itr->current_rec.body_str = strdup(buf);
+}
+
+/*********************************************************************//**
+Get name of operation with compressed page */
+static
+const char*
+ib_log_sys_get_zip_op_name(
+/*=======================*/
+	byte	type)	/*!< in: log record type */
+{
+	if (type == MLOG_ZIP_WRITE_NODE_PTR)
+		return "node_ptr";
+	if (type == MLOG_ZIP_WRITE_BLOB_PTR)
+		return "blob_ptr";
+	ut_a (0);
+	return "WRONG TYPE";
+}
+
+/*********************************************************************//**
+Get pointer length for operation with compressed page */
+static
+ulint
+ib_log_sys_get_zip_op_ptr_len(
+/*==========================*/
+	byte	type)	/*!< in: log record type */
+{
+	if (type == MLOG_ZIP_WRITE_NODE_PTR)
+		return REC_NODE_PTR_SIZE;
+	if (type == MLOG_ZIP_WRITE_BLOB_PTR)
+		return BTR_EXTERN_FIELD_REF_SIZE;
+	ut_a (0);
+	return ULINT_UNDEFINED;
+}
+
+/*********************************************************************//**
+Parse operation with compressed page */
+static
+void
+ib_log_sys_parse_zip_op(
+/*====================*/
+	ib_log_rec_itr_t	itr,	/*!< in/out: log iterator */
+	byte**			ptr)	/*!< in/out: pointer to log data */
+{
+	char* buf_end = buf;
+	ulint z_offset;
+	ulint offset = mach_read_from_2(*ptr);
+	*ptr += 2;
+	z_offset = mach_read_from_2(*ptr);
+	*ptr += 2;
+	buf_end += snprintf(buf_end,
+			    RECV_SCAN_SIZE - (buf_end - buf),
+			    "offset: %lu, zip_offset: %lu, "
+			    "%s:",
+			    offset, z_offset,
+			    ib_log_sys_get_zip_op_name(itr->current_rec.type));
+	ib_log_sys_output_raw(ptr, *ptr + ib_log_sys_get_zip_op_ptr_len(
+				      itr->current_rec.type), &buf_end);
+	itr->current_rec.body_str = strdup(buf);
+}
+
+/*********************************************************************//**
+Parse log record body */
+static
+void
+ib_log_sys_parse_rec_body(
+/*======================*/
+	ib_log_rec_itr_t	itr,		/*!< in/out: log iterator */
+	byte*			body_start,	/*!< in: pointer to start of
+						a log record body */
+	byte*			body_end)	/*!< in: pointer to end of a log
+						record body */
+{
+	byte* ptr = body_start;
+
+	ut_a (ib_log_sys_rec_has_body(&itr->current_rec) || ptr == NULL
+	      || body_start == body_end);
+	if (ptr == NULL)
+		ptr = body_end;
+
+	buf[0] = '\0';
+
+	if (itr->current_rec.body_str) {
+
+		free (itr->current_rec.body_str);
+		itr->current_rec.body_str = NULL;
+	}
+
+	switch (itr->current_rec.type) {
+	case MLOG_1BYTE:
+	case MLOG_2BYTES:
+	case MLOG_4BYTES:
+		{
+			ulint offset = mach_read_from_2(ptr);
+			ulint val;
+			int ret;
+			ptr += 2;
+			ptr = mach_parse_compressed(ptr, body_end, &val);
+			ret = asprintf(&itr->current_rec.body_str,
+				       "offset: %lu, value: 0x%lX", offset,
+				       val);
+			ut_a (ret > 0);
+			break;
+		}
+	case MLOG_8BYTES:
+		{
+			ulint offset = mach_read_from_2(ptr);
+			dulint val;
+			int ret;
+			ptr += 2;
+			ptr = mach_dulint_parse_compressed(ptr, body_end,
+							   &val);
+			ret = asprintf(&itr->current_rec.body_str,
+				       "offset: %lu, value: 0x%llX", offset,
+				       ut_conv_dulint_to_longlong(val));
+			ut_a (ret > 0);
+			break;
+		}
+	case MLOG_REC_INSERT:
+		ib_log_sys_parse_rec_insert(itr, &ptr, body_end);
+		break;
+	case MLOG_COMP_REC_INSERT:
+		ib_log_sys_parse_index(&ptr);
+		ib_log_sys_parse_rec_insert(itr, &ptr, body_end);
+		break;
+	case MLOG_COMP_PAGE_REORGANIZE:
+		ib_log_sys_parse_index(&ptr);
+		itr->current_rec.body_str = strdup(buf);
+		break;
+	case MLOG_COMP_REC_CLUST_DELETE_MARK:
+		{
+			char* buf_end = ib_log_sys_parse_index(&ptr);
+			*buf_end++ = ',';
+			*buf_end++ = ' ';
+			ib_log_sys_parse_del_mark_set_clust_rec(itr, &ptr,
+								body_end);
+			break;
+		}
+	case MLOG_REC_SEC_DELETE_MARK:
+		{
+			int ret;
+			ulint offset;
+			ulint val = mach_read_from_1(ptr);
+			ptr++;
+			offset = mach_read_from_2(ptr);
+			ptr += 2;
+			ret = asprintf(&itr->current_rec.body_str,
+				       "value: %lu, offset: %lu", val, offset);
+			ut_a(ret > 0);
+			break;
+		}
+	case MLOG_REC_CLUST_DELETE_MARK:
+		ib_log_sys_parse_del_mark_set_clust_rec(itr, &ptr, body_end);
+		break;
+	case MLOG_REC_UPDATE_IN_PLACE:
+		ib_log_sys_parse_update_in_place(itr, &ptr, body_end);
+		break;
+	case MLOG_COMP_REC_UPDATE_IN_PLACE:
+		{
+			char* buf_end = ib_log_sys_parse_index(&ptr);
+			*buf_end++ = ',';
+			*buf_end++ = ' ';
+			ib_log_sys_parse_update_in_place(itr, &ptr, body_end);
+			break;
+		}
+	case MLOG_LIST_END_DELETE:
+	case MLOG_LIST_START_DELETE:
+		/* TODO: test */
+		ib_log_sys_parse_delete_rec_list(itr, &ptr);
+		break;
+	case MLOG_COMP_LIST_END_DELETE:
+	case MLOG_COMP_LIST_START_DELETE:
+		{
+			char* buf_end = ib_log_sys_parse_index(&ptr);
+			*buf_end++ = ','; *buf_end++ = ' '; *buf_end++ = '\0';
+			ib_log_sys_parse_delete_rec_list(itr, &ptr);
+			break;
+		}
+	case MLOG_LIST_END_COPY_CREATED:
+		/* TODO: test */
+		ib_log_sys_parse_end_list_copy(itr, &ptr, body_end);
+		break;
+	case MLOG_COMP_LIST_END_COPY_CREATED:
+		{
+			char* buf_end = ib_log_sys_parse_index(&ptr);
+			*buf_end++ = ',';
+			*buf_end++ = ' ';
+			ib_log_sys_parse_end_list_copy(itr, &ptr, body_end);
+			break;
+		}
+	case MLOG_UNDO_INSERT:
+		{
+			char* buf_end = buf;
+			ulint data_len = mach_read_from_2(ptr);
+			ptr += 2;
+			buf_end += snprintf(buf_end,
+					    RECV_SCAN_SIZE - (buf_end - buf),
+					    "data_len: %lu, data:", data_len);
+			ib_log_sys_output_raw(&ptr, ptr + data_len, &buf_end);
+			itr->current_rec.body_str = strdup(buf);
+			break;
+		}
+	case MLOG_UNDO_INIT:
+		{
+			int ret;
+			ulint undo_log_seg_type;
+			ptr = mach_parse_compressed(ptr, body_end,
+						    &undo_log_seg_type);
+			ret = asprintf(&itr->current_rec.body_str,
+				       "undo_log_seg_type: %lu",
+				       undo_log_seg_type);;
+			ut_a (ret > 0);
+			break;
+		}
+	case MLOG_UNDO_HDR_CREATE:
+	case MLOG_UNDO_HDR_REUSE:
+		{
+			int ret;
+			trx_id_t trx_id;
+			/* TODO: test _REUSE */
+			ptr = mach_dulint_parse_compressed(ptr, body_end,
+							   &trx_id);
+			ret = asprintf(&itr->current_rec.body_str,
+				       "trx_id: 0x%llX",
+				       ut_conv_dulint_to_longlong(trx_id));
+			ut_a (ret > 0);
+			break;
+		}
+	case MLOG_REC_MIN_MARK:
+	case MLOG_COMP_REC_MIN_MARK:
+		{
+			/* TODO: test MLOG_REC_MIN_MARK */
+			int ret;
+			ulint min_rec_mark_offset = mach_read_from_2(ptr);
+			ptr += 2;
+			ret = asprintf(&itr->current_rec.body_str,
+				       "min_rec_mark_offset: %lu",
+				       min_rec_mark_offset);
+			ut_a (ret > 0);
+			break;
+		}
+	case MLOG_REC_DELETE:
+		ib_log_sys_parse_delete_rec(itr, &ptr);
+		break;
+	case MLOG_COMP_REC_DELETE:
+		{
+			char* buf_end = ib_log_sys_parse_index(&ptr);
+			*buf_end++ = ',';
+			*buf_end++ = ' ';
+			ib_log_sys_parse_delete_rec(itr, &ptr);
+			break;
+		}
+	case MLOG_WRITE_STRING:
+		{
+			ulint data_len;
+			char* buf_end = buf;
+			ulint offset = mach_read_from_2(ptr);
+			ptr += 2;
+			data_len = mach_read_from_2(ptr);
+			ptr += 2;
+			buf_end += snprintf(buf_end,
+					    RECV_SCAN_SIZE - (buf_end - buf),
+					    "offset: %lu, data_len: %lu, "
+					    "data:", offset, data_len);
+			ib_log_sys_output_raw(&ptr, ptr + data_len, &buf_end);
+			itr->current_rec.body_str = strdup(buf);
+			break;
+		}
+	case MLOG_FILE_CREATE2:
+		{
+			/* TODO: test */
+			char* buf_end = buf;
+			ulint flags = mach_read_from_4(ptr);
+			ptr += 4;
+			buf_end += snprintf(buf_end,
+					    RECV_SCAN_SIZE - (buf_end - buf),
+					    "flags: 0x%lX:", flags);
+			*buf_end++ = ',';
+			*buf_end++ = ' ';
+			ib_log_sys_parse_fil_op(itr, &ptr, &buf_end);
+			break;
+		}
+	case MLOG_FILE_CREATE:
+	case MLOG_FILE_RENAME:
+	case MLOG_FILE_DELETE:
+		{
+			char* buf_end = buf;
+			ib_log_sys_parse_fil_op(itr, &ptr, &buf_end);
+			break;
+		}
+	case MLOG_ZIP_WRITE_NODE_PTR:
+	case MLOG_ZIP_WRITE_BLOB_PTR:
+		/* TODO: test */
+		ib_log_sys_parse_zip_op(itr, &ptr);
+		break;
+	case MLOG_ZIP_WRITE_HEADER:
+		{
+			/* TODO: test */
+			ulint offset = *ptr++;
+			ulint data_len = *ptr++;
+			char* buf_end = buf;
+			buf_end += snprintf(buf_end,
+					    RECV_SCAN_SIZE - (buf_end - buf),
+					    "offset: %lu, data_len: %lu, "
+					    "data:", offset, data_len);
+			ib_log_sys_output_raw(&ptr, ptr + data_len, &buf_end);
+			itr->current_rec.body_str = strdup(buf);
+			break;
+		}
+	case MLOG_ZIP_PAGE_COMPRESS:
+		{
+			/* TODO: test */
+			char* buf_end = buf;
+			ulint trailer_size;
+			ulint size = mach_read_from_2(ptr);
+			ptr += 2;
+			trailer_size = mach_read_from_2(ptr);
+			ptr += 2;
+			buf_end += snprintf(buf_end,
+					    RECV_SCAN_SIZE - (buf_end - buf),
+					    "data_size: %lu, "
+					    "trailer_size: %lu, page_prev:",
+					    size, trailer_size);
+			ib_log_sys_output_raw(&ptr, ptr + 4, &buf_end);
+			ptr += 4;
+			buf_end += snprintf(buf_end,
+					    RECV_SCAN_SIZE - (buf_end - buf),
+					    ", page_next:");
+			ib_log_sys_output_raw(&ptr, ptr + 4, &buf_end);
+			ptr += 4;
+			buf_end += snprintf(buf_end,
+					    RECV_SCAN_SIZE - (buf_end - buf),
+					    ", data:");
+			ib_log_sys_output_raw(&ptr, ptr + size, &buf_end);
+			ptr += size;
+			buf_end += snprintf(buf_end,
+					    RECV_SCAN_SIZE - (buf_end - buf),
+					    ", trailer_data:");
+			ib_log_sys_output_raw(&ptr, ptr + trailer_size,
+					      &buf_end);
+			ptr += trailer_size;
+			itr->current_rec.body_str = strdup(buf);
+			break;
+		}
+	case MLOG_INIT_FILE_PAGE:
+	case MLOG_IBUF_BITMAP_INIT:
+	case MLOG_UNDO_HDR_DISCARD: /* TODO: test */
+	case MLOG_PAGE_REORGANIZE: /* TODO: test */
+	case MLOG_PAGE_CREATE:
+	case MLOG_COMP_PAGE_CREATE:
+	case MLOG_UNDO_ERASE_END:
+	case MLOG_MULTI_REC_END:
+	case MLOG_DUMMY_RECORD:
+	case MLOG_LSN:
+		/* No body */
+		break;
+	default: ;
+		ib_logger(ib_stream, "Corrupt log rec at LSN = %llu, ",
+			  itr->current_rec.lsn);
+		ut_a(0);
+	}
+	ut_a (ptr == body_end);
+}
+
+/*********************************************************************//**
+Get next log record */
+HAILDB_API
+ib_log_rec_t
+ib_log_sys_get_next_rec(
+/*====================*/
+	ib_log_rec_itr_t	itr)	/*!< in: log iterator */
+{
+	ulint len;
+	byte  type;
+	ulint space;
+	ulint page_no;
+	byte* body;
+
+	/* Already reached the end of requested LSN range? */
+	if (itr->next_parse_lsn >= itr->end_lsn)
+		return NULL;
+
+	if (itr->parse_buf_ptr == itr->parse_buf_end) {
+
+		/* Parse buf empty */
+		if (!fill_parse_buffer(itr))
+			return NULL;
+	}
+
+	/* Have some data in the parse buf, parse it */
+	recv_sys->found_corrupt_log = FALSE;
+	len = recv_parse_log_rec(itr->parse_buf_ptr, itr->parse_buf_end, &type,
+				 &space, &page_no, &body);
+	if (recv_sys->found_corrupt_log) {
+
+		/* Uh-oh, corrupt log. Now what? */
+		ib_logger(ib_stream, "Corrupt log at LSN = %llu, "
+			  "proceeding in 1 byte increments, "
+			  "no correct parse guarantee and InnoDB may crash!\n",
+			  itr->next_parse_lsn);
+		itr->parse_buf_ptr++;
+		itr->next_parse_lsn
+			= recv_calc_lsn_on_data_add(itr->next_parse_lsn, 1);
+		return ib_log_sys_get_next_rec(itr);
+	}
+	if (len > 0) {
+
+		/* Full rec, see if its LSN is inside the requested range  */
+		if (itr->next_parse_lsn >= itr->start_lsn) {
+
+			itr->current_rec.single_rec
+				= (*itr->parse_buf_ptr & MLOG_SINGLE_REC_FLAG)
+				!= 0;
+			itr->current_rec.lsn = itr->next_parse_lsn;
+			itr->current_rec.len = len;
+			itr->current_rec.type = type;
+
+			if (log_online_rec_has_page(type)) {
+
+				itr->current_rec.space = space;
+				itr->current_rec.page_no = page_no;
+			}
+			else {
+
+				itr->current_rec.space = ULINT_UNDEFINED;
+				itr->current_rec.page_no = ULINT_UNDEFINED;
+			}
+
+			itr->parse_buf_ptr += len;
+			ib_log_sys_parse_rec_body(itr, body,
+						  itr->parse_buf_ptr);
+
+			itr->next_parse_lsn
+				= recv_calc_lsn_on_data_add(
+					itr->next_parse_lsn, len);
+
+			return &itr->current_rec;
+		}
+		else if (itr->next_parse_lsn < itr->start_lsn) {
+
+			/* Full rec but below the requested LSN range.  Eat it,
+			try the next one. */
+			itr->parse_buf_ptr += len;
+			itr->next_parse_lsn
+				= recv_calc_lsn_on_data_add(
+					itr->next_parse_lsn, len);
+			return ib_log_sys_get_next_rec(itr);
+		}
+		else {
+
+			/* Rec past the requested LSN range, EOF */
+			ut_a (itr->next_parse_lsn > itr->end_lsn);
+			return NULL;
+		}
+	}
+
+	/* Incomplete rec.  Shift it to the beginning of the parse buffer, get
+	more data and parse it again.  */
+	ut_memmove(itr->parse_buf, itr->parse_buf_ptr,
+		   itr->parse_buf_end - itr->parse_buf_ptr);
+	itr->parse_buf_end = itr->parse_buf
+		+ (itr->parse_buf_end - itr->parse_buf_ptr);
+	itr->parse_buf_ptr = itr->parse_buf;
+
+	if (!fill_parse_buffer(itr)) {
+
+		ib_logger(ib_stream, "Incomplete record at LSN = %llu\n",
+			  itr->next_parse_lsn);
+		return NULL;
+	}
+	return ib_log_sys_get_next_rec(itr);
+}
+
+/*********************************************************************//**
+Get LSN of record */
+HAILDB_API
+ib_u64_t
+ib_log_sys_get_rec_lsn(
+/*===================*/
+	const ib_log_rec_t	log_rec)	/*!< in: log record */
+{
+	return log_rec->lsn;
+}
+
+/*********************************************************************//**
+Get length of record */
+HAILDB_API
+ib_ulint_t
+ib_log_sys_get_rec_len(
+/*===================*/
+	const ib_log_rec_t	log_rec)	/*!< in: log record */
+{
+	return log_rec->len;
+}
+
+/*********************************************************************//**
+Get log record type (MLOG_*) */
+HAILDB_API
+ib_byte_t
+ib_log_sys_get_rec_type(
+/*====================*/
+	const ib_log_rec_t	log_rec)	/*!< in: log record */
+{
+	return log_rec->type;
+}
+
+/*********************************************************************//**
+@return TRUE if MLOG_SINGLE_REC_FLAG is set for log record */
+HAILDB_API
+ib_bool_t
+ib_log_sys_get_single_rec_flag(
+/*===========================*/
+	const ib_log_rec_t	log_rec)	/*!< in: log record */
+{
+	return log_rec->single_rec != 0;
+}
+
+/*********************************************************************//**
+@return space id associated with log record or ULINT_UNDEFINED if
+record doesn't have space id associated */
+HAILDB_API
+ib_ulint_t
+ib_log_sys_get_rec_space(
+/*=====================*/
+	const ib_log_rec_t	log_rec)	/*!< in: log record */
+{
+	if (!log_online_rec_has_page(log_rec->type))
+		ut_a (log_rec->space == ULINT_UNDEFINED);
+	return log_rec->space;
+}
+
+/*********************************************************************//**
+@return page id associated with log record or ULINT_UNDEFINED if
+record doesn't have page id associated */
+HAILDB_API
+ib_ulint_t
+ib_log_sys_get_rec_page_no(
+/*=======================*/
+	const ib_log_rec_t	log_rec)	/*!< in: log record */
+{
+	if (!log_online_rec_has_page(log_rec->type))
+		ut_a (log_rec->page_no == ULINT_UNDEFINED);
+	return log_rec->page_no;
+}
+
+/*********************************************************************//**
+Release log iterator */
+HAILDB_API
+void
+ib_log_sys_free_iterator(
+/*=====================*/
+	ib_log_rec_itr_t	itr)	/*!< in: log iterator */
+{
+	mem_free(itr->read_buf);
+	mem_free(itr->parse_buf);
+	mem_free(itr);
+}
+
+/*********************************************************************//**
+@return page id associated with log record or ULINT_UNDEFINED if
+record doesn't have page id associated */
+HAILDB_API
+const char *
+ib_log_sys_get_rec_name(
+/*====================*/
+	const ib_log_rec_t	log_rec)	/*!< in: log record */
+{
+	byte type = ib_log_sys_get_rec_type(log_rec);
+	if (type < sizeof(mlog_type_names) / sizeof(char*))
+		return mlog_type_names[type];
+	return "undefined";
+}
+
+/*********************************************************************//**
+@return TRUE if is log record about an .ibd file operation */
+HAILDB_API
+ib_bool_t
+ib_log_sys_rec_has_mlog_file_flag(
+/*==============================*/
+	const ib_log_rec_t	log_rec)	/*!< in: log record */
+{
+	return log_rec->type == MLOG_FILE_CREATE
+		|| log_rec->type == MLOG_FILE_RENAME
+		|| log_rec->type == MLOG_FILE_DELETE
+		|| log_rec->type == MLOG_FILE_CREATE2;
+}
+
+/*********************************************************************//**
+@return TRUE if MLOG_FILE_FLAG_TEMP is set */
+HAILDB_API
+ib_bool_t
+ib_log_sys_get_mlog_file_flag_temp(
+/*===============================*/
+	const ib_log_rec_t	log_rec)	/*!< in: log record */
+{
+	ut_ad (ib_log_sys_rec_has_mlog_file_flag(log_rec));
+	return ib_log_sys_get_rec_page_no(log_rec) & MLOG_FILE_FLAG_TEMP;
+}
+
+/*********************************************************************//**
+@return TRUE if record of type MLOG_LSN (LSN pseudo-record) */
+HAILDB_API
+ib_bool_t
+ib_log_sys_is_mlog_lsn_rec(
+/*=======================*/
+	const ib_log_rec_t	log_rec)	/*!< in: log record */
+{
+	return log_rec->type == MLOG_LSN;
+}
+
+/*********************************************************************//**
+@return LSN from lsn pseudo-record */
+HAILDB_API
+ib_u64_t
+ib_log_sys_get_mlog_lsn(
+/*====================*/
+	const ib_log_rec_t	log_rec)	/*!< in: log record */
+{
+	ut_a (ib_log_sys_is_mlog_lsn_rec(log_rec));
+	return (ib_u64_t)log_rec->space << 32 | log_rec->page_no;
+}
+
+/*********************************************************************//**
+@return TRUE if log record has body */
+HAILDB_API
+ib_bool_t
+ib_log_sys_rec_has_body(
+/*====================*/
+	const ib_log_rec_t	log_rec)	/*!< in: log record */
+{
+	return log_rec->type != MLOG_MULTI_REC_END
+		&& log_rec->type != MLOG_DUMMY_RECORD
+		&& log_rec->type != MLOG_LSN
+		&& log_rec->type != MLOG_PAGE_REORGANIZE
+		&& log_rec->type != MLOG_PAGE_CREATE
+		&& log_rec->type != MLOG_COMP_PAGE_CREATE
+		&& log_rec->type != MLOG_UNDO_ERASE_END
+		&& log_rec->type != MLOG_UNDO_HDR_DISCARD
+		&& log_rec->type != MLOG_IBUF_BITMAP_INIT
+		&& log_rec->type != MLOG_INIT_FILE_PAGE;
+}
+
+/*********************************************************************//**
+@return log record's body as string */
+HAILDB_API
+const char*
+ib_log_sys_get_rec_body_str(
+/*========================*/
+	const ib_log_rec_t	log_rec)	/*!< in: log record */
+{
+	ut_ad (ib_log_sys_rec_has_body(log_rec));
+	return log_rec->body_str;
+}
+
+/*********************************************************************//**
+Print log records in human-readable format */
+ibool
+ib_log_sys_print(
+/*=============*/
+	ib_uint64_t	start_lsn,		/*!< in: parse start LSN.
+						0 for START_LSN_LAST_CP */
+	ib_uint64_t	end_lsn,		/*!< in: parse end LSN.
+						IB_ULONGLONG_MAX for log to be
+						parsed to the end */
+	ulint		filter_space,		/*!< in: Space ID to filter
+						records on or ULINT_UNDEFINED */
+	ulint		filter_page,		/*!< in: Page ID to filter
+						records on or ULINT_UNDEFINED */
+	ibool		numeric,		/*!< in: TRUE for output log
+						item type byte values instead of
+						mnemonics */
+	ibool		print_rec_bodies)	/*!< in: TRUE for print log
+						record body contents */
+{
+	ib_err_t ib_err;
+
+	if (start_lsn == 0) {
+		ib_logger(ib_stream, "Reading last checkpoint LSN\n");
+		ib_err = ib_log_sys_find_last_checkpoint_lsn(&start_lsn);
+		if (ib_err != DB_SUCCESS) {
+			ib_logger(ib_stream,
+				"ib_log_sys_find_last_checkpoint_lsn: %d\n",
+				ib_err);
+			return FALSE;
+		}
+	}
+
+	ib_logger(ib_stream, "Reading InnoDB redo logs "
+				"from LSN %llu to %llu\n",
+				start_lsn, end_lsn);
+
+	ib_log_rec_itr_t log_rec_iterator =
+		ib_log_sys_create_iterator(start_lsn, end_lsn);
+	ib_log_rec_t log_rec;
+
+	while ((log_rec = ib_log_sys_get_next_rec(log_rec_iterator)) != NULL) {
+
+		ib_ulint_t space = ib_log_sys_get_rec_space(log_rec);
+		ib_ulint_t page = ib_log_sys_get_rec_page_no(log_rec);
+
+		if ((filter_space != ULINT_UNDEFINED && space != filter_space)
+			|| (filter_page != ULINT_UNDEFINED
+				&& page != filter_page))
+			continue;
+
+		ib_logger(ib_stream, "{LSN: %llu, len: %lu, type: ",
+				     ib_log_sys_get_rec_lsn(log_rec),
+				     ib_log_sys_get_rec_len(log_rec));
+		if (numeric) {
+			ib_logger(ib_stream,
+				  "%d", ib_log_sys_get_rec_type(log_rec));
+		} else {
+			ib_logger(ib_stream,
+				  "%s", ib_log_sys_get_rec_name(log_rec));
+		}
+		ib_logger(ib_stream, ", singlerec: %d",
+			  (ib_log_sys_get_single_rec_flag(log_rec) ? 1 : 0));
+
+		if (ib_log_sys_rec_has_mlog_file_flag(log_rec)) {
+			ib_logger(ib_stream, ", MLOG_FILE_FLAG_TEMP: %d",
+				(ib_log_sys_get_mlog_file_flag_temp(log_rec) ?
+							 1 : 0));
+		} else if (ib_log_sys_is_mlog_lsn_rec(log_rec)) {
+			ib_logger(ib_stream, ", mloglsn: %llu",
+				  ib_log_sys_get_mlog_lsn(log_rec));
+		} else if (space != ULINT_UNDEFINED) {
+			ib_logger(ib_stream, ", space: %lu, page: %lu",
+				  space, page);
+		} else {
+			assert(page == ULINT_UNDEFINED);
+		}
+
+		if (print_rec_bodies && ib_log_sys_rec_has_body(log_rec))
+		{
+			ib_logger(ib_stream, ", %s",
+				  ib_log_sys_get_rec_body_str(log_rec));
+		}
+		ib_logger(ib_stream, "}\n");
+	}
+	ib_log_sys_free_iterator(log_rec_iterator);
+	return TRUE;
+}
 
=== added file 'src/api_log.h'
--- src/api_log.h	1970-01-01 00:00:00 +0000
+++ src/api_log.h	2012-12-05 22:33:23 +0000
@@ -0,0 +1,213 @@
+/*
+ * Copyright (C) 2012 Percona Inc.
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef api_log_h
+#define api_log_h
+
+#include "univ.i"
+#include "innodb_int.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define HAILDB_API UNIV_INTERN
+
+typedef struct ib_log_rec_itr_struct* ib_log_rec_itr_t;
+
+typedef struct ib_log_rec_struct* ib_log_rec_t;
+
+/*********************************************************************//**
+Initialize InnoDB systems needed for the log printer
+@return DB_SUCCESS if successfull */
+HAILDB_API
+ib_err_t
+ib_log_sys_start(
+/*=============*/
+	ib_ulint_t	log_buf_size,	/*!< in: the size of the buffer */
+	const char*	log_dir);	/*!< in: path to InnoDB log files. */
+
+/*********************************************************************//**
+Uninitialize InnoDB systems needed for the log printer */
+HAILDB_API
+void
+ib_log_sys_stop(void);
+
+/*********************************************************************//**
+Find last consistent checkpoint LSN in log groups */
+HAILDB_API
+ib_err_t
+ib_log_sys_find_last_checkpoint_lsn(
+/*================================*/
+	ib_u64_t*	last_checkpoint_lsn);	/*!< out: last checkpoint LSN */
+
+/*********************************************************************//**
+Create iterator through log records */
+HAILDB_API
+ib_log_rec_itr_t
+ib_log_sys_create_iterator(
+/*=======================*/
+	ib_u64_t	start_lsn,	/*!< in: starting LSN */
+	ib_u64_t	end_lsn);	/*!< in: last LSN */
+
+/*********************************************************************//**
+Get next log record */
+HAILDB_API
+ib_log_rec_t
+ib_log_sys_get_next_rec(
+/*====================*/
+	ib_log_rec_itr_t	itr);	/*!< in: log iterator */
+
+/*********************************************************************//**
+Release log iterator */
+HAILDB_API
+void
+ib_log_sys_free_iterator(
+/*=====================*/
+	ib_log_rec_itr_t	itr);	/*!< in: log iterator */
+
+/*********************************************************************//**
+Get LSN of record */
+HAILDB_API
+ib_u64_t
+ib_log_sys_get_rec_lsn(
+/*===================*/
+	const ib_log_rec_t	log_rec);	/*!< in: log record */
+
+/*********************************************************************//**
+Get length of record */
+HAILDB_API
+ib_ulint_t
+ib_log_sys_get_rec_len(
+/*===================*/
+	const ib_log_rec_t	log_rec);	/*!< in: log record */
+
+/*********************************************************************//**
+Get log record type (MLOG_*) */
+HAILDB_API
+ib_byte_t
+ib_log_sys_get_rec_type(
+/*====================*/
+	const ib_log_rec_t	log_rec);	/*!< in: log record */
+
+
+/*********************************************************************//**
+@return TRUE if MLOG_SINGLE_REC_FLAG is set for log record */
+HAILDB_API
+ib_bool_t
+ib_log_sys_get_single_rec_flag(
+/*===========================*/
+	const ib_log_rec_t	log_rec);	/*!< in: log record */
+
+/*********************************************************************//**
+@return space id associated with log record or ULINT_UNDEFINED if
+record doesn't have space id associated */
+HAILDB_API
+ib_ulint_t
+ib_log_sys_get_rec_space(
+/*=====================*/
+	const ib_log_rec_t	log_rec);	/*!< in: log record */
+
+/*********************************************************************//**
+@return page id associated with log record or ULINT_UNDEFINED if
+record doesn't have page id associated */
+HAILDB_API
+ib_ulint_t
+ib_log_sys_get_rec_page_no(
+/*=======================*/
+	const ib_log_rec_t	log_rec);	/*!< in: log record */
+
+/*********************************************************************//**
+@return page id associated with log record or ULINT_UNDEFINED if
+record doesn't have page id associated */
+HAILDB_API
+const char *
+ib_log_sys_get_rec_name(
+/*====================*/
+	const ib_log_rec_t	log_rec);	/*!< in: log record */
+
+/*********************************************************************//**
+@return TRUE if is log record about an .ibd file operation */
+HAILDB_API
+ib_bool_t
+ib_log_sys_rec_has_mlog_file_flag(
+/*==============================*/
+	const ib_log_rec_t	log_rec);	/*!< in: log record */
+
+/*********************************************************************//**
+@return TRUE if MLOG_FILE_FLAG_TEMP is set */
+HAILDB_API
+ib_bool_t
+ib_log_sys_get_mlog_file_flag_temp(
+/*===============================*/
+	const ib_log_rec_t	log_rec);	/*!< in: log record */
+
+/*********************************************************************//**
+@return TRUE if record of type MLOG_LSN (LSN pseudo-record) */
+HAILDB_API
+ib_bool_t
+ib_log_sys_is_mlog_lsn_rec(
+/*=======================*/
+	const ib_log_rec_t	log_rec);	/*!< in: log record */
+
+/*********************************************************************//**
+@return LSN from lsn pseudo-record */
+HAILDB_API
+ib_u64_t
+ib_log_sys_get_mlog_lsn(
+/*====================*/
+	const ib_log_rec_t	log_rec);	/*!< in: log record */
+
+/*********************************************************************//**
+@return TRUE if log record has body */
+HAILDB_API
+ib_bool_t
+ib_log_sys_rec_has_body(
+/*====================*/
+	const ib_log_rec_t	log_rec);	/*!< in: log record */
+
+/*********************************************************************//**
+@return log record's body as string */
+HAILDB_API
+const char*
+ib_log_sys_get_rec_body_str(
+/*========================*/
+	const ib_log_rec_t	log_rec);	/*!< in: log record */
+
+/*********************************************************************//**
+Print log records in human-readable format */
+ibool
+ib_log_sys_print(
+/*=============*/
+	ib_uint64_t	start_lsn,		/*!< in: parse start LSN.
+						0 for START_LSN_LAST_CP */
+	ib_uint64_t	end_lsn,		/*!< in: parse end LSN.
+						IB_ULONGLONG_MAX for log to be
+						parsed to the end */
+	ulint		filter_space,		/*!< in: Space ID to filter
+						records on or ULINT_UNDEFINED */
+	ulint		filter_page,		/*!< in: Page ID to filter
+						records on or ULINT_UNDEFINED */
+	ibool		numeric,		/*!< in: TRUE for output log
+						item type byte values instead of
+						mnemonics */
+	ibool		print_rec_bodies);	/*!< in: TRUE for print log
+						record body contents */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
+
+#endif
 
=== added file 'src/api_page.c'
--- src/api_page.c	1970-01-01 00:00:00 +0000
+++ src/api_page.c	2012-12-05 22:33:23 +0000
@@ -0,0 +1,3522 @@
+/*
+ * Copyright (C) 2012 Percona Inc.
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define DULINT_STANDARD
+
+#include <fil0fil.h>
+#include <log0log.h>
+#include <log0recv.h>
+#include <rem0rec.h>
+#include <os0file.h>
+#include <os0sync.h>
+#include <sync0sync.h>
+#include <srv0srv.h>
+#include <fsp0fsp.h>
+#include <buf0buf.h>
+#include <trx0undo.h>
+#include <btr0btr.h>
+#include <page0page.h>
+#include <page0zip.h>
+#include <lock0lock.h>
+#include <btr0pcur.h>
+#include <ibuf0ibuf.h>
+#include <dict0load.h>
+#include <dict0boot.h>
+#include <trx0rec.h>
+#include <row0upd.h>
+#include <row0row.h>
+#include <fsp0fsp.h>
+#include <data0type.h>
+#include <dict0boot.h>
+#include <srv0start.h>
+#include "api_page.h"
+#include "innodb_int.h"
+
+#ifndef DATA_VARCLIENT
+#define DATA_VARCLIENT DATA_VARMYSQL
+#define DATA_CLIENT DATA_MYSQL
+#endif
+
+#define SRV_N_PENDING_IOS_PER_THREAD 	OS_AIO_N_PENDING_IOS_PER_THREAD
+#define SRV_MAX_N_PENDING_SYNC_IOS	100
+
+#ifndef IBUF_PAGE_SIZE_PER_FREE_SPACE
+
+/** An index page must contain at least UNIV_PAGE_SIZE /
+IBUF_PAGE_SIZE_PER_FREE_SPACE bytes of free space for ibuf to try to
+buffer inserts to this page.  If there is this much of free space, the
+corresponding bits are set in the ibuf bitmap. */
+#define IBUF_PAGE_SIZE_PER_FREE_SPACE	32
+
+/** Insert buffer struct */
+struct ibuf_struct{
+	ulint		size;		/*!< current size of the ibuf index
+					tree, in pages */
+	ulint		max_size;	/*!< recommended maximum size of the
+					ibuf index tree, in pages */
+	ulint		seg_size;	/*!< allocated pages of the file
+					segment containing ibuf header and
+					tree */
+	ibool		empty;		/*!< after an insert to the ibuf tree
+					is performed, this is set to FALSE,
+					and if a contract operation finds
+					the tree empty, this is set to
+					TRUE */
+	ulint		free_list_len;	/*!< length of the free list */
+	ulint		height;		/*!< tree height */
+	dict_index_t*	index;		/*!< insert buffer index */
+
+	ulint		n_inserts;	/*!< number of inserts made to
+					the insert buffer */
+	ulint		n_merges;	/*!< number of pages merged */
+	ulint		n_merged_recs;	/*!< number of records merged */
+};
+
+#endif
+
+/***************************************************************//**
+Print undo log page. */
+UNIV_INTERN
+void
+ib_page_print_undo(
+/*===============*/
+	const page_t*	page);	/*!< in: page */
+
+/***************************************************************//**
+Determine direction name.
+@return direction name. */
+UNIV_INTERN
+const char*
+ib_page_page_cursor_direction(
+/*==========================*/
+	ulint	direction);	/*!< in: direction */
+
+/***************************************************************//**
+Dump raw field as hex and ascii. */
+UNIV_INTERN
+void
+ib_page_print_field_hex_asc(
+/*========================*/
+	const rec_t* 	rec,	/*!< in: physical record */
+	ulint		i);	/*!< in: field number */
+
+/***************************************************************//**
+Format externally stored field. */
+UNIV_INTERN
+void
+ib_page_format_ext(
+/*===============*/
+	char*		buf,		/*!< out: buffer */
+	ulint		buf_len,	/*!< in: buffer length */
+	const rec_t*	rec,		/*!< in: physical record */
+	ulint		no,		/*!< in: field number */
+	const ulint*	offsets);	/*!< in: array returned by
+					rec_get_offsets() */
+
+/***************************************************************//**
+Hex dump of page. */
+UNIV_INTERN
+void
+ib_page_print_hex_dump(
+/*===================*/
+	const page_t*	page,		/*!< in: page */
+	ulint		zip_size);	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+
+/***************************************************************//**
+Print page dictionary header. */
+UNIV_INTERN
+void
+ib_page_print_dict_header(
+/*======================*/
+	const page_t*	page);		/*!< in: page */
+
+/***************************************************************//**
+@return XDES state as string. */
+UNIV_INTERN
+const char*
+ib_page_xdes_state_str(
+/*===================*/
+	ulint	state);			/*!< in: XDES state */
+
+/***************************************************************//**
+Print XDES page. */
+UNIV_INTERN
+void
+ib_page_print_xdes(
+/*===============*/
+	const page_t*	page,		/*!< in: page */
+	ulint		zip_size);	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+
+/***************************************************************//**
+Create IBUF index in data dictionary. */
+UNIV_INTERN
+void
+ib_page_ibuf_index_create(void);
+/*============================*/
+
+/***************************************************************//**
+Load a table object based on the index id.
+@return	table; NULL if table does not exist */
+UNIV_INTERN
+dict_table_t*
+ib_page_load_table_for_index(
+/*=========================*/
+	dulint	index_id);		/*!< in: index id */
+
+/***************************************************************//**
+Allocate signle aligned page.
+@return	page */
+UNIV_INTERN
+page_t*
+ib_page_page_alloc();
+
+/***************************************************************//**
+Allocate signle aligned page.
+@return	page */
+UNIV_INTERN
+page_t*
+ib_page_heap_page_alloc(
+/*====================*/
+	mem_heap_t*	heap);	/*!< in: memory heap where allocate in */
+
+/***************************************************************//**
+Get space id of given tablespace in file.
+@return	space id if given tablespace file */
+UNIV_INTERN
+ulint
+ib_page_file_space_id(
+/*==================*/
+	os_file_t	file);		/*!< in: file */
+
+/***************************************************************//**
+Calculate the low 32 bits and the high 32 bits
+of the file offset. */
+UNIV_INTERN
+void
+ib_page_calc_offsets(
+/*=================*/
+	ulint	zip_size,		/*!< in: compressed page size, or
+					0 for uncompressed pages */
+	ulint	page_no,		/*!< in: page number */
+	ulint*	offset_low,		/*!< out: low 32 bits */
+	ulint*	offset_high);		/*!< out: high 32 bits */
+
+/***************************************************************//**
+Load compressed page into memory.
+Space for page allocated in heap.
+@return loaded page; NULL if page was not loaded */
+UNIV_INTERN
+page_t*
+ib_page_load_compressed(
+/*====================*/
+	os_file_t	file,		/*!< in: file */
+	ulint		page_no,	/*!< in: page number */
+	ulint		zip_size,	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+	mem_heap_t*	heap);		/*!< in: memory heap */
+
+/***************************************************************//**
+Decompress compressed page.
+Space for decompressed page allocated in heap.
+@return loaded page; NULL if page was not loaded */
+UNIV_INTERN
+page_t*
+ib_page_decompress(
+/*===============*/
+	const page_t*	compressed_page,/*!< in: compressed page */
+	ulint		zip_size,	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+	mem_heap_t*	heap);		/*!< in: memory heap */
+
+/***************************************************************//**
+Test if page if IBUF page.
+@return TRUE if page is IBUF page; FALE otherwise */
+UNIV_INTERN
+ibool
+ib_page_page_is_ibuf(
+/*=================*/
+	const page_t*	page);		/*!< in: page */
+
+/***************************************************************//**
+Test if page is UNDO INSERT page.
+@return TRUE if page is UNDO INSERT page; FALE otherwise */
+UNIV_INTERN
+ibool
+ib_page_is_undo_insert(
+/*===================*/
+	const page_t*	page);		/*!< in: page */
+
+/***************************************************************//**
+Test if page is UNDO UPDATE page.
+@return TRUE if page is UNDO UPDATE page; FALE otherwise */
+UNIV_INTERN
+ibool
+ib_page_is_undo_update(
+/*===================*/
+	const page_t*	page);		/*!< in: page */
+
+/***************************************************************//**
+Test if page is UNDO page.
+@return TRUE if page is UNDO page; FALE otherwise */
+UNIV_INTERN
+ibool
+ib_page_is_undo(
+/*============*/
+	const page_t*	page);		/*!< in: page */
+
+/***************************************************************//**
+Print file-based list address. */
+UNIV_INTERN
+void
+ib_page_print_flst_addr(
+/*====================*/
+	const byte*	base);		/*!< in: pointer to base node of list */
+
+/***************************************************************//**
+Print file-based list. */
+UNIV_INTERN
+void
+ib_page_print_flst(
+/*===============*/
+	const byte*	base);		/*!< in: pointer to base node of list */
+
+/***************************************************************//**
+Print filespace header page. */
+UNIV_INTERN
+void
+ib_page_print_fsp_header(
+/*=====================*/
+	const page_t*	page);		/*!< in: page */
+
+/***************************************************************//**
+Print ZBLOB page. */
+UNIV_INTERN
+void
+ib_page_print_zblob(
+/*================*/
+	const page_t*	page,		/*!< in: page */
+	ulint		zip_size);	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+
+/***************************************************************//**
+Print ZBLOB2 page. */
+UNIV_INTERN
+void
+ib_page_print_zblob2(
+/*=================*/
+	const page_t*	page,		/*!< in: page */
+	ulint		zip_size);	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+
+/***************************************************************//**
+Print BLOB page. */
+UNIV_INTERN
+void
+ib_page_print_blob(
+/*===============*/
+	const page_t*	page);		/*!< in: page */
+
+/***************************************************************//**
+Print inode page. */
+UNIV_INTERN
+void
+ib_page_print_inode(
+/*================*/
+	const page_t*	page,		/*!< in: page */
+	ulint		zip_size);	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+
+/***************************************************************//**
+Print a physical record. */
+UNIV_INTERN
+void
+ib_page_rec_print_new(
+/*==================*/
+	ib_stream_t	ib_stream,	/*!< in: stream where to print */
+	const page_t*	page,		/*!< in: page */
+	const rec_t*	rec,		/*!< in: physical record */
+	const ulint*	offsets,	/*!< in: array returned by
+					rec_get_offsets() */
+	dict_index_t*	index);		/*!< in: index */
+
+
+/***************************************************************//**
+Print an old-style physical record. */
+UNIV_INTERN
+void
+ib_page_rec_print_old(
+/*==================*/
+	ib_stream_t	ib_stream,	/*!< in: stream where to print */
+	const page_t*	page,
+	const rec_t*	rec,		/*!< in: physical record */
+	const ulint*	offsets,	/*!< in: array returned by
+					rec_get_offsets() */
+	dict_index_t*	index);		/*!< in: index */
+
+/***************************************************************//**
+Prints a physical record in ROW_FORMAT=COMPACT.  Ignores the
+record header. */
+UNIV_INTERN
+void
+ib_page_rec_print_comp(
+/*===================*/
+	ib_stream_t	ib_stream,	/*!< in: streamwhere to print */
+	const page_t*	page,
+	const rec_t*	rec,		/*!< in: physical record */
+	const ulint*	offsets,	/*!< in: array returned by
+					rec_get_offsets() */
+	dict_index_t*	index);		/*!< in: index */
+
+/*******************************************************************//**
+Copy types of fields contained in index to tuple. */
+UNIV_INTERN
+void
+ib_page_dict_index_copy_types(
+/*==========================*/
+	dtuple_t*		tuple,		/*!< in/out: data tuple */
+	const dict_index_t*	index,		/*!< in: index */
+	ulint			n_fields,	/*!< in: number of
+						field types to copy */
+	ibool			is_leaf_page);	/*!< in: TRUE if leas page */
+
+/*******************************************************************//**
+Converts an index record to a typed data tuple.
+@return index entry built; does not set info_bits, and the data fields
+in the entry will point directly to rec */
+UNIV_INTERN
+dtuple_t*
+ib_page_row_rec_to_index_entry_low(
+/*===============================*/
+	const page_t*		page,
+	const rec_t*		rec,	/*!< in: record in the index */
+	const dict_index_t*	index,	/*!< in: index */
+	const ulint*		offsets,/*!< in: rec_get_offsets(rec, index) */
+	ulint*			n_ext,	/*!< out: number of externally
+					stored columns */
+	mem_heap_t*		heap);	/*!< in: memory heap from which
+					the memory needed is allocated */
+
+/*******************************************************************//**
+Converts an index record to a typed data tuple.
+@return index entry built; does not set info_bits, and the data fields
+in the entry will point directly to rec */
+UNIV_INTERN
+dtuple_t*
+ib_page_row_rec_to_index_entry_low(
+/*===============================*/
+	const page_t*		page,
+	const rec_t*		rec,	/*!< in: record in the index */
+	const dict_index_t*	index,	/*!< in: index */
+	const ulint*		offsets,/*!< in: rec_get_offsets(rec, index) */
+	ulint*			n_ext,	/*!< out: number of externally
+					stored columns */
+	mem_heap_t*		heap);	/*!< in: memory heap from which
+					the memory needed is allocated */
+
+
+/*******************************************************************//**
+Converts an index record to a typed data tuple. NOTE that externally
+stored (often big) fields are NOT copied to heap.
+@return	own: index entry built; see the NOTE below! */
+UNIV_INTERN
+dtuple_t*
+ib_page_row_rec_to_index_entry(
+/*===========================*/
+	ulint			type,	/*!< in: ROW_COPY_DATA, or
+					ROW_COPY_POINTERS: the former
+					copies also the data fields to
+					heap as the latter only places
+					pointers to data fields on the
+					index page */
+	const page_t*		page,
+	const rec_t*		rec,	/*!< in: record in the index;
+					NOTE: in the case
+					ROW_COPY_POINTERS the data
+					fields in the row will point
+					directly into this record,
+					therefore, the buffer page of
+					this record must be at least
+					s-latched and the latch held
+					as long as the dtuple is used! */
+	const dict_index_t*	index,	/*!< in: index */
+	ulint*			offsets,/*!< in/out: rec_get_offsets(rec) */
+	ulint*			n_ext,	/*!< out: number of externally
+					stored columns */
+	mem_heap_t*		heap);	/*!< in: memory heap from which
+					the memory needed is allocated */
+
+/*******************************************************************//**
+Load page from file into memory and decompress it if needed.
+@return	TRUE on success */
+ibool
+ib_page_load(
+/*=========*/
+	const char*	ibd_file_name,		/*!< in: file name */
+	ulint		page_no,		/*!< in: page number */
+	ulint*		zip_size,		/*!< in: compressed page size, or
+						0 for uncompressed pages */
+	page_t**	compressed_page,	/*!< out: compressed page  */
+	page_t**	decompressed_page,	/*!< out: decompressed page  */
+	mem_heap_t*	heap);			/*!< out: memory heap  */
+
+/*******************************************************************//**
+Print IBUF bitmap page. */
+UNIV_INTERN
+void
+ib_page_ibuf_bitmap_print(
+/*======================*/
+	const page_t*	page,		/*!< in: page */
+	ulint		zip_size);	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+
+/*******************************************************************//**
+Format SYS value. */
+UNIV_INTERN
+void
+ib_page_format_sys(
+/*===============*/
+	ulint		prtype,		/*!< in: precise type */
+	char*		buf,		/*!< out: buffer */
+	ulint		buf_len,	/*!< in: buffer length */
+	const byte*	data);		/*!< in: field data */
+
+/*******************************************************************//**
+Format INT value. */
+UNIV_INTERN
+void
+ib_page_format_int(
+/*===============*/
+	ulint		prtype,		/*!< in: precise type */
+	char*		buf,		/*!< out: buffer */
+	ulint		buf_len,	/*!< in: buffer length */
+	const byte*	data,		/*!< in: field data */
+	ulint		data_len);	/*!< in: length of data */
+
+/*******************************************************************//**
+Format string value. */
+UNIV_INTERN
+void
+ib_page_format_str(
+/*===============*/
+	char*		buf,		/*!< out: buffer */
+	ulint		buf_len,	/*!< in: buffer length */
+	const byte*	data,		/*!< in: field data */
+	ulint		data_len);	/*!< in: length of data */
+
+/*******************************************************************//**
+Format binalry value. */
+UNIV_INTERN
+void
+ib_page_format_bin(
+/*===============*/
+	char*		buf,		/*!< out: buffer */
+	ulint		buf_len,	/*!< in: buffer length */
+	const byte*	data,		/*!< in: field data */
+	ulint		data_len);	/*!< in: length of data */
+
+/*******************************************************************//**
+Print field. */
+UNIV_INTERN
+void
+ib_page_rec_print_field(
+/*====================*/
+	const dfield_t*	field,		/*!< in: field */
+	const rec_t*	rec,		/*!< in: physical record */
+	ulint		no,		/*!< in: field number */
+	const ulint*	offsets);	/*!< in: array returned by
+					rec_get_offsets() */
+/********************************************************************//**
+Print first page header. */
+UNIV_INTERN
+void
+ib_buf_page_print_header(
+/*=====================*/
+	const byte*	read_buf,	/*!< in: a database page */
+	ulint		zip_size);	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+
+/***************************************************************//**
+Print second page header. */
+UNIV_INTERN
+void
+ib_page_page_header_print(
+/*======================*/
+	const page_t*	page);		/*!< in: page */
+
+/***************************************************************//**
+Print the contents of the directory. */
+UNIV_INTERN
+void
+ib_page_page_dir_print(
+/*===================*/
+	const page_t*	page);	/*!< in: index page */
+
+/************************************************************//**
+Print record contents including the data relevant only in
+the index page context. */
+UNIV_INTERN
+void
+ib_page_page_rec_print(
+/*===================*/
+	const page_t*	page,
+	const rec_t*	rec,	/*!< in: physical record */
+	const ulint*	offsets,/*!< in: record descriptor */
+	dict_index_t*	index);	/*!< in: dictionary index of the page */
+
+/***************************************************************//**
+This is used to print the contents of the page record list for
+debugging purposes. */
+UNIV_INTERN
+void
+ib_page_page_print_list(
+/*====================*/
+	const page_t*	page,	/*!< in: index page */
+	dict_index_t*	index);	/*!< in: dictionary index of the page */
+
+
+/** @name Offsets to the per-page bits in the insert buffer bitmap */
+/* @{ */
+#define	IBUF_BITMAP_FREE	0	/*!< Bits indicating the
+					amount of free space */
+#define IBUF_BITMAP_BUFFERED	2	/*!< TRUE if there are buffered
+					changes for the page */
+#define IBUF_BITMAP_IBUF	3	/*!< TRUE if page is a part of
+					the ibuf tree, excluding the
+					root page, or is in the free
+					list of the ibuf */
+/* @} */
+
+/* Various constants for checking the type of an ibuf record and extracting
+data from it. For details, see the description of the record format at the
+top of this file. */
+
+/** @name Format of the fourth column of an insert buffer record
+The fourth column in the MySQL 5.5 format contains an operation
+type, counter, and some flags. */
+/* @{ */
+#define IBUF_REC_INFO_SIZE	4	/*!< Combined size of info fields at
+					the beginning of the fourth field */
+#if IBUF_REC_INFO_SIZE >= DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE
+# error "IBUF_REC_INFO_SIZE >= DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE"
+#endif
+
+/* Offsets for the fields at the beginning of the fourth field */
+#define IBUF_REC_OFFSET_COUNTER	0	/*!< Operation counter */
+#define IBUF_REC_OFFSET_TYPE	2	/*!< Type of operation */
+#define IBUF_REC_OFFSET_FLAGS	3	/*!< Additional flags */
+
+/* Record flag masks */
+#define IBUF_REC_COMPACT	0x1	/*!< Set in
+					IBUF_REC_OFFSET_FLAGS if the
+					user index is in COMPACT
+					format or later */
+
+
+/** The area in pages from which contract looks for page numbers for merge */
+#define	IBUF_MERGE_AREA			8
+
+/** Inside the merge area, pages which have at most 1 per this number less
+buffered entries compared to maximum volume that can buffered for a single
+page are merged along with the page whose buffer became full */
+#define IBUF_MERGE_THRESHOLD		4
+
+/** In ibuf_contract at most this number of pages is read to memory in one
+batch, in order to merge the entries for them in the insert buffer */
+#define	IBUF_MAX_N_PAGES_MERGED		IBUF_MERGE_AREA
+
+/** If the combined size of the ibuf trees exceeds ibuf->max_size by this
+many pages, we start to contract it in connection to inserts there, using
+non-synchronous contract */
+#define IBUF_CONTRACT_ON_INSERT_NON_SYNC	0
+
+/** If the combined size of the ibuf trees exceeds ibuf->max_size by this
+many pages, we start to contract it in connection to inserts there, using
+synchronous contract */
+#define IBUF_CONTRACT_ON_INSERT_SYNC		5
+
+/** If the combined size of the ibuf trees exceeds ibuf->max_size by
+this many pages, we start to contract it synchronous contract, but do
+not insert */
+#define IBUF_CONTRACT_DO_NOT_INSERT		10
+
+
+/* Possible operations buffered in the insert/whatever buffer. See
+ibuf_insert(). DO NOT CHANGE THE VALUES OF THESE, THEY ARE STORED ON DISK. */
+typedef enum {
+	IBUF_OP_INSERT = 0,
+	IBUF_OP_DELETE_MARK = 1,
+	IBUF_OP_DELETE = 2,
+
+	/* Number of different operation types. */
+	IBUF_OP_COUNT = 3
+} ibuf_op_t;
+
+/***************************************************************//**
+Load a index object based on the index id.
+@return	index; NULL if table does not exist */
+dict_index_t*
+ib_dict_index_get_on_id(
+/*====================*/
+	dulint	index_id);	/*!< in: index id */
+
+/****************************************************************//**
+Read the first two bytes from a record's fourth field (counter field in new
+records; something else in older records).
+@return "counter" field, or ULINT_UNDEFINED if for some reason it
+can't be read */
+UNIV_INTERN
+ulint
+ib_page_ibuf_rec_get_counter(
+/*=========================*/
+	const rec_t*	rec);	/*!< in: ibuf record */
+
+
+/*******************************************************************//**
+Initialize necessary InndoDB systems for page printer
+to work properly. */
+ib_err_t
+ib_page_sys_start(
+/*==============*/
+	ulint		buf_pool_size,	/*!< in: size of buffer pool */
+	const char*	datadir)	/*!< in: InnoDB data directory */
+{
+	ulint err;
+
+	innodb_init_param_for_util(datadir, datadir,
+				buf_pool_size, 16*1024*1024, TRUE);
+
+	srv_max_n_threads = 1;
+	srv_normalize_init_values();
+
+	ut_mem_init();
+	os_sync_init();
+	sync_init();
+	srv_n_read_io_threads = srv_n_write_io_threads = 1;
+	srv_n_file_io_threads = 2 + srv_n_read_io_threads +
+		srv_n_write_io_threads;
+	// os_io_init_simple();
+	os_aio_init(8 * SRV_N_PENDING_IOS_PER_THREAD,
+		    srv_n_read_io_threads,
+		    srv_n_write_io_threads,
+		    SRV_MAX_N_PENDING_SYNC_IOS);
+	mem_init(1);
+
+	kernel_mutex_temp = mem_alloc(sizeof(mutex_t));
+	mutex_create(&kernel_mutex, SYNC_KERNEL);
+
+	fil_init(10, 10);
+	buf_pool_init();
+	fsp_init();
+	lock_sys_create(1000);
+	recv_sys_create();
+
+	ibool create_new_db;
+	ib_uint64_t min_flushed_lsn, max_flushed_lsn;
+	ulint sum_of_new_sizes;
+
+	err = open_or_create_data_files(&create_new_db,
+					&min_flushed_lsn, &max_flushed_lsn,
+					&sum_of_new_sizes);
+
+	if (err != DB_SUCCESS) {
+		return err;
+	}
+
+	/* open_or_create_log_file will set srv_log_file_size.  Normalize the
+	init values again to get srv_log_file_size/srv_log_file_curr_size in
+	sync.  */
+	srv_normalize_init_values();
+
+	dict_ind_init();
+	dict_boot(FALSE);
+	mutex_enter(&(dict_sys->mutex));
+	ib_page_ibuf_index_create();
+	mutex_exit(&(dict_sys->mutex));
+	dict_check_tablespaces_and_store_max_id(FALSE);
+
+	return DB_SUCCESS;
+}
+
+/*******************************************************************//**
+Uninitialize InndoDB systems been initialized by ib_page_sys_start. */
+void
+ib_page_sys_stop(void)
+/*==================*/
+{
+	/* This must be disabled before closing the buffer pool
+	and closing the data dictionary.  */
+	btr_search_disable();
+
+	recv_sys_close();
+	recv_sys_mem_free();
+	fil_close_all_files();
+	dict_close();
+	// buf_close();
+
+	mutex_free(&kernel_mutex);
+	mem_free(kernel_mutex_temp);
+	kernel_mutex_temp = NULL;
+
+	sync_close();
+	os_sync_free();
+	fil_close();
+
+	buf_pool_free();
+	ut_free_all_mem();
+}
+
+#define ASSERT_MTR_READONLY(mtr) ut_a(!(mtr.modifications && mtr.n_log_recs));
+
+/***************************************************************//**
+Load a table object based on the index id.
+@return	table; NULL if table does not exist */
+UNIV_INTERN
+dict_table_t*
+ib_page_load_table_for_index(
+/*=========================*/
+	dulint	index_id)		/*!< in: index id */
+{
+	dict_table_t*	sys_tables_table;
+	dict_index_t*	sys_tables_index;
+
+	mtr_t		mtr;
+	btr_pcur_t	pcur;
+	dict_table_t*	result			= NULL;
+
+	sys_tables_table = dict_table_get_low("SYS_INDEXES");
+	sys_tables_index = UT_LIST_GET_FIRST(sys_tables_table->indexes);
+
+	mtr_start(&mtr);
+
+	btr_pcur_open_at_index_side(TRUE, sys_tables_index,
+		BTR_SEARCH_LEAF, &pcur,
+		TRUE, &mtr);
+
+	for (;;)
+	{
+		rec_t*		rec;
+		ulint		len;
+		byte*		field;
+		dulint		loc_index_id;
+		dulint		loc_table_id;
+
+		btr_pcur_move_to_next_user_rec(&pcur, &mtr);
+		rec = btr_pcur_get_rec(&pcur);
+
+		if (!btr_pcur_is_on_user_rec(&pcur))
+		{
+			/* end of index */
+
+			break;
+		}
+
+		if (rec_get_deleted_flag(rec, 0))
+			continue;
+
+		field = rec_get_nth_field_old(rec, 1, &len);
+		loc_index_id = mach_read_from_8(field);
+
+		if (ut_dulint_cmp(loc_index_id, index_id) == 0) {
+			field = rec_get_nth_field_old(rec, 0, &len);
+			loc_table_id = mach_read_from_8(field);
+
+			btr_pcur_close(&pcur);
+
+			ASSERT_MTR_READONLY(mtr);
+			mtr_commit(&mtr);
+
+			return dict_table_get_on_id_low(loc_table_id);
+		}
+
+	}
+
+	btr_pcur_close(&pcur);
+
+	ASSERT_MTR_READONLY(mtr);
+	mtr_commit(&mtr);
+
+	return(result);
+}
+
+/** Table name for the insert buffer. */
+#define IBUF_TABLE_NAME		"SYS_IBUF_TABLE"
+
+/***************************************************************//**
+Create IBUF index in data dictionary. */
+UNIV_INTERN
+void
+ib_page_ibuf_index_create(void)
+/*===========================*/
+{
+	dict_table_t*	table;
+	mem_heap_t*	heap;
+	dict_index_t*	index;
+	ulint error;
+
+	ibuf = mem_alloc(sizeof(ibuf_t));
+
+	memset(ibuf, 0, sizeof(*ibuf));
+
+	heap = mem_heap_create(450);
+
+	/* Use old-style record format for the insert buffer. */
+	table = dict_mem_table_create(IBUF_TABLE_NAME, IBUF_SPACE_ID, 1, 0);
+
+	dict_mem_table_add_col(table, heap, "DUMMY_COLUMN", DATA_BINARY, 0, 0);
+
+	table->id = ut_dulint_add(DICT_IBUF_ID_MIN, IBUF_SPACE_ID);
+
+	dict_table_add_to_cache(table, heap);
+	mem_heap_free(heap);
+
+	index = dict_mem_index_create(
+		IBUF_TABLE_NAME, "CLUST_IND",
+		IBUF_SPACE_ID, DICT_CLUSTERED | DICT_UNIVERSAL | DICT_IBUF, 1);
+
+	dict_mem_index_add_field(index, "DUMMY_COLUMN", 0);
+
+	index->id = ut_dulint_add(DICT_IBUF_ID_MIN, IBUF_SPACE_ID);
+
+	error = dict_index_add_to_cache(table, index,
+					FSP_IBUF_TREE_ROOT_PAGE_NO, FALSE);
+	ut_a(error == DB_SUCCESS);
+
+	ibuf->index = dict_table_get_first_index(table);
+
+}
+
+/***************************************************************//**
+Load a index object based on the index id.
+@return	index; NULL if table does not exist */
+dict_index_t*
+ib_dict_index_get_on_id(
+/*====================*/
+	dulint	index_id)	/*!< in: index id */
+{
+	dict_table_t*	table;
+	dict_index_t*	index	= NULL;
+
+	const char* SYS_TABLES[] = {"SYS_TABLES", "SYS_INDEXES",
+				    "SYS_COLUMNS", "SYS_FIELDS",
+				    IBUF_TABLE_NAME, NULL};
+
+	mutex_enter(&(dict_sys->mutex));
+	for (const char** ptbl_name = SYS_TABLES; *ptbl_name; ptbl_name++)
+	{
+		table = dict_table_get_low(*ptbl_name);
+		if (table != NULL) {
+			index = dict_index_get_on_id_low(table, index_id);
+			if (index != NULL) {
+				mutex_exit(&(dict_sys->mutex));
+				return(index);
+			}
+		}
+	}
+
+	table = ib_page_load_table_for_index(index_id);
+	if (table != NULL) {
+		index = dict_index_get_on_id_low(table, index_id);
+		mutex_exit(&(dict_sys->mutex));
+		return index;
+	}
+
+	mutex_exit(&(dict_sys->mutex));
+
+	return(NULL);
+}
+
+/********************************************************************//**
+Returns the page number field of an ibuf record.
+@return	page number */
+static
+ulint
+ib_page_ibuf_rec_get_page_no(
+/*=========================*/
+	const rec_t*	rec)	/*!< in: ibuf record */
+{
+	const byte*	field;
+	ulint		len;
+
+	ut_ad(rec_get_n_fields_old(rec) > 2);
+
+	field = rec_get_nth_field_old(rec, 1, &len);
+
+	if (len == 1) {
+		/* This is of the >= 4.1.x record format */
+
+		field = rec_get_nth_field_old(rec, 2, &len);
+	} else {
+
+		field = rec_get_nth_field_old(rec, 0, &len);
+	}
+
+	ut_a(len == 4);
+
+	return(mach_read_from_4(field));
+}
+
+/********************************************************************//**
+Returns the space id field of an ibuf record. For < 4.1.x format records
+returns 0.
+@return	space id */
+static
+ulint
+ib_page_ibuf_rec_get_space(
+/*=======================*/
+	const rec_t*	rec)	/*!< in: ibuf record */
+{
+	const byte*	field;
+	ulint		len;
+
+	field = rec_get_nth_field_old(rec, 1, &len);
+
+	if (len == 1) {
+		/* This is of the >= 4.1.x record format */
+
+		field = rec_get_nth_field_old(rec, 0, &len);
+		ut_a(len == 4);
+
+		return(mach_read_from_4(field));
+	}
+
+	return(0);
+}
+
+/****************************************************************//**
+Get various information about an ibuf record in >= 4.1.x format. */
+static
+void
+ib_page_ibuf_rec_get_info(
+/*======================*/
+	const rec_t*	rec,		/*!< in: ibuf record */
+	ibuf_op_t*	op,		/*!< out: operation type, or NULL */
+	ibool*		comp,		/*!< out: compact flag, or NULL */
+	ulint*		info_len,	/*!< out: length of info fields at the
+					start of the fourth field, or
+					NULL */
+	ulint*		counter)	/*!< in: counter value, or NULL */
+{
+	const byte*	types;
+	ulint		fields;
+	ulint		len;
+
+	/* Local variables to shadow arguments. */
+	ibuf_op_t	op_local;
+	ibool		comp_local;
+	ulint		info_len_local;
+	ulint		counter_local;
+
+	fields = rec_get_n_fields_old(rec);
+	ut_a(fields > 4);
+
+	types = rec_get_nth_field_old(rec, 3, &len);
+
+	info_len_local = len % DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE;
+
+	switch (info_len_local) {
+	case 0:
+	case 1:
+		op_local = IBUF_OP_INSERT;
+		comp_local = info_len_local;
+		ut_ad(!counter);
+		counter_local = ULINT_UNDEFINED;
+		break;
+
+	case IBUF_REC_INFO_SIZE:
+		op_local = (ibuf_op_t)types[IBUF_REC_OFFSET_TYPE];
+		comp_local = types[IBUF_REC_OFFSET_FLAGS] & IBUF_REC_COMPACT;
+		counter_local = mach_read_from_2(
+			types + IBUF_REC_OFFSET_COUNTER);
+		break;
+
+	default:
+		ut_error;
+	}
+
+	ut_a(op_local < IBUF_OP_COUNT);
+	ut_a((len - info_len_local) ==
+	     (fields - 4) * DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE);
+
+	if (op) {
+		*op = op_local;
+	}
+
+	if (comp) {
+		*comp = comp_local;
+	}
+
+	if (info_len) {
+		*info_len = info_len_local;
+	}
+
+	if (counter) {
+		*counter = counter_local;
+	}
+}
+
+/****************************************************************//**
+Returns the operation type field of an ibuf record.
+@return	operation type */
+static
+ibuf_op_t
+ib_page_ibuf_rec_get_op_type(
+/*=========================*/
+	const rec_t*	rec)	/*!< in: ibuf record */
+{
+	ulint		len;
+
+	(void) rec_get_nth_field_old(rec, 1, &len);
+
+	if (len > 1) {
+		/* This is a < 4.1.x format record */
+
+		return(IBUF_OP_INSERT);
+	} else {
+		ibuf_op_t	op;
+
+		ib_page_ibuf_rec_get_info(rec, &op, NULL, NULL, NULL);
+
+		return(op);
+	}
+}
+
+/****************************************************************//**
+Read the first two bytes from a record's fourth field (counter field in new
+records; something else in older records).
+@return "counter" field, or ULINT_UNDEFINED if for some reason it
+can't be read */
+UNIV_INTERN
+ulint
+ib_page_ibuf_rec_get_counter(
+/*=========================*/
+	const rec_t*	rec)	/*!< in: ibuf record */
+{
+	const byte*	ptr;
+	ulint		len;
+
+	if (rec_get_n_fields_old(rec) < 4) {
+
+		return(ULINT_UNDEFINED);
+	}
+
+	ptr = rec_get_nth_field_old(rec, 3, &len);
+
+	if (len >= 2) {
+
+		return(mach_read_from_2(ptr));
+	} else {
+
+		return(ULINT_UNDEFINED);
+	}
+}
+
+/********************************************************************//**
+Creates a dummy index for inserting a record to a non-clustered index.
+@return	dummy index */
+static
+dict_index_t*
+ib_page_ibuf_dummy_index_create(
+/*============================*/
+	ulint		n,	/*!< in: number of fields */
+	ibool		comp)	/*!< in: TRUE=use compact record format */
+{
+	dict_table_t*	table;
+	dict_index_t*	index;
+
+	table = dict_mem_table_create("IBUF_DUMMY",
+				      DICT_HDR_SPACE, n,
+				      comp ? DICT_TF_COMPACT : 0);
+
+	index = dict_mem_index_create("IBUF_DUMMY", "IBUF_DUMMY",
+				      DICT_HDR_SPACE, 0, n);
+
+	index->table = table;
+
+	/* avoid ut_ad(index->cached) in dict_index_get_n_unique_in_tree */
+	index->cached = TRUE;
+
+	return(index);
+}
+
+/********************************************************************//**
+Add a column to the dummy index */
+static
+void
+ib_page_ibuf_dummy_index_add_col(
+/*=============================*/
+	dict_index_t*	index,	/*!< in: dummy index */
+	const dtype_t*	type,	/*!< in: the data type of the column */
+	ulint		len)	/*!< in: length of the column */
+{
+	ulint	i	= index->table->n_def;
+	dict_mem_table_add_col(index->table, NULL, NULL,
+			       dtype_get_mtype(type),
+			       dtype_get_prtype(type),
+			       dtype_get_len(type));
+	dict_index_add_col(index, index->table,
+			   dict_table_get_nth_col(index->table, i), len);
+}
+/********************************************************************//**
+Deallocates a dummy index for inserting a record to a non-clustered index. */
+static
+void
+ib_page_ibuf_dummy_index_free(
+/*==========================*/
+	dict_index_t*	index)	/*!< in, own: dummy index */
+{
+	dict_table_t*	table = index->table;
+
+	dict_mem_index_free(index);
+	dict_mem_table_free(table);
+}
+
+/*********************************************************************//**
+Builds the entry to insert into a non-clustered index when we have the
+corresponding record in an ibuf index.
+
+NOTE that as we copy pointers to fields in ibuf_rec, the caller must
+hold a latch to the ibuf_rec page as long as the entry is used!
+
+@return own: entry to insert to a non-clustered index */
+UNIV_INLINE
+dtuple_t*
+ib_page_ibuf_build_entry_pre_4_1_x(
+/*===============================*/
+	const rec_t*	ibuf_rec,	/*!< in: record in an insert buffer */
+	mem_heap_t*	heap,		/*!< in: heap where built */
+	dict_index_t**	pindex)		/*!< out, own: dummy index that
+					describes the entry */
+{
+	ulint		i;
+	ulint		len;
+	const byte*	types;
+	dtuple_t*	tuple;
+	ulint		n_fields;
+
+	n_fields = rec_get_n_fields_old(ibuf_rec) - 2;
+	tuple = dtuple_create(heap, n_fields);
+	types = rec_get_nth_field_old(ibuf_rec, 1, &len);
+
+	ut_a(len == n_fields * DATA_ORDER_NULL_TYPE_BUF_SIZE);
+
+	for (i = 0; i < n_fields; i++) {
+		const byte*	data;
+		dfield_t*	field;
+
+		field = dtuple_get_nth_field(tuple, i);
+
+		data = rec_get_nth_field_old(ibuf_rec, i + 2, &len);
+
+		dfield_set_data(field, data, len);
+
+		dtype_read_for_order_and_null_size(
+			dfield_get_type(field),
+			types + i * DATA_ORDER_NULL_TYPE_BUF_SIZE);
+	}
+
+	*pindex = ib_page_ibuf_dummy_index_create(n_fields, FALSE);
+
+	return(tuple);
+}
+
+/*********************************************************************//**
+Builds the entry used to
+
+1) IBUF_OP_INSERT: insert into a non-clustered index
+
+2) IBUF_OP_DELETE_MARK: find the record whose delete-mark flag we need to
+   activate
+
+3) IBUF_OP_DELETE: find the record we need to delete
+
+when we have the corresponding record in an ibuf index.
+
+NOTE that as we copy pointers to fields in ibuf_rec, the caller must
+hold a latch to the ibuf_rec page as long as the entry is used!
+
+@return own: entry to insert to a non-clustered index */
+static
+dtuple_t*
+ib_page_ibuf_build_entry_from_ibuf_rec(
+/*===================================*/
+	const rec_t*	ibuf_rec,	/*!< in: record in an insert buffer */
+	mem_heap_t*	heap,		/*!< in: heap where built */
+	dict_index_t**	pindex)		/*!< out, own: dummy index that
+					describes the entry */
+{
+	dtuple_t*	tuple;
+	dfield_t*	field;
+	ulint		n_fields;
+	const byte*	types;
+	const byte*	data;
+	ulint		len;
+	ulint		info_len;
+	ulint		i;
+	ulint		comp;
+	dict_index_t*	index;
+
+	data = rec_get_nth_field_old(ibuf_rec, 1, &len);
+
+	if (len > 1) {
+		/* This a < 4.1.x format record */
+
+		return(ib_page_ibuf_build_entry_pre_4_1_x(
+			ibuf_rec, heap, pindex));
+	}
+
+	/* This a >= 4.1.x format record */
+
+	ut_a(*data == 0);
+	ut_a(rec_get_n_fields_old(ibuf_rec) > 4);
+
+	n_fields = rec_get_n_fields_old(ibuf_rec) - 4;
+
+	tuple = dtuple_create(heap, n_fields);
+
+	types = rec_get_nth_field_old(ibuf_rec, 3, &len);
+
+	ib_page_ibuf_rec_get_info(ibuf_rec, NULL, &comp, &info_len, NULL);
+
+	index = ib_page_ibuf_dummy_index_create(n_fields, comp);
+
+	len -= info_len;
+	types += info_len;
+
+	ut_a(len == n_fields * DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE);
+
+	for (i = 0; i < n_fields; i++) {
+		field = dtuple_get_nth_field(tuple, i);
+
+		data = rec_get_nth_field_old(ibuf_rec, i + 4, &len);
+
+		dfield_set_data(field, data, len);
+
+		dtype_new_read_for_order_and_null_size(
+			dfield_get_type(field),
+			types + i * DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE);
+
+		ib_page_ibuf_dummy_index_add_col(
+			index, dfield_get_type(field), len);
+	}
+
+	/* Prevent an ut_ad() failure in page_zip_write_rec() by
+	adding system columns to the dummy table pointed to by the
+	dummy secondary index.  The insert buffer is only used for
+	secondary indexes, whose records never contain any system
+	columns, such as DB_TRX_ID. */
+	ut_d(dict_table_add_system_columns(index->table, index->table->heap));
+
+	*pindex = index;
+
+	return(tuple);
+}
+
+/******************************************************************//**
+Get the data size.
+@return	size of fields */
+UNIV_INLINE
+ulint
+ib_page_ibuf_rec_get_size(
+/*======================*/
+	const rec_t*	rec,			/*!< in: ibuf record */
+	const byte*	types,			/*!< in: fields */
+	ulint		n_fields,		/*!< in: number of fields */
+	ibool		pre_4_1,		/*!< in: TRUE=pre-4.1 format,
+						FALSE=newer */
+	ulint		comp)			/*!< in: 0=ROW_FORMAT=REDUNDANT,
+						nonzero=ROW_FORMAT=COMPACT */
+{
+	ulint	i;
+	ulint	field_offset;
+	ulint	types_offset;
+	ulint	size = 0;
+
+	if (pre_4_1) {
+		field_offset = 2;
+		types_offset = DATA_ORDER_NULL_TYPE_BUF_SIZE;
+	} else {
+		field_offset = 4;
+		types_offset = DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE;
+	}
+
+	for (i = 0; i < n_fields; i++) {
+		ulint		len;
+		dtype_t		dtype;
+
+		rec_get_nth_field_offs_old(rec, i + field_offset, &len);
+
+		if (len != UNIV_SQL_NULL) {
+			size += len;
+		} else if (pre_4_1) {
+			dtype_read_for_order_and_null_size(&dtype, types);
+
+			size += dtype_get_sql_null_size(&dtype, comp);
+		} else {
+			dtype_new_read_for_order_and_null_size(&dtype, types);
+
+			size += dtype_get_sql_null_size(&dtype, comp);
+		}
+
+		types += types_offset;
+	}
+
+	return(size);
+}
+
+/*******************************************************************//**
+Copy types of fields contained in index to tuple. */
+UNIV_INTERN
+void
+ib_page_dict_index_copy_types(
+/*==========================*/
+	dtuple_t*		tuple,		/*!< in/out: data tuple */
+	const dict_index_t*	index,		/*!< in: index */
+	ulint			n_fields,	/*!< in: number of
+						field types to copy */
+	ibool			is_leaf_page)	/*!< in: TRUE if leas page */
+{
+	ulint		i;
+
+	if (UNIV_UNLIKELY(index->type & DICT_UNIVERSAL)) {
+		dtuple_set_types_binary(tuple, n_fields);
+
+		return;
+	}
+
+	for (i = 0; i < n_fields; i++) {
+		const dict_field_t*	ifield;
+		dtype_t*		dfield_type;
+
+		ifield = dict_index_get_nth_field(index, i);
+		dfield_type = dfield_get_type(dtuple_get_nth_field(tuple, i));
+		if (i >= dict_index_get_n_unique(index) && !is_leaf_page) {
+			dfield_type->mtype = DATA_INT;
+			dfield_type->prtype = 0;
+			dfield_type->len = 8;
+			dfield_type->mbminlen = 0;
+			dfield_type->mbmaxlen = 0;
+		} else {
+			dict_col_copy_type(
+				dict_field_get_col(ifield), dfield_type);
+		}
+	}
+}
+
+/*******************************************************************//**
+Converts an index record to a typed data tuple.
+@return index entry built; does not set info_bits, and the data fields
+in the entry will point directly to rec */
+UNIV_INTERN
+dtuple_t*
+ib_page_row_rec_to_index_entry_low(
+/*===============================*/
+	const page_t*		page,
+	const rec_t*		rec,	/*!< in: record in the index */
+	const dict_index_t*	index,	/*!< in: index */
+	const ulint*		offsets,/*!< in: rec_get_offsets(rec, index) */
+	ulint*			n_ext,	/*!< out: number of externally
+					stored columns */
+	mem_heap_t*		heap)	/*!< in: memory heap from which
+					the memory needed is allocated */
+{
+	dtuple_t*	entry;
+	dfield_t*	dfield;
+	ulint		i;
+	const byte*	field;
+	ulint		len;
+	ulint		rec_len;
+
+	ut_ad(rec && heap && index);
+	ut_ad(n_ext);
+	*n_ext = 0;
+
+	rec_len = rec_offs_n_fields(offsets);
+
+	entry = dtuple_create(heap, rec_len);
+
+	dtuple_set_n_fields_cmp(entry,
+				dict_index_get_n_unique_in_tree(index));
+	ut_ad((!page_is_leaf(page) && rec_len == 2)
+	      || (rec_len == dict_index_get_n_fields(index)));
+
+	ib_page_dict_index_copy_types(
+		entry, index, rec_len, page_is_leaf(page));
+
+	for (i = 0; i < rec_len; i++) {
+
+		dfield = dtuple_get_nth_field(entry, i);
+		field = rec_get_nth_field(rec, offsets, i, &len);
+
+		dfield_set_data(dfield, field, len);
+
+		if (rec_offs_nth_extern(offsets, i)) {
+			dfield_set_ext(dfield);
+			(*n_ext)++;
+		}
+	}
+
+	ut_ad(dtuple_check_typed(entry));
+
+	return(entry);
+}
+
+/*******************************************************************//**
+Converts an index record to a typed data tuple. NOTE that externally
+stored (often big) fields are NOT copied to heap.
+@return	own: index entry built; see the NOTE below! */
+UNIV_INTERN
+dtuple_t*
+ib_page_row_rec_to_index_entry(
+/*===========================*/
+	ulint			type,	/*!< in: ROW_COPY_DATA, or
+					ROW_COPY_POINTERS: the former
+					copies also the data fields to
+					heap as the latter only places
+					pointers to data fields on the
+					index page */
+	const page_t*		page,
+	const rec_t*		rec,	/*!< in: record in the index;
+					NOTE: in the case
+					ROW_COPY_POINTERS the data
+					fields in the row will point
+					directly into this record,
+					therefore, the buffer page of
+					this record must be at least
+					s-latched and the latch held
+					as long as the dtuple is used! */
+	const dict_index_t*	index,	/*!< in: index */
+	ulint*			offsets,/*!< in/out: rec_get_offsets(rec) */
+	ulint*			n_ext,	/*!< out: number of externally
+					stored columns */
+	mem_heap_t*		heap)	/*!< in: memory heap from which
+					the memory needed is allocated */
+{
+	dtuple_t*	entry;
+	byte*		buf;
+
+	ut_ad(rec && heap && index);
+	ut_ad(rec_offs_validate(rec, index, offsets));
+
+	if (type == ROW_COPY_DATA) {
+		/* Take a copy of rec to heap */
+		buf = mem_heap_alloc(heap, rec_offs_size(offsets));
+		rec = rec_copy(buf, rec, offsets);
+		/* Avoid a debug assertion in rec_offs_validate(). */
+		rec_offs_make_valid(rec, index, offsets);
+	}
+
+	entry = ib_page_row_rec_to_index_entry_low(
+				page, rec, index, offsets, n_ext, heap);
+
+	dtuple_set_info_bits(entry,
+			     rec_get_info_bits(rec, rec_offs_comp(offsets)));
+
+	return(entry);
+}
+
+/***************************************************************//**
+Allocate signle aligned page.
+@return	page */
+UNIV_INTERN
+page_t*
+ib_page_heap_page_alloc(
+/*====================*/
+	mem_heap_t*	heap)	/*!< in: memory heap where allocate in */
+{
+	page_t*	page = mem_heap_alloc(heap, UNIV_PAGE_SIZE * 2);
+	return page_align(page + UNIV_PAGE_SIZE);
+}
+
+/***************************************************************//**
+Get space id of given tablespace in file.
+@return	space id if given tablespace file */
+UNIV_INTERN
+ulint
+ib_page_file_space_id(
+/*==================*/
+	os_file_t	file)		/*!< in: file */
+{
+	ulint		space_id;
+	mem_heap_t*	heap = mem_heap_create(100);
+	page_t*		page = ib_page_heap_page_alloc(heap);
+
+	if (page == NULL)
+	{
+		mem_heap_free(heap);
+		ut_error;
+	}
+
+	if (!os_file_read(file, page, 0, 0, UNIV_PAGE_SIZE))
+	{
+		mem_heap_free(heap);
+		ut_error;
+	}
+
+	space_id = page_get_space_id(page);
+
+	mem_heap_free(heap);
+
+	return space_id;
+
+}
+
+/***************************************************************//**
+Calculate the low 32 bits and the high 32 bits
+of the file offset. */
+UNIV_INTERN
+void
+ib_page_calc_offsets(
+/*=================*/
+	ulint	zip_size,		/*!< in: compressed page size, or
+					0 for uncompressed pages */
+	ulint	page_no,		/*!< in: page number */
+	ulint*	offset_low,		/*!< out: low 32 bits */
+	ulint*	offset_high)		/*!< out: high 32 bits */
+{
+	/* Calculate the low 32 bits and the high 32 bits of the file offset */
+
+	if (!zip_size) {
+		*offset_high = (page_no >> (32 - UNIV_PAGE_SIZE_SHIFT));
+		*offset_low  = ((page_no << UNIV_PAGE_SIZE_SHIFT)
+				& 0xFFFFFFFFUL);
+	} else {
+		ulint	zip_size_shift;
+		switch (zip_size) {
+		case 1024: zip_size_shift = 10; break;
+		case 2048: zip_size_shift = 11; break;
+		case 4096: zip_size_shift = 12; break;
+		case 8192: zip_size_shift = 13; break;
+		case 16384: zip_size_shift = 14; break;
+		default: ut_error;
+		}
+		*offset_high = page_no >> (32 - zip_size_shift);
+		*offset_low = (page_no << zip_size_shift & 0xFFFFFFFFUL);
+	}
+}
+
+/***************************************************************//**
+Load compressed page into memory.
+Space for page allocated in heap.
+@return loaded page; NULL if page was not loaded */
+UNIV_INTERN
+page_t*
+ib_page_load_compressed(
+/*====================*/
+	os_file_t	file,		/*!< in: file */
+	ulint		page_no,	/*!< in: page number */
+	ulint		zip_size,	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+	mem_heap_t*	heap)		/*!< in: memory heap */
+{
+	ulint	offset_high;
+	ulint	offset_low;
+	ulint	page_size;
+	page_t*	page;
+
+	page_size = zip_size ? zip_size : UNIV_PAGE_SIZE;
+	page = ib_page_heap_page_alloc(heap);
+
+	ib_page_calc_offsets(zip_size, page_no, &offset_low, &offset_high);
+	if (!os_file_read(file, page, offset_low, offset_high, page_size))
+	{
+		ib_logger(ib_stream,
+			  "Failed to read %lu bytes from offset {%lu %lu}\n",
+			  page_size, offset_low, offset_high);
+		ut_error;
+	}
+
+	return page;
+}
+
+/***************************************************************//**
+Decompress compressed page.
+Space for decompressed page allocated in heap.
+@return loaded page; NULL if page was not loaded */
+UNIV_INTERN
+page_t*
+ib_page_decompress(
+/*===============*/
+	const page_t*	compressed_page,/*!< in: compressed page */
+	ulint		zip_size,	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+	mem_heap_t*	heap)		/*!< in: memory heap */
+{
+	page_t* decompressed_page = ib_page_heap_page_alloc(heap);
+
+	if (decompressed_page == NULL)
+	{
+		ut_error;
+	}
+
+	if (zip_size)
+	{
+		page_zip_des_t des;
+		des.data = (page_t*) compressed_page;
+		page_zip_set_size(&des, zip_size);
+
+		ulint	stamp_checksum	= mach_read_from_4(
+			compressed_page + FIL_PAGE_SPACE_OR_CHKSUM);
+		ulint	calc_checksum	= page_zip_calc_checksum(
+			compressed_page, zip_size);
+
+		if (UNIV_UNLIKELY(stamp_checksum != calc_checksum)) {
+			ut_print_timestamp(ib_stream);
+			ib_logger(ib_stream,
+				"  compressed page checksum mismatch"
+				"%lu != %lu\n",
+				stamp_checksum, calc_checksum);
+			ut_error;
+		}
+
+		switch (fil_page_get_type(compressed_page)) {
+		case FIL_PAGE_INDEX:
+			if (page_zip_decompress(&des,
+						decompressed_page, TRUE)) {
+				return decompressed_page;
+			}
+
+			ib_logger(ib_stream,
+				" unable to decompress page\n");
+			ut_error;
+
+		case FIL_PAGE_TYPE_ALLOCATED:
+		case FIL_PAGE_INODE:
+		case FIL_PAGE_IBUF_BITMAP:
+		case FIL_PAGE_TYPE_FSP_HDR:
+		case FIL_PAGE_TYPE_XDES:
+		case FIL_PAGE_TYPE_ZBLOB:
+		case FIL_PAGE_TYPE_ZBLOB2:
+			/* Copy to uncompressed storage. */
+			memcpy(decompressed_page, compressed_page, zip_size);
+			return decompressed_page;
+		}
+
+		ut_print_timestamp(ib_stream);
+		ib_logger(ib_stream,
+			"  unknown compressed page"
+			" type %lu\n",
+			fil_page_get_type(compressed_page));
+		ut_error;
+	}
+	else
+	{
+		ut_memcpy(decompressed_page, compressed_page, UNIV_PAGE_SIZE);
+	}
+
+	return decompressed_page;
+}
+
+/*******************************************************************//**
+Load page from file into memory and decompress it if needed.
+@return	TRUE on success */
+ibool
+ib_page_load(
+/*=========*/
+	const char*	ibd_file_name,		/*!< in: file name */
+	ulint		page_no,		/*!< in: page number */
+	ulint*		zip_size,		/*!< in: compressed page size, or
+						0 for uncompressed pages */
+	page_t**	compressed_page,	/*!< out: compressed page  */
+	page_t**	decompressed_page,	/*!< out: decompressed page  */
+	mem_heap_t*	heap)			/*!< out: memory heap  */
+{
+	ibool		success;
+	os_file_t	file;
+
+	file = os_file_create(ibd_file_name,
+		OS_FILE_OPEN, OS_FILE_NORMAL,
+		OS_DATA_FILE, &success);
+
+	if (!success)
+	{
+		ib_logger(ib_stream, "Failed to open file %s\n", ibd_file_name);
+		return(FALSE);
+	}
+
+	ulint space_id = ib_page_file_space_id(file);
+	*zip_size = fil_space_get_zip_size(space_id);
+	if (*zip_size == ULINT_UNDEFINED) {
+		*zip_size = 0;
+	}
+
+	*compressed_page = ib_page_load_compressed(file, page_no,
+						   *zip_size, heap);
+	if (*compressed_page == NULL)
+	{
+		return(FALSE);
+	}
+
+	*decompressed_page = ib_page_decompress(*compressed_page,
+						*zip_size, heap);
+	if (*decompressed_page == NULL)
+	{
+		return(FALSE);
+	}
+
+	os_file_close(file);
+
+	return(TRUE);
+
+}
+
+
+/*******************************************************************//**
+Print IBUF bitmap page. */
+UNIV_INTERN
+void
+ib_page_ibuf_bitmap_print(
+/*======================*/
+	const page_t*	page,		/*!< in: page */
+	ulint		zip_size)	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+{
+	ulint	byte_offset;
+	ulint	i;
+
+	enum { IBUF_BITS_PER_PAGE = 4 };
+
+	ulint	page_no = page_get_page_no(page);
+
+	if (!zip_size) {
+		byte_offset = UT_BITS_IN_BYTES(UNIV_PAGE_SIZE
+					       * IBUF_BITS_PER_PAGE);
+	} else {
+		byte_offset = UT_BITS_IN_BYTES(zip_size * IBUF_BITS_PER_PAGE);
+	}
+
+	for (i = 0; i < byte_offset; i++) {
+		uint bits;
+
+		bits = (uint)mach_read_from_1(page + PAGE_DATA + i / 2) & 0xF;
+		ib_logger(ib_stream, "%lu: %2x", page_no + 2*i - 1, bits);
+		ib_logger(ib_stream, " (%d free)", bits & 0x2);
+		if (bits & 2) {
+			ib_logger(ib_stream, ", buffered");
+		}
+		if (bits & 4) {
+			ib_logger(ib_stream, ", ibuf");
+		}
+		ib_logger(ib_stream, "\n");
+
+		bits = (uint)
+			(mach_read_from_1(page + PAGE_DATA + i / 2) >> 4) & 0xF;
+		ib_logger(ib_stream, "%lu: %2x", page_no + 2*i, bits);
+		ib_logger(ib_stream, " (%d free)", bits & 0x2);
+		if (bits & 2) {
+			ib_logger(ib_stream, ", buffered");
+		}
+		if (bits & 4) {
+			ib_logger(ib_stream, ", ibuf");
+		}
+		ib_logger(ib_stream, "\n");
+
+	}
+
+}
+
+/***************************************************************//**
+Print undo log page. */
+UNIV_INTERN
+void
+ib_page_print_undo(
+/*===============*/
+	const page_t*	page)	/*!< in: page */
+{
+	const trx_undo_rec_t*	rec;
+	ulint 			rec_offs;
+	ulint			prev_offs;
+	ulint			first_free;
+	ulint			type;
+	ulint			cmpl_info;
+	ibool			updated_extern;
+	undo_no_t		undo_no;
+	dulint			table_id;
+	byte*			ptr;
+	trx_id_t		trx_id;
+	roll_ptr_t		roll_ptr;
+	ulint			info_bits;
+	dict_table_t*		table;
+	dict_index_t*		index;
+	upd_t*			update;
+
+	first_free = mach_read_from_2(page + TRX_UNDO_PAGE_HDR
+					+ TRX_UNDO_PAGE_FREE);
+	ib_logger(ib_stream, "first free: %lu\n", first_free);
+	rec_offs = mach_read_from_2(page + first_free - 2);
+
+
+	while (rec_offs != first_free
+	       && rec_offs >= TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_HDR_SIZE) {
+		rec = page + rec_offs;
+
+		ib_logger(ib_stream, "===============================\n");
+
+		ptr = trx_undo_rec_get_pars((trx_undo_rec_t*)rec,
+					    &type, &cmpl_info,
+					    &updated_extern, &undo_no,
+					    &table_id);
+		ib_logger(ib_stream,
+			  "Undo log record with offset: %lu,"
+			  " compiler info: %ld, updated extern: %s,"
+			  " undo log record number: {%lu %lu},"
+			  " table id: {%lu %lu}\n",
+			  rec_offs, cmpl_info,
+			  updated_extern ? "YES" : "NO",
+			  ut_dulint_get_high(undo_no),
+			  ut_dulint_get_low(undo_no),
+			  ut_dulint_get_high(table_id),
+			  ut_dulint_get_low(table_id));
+
+		mutex_enter(&(dict_sys->mutex));
+		table = dict_table_get_on_id_low(table_id);
+		mutex_exit(&(dict_sys->mutex));
+		if (table)
+			ib_logger(ib_stream, "table name: %s\n", table->name);
+
+		switch (type) {
+		case TRX_UNDO_INSERT_REC:
+			ib_logger(ib_stream,
+				  "fresh insert into clustered index\n");
+			break;
+		case TRX_UNDO_UPD_EXIST_REC:
+			ib_logger(ib_stream,
+				  "update of a non-delete-marked record\n");
+			break;
+		case TRX_UNDO_UPD_DEL_REC:
+			ib_logger(ib_stream,
+				  "update of a delete marked record to "
+				  "a not delete marked record; also the "
+				  "fields of the record can change\n");
+			break;
+		case TRX_UNDO_DEL_MARK_REC:
+			ib_logger(ib_stream,
+				  "delete marking of a record; fields "
+				  "do not change\n");
+			break;
+		}
+
+		if (type == TRX_UNDO_UPD_EXIST_REC ||
+		    type == TRX_UNDO_UPD_DEL_REC ||
+		    type == TRX_UNDO_DEL_MARK_REC) {
+			ptr = trx_undo_update_rec_get_sys_cols(ptr,
+							       &trx_id,
+							       &roll_ptr,
+							       &info_bits);
+		}
+
+		ib_logger(ib_stream,
+			  "trx_id: {%lu %lu}, roll_ptr: {%lu %lu}, "
+			  "info bits: %lu\n",
+			  ut_dulint_get_high(trx_id),
+			  ut_dulint_get_low(trx_id),
+			  ut_dulint_get_high(roll_ptr),
+			  ut_dulint_get_low(roll_ptr),
+			  info_bits);
+
+		if (table) {
+			index = dict_table_get_first_index(table);
+
+			mem_heap_t* heap = mem_heap_create(100);
+			dtuple_t* ref;
+
+			ptr = trx_undo_rec_get_row_ref(ptr, index, &ref, heap);
+
+			if (ptr != NULL) {
+
+				for (ulint i = 0;
+					i < dtuple_get_n_fields(ref);i++) {
+					dfield_t* dfield =
+						dtuple_get_nth_field(ref, i);
+
+					ib_logger(ib_stream,
+						  "(%s/%s/%lu) %s:",
+						  table->name, index->name,
+						  i,
+						  dict_table_get_col_name(table,
+						  			  i));
+					ib_page_rec_print_field(dfield,
+								NULL, 0, NULL);
+					ib_logger(ib_stream, "\n");
+				}
+			}
+
+			if (type == TRX_UNDO_UPD_EXIST_REC ||
+				type == TRX_UNDO_UPD_DEL_REC ||
+				type == TRX_UNDO_DEL_MARK_REC) {
+
+				ptr = trx_undo_update_rec_get_update(ptr, index,
+					type, trx_id,
+					roll_ptr, info_bits,
+					NULL, heap, &update);
+
+				if (ptr != NULL) {
+
+					for (ulint i = 0;
+						i < upd_get_n_fields(update);
+						i++) {
+						upd_field_t* upd_field;
+						dfield_t* field;
+						upd_field = upd_get_nth_field(
+								update, i);
+						field = &upd_field->new_val;
+						ib_logger(ib_stream,
+							  "(%s/%s/%u) %s:",
+							  table->name,
+							  index->name,
+							  upd_field->field_no,
+							  dict_table_get_col_name(
+							  	table,
+							  	upd_field->field_no));
+						ib_page_rec_print_field(field,
+							NULL, 0, NULL);
+						ib_logger(ib_stream, "\n");
+					}
+
+				}
+
+			}
+
+			mem_heap_free(heap);
+
+		}
+
+		prev_offs = rec_offs;
+		rec_offs = mach_read_from_2(rec - 2);
+
+		ib_logger(ib_stream, "prev_offs: %lu, rec_offs: %lu\n",
+				      prev_offs, rec_offs);
+
+	}
+
+}
+
+/***************************************************************//**
+Test if page is UNDO INSERT page.
+@return TRUE if page is UNDO INSERT page; FALE otherwise */
+UNIV_INTERN
+ibool
+ib_page_is_undo_insert(
+/*===================*/
+	const page_t*	page)		/*!< in: page */
+{
+	return (mach_read_from_2(page + TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_TYPE)
+		== TRX_UNDO_INSERT);
+}
+
+/***************************************************************//**
+Test if page is UNDO UPDATE page.
+@return TRUE if page is UNDO UPDATE page; FALE otherwise */
+UNIV_INTERN
+ibool
+ib_page_is_undo_update(
+/*===================*/
+	const page_t*	page)		/*!< in: page */
+{
+	return (mach_read_from_2(page + TRX_UNDO_PAGE_HDR
+				      + TRX_UNDO_PAGE_TYPE)
+				 == TRX_UNDO_UPDATE);
+}
+
+/***************************************************************//**
+Test if page is UNDO page.
+@return TRUE if page is UNDO page; FALE otherwise */
+UNIV_INTERN
+ibool
+ib_page_is_undo(
+/*============*/
+	const page_t*	page)		/*!< in: page */
+{
+	return ib_page_is_undo_insert(page) || ib_page_is_undo_update(page);
+}
+
+/***************************************************************//**
+Print file-based list address. */
+UNIV_INTERN
+void
+ib_page_print_flst_addr(
+/*====================*/
+	const byte*	base)		/*!< in: pointer to base node of list */
+{
+	ulint	page = mach_read_from_4(base + FIL_ADDR_PAGE);
+	ulint	boffset = mach_read_from_2(base + FIL_ADDR_BYTE);
+	ib_logger(ib_stream, "page %lu, byte offset %lu\n",
+		  page, boffset);
+}
+
+/***************************************************************//**
+Print file-based list. */
+UNIV_INTERN
+void
+ib_page_print_flst(
+/*===============*/
+	const byte*	base)		/*!< in: pointer to base node of list */
+{
+	ulint	len = mach_read_from_4(base + FLST_LEN);
+	ib_logger(ib_stream, "len: %lu\n", len);
+	ib_logger(ib_stream, "first: ");
+	ib_page_print_flst_addr(base + FLST_FIRST);
+	ib_logger(ib_stream, "last: ");
+	ib_page_print_flst_addr(base + FLST_LAST);
+}
+
+/***************************************************************//**
+Print filespace header page. */
+UNIV_INTERN
+void
+ib_page_print_fsp_header(
+/*=====================*/
+	const page_t*	page)		/*!< in: page */
+{
+	const byte*	header;
+
+	ut_a(mach_read_from_2(page + FIL_PAGE_TYPE) == FIL_PAGE_TYPE_FSP_HDR);
+
+	header = FSP_HEADER_OFFSET + page;
+
+	ib_logger(ib_stream,
+		  "space id: %lu, not used: %lu, size: %lu\n"
+		  "free limit: %lu, space flags: %lu, frag n used: %lu\n",
+		  mach_read_from_4(header + FSP_SPACE_ID),
+		  mach_read_from_4(header + FSP_NOT_USED),
+		  mach_read_from_4(header + FSP_SIZE),
+		  mach_read_from_4(header + FSP_FREE_LIMIT),
+		  mach_read_from_4(header + FSP_SPACE_FLAGS),
+		  mach_read_from_4(header + FSP_FRAG_N_USED));
+
+	dulint seg_id = mach_read_from_8(header + FSP_SEG_ID);
+	ib_logger(ib_stream, "seg_id: {%lu %lu}\n\n",
+		  ut_dulint_get_high(seg_id),
+		  ut_dulint_get_low(seg_id));
+
+	ib_logger(ib_stream, "FREE LIST:\n");
+	ib_page_print_flst(header + FSP_FREE);
+	ib_logger(ib_stream, "\n");
+	ib_logger(ib_stream, "FREE FRAG LIST:\n");
+	ib_page_print_flst(header + FSP_FREE_FRAG);
+	ib_logger(ib_stream, "\n");
+	ib_logger(ib_stream, "FREE FULL FRAG LIST:\n");
+	ib_page_print_flst(header + FSP_FULL_FRAG);
+	ib_logger(ib_stream, "\n");
+	ib_logger(ib_stream, "FREE FSP SEG INODES FULL LIST:\n");
+	ib_page_print_flst(header + FSP_SEG_INODES_FULL);
+	ib_logger(ib_stream, "\n");
+	ib_logger(ib_stream, "FREE FSP SEG INODES FREE LIST:\n");
+	ib_page_print_flst(header + FSP_SEG_INODES_FREE);
+	ib_logger(ib_stream, "\n");
+
+}
+
+/***************************************************************//**
+Print ZBLOB page. */
+UNIV_INTERN
+void
+ib_page_print_zblob(
+/*================*/
+	const page_t*	page,		/*!< in: page */
+	ulint		zip_size)	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+{
+	enum { buf_len = 80 };
+	const ulint	offset = FIL_PAGE_NEXT;
+	char		buf[buf_len];
+
+	ulint next_page_no = mach_read_from_4(page + offset);
+
+	ib_logger(ib_stream,
+		  "compressed blob page, next page %lu\n", next_page_no);
+	ib_page_format_bin(buf, buf_len, page + FIL_PAGE_DATA, zip_size);
+	ib_logger(ib_stream, "data: %s\n", buf);
+
+	// TODO: we might uncompress page. do we need it?
+}
+
+/***************************************************************//**
+Print ZBLOB2 page. */
+UNIV_INTERN
+void
+ib_page_print_zblob2(
+/*=================*/
+	const page_t*	page,		/*!< in: page */
+	ulint		zip_size)	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+{
+	enum { buf_len = 80 };
+	const ulint	offset = FIL_PAGE_NEXT;
+	char		buf[buf_len];
+
+	ulint next_page_no = mach_read_from_4(page + offset);
+
+	ib_logger(ib_stream,
+		  "compressed blob (continued) page, next page %lu\n",
+		  next_page_no);
+	ib_page_format_bin(buf, buf_len, page + FIL_PAGE_DATA, zip_size);
+	ib_logger(ib_stream, "data: %s\n", buf);
+}
+
+/***************************************************************//**
+Print BLOB page. */
+UNIV_INTERN
+void
+ib_page_print_blob(
+/*===============*/
+	const page_t*	page)		/*!< in: page */
+{
+	enum { buf_len = 80 };
+	const ulint	offset = FIL_PAGE_DATA;
+	char		buf[buf_len];
+
+	ulint next_page_no = mach_read_from_4(
+				page + offset + BTR_BLOB_HDR_NEXT_PAGE_NO);
+	ulint part_len = mach_read_from_4(
+				page + offset + BTR_BLOB_HDR_PART_LEN);
+
+	ib_logger(ib_stream,
+		  "blob page, next page %lu, part len %lu\n",
+		  next_page_no, part_len);
+	ib_page_format_bin(buf, buf_len, page + offset + BTR_BLOB_HDR_SIZE,
+		           part_len);
+	ib_logger(ib_stream, "data: %s\n", buf);
+}
+
+/***************************************************************//**
+Print inode page. */
+UNIV_INTERN
+void
+ib_page_print_inode(
+/*================*/
+	const page_t*	page,		/*!< in: page */
+	ulint		zip_size)	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+{
+	for (ulint i = 0; i < FSP_SEG_INODES_PER_PAGE(zip_size); i++)
+	{
+		const byte* inode;
+		inode = page + FSEG_ARR_OFFSET + FSEG_INODE_SIZE * i;
+
+		ib_logger(ib_stream, "====================================\n");
+		ib_logger(ib_stream, "Inode ");
+
+		dulint seg_id = mach_read_from_8(inode + FSEG_ID);
+		ib_logger(ib_stream, "segment id {%lu %lu}, ",
+			ut_dulint_get_high(seg_id), ut_dulint_get_low(seg_id));
+		dulint seg_not_full_n_used = mach_read_from_8(
+					inode + FSEG_NOT_FULL_N_USED);
+		ib_logger(ib_stream, "number of used segment pages in "
+				"FSEG_NOT_FULL list {%lu %lu}\n\n",
+				ut_dulint_get_low(seg_not_full_n_used),
+				ut_dulint_get_low(seg_not_full_n_used));
+
+		ib_logger(ib_stream, "List of free extents of this segment:\n");
+		ib_page_print_flst(inode + FSEG_FREE);
+
+		ib_logger(ib_stream, "\nList of partially free extents:\n");
+		ib_page_print_flst(inode + FSEG_NOT_FULL);
+
+		ib_logger(ib_stream, "\nList of full extents:\n");
+		ib_page_print_flst(inode + FSEG_FULL);
+
+		ulint magic_n = mach_read_from_4(inode + FSEG_MAGIC_N);
+		ib_logger(ib_stream, "\nMagic number %lu (should be %lu)\n\n",
+				magic_n, (ulint) FSEG_MAGIC_N_VALUE);
+
+		for (ulint i = 0; i < FSEG_FRAG_ARR_N_SLOTS; i++)
+		{
+			ulint frag_n = mach_read_from_4(inode + FSEG_FRAG_ARR
+					+ i * FSEG_FRAG_SLOT_SIZE);
+			ib_logger(ib_stream, "%2lu frag slot: %lu", i, frag_n);
+			ib_logger(ib_stream, "%s\n",
+					frag_n == FIL_NULL ? " (null)" : "");
+		}
+		ib_logger(ib_stream, "\n");
+	}
+}
+
+/***************************************************************//**
+@return XDES state as string. */
+UNIV_INTERN
+const char*
+ib_page_xdes_state_str(
+/*===================*/
+	ulint	state)			/*!< in: XDES state */
+{
+	switch (state) {
+	case XDES_FREE:
+		return "extent is in free list of space";
+	case XDES_FREE_FRAG:
+		return "extent is in free fragment list of space";
+	case XDES_FULL_FRAG:
+		return "extent is in full fragment list of space";
+	case XDES_FSEG:
+		return "extent belongs to a segment";
+	}
+	return "unknown";
+}
+
+/***************************************************************//**
+Print XDES page. */
+UNIV_INTERN
+void
+ib_page_print_xdes(
+/*===============*/
+	const page_t*	page,		/*!< in: page */
+	ulint		zip_size)	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+{
+
+	for (ulint j = 0;
+	     j < (zip_size ? zip_size : UNIV_PAGE_SIZE) / FSP_EXTENT_SIZE;
+	     j++)
+	{
+		const byte* descr = page + XDES_ARR_OFFSET + XDES_SIZE * j;
+
+		dulint seg_id = mach_read_from_8(descr + XDES_ID);
+		ib_logger(ib_stream, "====================================\n");
+		ib_logger(ib_stream, "Segment ID {%lu %lu}\n\n",
+			ut_dulint_get_high(seg_id), ut_dulint_get_low(seg_id));
+
+		ib_logger(ib_stream, "List of descriptors:\n");
+		ib_page_print_flst(descr + XDES_FLST_NODE);
+
+		ulint state = mach_read_from_4(descr + XDES_STATE);
+		ib_logger(ib_stream, "\nState of descriptor %lu (%s)\n",
+				     state, ib_page_xdes_state_str(state));
+
+		ib_logger(ib_stream, "\nXDES bitmap\n");
+		for (ulint i = 0; i < FSP_EXTENT_SIZE; i++)
+		{
+			ulint	index;
+			ulint	byte_index;
+			ulint	bit_index;
+			byte	byte_contents;
+
+			index = XDES_FREE_BIT + XDES_BITS_PER_PAGE * i;
+			byte_index = index / 8;
+			bit_index = index % 8;
+
+			ib_logger(ib_stream, "%2lu", i);
+
+			byte_contents = mach_read_from_1(descr
+						+ XDES_BITMAP + byte_index);
+			ib_logger(ib_stream, "%12s", ut_bit_get_nth(
+				byte_contents,
+				bit_index) ? "free" : "not free");
+
+			index = XDES_CLEAN_BIT + XDES_BITS_PER_PAGE * i;
+			ib_logger(ib_stream, "%12s", ut_bit_get_nth(
+				byte_contents,
+				bit_index + 1) ? "clean" : "not clean");
+
+			ib_logger(ib_stream, "\n");
+		}
+		ib_logger(ib_stream, "\n");
+	}
+}
+
+#define DICT_HDR_MIX_ID DICT_HDR_MAX_SPACE_ID
+
+#define DICT_HDR_XTRADB_FLAG		ut_dulint_create(0x58545241UL,0x44425F31UL)	/* "XTRADB_1" */
+#define	DICT_HDR_STATS		52	/* Root of the stats tree */
+#define	DICT_HDR_XTRADB_MARK	256	/* Flag to distinguish expansion of XtraDB */
+
+/***************************************************************//**
+Print page dictionary header. */
+UNIV_INTERN
+void
+ib_page_print_dict_header(
+/*======================*/
+	const page_t*	page)		/*!< in: page */
+{
+	const page_t*	header;
+	dulint 		row_id;
+	dulint		table_id;
+	dulint		index_id;
+	dulint		mix_id;
+	ulint		tables_root;
+	ulint		table_ids_root;
+	ulint		columns_root;
+	ulint		indexes_root;
+	ulint		fields_root;
+
+
+	header = page + DICT_HDR;
+	row_id = mach_read_from_8(header + DICT_HDR_ROW_ID);
+	table_id = mach_read_from_8(header + DICT_HDR_TABLE_ID);
+	index_id = mach_read_from_8(header + DICT_HDR_INDEX_ID);
+	mix_id = mach_read_from_8(header + DICT_HDR_MIX_ID);
+	tables_root = mach_read_from_4(header + DICT_HDR_TABLES);
+	table_ids_root = mach_read_from_4(header + DICT_HDR_TABLE_IDS);
+	columns_root = mach_read_from_4(header + DICT_HDR_COLUMNS);
+	indexes_root = mach_read_from_4(header + DICT_HDR_INDEXES);
+	fields_root = mach_read_from_4(header + DICT_HDR_FIELDS);
+
+	ib_logger(ib_stream, "latest assigned IDS:\n"
+		  "row {%lu, %lu}, table {%lu, %lu}, "
+		  "index {%lu, %lu}, mix {%lu, %lu}\n"
+		  "root pages:\n"
+		  "tables %lu, tables secondary %lu, columns %lu, "
+		  "indexes %lu, fields %lu\n",
+		  ut_dulint_get_high(row_id), ut_dulint_get_low(row_id),
+		  ut_dulint_get_high(table_id), ut_dulint_get_low(table_id),
+		  ut_dulint_get_high(index_id), ut_dulint_get_low(index_id),
+		  ut_dulint_get_high(mix_id), ut_dulint_get_low(mix_id),
+		  tables_root, table_ids_root, columns_root,
+		  indexes_root, fields_root);
+
+
+	if (ut_dulint_cmp(mach_read_from_8(header + DICT_HDR_XTRADB_MARK),
+			  DICT_HDR_XTRADB_FLAG) == 0)
+	{
+		ib_logger(ib_stream,
+			"XtraDB detected, SYS_STATS root page %lu\n",
+			mach_read_from_4(header + DICT_HDR_STATS));
+	}
+}
+
+/*******************************************************************//**
+Print page stored in memory. */
+ib_err_t
+ib_page_print_mem(
+	const page_t*	page,		/*!< in: page */
+	ulint		zip_size,	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+	ibool		print_contents)	/*!< in: TRUE if page print contents */
+{
+	ib_buf_page_print_header(page, zip_size);
+	ib_page_page_header_print(page);
+	if (print_contents)
+	{
+		switch (fil_page_get_type(page)) {
+		case FIL_PAGE_INDEX:
+		{
+			dict_index_t* index;
+			ib_page_page_dir_print(page);
+			ib_logger(ib_stream, "WILL PRINT RECORDS\n");
+			index = ib_dict_index_get_on_id(
+				btr_page_get_index_id(page));
+			ib_page_page_print_list(page, index);
+			break;
+		}
+		case FIL_PAGE_IBUF_BITMAP:
+		{
+			ib_logger(ib_stream, "PAGE BITS:\n");
+			ib_page_ibuf_bitmap_print(page, zip_size);
+			break;
+		}
+		case FIL_PAGE_UNDO_LOG:
+		{
+			ib_page_print_undo(page);
+			break;
+		}
+		case FIL_PAGE_TYPE_BLOB:
+		{
+			ib_page_print_blob(page);
+			break;
+		}
+		case FIL_PAGE_TYPE_ZBLOB:
+		{
+			ib_page_print_zblob(page, zip_size);
+			break;
+		}
+		case FIL_PAGE_TYPE_ZBLOB2:
+		{
+			ib_page_print_zblob2(page, zip_size);
+			break;
+		}
+		case FIL_PAGE_TYPE_FSP_HDR:
+		{
+			ib_page_print_fsp_header(page);
+			break;
+		}
+		case FIL_PAGE_INODE:
+		{
+			ib_page_print_inode(page, zip_size);
+			break;
+		}
+		case FIL_PAGE_TYPE_XDES:
+		{
+			ib_page_print_xdes(page, zip_size);
+			break;
+		}
+		case FIL_PAGE_TYPE_SYS:
+		{
+			if (page_get_page_no(page) == DICT_HDR_PAGE_NO)
+			{
+				ib_page_print_dict_header(page);
+			}
+		}
+		}
+	}
+	ib_logger(ib_stream, "PAGE PRINT END\n");
+
+	return DB_SUCCESS;
+}
+
+/*******************************************************************//**
+Print page stored in file. */
+ib_err_t
+ib_page_print_file(
+	const char*	ibd_file_name,	/*!< in: file name */
+	ulint		page_no,	/*!< in: number of page to print */
+	ibool		print_contents)	/*!< in: TRUE if page print contents */
+{
+	ib_err_t	err;
+	mem_heap_t*	heap = mem_heap_create(100);
+	ulint		zip_size;
+	page_t*		compressed_page;
+	page_t*		decompressed_page;
+
+	if (!ib_page_load(ibd_file_name, page_no, &zip_size,
+			&compressed_page, &decompressed_page, heap))
+	{
+		mem_heap_free(heap);
+		return DB_ERROR;
+	}
+
+	if (!print_contents)
+	{
+		ib_logger(ib_stream, "Print page header only\n");
+	}
+
+	page_t* page = decompressed_page;
+
+	err = ib_page_print_mem(page, zip_size, print_contents);
+
+	mem_heap_free(heap);
+
+	return err;
+}
+
+/*******************************************************************//**
+Format SYS value. */
+UNIV_INTERN
+void
+ib_page_format_sys(
+/*===============*/
+	ulint		prtype,		/*!< in: precise type */
+	char*		buf,		/*!< out: buffer */
+	ulint		buf_len,	/*!< in: buffer length */
+	const byte*	data)		/*!< in: field data */
+{
+	dulint id;
+	switch (prtype & DATA_SYS_PRTYPE_MASK) {
+	case DATA_TRX_ID:
+		id = mach_read_from_6(data);
+
+		snprintf(buf, buf_len, "trx_id " TRX_ID_FMT,
+			TRX_ID_PREP_PRINTF(id));
+		break;
+
+	case DATA_ROLL_PTR:
+		id = mach_read_from_7(data);
+
+		snprintf(buf, buf_len, "roll_ptr {%lu %lu}",
+			ut_dulint_get_high(id), ut_dulint_get_low(id));
+		break;
+
+	case DATA_ROW_ID:
+		id = mach_read_from_6(data);
+
+		snprintf(buf, buf_len, "row_id {%lu %lu}",
+			ut_dulint_get_high(id), ut_dulint_get_low(id));
+		break;
+
+	default:
+		id = mach_dulint_read_compressed(data);
+
+		snprintf(buf, buf_len, "mix_id {%lu %lu}",
+			ut_dulint_get_high(id), ut_dulint_get_low(id));
+	}
+}
+
+/*******************************************************************//**
+Format INT value. */
+UNIV_INTERN
+void
+ib_page_format_int(
+/*===============*/
+	ulint		prtype,		/*!< in: precise type */
+	char*		buf,		/*!< out: buffer */
+	ulint		buf_len,	/*!< in: buffer length */
+	const byte*	data,		/*!< in: field data */
+	ulint		data_len)	/*!< in: length of data */
+{
+	ulint	val;
+	dulint	id;
+	switch (data_len) {
+	case 1:
+		val = mach_read_from_1(data);
+
+		if (!(prtype & DATA_UNSIGNED)) {
+			val &= ~0x80;
+			snprintf(buf, buf_len, "%ld", (long) val);
+		} else {
+			snprintf(buf, buf_len, "%lu", (ulong) val);
+		}
+		break;
+
+	case 2:
+		val = mach_read_from_2(data);
+
+		if (!(prtype & DATA_UNSIGNED)) {
+			val &= ~0x8000;
+			snprintf(buf, buf_len, "%ld", (long) val);
+		} else {
+			snprintf(buf, buf_len, "%lu", (ulong) val);
+		}
+		break;
+
+	case 3:
+		val = mach_read_from_3(data);
+
+		if (!(prtype & DATA_UNSIGNED)) {
+			val &= ~0x800000;
+			snprintf(buf, buf_len, "%ld", (long) val);
+		} else {
+			snprintf(buf, buf_len, "%lu", (ulong) val);
+		}
+		break;
+
+	case 4:
+		val = mach_read_from_4(data);
+
+		if (!(prtype & DATA_UNSIGNED)) {
+			val &= ~0x80000000;
+			snprintf(buf, buf_len, "%ld", (long) val);
+		} else {
+			snprintf(buf, buf_len, "%lu", (ulong) val);
+		}
+		break;
+
+	case 6:
+		id = mach_read_from_6(data);
+		snprintf(buf, buf_len, "{%lu %lu}",
+			ut_dulint_get_high(id),
+			ut_dulint_get_low(id));
+		break;
+
+	case 7:
+		id = mach_read_from_7(data);
+		snprintf(buf, buf_len, "{%lu %lu}",
+			ut_dulint_get_high(id),
+			ut_dulint_get_low(id));
+		break;
+	case 8:
+		id = mach_read_from_8(data);
+		snprintf(buf, buf_len, "{%lu %lu}",
+			ut_dulint_get_high(id),
+			ut_dulint_get_low(id));
+		break;
+	default:
+		break;
+	}
+}
+
+
+/*******************************************************************//**
+Format string value. */
+UNIV_INTERN
+void
+ib_page_format_str(
+/*===============*/
+	char*		buf,		/*!< out: buffer */
+	ulint		buf_len,	/*!< in: buffer length */
+	const byte*	data,		/*!< in: field data */
+	ulint		data_len)	/*!< in: length of data */
+{
+	if (data_len >= buf_len) {
+		strncpy(buf, (const char*)data, buf_len);
+		buf[buf_len - 4]= '.';
+		buf[buf_len - 3]= '.';
+		buf[buf_len - 2]= '.';
+		buf[buf_len - 1]= 0;
+	} else if (data_len != UNIV_SQL_NULL) {
+		strncpy(buf, (const char*)data, data_len);
+		buf[data_len]= 0;
+	}
+}
+
+
+/*******************************************************************//**
+Format binalry value. */
+UNIV_INTERN
+void ib_page_format_bin(
+/*====================*/
+	char*		buf,		/*!< out: buffer */
+	ulint		buf_len,	/*!< in: buffer length */
+	const byte*	data,		/*!< in: field data */
+	ulint		data_len)	/*!< in: length of data */
+{
+	ulint i;
+	for (i = 0; i < data_len * 2 && i + 2 < buf_len; i += 2)
+		sprintf(buf + i, "%02x", data[i / 2]);
+	if (data_len * 2 >= buf_len) {
+		buf[buf_len - 5]= '.';
+		buf[buf_len - 4]= '.';
+		buf[buf_len - 3]= '.';
+		buf[buf_len - 2]= '.';
+	}
+	buf[buf_len - 1]= 0;
+}
+
+
+/***************************************************************//**
+Hex dump of page. */
+UNIV_INTERN
+void
+ib_page_print_hex_dump(
+/*===================*/
+	const page_t*	page,		/*!< in: page */
+	ulint		zip_size)	/*!< in: compressed page size, or
+					0 for uncompressed pages */
+{
+	const byte*	s	= page;
+	ulint		addr;
+	const ulint	width	= 32; /* bytes per line */
+	ulint		size;
+
+	size = zip_size ? zip_size : UNIV_PAGE_SIZE;
+
+	for (addr = 0; addr < size; addr += width) {
+		ulint	i;
+
+		ib_logger(ib_stream, "%04lx ", (ulong) addr);
+
+		i = ut_min(width, size - addr);
+
+		while (i--) {
+			ib_logger(ib_stream, "%02x", *s++);
+		}
+
+		ib_logger(ib_stream, "\n");
+	}
+}
+
+
+/***************************************************************//**
+Format externally stored field. */
+UNIV_INTERN
+void
+ib_page_format_ext(
+/*===============*/
+	char*		buf,		/*!< out: buffer */
+	ulint		buf_len,	/*!< in: buffer length */
+	const rec_t*	rec,		/*!< in: physical record */
+	ulint		no,		/*!< in: field number */
+	const ulint*	offsets)	/*!< in: array returned by
+					rec_get_offsets() */
+{
+	char		local_data[30];
+	ulint		local_len;
+	ulint		space_id;
+	ulint		page_no;
+	ulint		offset;
+	ulint		extern_len;
+	const byte*	data;
+
+	ut_a(rec_offs_nth_extern(offsets, no));
+
+	/* An externally stored field can contain some initial
+	data from the field, and in the last 20 bytes it has the
+	space id, page number, and offset where the rest of the
+	field data is stored, and the data length in addition to
+	the data stored locally. We may need to store some data
+	locally to get the local record length above the 128 byte
+	limit so that field offsets are stored in two bytes, and
+	the extern bit is available in those two bytes. */
+
+	data = rec_get_nth_field(rec, offsets, no, &local_len);
+
+	ib_page_format_bin(local_data, 30, data, local_len);
+
+	local_len -= BTR_EXTERN_FIELD_REF_SIZE;
+
+	space_id = mach_read_from_4(data + local_len + BTR_EXTERN_SPACE_ID);
+
+	page_no = mach_read_from_4(data + local_len + BTR_EXTERN_PAGE_NO);
+
+	offset = mach_read_from_4(data + local_len + BTR_EXTERN_OFFSET);
+
+	/* Currently a BLOB cannot be bigger than 4 GB; we
+	leave the 4 upper bytes in the length field unused */
+
+	extern_len = mach_read_from_4(data + local_len + BTR_EXTERN_LEN + 4);
+
+	snprintf(buf, buf_len,
+		 "(loc len %lu, space %lu, page %lu,"
+		 " offs %lu, ext len %lu) %s",
+		 local_len, space_id, page_no,
+		 offset, extern_len, local_data);
+
+}
+
+/*******************************************************************//**
+Print field. */
+UNIV_INTERN
+void
+ib_page_rec_print_field(
+/*====================*/
+	const dfield_t*	field,		/*!< in: field */
+	const rec_t*	rec,		/*!< in: physical record */
+	ulint		no,		/*!< in: field number */
+	const ulint*	offsets)	/*!< in: array returned by
+					rec_get_offsets() */
+{
+	enum { BUF_LEN = 80 };
+	char		buf[BUF_LEN];
+	char		type_buf[BUF_LEN];
+	const dtype_t*	type;
+	const byte*	data;
+	ulint		len;
+	ulint		mtype;