/*****************************************************************************

Copyright (c) 1994, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2012, Facebook Inc.
Copyright (c) 2017, 2023, MariaDB Corporation.

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 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, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA

*****************************************************************************/

/**************************************************//**
@file page/page0page.cc
Index page routines

Created 2/2/1994 Heikki Tuuri
*******************************************************/

#include "page0page.h"
#include "page0cur.h"
#include "page0zip.h"
#include "buf0buf.h"
#include "buf0checksum.h"
#include "btr0btr.h"
#include "srv0srv.h"
#include "lock0lock.h"
#include "fut0lst.h"
#include "btr0sea.h"
#include "trx0sys.h"
#include <algorithm>

/* THE INDEX PAGE
   ==============

The index page consists of a page header which contains the page's
id and other information. On top of it are the index records
in a heap linked into a one way linear list according to alphabetic order.

Just below page end is an array of pointers which we call page directory,
to about every sixth record in the list. The pointers are placed in
the directory in the alphabetical order of the records pointed to,
enabling us to make binary search using the array. Each slot n:o I
in the directory points to a record, where a 4-bit field contains a count
of those records which are in the linear list between pointer I and
the pointer I - 1 in the directory, including the record
pointed to by pointer I and not including the record pointed to by I - 1.
We say that the record pointed to by slot I, or that slot I, owns
these records. The count is always kept in the range 4 to 8, with
the exception that it is 1 for the first slot, and 1--8 for the second slot.

An essentially binary search can be performed in the list of index
records, like we could do if we had pointer to every record in the
page directory. The data structure is, however, more efficient when
we are doing inserts, because most inserts are just pushed on a heap.
Only every 8th insert requires block move in the directory pointer
table, which itself is quite small. A record is deleted from the page
by just taking it off the linear list and updating the number of owned
records-field of the record which owns it, and updating the page directory,
if necessary. A special case is the one when the record owns itself.
Because the overhead of inserts is so small, we may also increase the
page size from the projected default of 8 kB to 64 kB without too
much loss of efficiency in inserts. Bigger page becomes actual
when the disk transfer rate compared to seek and latency time rises.
On the present system, the page size is set so that the page transfer
time (3 ms) is 20 % of the disk random access time (15 ms).

When the page is split, merged, or becomes full but contains deleted
records, we have to reorganize the page.

Assuming a page size of 8 kB, a typical index page of a secondary
index contains 300 index entries, and the size of the page directory
is 50 x 4 bytes = 200 bytes. */

/***************************************************************//**
Looks for the directory slot which owns the given record.
@return the directory slot number
@retval ULINT_UNDEFINED on corruption */
ulint
page_dir_find_owner_slot(
/*=====================*/
 const rec_t* rec) /*!< in: the physical record */
{
 ut_ad(page_rec_check(rec));

 const page_t* page = page_align(rec);
 const page_dir_slot_t* first_slot = page_dir_get_nth_slot(page, 0);
 const page_dir_slot_t* slot = page_dir_get_nth_slot(
  page, ulint(page_dir_get_n_slots(page)) - 1);
 const rec_t*  r = rec;

 if (page_is_comp(page)) {
  while (rec_get_n_owned_new(r) == 0) {
   r = page_rec_next_get<true>(page, r);
   if (UNIV_UNLIKELY(r < page + PAGE_NEW_SUPREMUM
       || r >= slot)) {
    return ULINT_UNDEFINED;
   }
  }
 } else {
  while (rec_get_n_owned_old(r) == 0) {
   r = page_rec_next_get<false>(page, r);
   if (UNIV_UNLIKELY(r < page + PAGE_OLD_SUPREMUM
       || r >= slot)) {
    return ULINT_UNDEFINED;
   }
  }
 }

 while (UNIV_LIKELY(*(uint16*) slot
      != mach_encode_2(ulint(r - page)))) {
  if (UNIV_UNLIKELY(slot == first_slot)) {
   return ULINT_UNDEFINED;
  }

  slot += PAGE_DIR_SLOT_SIZE;
 }

 return(((ulint) (first_slot - slot)) / PAGE_DIR_SLOT_SIZE);
}

/**************************************************************//**
Used to check the consistency of a directory slot.
@return TRUE if succeed */
static
ibool
page_dir_slot_check(
/*================*/
 const page_dir_slot_t* slot) /*!< in: slot */
{
 const page_t* page;
 ulint  n_slots;
 ulint  n_owned;

 ut_a(slot);

 page = page_align(slot);

 n_slots = page_dir_get_n_slots(page);

 ut_a(slot <= page_dir_get_nth_slot(page, 0));
 ut_a(slot >= page_dir_get_nth_slot(page, n_slots - 1));

 ut_a(page_rec_check(page_dir_slot_get_rec(slot)));

 if (page_is_comp(page)) {
  n_owned = rec_get_n_owned_new(page_dir_slot_get_rec(slot));
 } else {
  n_owned = rec_get_n_owned_old(page_dir_slot_get_rec(slot));
 }

 if (slot == page_dir_get_nth_slot(page, 0)) {
  ut_a(n_owned == 1);
 } else if (slot == page_dir_get_nth_slot(page, n_slots - 1)) {
  ut_a(n_owned >= 1);
  ut_a(n_owned <= PAGE_DIR_SLOT_MAX_N_OWNED);
 } else {
  ut_a(n_owned >= PAGE_DIR_SLOT_MIN_N_OWNED);
  ut_a(n_owned <= PAGE_DIR_SLOT_MAX_N_OWNED);
 }

 return(TRUE);
}

/*************************************************************//**
Sets the max trx id field value. */
void
page_set_max_trx_id(
/*================*/
 buf_block_t* block, /*!< in/out: page */
 page_zip_des_t* page_zip,/*!< in/out: compressed page, or NULL */
 trx_id_t trx_id, /*!< in: transaction id */
 mtr_t*  mtr) /*!< in/out: mini-transaction, or NULL */
{
  ut_ad(!mtr || mtr->memo_contains_flagged(block, MTR_MEMO_PAGE_X_FIX));
  ut_ad(!page_zip || page_zip == &block->page.zip);
  static_assert((PAGE_HEADER + PAGE_MAX_TRX_ID) % 8 == 0, "alignment");
  byte *max_trx_id= my_assume_aligned<8>(PAGE_MAX_TRX_ID +
                                         PAGE_HEADER + block->page.frame);

  mtr->write<8>(*block, max_trx_id, trx_id);
  if (UNIV_LIKELY_NULL(page_zip))
    memcpy_aligned<8>(&page_zip->data[PAGE_MAX_TRX_ID + PAGE_HEADER],
                      max_trx_id, 8);
}

/** Persist the AUTO_INCREMENT value on a clustered index root page.
@param[in,out] block clustered index root page
@param[in] index clustered index
@param[in] autoinc next available AUTO_INCREMENT value
@param[in,out] mtr mini-transaction
@param[in] reset whether to reset the AUTO_INCREMENT
   to a possibly smaller value than currently
exists in the page */
void
page_set_autoinc(
 buf_block_t*  block,
 ib_uint64_t  autoinc,
 mtr_t*   mtr,
 bool   reset)
{
  ut_ad(mtr->memo_contains_flagged(block, MTR_MEMO_PAGE_X_FIX |
                                   MTR_MEMO_PAGE_SX_FIX));

  byte *field= my_assume_aligned<8>(PAGE_HEADER + PAGE_ROOT_AUTO_INC +
                                    block->page.frame);
  ib_uint64_t old= mach_read_from_8(field);
  if (old == autoinc || (old > autoinc && !reset))
    return; /* nothing to update */

  mtr->write<8>(*block, field, autoinc);
  if (UNIV_LIKELY_NULL(block->page.zip.data))
    memcpy_aligned<8>(PAGE_HEADER + PAGE_ROOT_AUTO_INC + block->page.zip.data,
                      field, 8);
}

/** The page infimum and supremum of an empty page in ROW_FORMAT=REDUNDANT */
static const byte infimum_supremum_redundant[] = {
 /* the infimum record */
 0x08/*end offset*/,
 0x01/*n_owned*/,
 0x00, 0x00/*heap_no=0*/,
 0x03/*n_fields=1, 1-byte offsets*/,
 0x00, 0x74/* pointer to supremum */,
 'i', 'n', 'f', 'i', 'm', 'u', 'm', 0,
 /* the supremum record */
 0x09/*end offset*/,
 0x01/*n_owned*/,
 0x00, 0x08/*heap_no=1*/,
 0x03/*n_fields=1, 1-byte offsets*/,
 0x00, 0x00/* end of record list */,
 's', 'u', 'p', 'r', 'e', 'm', 'u', 'm', 0
};

/** The page infimum and supremum of an empty page in ROW_FORMAT=COMPACT */
static const byte infimum_supremum_compact[] = {
 /* the infimum record */
 0x01/*n_owned=1*/,
 0x00, 0x02/* heap_no=0, REC_STATUS_INFIMUM */,
 0x00, 0x0d/* pointer to supremum */,
 'i', 'n', 'f', 'i', 'm', 'u', 'm', 0,
 /* the supremum record */
 0x01/*n_owned=1*/,
 0x00, 0x0b/* heap_no=1, REC_STATUS_SUPREMUM */,
 0x00, 0x00/* end of record list */,
 's', 'u', 'p', 'r', 'e', 'm', 'u', 'm'
};

/** Create an index page.
@param[in,out] block buffer block
@param[in] comp nonzero=compact page format */
void page_create_low(const buf_block_t* block, bool comp)
{
 page_t*  page;

 compile_time_assert(PAGE_BTR_IBUF_FREE_LIST + FLST_BASE_NODE_SIZE
       <= PAGE_DATA);
 compile_time_assert(PAGE_BTR_IBUF_FREE_LIST_NODE + FLST_NODE_SIZE
       <= PAGE_DATA);

 page = block->page.frame;

 fil_page_set_type(page, FIL_PAGE_INDEX);

 memset(page + PAGE_HEADER, 0, PAGE_HEADER_PRIV_END);
 page[PAGE_HEADER + PAGE_N_DIR_SLOTS + 1] = 2;
 page[PAGE_HEADER + PAGE_INSTANT] = 0;
 page[PAGE_HEADER + PAGE_DIRECTION_B] = PAGE_NO_DIRECTION;

 if (comp) {
  page[PAGE_HEADER + PAGE_N_HEAP] = 0x80;/*page_is_comp()*/
  page[PAGE_HEADER + PAGE_N_HEAP + 1] = PAGE_HEAP_NO_USER_LOW;
  page[PAGE_HEADER + PAGE_HEAP_TOP + 1] = PAGE_NEW_SUPREMUM_END;
  memcpy(page + PAGE_DATA, infimum_supremum_compact,
         sizeof infimum_supremum_compact);
  memset(page
         + PAGE_NEW_SUPREMUM_END, 0,
         srv_page_size - PAGE_DIR - PAGE_NEW_SUPREMUM_END);
  page[srv_page_size - PAGE_DIR - PAGE_DIR_SLOT_SIZE * 2 + 1]
   = PAGE_NEW_SUPREMUM;
  page[srv_page_size - PAGE_DIR - PAGE_DIR_SLOT_SIZE + 1]
   = PAGE_NEW_INFIMUM;
 } else {
  page[PAGE_HEADER + PAGE_N_HEAP + 1] = PAGE_HEAP_NO_USER_LOW;
  page[PAGE_HEADER + PAGE_HEAP_TOP + 1] = PAGE_OLD_SUPREMUM_END;
  memcpy(page + PAGE_DATA, infimum_supremum_redundant,
         sizeof infimum_supremum_redundant);
  memset(page
         + PAGE_OLD_SUPREMUM_END, 0,
         srv_page_size - PAGE_DIR - PAGE_OLD_SUPREMUM_END);
  page[srv_page_size - PAGE_DIR - PAGE_DIR_SLOT_SIZE * 2 + 1]
   = PAGE_OLD_SUPREMUM;
  page[srv_page_size - PAGE_DIR - PAGE_DIR_SLOT_SIZE + 1]
   = PAGE_OLD_INFIMUM;
 }
}

/** Create an uncompressed index page.
@param[in,out] block buffer block
@param[in,out] mtr mini-transaction
@param[in] comp set unless ROW_FORMAT=REDUNDANT */
void page_create(buf_block_t *block, mtr_t *mtr, bool comp)
{
  mtr->page_create(*block, comp);
  buf_block_modify_clock_inc(block);
  page_create_low(block, comp);
}

/**********************************************************//**
Create a compressed B-tree index page. */
void
page_create_zip(
/*============*/
 buf_block_t*  block,  /*!< in/out: a buffer frame
where the page is created */
 dict_index_t*  index,  /*!< in: the index of the
page */
 ulint   level,  /*!< in: the B-tree level
of the page */
 trx_id_t  max_trx_id, /*!< in: PAGE_MAX_TRX_ID */
 mtr_t*   mtr)  /*!< in/out: mini-transaction
handle */
{
 ut_ad(block);
 ut_ad(buf_block_get_page_zip(block));
 ut_ad(dict_table_is_comp(index->table));

 /* PAGE_MAX_TRX_ID or PAGE_ROOT_AUTO_INC are always 0 for
temporary tables. */
 ut_ad(max_trx_id == 0 || !index->table->is_temporary());
 /* In secondary indexes, PAGE_MAX_TRX_ID
 must be zero on non-leaf pages. max_trx_id can be 0 when the
 index consists of an empty root (leaf) page.

 the clustered index, PAGE_ROOT_AUTOINC or
PAGE_MAX_TRX_ID must be 0 on other pages than the root. */
 ut_ad(max_trx_id == 0 || level == 0 || index->is_primary()
       || index->table->is_temporary());

 buf_block_modify_clock_inc(block);
 page_create_low(block, true);

 if (index->is_spatial()) {
  mach_write_to_2(FIL_PAGE_TYPE + block->page.frame,
    FIL_PAGE_RTREE);
  memset(block->page.frame + FIL_RTREE_SPLIT_SEQ_NUM, 0, 8);
  memset(block->page.zip.data + FIL_RTREE_SPLIT_SEQ_NUM, 0, 8);
 }

 mach_write_to_2(PAGE_HEADER + PAGE_LEVEL + block->page.frame, level);
 mach_write_to_8(PAGE_HEADER + PAGE_MAX_TRX_ID + block->page.frame,
   max_trx_id);

 if (!page_zip_compress(block, index, page_zip_level, mtr)) {
  /* The compression of a newly created
page should always succeed. */
  ut_error;
 }
}

/**********************************************************//**
Empty a previously created B-tree index page. */
void
page_create_empty(
/*==============*/
 buf_block_t* block, /*!< in/out: B-tree block */
 dict_index_t* index, /*!< in: the index of the page */
 mtr_t*  mtr) /*!< in/out: mini-transaction */
{
 trx_id_t max_trx_id;
 page_zip_des_t* page_zip= buf_block_get_page_zip(block);

 ut_ad(fil_page_index_page_check(block->page.frame));
 ut_ad(!index->is_dummy);
 ut_ad(block->page.id().space() == index->table->space->id);

 /* Multiple transactions cannot simultaneously operate on the
 same temp-table in parallel.
 max_trx_id is ignored for temp tables because it not required
for MVCC. */
 if (!index->is_primary() && !index->table->is_temporary()
     && page_is_leaf(block->page.frame)) {
  max_trx_id = page_get_max_trx_id(block->page.frame);
  ut_ad(max_trx_id);
 } else if (block->page.id().page_no() == index->page) {
  /* Preserve PAGE_ROOT_AUTO_INC. */
  max_trx_id = page_get_max_trx_id(block->page.frame);
 } else {
  max_trx_id = 0;
 }

 if (page_zip) {
  ut_ad(!index->table->is_temporary());
  page_create_zip(block, index,
    page_header_get_field(block->page.frame,
            PAGE_LEVEL),
    max_trx_id, mtr);
 } else {
  page_create(block, mtr, index->table->not_redundant());
  if (index->is_spatial()) {
   static_assert(((FIL_PAGE_INDEX & 0xff00)
           | byte(FIL_PAGE_RTREE))
          == FIL_PAGE_RTREE, "compatibility");
   mtr->write<1>(*block,
          FIL_PAGE_TYPE + 1 + block->page.frame,
          byte(FIL_PAGE_RTREE));
   if (mach_read_from_8(block->page.frame
          + FIL_RTREE_SPLIT_SEQ_NUM)) {
    mtr->memset(block, FIL_RTREE_SPLIT_SEQ_NUM,
         8, 0);
   }
  }

  if (max_trx_id) {
   mtr->write<8>(*block, PAGE_HEADER + PAGE_MAX_TRX_ID
          + block->page.frame, max_trx_id);
  }
 }
}

/*************************************************************//**
Differs from page_copy_rec_list_end, because this function does not
touch the lock table and max trx id on page or compress the page.

@return error code */
dberr_t
page_copy_rec_list_end_no_locks(
/*============================*/
 buf_block_t* new_block, /*!< in: index page to copy to */
 buf_block_t* block,  /*!< in: index page of rec */
 rec_t*  rec,  /*!< in: record on page */
 dict_index_t* index,  /*!< in: record descriptor */
 mtr_t*  mtr)  /*!< in: mtr */
{
 page_t*  new_page = buf_block_get_frame(new_block);
 page_cur_t cur1;
 page_cur_t cur2;
 mem_heap_t* heap  = NULL;
 rec_offs offsets_[REC_OFFS_NORMAL_SIZE];
 rec_offs* offsets  = offsets_;
 rec_offs_init(offsets_);

 cur1.index = cur2.index = index;
 page_cur_position(rec, block, &cur1);

 if (page_cur_is_before_first(&cur1) && !page_cur_move_to_next(&cur1)) {
  return DB_CORRUPTION;
 }

 if (UNIV_UNLIKELY(page_is_comp(new_page)
     != page_is_comp(block->page.frame)
     || mach_read_from_2(new_page + srv_page_size - 10)
     != ulint(page_is_comp(new_page)
       ? PAGE_NEW_INFIMUM : PAGE_OLD_INFIMUM))) {
  return DB_CORRUPTION;
 }

 const ulint n_core = page_is_leaf(block->page.frame)
  ? index->n_core_fields : 0;

 dberr_t err = DB_SUCCESS;
 page_cur_set_before_first(new_block, &cur2);

 /* Copy records from the original page to the new page */

 while (!page_cur_is_after_last(&cur1)) {
  rec_t* ins_rec;
  offsets = rec_get_offsets(cur1.rec, index, offsets, n_core,
       ULINT_UNDEFINED, &heap);
  ins_rec = page_cur_insert_rec_low(&cur2, cur1.rec, offsets,
        mtr);
  if (UNIV_UNLIKELY(!ins_rec || !page_cur_move_to_next(&cur1))) {
   err = DB_CORRUPTION;
   break;
  }
  ut_ad(!(rec_get_info_bits(cur1.rec, page_is_comp(new_page))
   & REC_INFO_MIN_REC_FLAG));
  cur2.rec = ins_rec;
 }

 if (UNIV_LIKELY_NULL(heap)) {
  mem_heap_free(heap);
 }

 return err;
}

/*************************************************************//**
Copies records from page to new_page, from a given record onward,
including that record. Infimum and supremum records are not copied.
The records are copied to the start of the record list on new_page.

@return pointer to the original successor of the infimum record on new_block
@retval nullptr on ROW_FORMAT=COMPRESSED page overflow */
rec_t*
page_copy_rec_list_end(
/*===================*/
 buf_block_t* new_block, /*!< in/out: index page to copy to */
 buf_block_t* block,  /*!< in: index page containing rec */
 rec_t*  rec,  /*!< in: record on page */
 dict_index_t* index,  /*!< in: record descriptor */
 mtr_t*  mtr,  /*!< in/out: mini-transaction */
 dberr_t* err)  /*!< out: error code */
{
 page_t*  new_page = new_block->page.frame;
 page_zip_des_t* new_page_zip = buf_block_get_page_zip(new_block);
 page_t*  page  = block->page.frame;
 rec_t*  ret  = page_rec_get_next(
  page_get_infimum_rec(new_page));
 ulint  num_moved = 0;
 ut_ad(page_align(rec) == page);

 if (UNIV_UNLIKELY(!ret)) {
  *err = DB_CORRUPTION;
  return nullptr;
 }

#ifdef UNIV_ZIP_DEBUG
 if (new_page_zip) {
  page_zip_des_t* page_zip = buf_block_get_page_zip(block);
  ut_a(page_zip);

  /* Strict page_zip_validate() may fail here.
  Furthermore, btr_compress() may set FIL_PAGE_PREV to
  FIL_NULL on new_page while leaving it intact on
new_page_zip.  So, we cannot validate new_page_zip. */
  ut_a(page_zip_validate_low(page_zip, page, index, TRUE));
 }
#endif /* UNIV_ZIP_DEBUG */
 ut_ad(buf_block_get_frame(block) == page);
 ut_ad(page_is_leaf(page) == page_is_leaf(new_page));
 ut_ad(page_is_comp(page) == page_is_comp(new_page));
 /* Here, "ret" may be pointing to a user record or the
predefined supremum record. */

 const mtr_log_t log_mode = new_page_zip
  ? mtr->set_log_mode(MTR_LOG_NONE) : MTR_LOG_NONE;
 const bool was_empty = page_dir_get_n_heap(new_page)
  == PAGE_HEAP_NO_USER_LOW;
 alignas(2) byte h[PAGE_N_DIRECTION + 2 - PAGE_LAST_INSERT];
 memcpy_aligned<2>(h, PAGE_HEADER + PAGE_LAST_INSERT + new_page,
     sizeof h);
 mem_heap_t* heap = nullptr;
 rtr_rec_move_t* rec_move = nullptr;

 if (index->is_spatial()) {
  ulint max_to_move = page_get_n_recs(
   buf_block_get_frame(block));
  heap = mem_heap_create(256);
  rec_move= static_cast<rtr_rec_move_t*>(
   mem_heap_alloc(heap, max_to_move * sizeof *rec_move));
  /* For spatial index, we need to insert recs one by one
to keep recs ordered. */
  *err = rtr_page_copy_rec_list_end_no_locks(new_block,
          block, rec, index,
          heap, rec_move,
          max_to_move,
          &num_moved,
          mtr);
 } else {
  *err = page_copy_rec_list_end_no_locks(new_block, block, rec,
             index, mtr);
  if (UNIV_UNLIKELY(*err != DB_SUCCESS)) {
err_exit:
   if (UNIV_LIKELY_NULL(heap)) {
    mem_heap_free(heap);
   }
   return nullptr;
  }
  if (was_empty) {
   mtr->memcpy<mtr_t::MAYBE_NOP>(*new_block, PAGE_HEADER
            + PAGE_LAST_INSERT
            + new_page, h, sizeof h);
  }
 }

 /* Update PAGE_MAX_TRX_ID on the uncompressed page.
 Modifications will be redo logged and copied to the compressed
 page in page_zip_compress() or page_zip_reorganize() below.
 Multiple transactions cannot simultaneously operate on the
 same temp-table in parallel.
 max_trx_id is ignored for temp tables because it not required
for MVCC. */
 if (!index->is_primary() && page_is_leaf(page)
     && !index->table->is_temporary()) {
  ut_ad(!was_empty || page_dir_get_n_heap(new_page)
        == PAGE_HEAP_NO_USER_LOW
        + page_header_get_field(new_page, PAGE_N_RECS));
  page_update_max_trx_id(new_block, NULL,
           page_get_max_trx_id(page), mtr);
 }

 if (new_page_zip) {
  mtr_set_log_mode(mtr, log_mode);

  if (!page_zip_compress(new_block, index,
           page_zip_level, mtr)) {
   /* Before trying to reorganize the page,
store the number of preceding records on the page. */
   ulint ret_pos
    = page_rec_get_n_recs_before(ret);
   /* Before copying, "ret" was the successor of
   the predefined infimum record.  It must still
   have at least one predecessor (the predefined
   infimum record, or a freshly copied record
that is smaller than "ret"). */
   if (UNIV_UNLIKELY(!ret_pos
       || ret_pos == ULINT_UNDEFINED)) {
    *err = DB_CORRUPTION;
    goto err_exit;
   }

   *err = page_zip_reorganize(new_block, index,
         page_zip_level, mtr);
   switch (*err) {
   case DB_FAIL:
    if (!page_zip_decompress(new_page_zip,
        new_page, FALSE)) {
     ut_error;
    }
    ut_ad(page_validate(new_page, index));
    /* fall through */
   default:
    goto err_exit;
   case DB_SUCCESS:
    /* The page was reorganized:
Seek to ret_pos. */
    ret = page_rec_get_nth(new_page, ret_pos);
    ut_ad(ret);
   }
  }
 }

 /* Update the lock table and possible hash index */

 if (!index->has_locking()) {
 } else if (UNIV_LIKELY_NULL(rec_move)) {
  lock_rtr_move_rec_list(new_block, block, rec_move, num_moved);
 } else {
  lock_move_rec_list_end(new_block, block, rec);
 }

 if (UNIV_LIKELY_NULL(heap)) {
  mem_heap_free(heap);
 }

 btr_search_move_or_delete_hash_entries(new_block, block, *mtr);

 return(ret);
}

/*************************************************************//**
Copies records from page to new_page, up to the given record,
NOT including that record. Infimum and supremum records are not copied.
The records are copied to the end of the record list on new_page.

@return pointer to the original predecessor of the supremum record on new_block
@retval nullptr on ROW_FORMAT=COMPRESSED page overflow */
rec_t*
page_copy_rec_list_start(
/*=====================*/
 buf_block_t* new_block, /*!< in/out: index page to copy to */
 buf_block_t* block,  /*!< in: index page containing rec */
 rec_t*  rec,  /*!< in: record on page */
 dict_index_t* index,  /*!< in: record descriptor */
 mtr_t*  mtr,  /*!< in/out: mini-transaction */
 dberr_t* err)  /*!< out: error code */
{
 ut_ad(page_align(rec) == block->page.frame);

 page_t*  new_page = buf_block_get_frame(new_block);
 page_zip_des_t* new_page_zip = buf_block_get_page_zip(new_block);
 page_cur_t cur1;
 page_cur_t cur2;
 mem_heap_t* heap  = NULL;
 ulint  num_moved = 0;
 rtr_rec_move_t* rec_move = NULL;
 rec_t*  ret
  = page_rec_get_prev(page_get_supremum_rec(new_page));
 rec_offs offsets_[REC_OFFS_NORMAL_SIZE];
 rec_offs* offsets  = offsets_;
 rec_offs_init(offsets_);

 if (UNIV_UNLIKELY(!ret)) {
corrupted:
  *err = DB_CORRUPTION;
  return nullptr;
 }

 /* Here, "ret" may be pointing to a user record or the
predefined infimum record. */

 if (page_rec_is_infimum(rec)) {
  *err = DB_SUCCESS;
  return(ret);
 }

 page_cur_set_before_first(block, &cur1);
 if (UNIV_UNLIKELY(!page_cur_move_to_next(&cur1))) {
  goto corrupted;
 }

 mtr_log_t log_mode = MTR_LOG_NONE;

 if (new_page_zip) {
  log_mode = mtr_set_log_mode(mtr, MTR_LOG_NONE);
 }

 cur2.index = index;
 page_cur_position(ret, new_block, &cur2);

 const ulint n_core = page_rec_is_leaf(rec) ? index->n_core_fields : 0;

 /* Copy records from the original page to the new page */
 if (index->is_spatial()) {
  ut_ad(!index->is_instant());
  ulint  max_to_move = page_get_n_recs(
      buf_block_get_frame(block));
  heap = mem_heap_create(256);

  rec_move = static_cast<rtr_rec_move_t*>(mem_heap_alloc(
     heap,
     sizeof (*rec_move) * max_to_move));

  /* For spatial index, we need to insert recs one by one
to keep recs ordered. */
  *err = rtr_page_copy_rec_list_start_no_locks(new_block,
            block, rec, index,
            heap, rec_move,
            max_to_move,
            &num_moved, mtr);
  if (*err != DB_SUCCESS) {
   return nullptr;
  }
 } else {
  while (page_cur_get_rec(&cur1) != rec) {
   offsets = rec_get_offsets(cur1.rec, index, offsets,
        n_core,
        ULINT_UNDEFINED, &heap);
   cur2.rec = page_cur_insert_rec_low(&cur2, cur1.rec,
          offsets, mtr);
   if (UNIV_UNLIKELY(!cur2.rec
       || !page_cur_move_to_next(&cur1))) {
    *err = DB_CORRUPTION;
    return nullptr;
   }

   ut_ad(!(rec_get_info_bits(cur1.rec,
        page_is_comp(new_page))
    & REC_INFO_MIN_REC_FLAG));
  }
 }

 /* Update PAGE_MAX_TRX_ID on the uncompressed page.
 Modifications will be redo logged and copied to the compressed
 page in page_zip_compress() or page_zip_reorganize() below.
 Multiple transactions cannot simultaneously operate on the
 same temp-table in parallel.
 max_trx_id is ignored for temp tables because it not required
for MVCC. */
 if (n_core && !index->is_primary() && !index->table->is_temporary()) {
  page_update_max_trx_id(new_block, nullptr,
           page_get_max_trx_id(block->page.frame),
                                       mtr);
 }

 if (new_page_zip) {
  mtr_set_log_mode(mtr, log_mode);

  DBUG_EXECUTE_IF("page_copy_rec_list_start_compress_fail",
    goto zip_reorganize;);

  if (!page_zip_compress(new_block, index,
           page_zip_level, mtr)) {
#ifndef DBUG_OFF
zip_reorganize:
#endif /* DBUG_OFF */
   /* Before trying to reorganize the page,
store the number of preceding records on the page. */
   ulint ret_pos = page_rec_get_n_recs_before(ret);
   /* Before copying, "ret" was the predecessor
   of the predefined supremum record.  If it was
   the predefined infimum record, then it would
   still be the infimum, and we would have
ret_pos == 0. */
   if (UNIV_UNLIKELY(ret_pos == ULINT_UNDEFINED)) {
    *err = DB_CORRUPTION;
    return nullptr;
   }

   *err = page_zip_reorganize(new_block, index,
         page_zip_level, mtr);
   switch (*err) {
   case DB_SUCCESS:
    ret = page_rec_get_nth(new_page, ret_pos);
    ut_ad(ret);
    break;
   case DB_FAIL:
    if (UNIV_UNLIKELY
        (!page_zip_decompress(new_page_zip,
         new_page, FALSE))) {
     ut_error;
    }
    ut_ad(page_validate(new_page, index));
    /* fall through */
   default:
    if (UNIV_LIKELY_NULL(heap)) {
     mem_heap_free(heap);
    }

    return nullptr;
   }
  }
 }

 /* Update the lock table and possible hash index */

 if (!index->has_locking()) {
 } else if (dict_index_is_spatial(index)) {
  lock_rtr_move_rec_list(new_block, block, rec_move, num_moved);
 } else {
  lock_move_rec_list_start(new_block, block, rec, ret);
 }

 if (heap) {
  mem_heap_free(heap);
 }

 btr_search_move_or_delete_hash_entries(new_block, block, *mtr);

 *err = DB_SUCCESS;
 return(ret);
}

/*************************************************************//**
Deletes records from a page from a given record onward, including that record.
The infimum and supremum records are not deleted. */
dberr_t
page_delete_rec_list_end(
/*=====================*/
 rec_t*  rec, /*!< in: pointer to record on page */
 buf_block_t* block, /*!< in: buffer block of the page */
 dict_index_t* index, /*!< in: record descriptor */
 ulint  n_recs, /*!< in: number of records to delete,
or ULINT_UNDEFINED if not known */
 ulint  size, /*!< in: the sum of the sizes of the
    records in the end of the chain to
delete, or ULINT_UNDEFINED if not known */
 mtr_t*  mtr) /*!< in: mtr */
{
  page_t * const page= block->page.frame;

  ut_ad(size == ULINT_UNDEFINED || size < srv_page_size);
  ut_ad(page_align(rec) == page);
  ut_ad(index->table->not_redundant() == !!page_is_comp(page));
#ifdef UNIV_ZIP_DEBUG
  ut_a(!block->page.zip.data ||
       page_zip_validate(&block->page.zip, page, index));
#endif /* UNIV_ZIP_DEBUG */

  if (page_rec_is_supremum(rec))
  {
    ut_ad(n_recs == 0 || n_recs == ULINT_UNDEFINED);
    /* Nothing to do, there are no records bigger than the page supremum. */
    return DB_SUCCESS;
  }

  if (n_recs == page_get_n_recs(page) ||
      (page_is_comp(page)
       ? (rec == page + PAGE_NEW_INFIMUM ||
          rec == page_rec_next_get<true>(page, page + PAGE_NEW_INFIMUM))
       : (rec == page + PAGE_OLD_INFIMUM ||
          rec == page_rec_next_get<false>(page, page + PAGE_OLD_INFIMUM))))
  {
    /* We are deleting all records. */
    page_create_empty(block, index, mtr);
    return DB_SUCCESS;
  }

#if 0 // FIXME: consider deleting the last record as a special case
  if (page_rec_is_last(rec))
  {
    page_cur_t cursor= { index, rec, offsets, block };
    page_cur_delete_rec(&cursor, index, offsets, mtr);
    return DB_SUCCESS;
  }
#endif

  /* The page becomes invalid for optimistic searches */
  buf_block_modify_clock_inc(block);

  const ulint n_core= page_is_leaf(page) ? index->n_core_fields : 0;
  mem_heap_t *heap= nullptr;
  rec_offs offsets_[REC_OFFS_NORMAL_SIZE];
  rec_offs *offsets= offsets_;
  rec_offs_init(offsets_);

#if 1 // FIXME: remove this, and write minimal amount of log! */
  if (UNIV_LIKELY_NULL(block->page.zip.data))
  {
    ut_ad(page_is_comp(page));
    do
    {
      page_cur_t cur;
      page_cur_position(rec, block, &cur);
      cur.index= index;
      offsets= rec_get_offsets(rec, index, offsets, n_core,
          ULINT_UNDEFINED, &heap);
      rec= const_cast<rec_t*>(page_rec_next_get<true>(page, rec));
#ifdef UNIV_ZIP_DEBUG
      ut_a(page_zip_validate(&block->page.zip, page, index));
#endif /* UNIV_ZIP_DEBUG */
      page_cur_delete_rec(&cur, offsets, mtr);
    }
    while (rec - page != PAGE_NEW_SUPREMUM);

    if (UNIV_LIKELY_NULL(heap))
      mem_heap_free(heap);
    return DB_SUCCESS;
  }
#endif

  byte *prev_rec= page_rec_get_prev(rec);
  if (UNIV_UNLIKELY(!prev_rec))
    return DB_CORRUPTION;
  byte *last_rec= page_rec_get_prev(page_get_supremum_rec(page));
  if (UNIV_UNLIKELY(!last_rec))
    return DB_CORRUPTION;

  // FIXME: consider a special case of shrinking PAGE_HEAP_TOP

  const bool scrub= srv_immediate_scrub_data_uncompressed;
  if (scrub || size == ULINT_UNDEFINED || n_recs == ULINT_UNDEFINED)
  {
    rec_t *rec2= rec;
    /* Calculate the sum of sizes and the number of records */
    size= 0;
    n_recs= 0;

    do
    {
      offsets = rec_get_offsets(rec2, index, offsets, n_core,
                                ULINT_UNDEFINED, &heap);
      ulint s= rec_offs_size(offsets);
      ut_ad(ulint(rec2 - page) + s - rec_offs_extra_size(offsets) <
            srv_page_size);
      ut_ad(size + s < srv_page_size);
      size+= s;
      n_recs++;

      if (UNIV_LIKELY(!scrub));
      else if (size_t size= rec_offs_data_size(offsets))
        mtr->memset(block, rec2 - page, size, 0);

      rec2= page_rec_get_next(rec2);
    }
    while (rec2 && !page_rec_is_supremum(rec2));

    if (UNIV_LIKELY_NULL(heap))
      mem_heap_free(heap);

    if (UNIV_UNLIKELY(!rec))
      return DB_CORRUPTION;
  }

  ut_ad(size < srv_page_size);

  ulint slot_index, n_owned;
  {
    const rec_t *owner_rec= rec;
    ulint count= 0;

    if (page_is_comp(page))
      while (!(n_owned= rec_get_n_owned_new(owner_rec)))
      {
        count++;
 if (!(owner_rec= page_rec_next_get<true>(page, owner_rec)))
          return DB_CORRUPTION;
      }
    else
      while (!(n_owned= rec_get_n_owned_old(owner_rec)))
      {
        count++;
 if (!(owner_rec= page_rec_next_get<false>(page, owner_rec)))
          return DB_CORRUPTION;
      }

    ut_ad(n_owned > count);
    n_owned-= count;
    slot_index= page_dir_find_owner_slot(owner_rec);
  }

  if (UNIV_UNLIKELY(!slot_index || slot_index == ULINT_UNDEFINED))
    return DB_CORRUPTION;

  mtr->write<2,mtr_t::MAYBE_NOP>(*block, my_assume_aligned<2>
                                 (PAGE_N_DIR_SLOTS + PAGE_HEADER + page),
                                 slot_index + 1);
  mtr->write<2,mtr_t::MAYBE_NOP>(*block, my_assume_aligned<2>
                                 (PAGE_LAST_INSERT + PAGE_HEADER + page), 0U);
  /* Catenate the deleted chain segment to the page free list */
  alignas(4) byte page_header[4];
  byte *page_free= my_assume_aligned<4>(PAGE_HEADER + PAGE_FREE + page);
  const uint16_t free= page_header_get_field(page, PAGE_FREE);
  static_assert(PAGE_FREE + 2 == PAGE_GARBAGE, "compatibility");

  mach_write_to_2(page_header, rec - page);
  mach_write_to_2(my_assume_aligned<2>(page_header + 2),
                  mach_read_from_2(my_assume_aligned<2>(page_free + 2)) +
                  size);
  mtr->memcpy(*block, page_free, page_header, 4);

  byte *page_n_recs= my_assume_aligned<2>(PAGE_N_RECS + PAGE_HEADER + page);
  mtr->write<2>(*block, page_n_recs,
                ulint{mach_read_from_2(page_n_recs)} - n_recs);

  /* Update the page directory; there is no need to balance the number
  of the records owned by the supremum record, as it is allowed to be
  less than PAGE_DIR_SLOT_MIN_N_OWNED */
  page_dir_slot_t *slot= page_dir_get_nth_slot(page, slot_index);

  if (page_is_comp(page))
  {
    mtr->write<2,mtr_t::MAYBE_NOP>(*block, slot, PAGE_NEW_SUPREMUM);
    byte *owned= PAGE_NEW_SUPREMUM - REC_NEW_N_OWNED + page;
    byte new_owned= static_cast<byte>((*owned & ~REC_N_OWNED_MASK) |
                                      n_owned << REC_N_OWNED_SHIFT);
#if 0 // FIXME: implement minimal logging for ROW_FORMAT=COMPRESSED
    if (UNIV_LIKELY_NULL(block->page.zip.data))
    {
      *owned= new_owned;
      memcpy_aligned<2>(PAGE_N_DIR_SLOTS + PAGE_HEADER + block->page.zip.data,
                        PAGE_N_DIR_SLOTS + PAGE_HEADER + page,
   PAGE_N_RECS + 2 - PAGE_N_DIR_SLOTS);
      // TODO: the equivalent of page_zip_dir_delete() for all records
      mach_write_to_2(prev_rec - REC_NEXT, static_cast<uint16_t>
        (PAGE_NEW_SUPREMUM - (prev_rec - page)));
      mach_write_to_2(last_rec - REC_NEXT, free
                      ? uint16_t(free - (last_rec - block->page.frame)) : 0U);
      return DB_SUCCESS;
    }
#endif
    mtr->write<1,mtr_t::MAYBE_NOP>(*block, owned, new_owned);
    mtr->write<2>(*block, prev_rec - REC_NEXT, static_cast<uint16_t>
                  (PAGE_NEW_SUPREMUM - (prev_rec - block->page.frame)));
    mtr->write<2>(*block, last_rec - REC_NEXT, free
                  ? uint16_t(free - (last_rec - block->page.frame)) : 0U);
  }
  else
  {
    mtr->write<2,mtr_t::MAYBE_NOP>(*block, slot, PAGE_OLD_SUPREMUM);
    byte *owned= PAGE_OLD_SUPREMUM - REC_OLD_N_OWNED + page;
    byte new_owned= static_cast<byte>((*owned & ~REC_N_OWNED_MASK) |
                                      n_owned << REC_N_OWNED_SHIFT);
    mtr->write<1,mtr_t::MAYBE_NOP>(*block, owned, new_owned);
    mtr->write<2>(*block, prev_rec - REC_NEXT, PAGE_OLD_SUPREMUM);
    mtr->write<2>(*block, last_rec - REC_NEXT, free);
  }

  return DB_SUCCESS;
}

/*************************************************************//**
Deletes records from page, up to the given record, NOT including
that record. Infimum and supremum records are not deleted. */
void
page_delete_rec_list_start(
/*=======================*/
 rec_t*  rec, /*!< in: record on page */
 buf_block_t* block, /*!< in: buffer block of the page */
 dict_index_t* index, /*!< in: record descriptor */
 mtr_t*  mtr) /*!< in: mtr */
{
 page_cur_t cur1;
 rec_offs offsets_[REC_OFFS_NORMAL_SIZE];
 rec_offs* offsets  = offsets_;
 mem_heap_t* heap  = NULL;

 rec_offs_init(offsets_);

 ut_ad(page_align(rec) == block->page.frame);
 ut_ad((ibool) !!page_rec_is_comp(rec)
       == dict_table_is_comp(index->table));
#ifdef UNIV_ZIP_DEBUG
 {
  page_zip_des_t* page_zip= buf_block_get_page_zip(block);
  page_t*  page = buf_block_get_frame(block);

  /* page_zip_validate() would detect a min_rec_mark mismatch
  in btr_page_split_and_insert()
  between btr_attach_half_pages() and insert_page = ...
  when btr_page_get_split_rec_to_left() holds
(direction == FSP_DOWN). */
  ut_a(!page_zip
       || page_zip_validate_low(page_zip, page, index, TRUE));
 }
#endif /* UNIV_ZIP_DEBUG */

 if (page_rec_is_infimum(rec)) {
  return;
 }

 if (page_rec_is_supremum(rec)) {
  /* We are deleting all records. */
  page_create_empty(block, index, mtr);
  return;
 }

 cur1.index = index;
 page_cur_set_before_first(block, &cur1);
 if (UNIV_UNLIKELY(!page_cur_move_to_next(&cur1))) {
  ut_ad("corrupted page" == 0);
  return;
 }

 const ulint n_core = page_rec_is_leaf(rec)
  ? index->n_core_fields : 0;

 while (page_cur_get_rec(&cur1) != rec) {
  offsets = rec_get_offsets(page_cur_get_rec(&cur1), index,
       offsets, n_core,
       ULINT_UNDEFINED, &heap);
  page_cur_delete_rec(&cur1, offsets, mtr);
 }

 if (UNIV_LIKELY_NULL(heap)) {
  mem_heap_free(heap);
 }
}

/************************************************************//**
Returns the nth record of the record list.
This is the inverse function of page_rec_get_n_recs_before().
@return nth record
@retval nullptr on corrupted page */
const rec_t*
page_rec_get_nth_const(
/*===================*/
 const page_t* page, /*!< in: page */
 ulint  nth) /*!< in: nth record */
{
 const page_dir_slot_t* slot;
 ulint   i;
 ulint   n_owned;
 const rec_t*  rec;

 if (nth == 0) {
  return(page_get_infimum_rec(page));
 }

 ut_ad(nth < srv_page_size / (REC_N_NEW_EXTRA_BYTES + 1));

 for (i = 0;; i++) {
  slot = page_dir_get_nth_slot(page, i);
  n_owned = page_dir_slot_get_n_owned(slot);

  if (n_owned > nth) {
   break;
  } else {
   nth -= n_owned;
  }
 }

 if (UNIV_UNLIKELY(!i)) {
  return nullptr;
 }
 rec = page_dir_slot_get_rec(slot + 2);

 if (page_is_comp(page)) {
  do {
   rec = page_rec_next_get<true>(page, rec);
  } while (rec && nth--);
 } else {
  do {
   rec = page_rec_next_get<false>(page, rec);
  } while (rec && nth--);
 }

 return(rec);
}


/************************************************************//**
Gets the pointer to the previous record.
@return pointer to previous record
@retval nullptr on error */
const rec_t*
page_rec_get_prev_const(
/*====================*/
 const rec_t* rec) /*!< in: pointer to record, must not be page
infimum */
{
 const rec_t*  rec2;
 const rec_t*  prev_rec = NULL;

 ut_ad(page_rec_check(rec));

 const page_t* const page = page_align(rec);

 ut_ad(!page_rec_is_infimum(rec));

 ulint slot_no = page_dir_find_owner_slot(rec);

 if (UNIV_UNLIKELY(!slot_no || slot_no == ULINT_UNDEFINED)) {
  return nullptr;
 }

 const page_dir_slot_t* slot = page_dir_get_nth_slot(page, slot_no - 1);

 if (UNIV_UNLIKELY(!(rec2 = page_dir_slot_get_rec_validate(slot)))) {
  return nullptr;
 }

 if (page_is_comp(page)) {
  while (rec2 && rec != rec2) {
   prev_rec = rec2;
   ulint offs = rec_get_next_offs(rec2, TRUE);
   if (offs < PAGE_NEW_INFIMUM
       || offs > page_header_get_field(page,
           PAGE_HEAP_TOP)) {
    return nullptr;
   }
   rec2 = page + offs;
  }
  switch (rec_get_status(prev_rec)) {
  case REC_STATUS_INSTANT:
  case REC_STATUS_ORDINARY:
   if (!page_is_leaf(page)) {
    return nullptr;
   }
   break;
  case REC_STATUS_INFIMUM:
   break;
  case REC_STATUS_NODE_PTR:
   if (!page_is_leaf(page)) {
    break;
   }
   /* fall through */
  default:
   return nullptr;
  }
 } else {
  while (rec2 && rec != rec2) {
   prev_rec = rec2;
   ulint offs = rec_get_next_offs(rec2, FALSE);
   if (offs < PAGE_OLD_INFIMUM
       || offs > page_header_get_field(page,
           PAGE_HEAP_TOP)) {
    return nullptr;
   }
   rec2 = page + offs;
  }
 }

 return(prev_rec);
}

/** Return the number of preceding records in an index page.
@param rec index record
@return number of preceding records, including the infimum pseudo-record
@retval ULINT_UNDEFINED on corrupted page */
ulint page_rec_get_n_recs_before(const rec_t *rec)
{
  const page_t *const page= page_align(rec);
  const page_dir_slot_t *slot = page_dir_get_nth_slot(page, 0);
  const page_dir_slot_t *const end_slot= slot - 2 * page_dir_get_n_slots(page);

  lint n= 0;

  ut_ad(page_rec_check(rec));

  if (page_is_comp(page))
  {
    for (; rec_get_n_owned_new(rec) == 0; n--)
      if (UNIV_UNLIKELY(!(rec= page_rec_next_get<true>(page, rec))))
        return ULINT_UNDEFINED;

    do
    {
      const rec_t *slot_rec= page_dir_slot_get_rec_validate(slot);
      if (UNIV_UNLIKELY(!slot_rec))
        break;
      n+= lint(rec_get_n_owned_new(slot_rec));

      if (rec == slot_rec)
        goto found;
    }
    while ((slot-= 2) > end_slot);
  }
  else
  {
    for (; rec_get_n_owned_old(rec) == 0; n--)
      if (UNIV_UNLIKELY(!(rec= page_rec_next_get<false>(page, rec))))
        return ULINT_UNDEFINED;

    do
    {
      const rec_t *slot_rec= page_dir_slot_get_rec_validate(slot);
      if (UNIV_UNLIKELY(!slot_rec))
        break;
      n+= lint(rec_get_n_owned_old(slot_rec));

      if (rec == slot_rec)
        goto found;
    }
    while ((slot-= 2) > end_slot);
  }

  return ULINT_UNDEFINED;
found:
  return --n < 0 ? ULINT_UNDEFINED : ulint(n);
}

/************************************************************//**
Prints record contents including the data relevant only in
the index page context. */
void
page_rec_print(
/*===========*/
 const rec_t* rec, /*!< in: physical record */
 const rec_offs* offsets)/*!< in: record descriptor */
{
 ut_a(!page_rec_is_comp(rec) == !rec_offs_comp(offsets));
 rec_print_new(stderr, rec, offsets);
 if (page_rec_is_comp(rec)) {
  ib::info() << "n_owned: " << rec_get_n_owned_new(rec)
   << "; heap_no: " << rec_get_heap_no_new(rec)
   << "; next rec: " << rec_get_next_offs(rec, TRUE);
 } else {
  ib::info() << "n_owned: " << rec_get_n_owned_old(rec)
   << "; heap_no: " << rec_get_heap_no_old(rec)
   << "; next rec: " << rec_get_next_offs(rec, FALSE);
 }

 page_rec_check(rec);
 rec_validate(rec, offsets);
}

#ifdef UNIV_BTR_PRINT
/***************************************************************//**
This is used to print the contents of the directory for
debugging purposes. */
void
page_dir_print(
/*===========*/
 page_t* page, /*!< in: index page */
 ulint pr_n) /*!< in: print n first and n last entries */
{
 ulint   n;
 ulint   i;
 page_dir_slot_t* slot;

 n = page_dir_get_n_slots(page);

 fprintf(stderr, "--------------------------------\n"
  "PAGE DIRECTORY\n"
  "Page address %p\n"
  "Directory stack top at offs: %zu; number of slots: %zu\n",
  page, page_dir_get_nth_slot(page, n - 1) - page, n);
 for (i = 0; i < n; i++) {
  slot = page_dir_get_nth_slot(page, i);
  if ((i == pr_n) && (i < n - pr_n)) {
   fputs("    ...   \n", stderr);
  }
  if ((i < pr_n) || (i >= n - pr_n)) {
   fprintf(stderr,
    "Contents of slot: %zu: n_owned: %zu,"
    " rec offs: %zu\n",
    i,
    page_dir_slot_get_n_owned(slot),
    page_dir_slot_get_rec(slot) - page);
  }
 }
 fprintf(stderr, "Total of %zu records\n"
  "--------------------------------\n",
  PAGE_HEAP_NO_USER_LOW + page_get_n_recs(page));
}

/***************************************************************//**
This is used to print the contents of the page record list for
debugging purposes. */
void
page_print_list(
/*============*/
 buf_block_t* block, /*!< in: index page */
 dict_index_t* index, /*!< in: dictionary index of the page */
 ulint  pr_n) /*!< in: print n first and n last entries */
{
 page_t*  page  = block->page.frame;
 page_cur_t cur;
 ulint  count;
 ulint  n_recs;
 mem_heap_t* heap  = NULL;
 rec_offs offsets_[REC_OFFS_NORMAL_SIZE];
 rec_offs* offsets  = offsets_;
 rec_offs_init(offsets_);

 ut_a((ibool)!!page_is_comp(page) == dict_table_is_comp(index->table));

 fprint(stderr,
  "--------------------------------\n"
  "PAGE RECORD LIST\n"
  "Page address %p\n", page);

 n_recs = page_get_n_recs(page);

 page_cur_set_before_first(block, &cur);
 count = 0;
 for (;;) {
  offsets = rec_get_offsets(cur.rec, index, offsets,
       page_rec_is_leaf(cur.rec),
       ULINT_UNDEFINED, &heap);
  page_rec_print(cur.rec, offsets);

  if (count == pr_n) {
   break;
  }
  if (page_cur_is_after_last(&cur)) {
   break;
  }
  page_cur_move_to_next(&cur);
  count++;
 }

 if (n_recs > 2 * pr_n) {
  fputs(" ... \n", stderr);
 }

 while (!page_cur_is_after_last(&cur)) {
  page_cur_move_to_next(&cur);

  if (count + pr_n >= n_recs) {
   offsets = rec_get_offsets(cur.rec, index, offsets,
        page_rec_is_leaf(cur.rec),
        ULINT_UNDEFINED, &heap);
   page_rec_print(cur.rec, offsets);
  }
  count++;
 }

 fprintf(stderr,
  "Total of %lu records \n"
  "--------------------------------\n",
  (ulong) (count + 1));

 if (UNIV_LIKELY_NULL(heap)) {
  mem_heap_free(heap);
 }
}

/***************************************************************//**
Prints the info in a page header. */
void
page_header_print(
/*==============*/
 const page_t* page)
{
 fprintf(stderr,
  "--------------------------------\n"
  "PAGE HEADER INFO\n"
  "Page address %p, n records %u (%s)\n"
  "n dir slots %u, heap top %u\n"
  "Page n heap %u, free %u, garbage %u\n"
  "Page last insert %u, direction %u, n direction %u\n",
  page, page_header_get_field(page, PAGE_N_RECS),
  page_is_comp(page) ? "compact format" : "original format",
  page_header_get_field(page, PAGE_N_DIR_SLOTS),
  page_header_get_field(page, PAGE_HEAP_TOP),
  page_dir_get_n_heap(page),
  page_header_get_field(page, PAGE_FREE),
  page_header_get_field(page, PAGE_GARBAGE),
  page_header_get_field(page, PAGE_LAST_INSERT),
  page_get_direction(page),
  page_header_get_field(page, PAGE_N_DIRECTION));
}

/***************************************************************//**
This is used to print the contents of the page for
debugging purposes. */
void
page_print(
/*=======*/
 buf_block_t* block, /*!< in: index page */
 dict_index_t* index, /*!< in: dictionary index of the page */
 ulint  dn, /*!< in: print dn first and last entries
in directory */
 ulint  rn) /*!< in: print rn first and last records
in directory */
{
 page_t* page = block->page.frame;

 page_header_print(page);
 page_dir_print(page, dn);
 page_print_list(block, index, rn);
}
#endif /* UNIV_BTR_PRINT */

/***************************************************************//**
The following is used to validate a record on a page. This function
differs from rec_validate as it can also check the n_owned field and
the heap_no field.
@return TRUE if ok */
ibool
page_rec_validate(
/*==============*/
 const rec_t* rec, /*!< in: physical record */
 const rec_offs* offsets)/*!< in: array returned by rec_get_offsets() */
{
 ulint  n_owned;
 ulint  heap_no;
 const page_t* page;

 page = page_align(rec);
 ut_a(!page_is_comp(page) == !rec_offs_comp(offsets));

 page_rec_check(rec);
 rec_validate(rec, offsets);

 if (page_is_comp(page)) {
  n_owned = rec_get_n_owned_new(rec);
  heap_no = rec_get_heap_no_new(rec);
 } else {
  n_owned = rec_get_n_owned_old(rec);
  heap_no = rec_get_heap_no_old(rec);
 }

 if (UNIV_UNLIKELY(!(n_owned <= PAGE_DIR_SLOT_MAX_N_OWNED))) {
  ib::warn() << "Dir slot of rec " << rec - page
   << ", n owned too big " << n_owned;
  return(FALSE);
 }

 if (UNIV_UNLIKELY(!(heap_no < page_dir_get_n_heap(page)))) {
  ib::warn() << "Heap no of rec " << rec - page
   << " too big " << heap_no << " "
   << page_dir_get_n_heap(page);
  return(FALSE);
 }

 return(TRUE);
}

#ifdef UNIV_DEBUG
/***************************************************************//**
Checks that the first directory slot points to the infimum record and
the last to the supremum. This function is intended to track if the
bug fixed in 4.0.14 has caused corruption to users' databases. */
void
page_check_dir(
/*===========*/
 const page_t* page) /*!< in: index page */
{
 ulint n_slots;
 ulint infimum_offs;
 ulint supremum_offs;

 n_slots = page_dir_get_n_slots(page);
 infimum_offs = mach_read_from_2(page_dir_get_nth_slot(page, 0));
 supremum_offs = mach_read_from_2(page_dir_get_nth_slot(page,
              n_slots - 1));

 if (UNIV_UNLIKELY(!page_rec_is_infimum_low(infimum_offs))) {

  ib::fatal() << "Page directory corruption: infimum not"
   " pointed to";
 }

 if (UNIV_UNLIKELY(!page_rec_is_supremum_low(supremum_offs))) {

  ib::fatal() << "Page directory corruption: supremum not"
   " pointed to";
 }
}
#endif /* UNIV_DEBUG */

/***************************************************************//**
This function checks the consistency of an index page when we do not
know the index. This is also resilient so that this should never crash
even if the page is total garbage.
@return TRUE if ok */
ibool
page_simple_validate_old(
/*=====================*/
 const page_t* page) /*!< in: index page in ROW_FORMAT=REDUNDANT */
{
 const page_dir_slot_t* slot;
 ulint   slot_no;
 ulint   n_slots;
 const rec_t*  rec;
 const byte*  rec_heap_top;
 ulint   count;
 ulint   own_count;
 ibool   ret = FALSE;

 ut_a(!page_is_comp(page));

 /* Check first that the record heap and the directory do not
overlap. */

 n_slots = page_dir_get_n_slots(page);

 if (UNIV_UNLIKELY(n_slots < 2 || n_slots > srv_page_size / 4)) {
  ib::error() << "Nonsensical number of page dir slots: "
       << n_slots;
  goto func_exit;
 }

 rec_heap_top = page_header_get_ptr(page, PAGE_HEAP_TOP);

 if (UNIV_UNLIKELY(rec_heap_top
     > page_dir_get_nth_slot(page, n_slots - 1))) {
  ib::error()
   << "Record heap and dir overlap on a page, heap top "
   << page_header_get_field(page, PAGE_HEAP_TOP)
   << ", dir "
   << page_dir_get_nth_slot(page, n_slots - 1) - page;

  goto func_exit;
 }

 /* Validate the record list in a loop checking also that it is
consistent with the page record directory. */

 count = 0;
 own_count = 1;
 slot_no = 0;
 slot = page_dir_get_nth_slot(page, slot_no);

 rec = page_get_infimum_rec(page);

 for (;;) {
  if (UNIV_UNLIKELY(rec > rec_heap_top)) {
   ib::error() << "Record " << (rec - page)
    << " is above rec heap top "
    << (rec_heap_top - page);

   goto func_exit;
  }

  if (UNIV_UNLIKELY(rec_get_n_owned_old(rec) != 0)) {
   /* This is a record pointed to by a dir slot */
   if (UNIV_UNLIKELY(rec_get_n_owned_old(rec)
       != own_count)) {

    ib::error() << "Wrong owned count "
     << rec_get_n_owned_old(rec)
     << ", " << own_count << ", rec "
     << (rec - page);

    goto func_exit;
   }

   if (UNIV_UNLIKELY
       (page_dir_slot_get_rec(slot) != rec)) {
    ib::error() << "Dir slot does not point"
     " to right rec " << (rec - page);

    goto func_exit;
   }

   own_count = 0;

   if (!page_rec_is_supremum(rec)) {
    slot_no++;
    slot = page_dir_get_nth_slot(page, slot_no);
   }
  }

  if (page_rec_is_supremum(rec)) {

   break;
  }

  if (UNIV_UNLIKELY
      (rec_get_next_offs(rec, FALSE) < FIL_PAGE_DATA
       || rec_get_next_offs(rec, FALSE) >= srv_page_size)) {

   ib::error() << "Next record offset nonsensical "
    << rec_get_next_offs(rec, FALSE) << " for rec "
    << (rec - page);

   goto func_exit;
  }

  count++;

  if (UNIV_UNLIKELY(count > srv_page_size)) {
   ib::error() << "Page record list appears"
    " to be circular " << count;
   goto func_exit;
  }

  rec = page_rec_next_get<false>(page, rec);
  own_count++;
 }

 if (UNIV_UNLIKELY(rec_get_n_owned_old(rec) == 0)) {
  ib::error() << "n owned is zero in a supremum rec";

  goto func_exit;
 }

 if (UNIV_UNLIKELY(slot_no != n_slots - 1)) {
  ib::error() <<  "n slots wrong "
   << slot_no << ", " << (n_slots - 1);
  goto func_exit;
 }

 if (UNIV_UNLIKELY(ulint(page_header_get_field(page, PAGE_N_RECS))
     + PAGE_HEAP_NO_USER_LOW
     != count + 1)) {
  ib::error() <<  "n recs wrong "
   << page_header_get_field(page, PAGE_N_RECS)
   + PAGE_HEAP_NO_USER_LOW << " " << (count + 1);

  goto func_exit;
 }

 /* Check then the free list */
 rec = page_header_get_ptr(page, PAGE_FREE);

 while (rec != NULL) {
  if (UNIV_UNLIKELY(rec < page + FIL_PAGE_DATA
      || rec >= page + srv_page_size)) {
   ib::error() << "Free list record has"
    " a nonsensical offset " << (rec - page);

   goto func_exit;
  }

  if (UNIV_UNLIKELY(rec > rec_heap_top)) {
   ib::error() << "Free list record " << (rec - page)
    << " is above rec heap top "
    << (rec_heap_top - page);

   goto func_exit;
  }

  count++;

  if (UNIV_UNLIKELY(count > srv_page_size)) {
   ib::error() << "Page free list appears"
    " to be circular " << count;
   goto func_exit;
  }

  ulint offs = rec_get_next_offs(rec, FALSE);
  if (!offs) {
   break;
  }
  if (UNIV_UNLIKELY(offs < PAGE_OLD_INFIMUM
      || offs >= srv_page_size)) {
   ib::error() << "Page free list is corrupted " << count;
   goto func_exit;
  }

  rec = page + offs;
 }

 if (UNIV_UNLIKELY(page_dir_get_n_heap(page) != count + 1)) {

  ib::error() <<  "N heap is wrong "
   << page_dir_get_n_heap(page) << ", " << (count + 1);

  goto func_exit;
 }

 ret = TRUE;

func_exit:
 return(ret);
}

/***************************************************************//**
This function checks the consistency of an index page when we do not
know the index. This is also resilient so that this should never crash
even if the page is total garbage.
@return TRUE if ok */
ibool
page_simple_validate_new(
/*=====================*/
 const page_t* page) /*!< in: index page in ROW_FORMAT!=REDUNDANT */
{
 const page_dir_slot_t* slot;
 ulint   slot_no;
 ulint   n_slots;
 const rec_t*  rec;
 const byte*  rec_heap_top;
 ulint   count;
 ulint   own_count;
 ibool   ret = FALSE;

 ut_a(page_is_comp(page));

 /* Check first that the record heap and the directory do not
overlap. */

 n_slots = page_dir_get_n_slots(page);

 if (UNIV_UNLIKELY(n_slots < 2 || n_slots > srv_page_size / 4)) {
  ib::error() << "Nonsensical number of page dir slots: "
       << n_slots;
  goto func_exit;
 }

 rec_heap_top = page_header_get_ptr(page, PAGE_HEAP_TOP);

 if (UNIV_UNLIKELY(rec_heap_top
     > page_dir_get_nth_slot(page, n_slots - 1))) {

  ib::error() << "Record heap and dir overlap on a page,"
   " heap top "
       << page_header_get_field(page, PAGE_HEAP_TOP)
       << ", dir "
       << page_dir_get_nth_slot(page, n_slots - 1) - page;

  goto func_exit;
 }

 /* Validate the record list in a loop checking also that it is
consistent with the page record directory. */

 count = 0;
 own_count = 1;
 slot_no = 0;
 slot = page_dir_get_nth_slot(page, slot_no);

 rec = page + PAGE_NEW_INFIMUM;

 for (;;) {
  if (UNIV_UNLIKELY(rec < page + PAGE_NEW_INFIMUM
      || rec > rec_heap_top)) {
   ib::error() << "Record " << rec - page
    << " is out of bounds: "
    << rec_heap_top - page;
   goto func_exit;
  }

  if (UNIV_UNLIKELY(rec_get_n_owned_new(rec) != 0)) {
   /* This is a record pointed to by a dir slot */
   if (UNIV_UNLIKELY(rec_get_n_owned_new(rec)
       != own_count)) {

    ib::error() << "Wrong owned count "
     << rec_get_n_owned_new(rec) << ", "
     << own_count << ", rec "
     << rec - page;

    goto func_exit;
   }

   if (UNIV_UNLIKELY
       (page_dir_slot_get_rec(slot) != rec)) {
    ib::error() << "Dir slot does not point"
     " to right rec " << rec - page;

    goto func_exit;
   }

   own_count = 0;

   if (!page_rec_is_supremum(rec)) {
    slot_no++;
    slot = page_dir_get_nth_slot(page, slot_no);
   }
  }

  if (page_rec_is_supremum(rec)) {

   break;
  }

  if (UNIV_UNLIKELY
      (rec_get_next_offs(rec, TRUE) < FIL_PAGE_DATA
       || rec_get_next_offs(rec, TRUE) >= srv_page_size)) {

   ib::error() << "Next record offset nonsensical "
    << rec_get_next_offs(rec, TRUE)
    << " for rec " << rec - page;

   goto func_exit;
  }

  count++;

  if (UNIV_UNLIKELY(count > srv_page_size)) {
   ib::error() << "Page record list appears to be"
    " circular " << count;
   goto func_exit;
  }

  rec = page_rec_next_get<true>(page, rec);
  own_count++;
 }

 if (UNIV_UNLIKELY(rec_get_n_owned_new(rec) == 0)) {
  ib::error() << "n owned is zero in a supremum rec";

  goto func_exit;
 }

 if (UNIV_UNLIKELY(slot_no != n_slots - 1)) {
  ib::error() << "n slots wrong " << slot_no << ", "
   << (n_slots - 1);
  goto func_exit;
 }

 if (UNIV_UNLIKELY(ulint(page_header_get_field(page, PAGE_N_RECS))
     + PAGE_HEAP_NO_USER_LOW
     != count + 1)) {
  ib::error() << "n recs wrong "
   << page_header_get_field(page, PAGE_N_RECS)
   + PAGE_HEAP_NO_USER_LOW << " " << (count + 1);

  goto func_exit;
 }

 /* Check then the free list */
 rec = page_header_get_ptr(page, PAGE_FREE);

 while (rec != NULL) {
  if (UNIV_UNLIKELY(rec < page + FIL_PAGE_DATA
      || rec >= page + srv_page_size)) {

   ib::error() << "Free list record has"
    " a nonsensical offset " << rec - page;

   goto func_exit;
  }

  if (UNIV_UNLIKELY(rec > rec_heap_top)) {
   ib::error() << "Free list record " << rec - page
    << " is above rec heap top "
    << rec_heap_top - page;

   goto func_exit;
  }

  count++;

  if (UNIV_UNLIKELY(count > srv_page_size)) {
   ib::error() << "Page free list appears to be"
    " circular " << count;
   goto func_exit;
  }

  const ulint offs = rec_get_next_offs(rec, TRUE);
  if (!offs) {
   break;
  }
  if (UNIV_UNLIKELY(offs < PAGE_OLD_INFIMUM
      || offs >= srv_page_size)) {
   ib::error() << "Page free list is corrupted " << count;
   goto func_exit;
  }

  rec = page + offs;
 }

 if (UNIV_UNLIKELY(page_dir_get_n_heap(page) != count + 1)) {

  ib::error() << "N heap is wrong "
   << page_dir_get_n_heap(page) << ", " << (count + 1);

  goto func_exit;
 }

 ret = TRUE;

func_exit:
 return(ret);
}

PRAGMA_DISABLE_CHECK_STACK_FRAME

/** Check the consistency of an index page.
@param[in] page index page
@param[in] index B-tree or R-tree index
@return whether the page is valid */
bool page_validate(const page_t* page, const dict_index_t* index)
{
 const page_dir_slot_t* slot;
 const rec_t*  rec;
 const rec_t*  old_rec  = NULL;
 const rec_t*  first_rec = NULL;
 ulint   offs = 0;
 ulint   n_slots;
 ibool   ret  = TRUE;
 ulint   i;
 rec_offs  offsets_1[REC_OFFS_NORMAL_SIZE];
 rec_offs  offsets_2[REC_OFFS_NORMAL_SIZE];
 rec_offs*  offsets  = offsets_1;
 rec_offs*  old_offsets = offsets_2;

 rec_offs_init(offsets_1);
 rec_offs_init(offsets_2);

#ifdef UNIV_GIS_DEBUG
 if (dict_index_is_spatial(index)) {
  fprintf(stderr, "Page no: %lu\n", page_get_page_no(page));
 }
#endif /* UNIV_DEBUG */

 if (UNIV_UNLIKELY((ibool) !!page_is_comp(page)
     != dict_table_is_comp(index->table))) {
  ib::error() << "'compact format' flag mismatch";
func_exit2:
  ib::error() << "Apparent corruption in space "
       << page_get_space_id(page) << " page "
       << page_get_page_no(page)
       << " of index " << index->name
       << " of table " << index->table->name;
  return FALSE;
 }

 if (page_is_comp(page)) {
  if (UNIV_UNLIKELY(!page_simple_validate_new(page))) {
   goto func_exit2;
  }
 } else {
  if (UNIV_UNLIKELY(!page_simple_validate_old(page))) {
   goto func_exit2;
  }
 }

 /* Multiple transactions cannot simultaneously operate on the
 same temp-table in parallel.
 max_trx_id is ignored for temp tables because it not required
for MVCC. */
 if (!page_is_leaf(page) || page_is_empty(page)
     || index->is_primary()
     || index->table->is_temporary()) {
 } else if (trx_id_t sys_max_trx_id = trx_sys.get_max_trx_id()) {
  trx_id_t max_trx_id = page_get_max_trx_id(page);

  if (max_trx_id == 0 || max_trx_id > sys_max_trx_id) {
   ib::error() << "PAGE_MAX_TRX_ID out of bounds: "
    << max_trx_id << ", " << sys_max_trx_id;
   ret = FALSE;
  }
 } else {
  ut_ad(srv_force_recovery >= SRV_FORCE_NO_UNDO_LOG_SCAN);
 }

 /* Check first that the record heap and the directory do not
overlap. */

 n_slots = page_dir_get_n_slots(page);

 if (UNIV_UNLIKELY(!(page_header_get_ptr(page, PAGE_HEAP_TOP)
       <= page_dir_get_nth_slot(page, n_slots - 1)))) {

  ib::warn() << "Record heap and directory overlap";
  goto func_exit2;
 }

 switch (uint16_t type = fil_page_get_type(page)) {
 case FIL_PAGE_RTREE:
  if (!index->is_spatial()) {
wrong_page_type:
   ib::warn() << "Wrong page type " << type;
   ret = FALSE;
  }
  break;
 case FIL_PAGE_TYPE_INSTANT:
  if (index->is_instant()
      && page_get_page_no(page) == index->page) {
   break;
  }
  goto wrong_page_type;
 case FIL_PAGE_INDEX:
  if (index->is_spatial()) {
   goto wrong_page_type;
  }
  if (index->is_instant()
      && page_get_page_no(page) == index->page) {
   goto wrong_page_type;
  }
  break;
 default:
  goto wrong_page_type;
 }

 /* The following buffer is used to check that the
records in the page record heap do not overlap */
 mem_heap_t* heap = mem_heap_create(srv_page_size + 200);;
 byte* buf = static_cast<byte*>(mem_heap_zalloc(heap, srv_page_size));

 /* Validate the record list in a loop checking also that
it is consistent with the directory. */
 ulint count = 0, data_size = 0, own_count = 1, slot_no = 0;
 ulint info_bits;
 slot_no = 0;
 slot = page_dir_get_nth_slot(page, slot_no);

 rec = page_get_infimum_rec(page);

 const ulint n_core = page_is_leaf(page) ? index->n_core_fields : 0;

 for (;;) {
  offsets = rec_get_offsets(rec, index, offsets, n_core,
       ULINT_UNDEFINED, &heap);

  if (page_is_comp(page) && page_rec_is_user_rec(rec)
      && UNIV_UNLIKELY(rec_get_node_ptr_flag(rec)
         == page_is_leaf(page))) {
   ib::error() << "'node_ptr' flag mismatch";
   ret = FALSE;
   goto next_rec;
  }

  if (UNIV_UNLIKELY(!page_rec_validate(rec, offsets))) {
   ret = FALSE;
   goto next_rec;
  }

  info_bits = rec_get_info_bits(rec, page_is_comp(page));
  if (info_bits
      & ~(REC_INFO_MIN_REC_FLAG | REC_INFO_DELETED_FLAG)) {
   ib::error() << "info_bits has an incorrect value "
        << info_bits;
   ret = false;
  }

  if (rec == first_rec) {
   if (info_bits & REC_INFO_MIN_REC_FLAG) {
    if (page_has_prev(page)) {
     ib::error() << "REC_INFO_MIN_REC_FLAG "
      "is set on non-left page";
     ret = false;
    } else if (!page_is_leaf(page)) {
     /* leftmost node pointer page */
    } else if (!index->is_instant()) {
     ib::error() << "REC_INFO_MIN_REC_FLAG "
      "is set in a leaf-page record";
     ret = false;
    } else if (!(info_bits & REC_INFO_DELETED_FLAG)
        != !index->table->instant) {
     ib::error() << (index->table->instant
       ? "Metadata record "
       "is not delete-marked"
       : "Metadata record "
       "is delete-marked");
     ret = false;
    }
   } else if (!page_has_prev(page)
       && index->is_instant()) {
    ib::error() << "Metadata record is missing";
    ret = false;
   }
  } else if (info_bits & REC_INFO_MIN_REC_FLAG) {
   ib::error() << "REC_INFO_MIN_REC_FLAG record is not "
           "first in page";
   ret = false;
  }

  if (page_is_comp(page)) {
   const rec_comp_status_t status = rec_get_status(rec);
   if (status != REC_STATUS_ORDINARY
       && status != REC_STATUS_NODE_PTR
       && status != REC_STATUS_INFIMUM
       && status != REC_STATUS_SUPREMUM
       && status != REC_STATUS_INSTANT) {
    ib::error() << "impossible record status "
         << status;
    ret = false;
   } else if (page_rec_is_infimum(rec)) {
    if (status != REC_STATUS_INFIMUM) {
     ib::error()
      << "infimum record has status "
      << status;
     ret = false;
    }
   } else if (page_rec_is_supremum(rec)) {
    if (status != REC_STATUS_SUPREMUM) {
     ib::error() << "supremum record has "
             "status "
          << status;
     ret = false;
    }
   } else if (!page_is_leaf(page)) {
    if (status != REC_STATUS_NODE_PTR) {
     ib::error() << "node ptr record has "
             "status "
          << status;
     ret = false;
    }
   } else if (!index->is_instant()
       && status == REC_STATUS_INSTANT) {
    ib::error() << "instantly added record in a "
            "non-instant index";
    ret = false;
   }
  }

  /* Check that the records are in the ascending order */
  if (count >= PAGE_HEAP_NO_USER_LOW
      && !page_rec_is_supremum(rec)) {

   int ret = cmp_rec_rec(
    rec, old_rec, offsets, old_offsets, index);

   /* For spatial index, on nonleaf level, we
allow recs to be equal. */
   if (ret <= 0 && !(ret == 0 && index->is_spatial()
       && !page_is_leaf(page))) {

    ib::error() << "Records in wrong order";

    fputs("\nInnoDB: previous record ", stderr);
    /* For spatial index, print the mbr info.*/
    if (index->type & DICT_SPATIAL) {
     putc('\n', stderr);
     rec_print_mbr_rec(stderr,
      old_rec, old_offsets);
     fputs("\nInnoDB: record ", stderr);
     putc('\n', stderr);
     rec_print_mbr_rec(stderr, rec, offsets);
     putc('\n', stderr);
     putc('\n', stderr);

    } else {
     rec_print_new(stderr, old_rec, old_offsets);
     fputs("\nInnoDB: record ", stderr);
     rec_print_new(stderr, rec, offsets);
     putc('\n', stderr);
    }

    ret = FALSE;
   }
  }

  if (page_rec_is_user_rec(rec)) {

   data_size += rec_offs_size(offsets);

#if defined(UNIV_GIS_DEBUG)
   /* For spatial index, print the mbr info.*/
   if (index->type & DICT_SPATIAL) {
    rec_print_mbr_rec(stderr, rec, offsets);
    putc('\n', stderr);
   }
#endif /* UNIV_GIS_DEBUG */
  }

  offs = rec_get_start(rec, offsets) - page;
  i = rec_offs_size(offsets);
  if (UNIV_UNLIKELY(offs + i >= srv_page_size)) {
   ib::error() << "Record offset out of bounds: "
        << offs << '+' << i;
   ret = FALSE;
   goto next_rec;
  }
  while (i--) {
   if (UNIV_UNLIKELY(buf[offs + i])) {
    ib::error() << "Record overlaps another: "
         << offs << '+' << i;
    ret = FALSE;
    break;
   }
   buf[offs + i] = 1;
  }

  if (ulint rec_own_count = page_is_comp(page)
      ? rec_get_n_owned_new(rec)
      : rec_get_n_owned_old(rec)) {
   /* This is a record pointed to by a dir slot */
   if (UNIV_UNLIKELY(rec_own_count != own_count)) {
    ib::error() << "Wrong owned count at " << offs
         << ": " << rec_own_count
         << ", " << own_count;
    ret = FALSE;
   }

   if (page_dir_slot_get_rec(slot) != rec) {
    ib::error() << "Dir slot does not"
     " point to right rec at " << offs;
    ret = FALSE;
   }

   if (ret) {
    page_dir_slot_check(slot);
   }

   own_count = 0;
   if (!page_rec_is_supremum(rec)) {
    slot_no++;
    slot = page_dir_get_nth_slot(page, slot_no);
   }
  }

next_rec:
  old_rec = rec;
  rec = page_rec_get_next_const(rec);

  if (UNIV_UNLIKELY(!rec != page_rec_is_supremum(old_rec))) {
   ib::error() << "supremum is not last record: " << offs;
   ret = FALSE;
  }

  if (!rec) {
   rec = old_rec; /* supremum */
   break;
  }

  count++;
  own_count++;

  if (page_rec_is_infimum(old_rec)
      && page_rec_is_user_rec(rec)) {
   first_rec = rec;
  }

  /* set old_offsets to offsets; recycle offsets */
  std::swap(old_offsets, offsets);
 }

 if (page_is_comp(page)) {
  if (UNIV_UNLIKELY(rec_get_n_owned_new(rec) == 0)) {

   goto n_owned_zero;
  }
 } else if (UNIV_UNLIKELY(rec_get_n_owned_old(rec) == 0)) {
n_owned_zero:
  ib::error() <<  "n owned is zero at " << offs;
  ret = FALSE;
 }

 if (UNIV_UNLIKELY(slot_no != n_slots - 1)) {
  ib::error() << "n slots wrong " << slot_no << " "
   << (n_slots - 1);
  ret = FALSE;
 }

 if (UNIV_UNLIKELY(ulint(page_header_get_field(page, PAGE_N_RECS))
     + PAGE_HEAP_NO_USER_LOW
     != count + 1)) {
  ib::error() << "n recs wrong "
   << page_header_get_field(page, PAGE_N_RECS)
   + PAGE_HEAP_NO_USER_LOW << " " << (count + 1);
  ret = FALSE;
 }

 if (UNIV_UNLIKELY(data_size != page_get_data_size(page))) {
  ib::error() << "Summed data size " << data_size
   << ", returned by func " << page_get_data_size(page);
  ret = FALSE;
 }

 /* Check then the free list */
 rec = page_header_get_ptr(page, PAGE_FREE);

 while (rec != NULL) {
  offsets = rec_get_offsets(rec, index, offsets, n_core,
       ULINT_UNDEFINED, &heap);
  if (UNIV_UNLIKELY(!page_rec_validate(rec, offsets))) {
   ret = FALSE;
next_free:
   const ulint offs = rec_get_next_offs(
    rec, page_is_comp(page));
   if (!offs) {
    break;
   }
   if (UNIV_UNLIKELY(offs < PAGE_OLD_INFIMUM
       || offs >= srv_page_size)) {
    ib::error() << "Page free list is corrupted";
    ret = FALSE;
    break;
   }

   rec = page + offs;
   continue;
  }

  count++;
  offs = rec_get_start(rec, offsets) - page;
  i = rec_offs_size(offsets);
  if (UNIV_UNLIKELY(offs + i >= srv_page_size)) {
   ib::error() << "Free record offset out of bounds: "
        << offs << '+' << i;
   ret = FALSE;
   goto next_free;
  }
  while (i--) {
   if (UNIV_UNLIKELY(buf[offs + i])) {
    ib::error() << "Free record overlaps another: "
         << offs << '+' << i;
    ret = FALSE;
    break;
   }
   buf[offs + i] = 1;
  }

  goto next_free;
 }

 if (UNIV_UNLIKELY(page_dir_get_n_heap(page) != count + 1)) {
  ib::error() << "N heap is wrong "
   << page_dir_get_n_heap(page) << " " << count + 1;
  ret = FALSE;
 }

 mem_heap_free(heap);

 if (UNIV_UNLIKELY(!ret)) {
  goto func_exit2;
 }

 return(ret);
}

PRAGMA_REENABLE_CHECK_STACK_FRAME

/***************************************************************//**
Looks in the page record list for a record with the given heap number.
@return record, NULL if not found */
const rec_t*
page_find_rec_with_heap_no(
/*=======================*/
 const page_t* page, /*!< in: index page */
 ulint  heap_no)/*!< in: heap number */
{
 const rec_t* rec;

 if (page_is_comp(page)) {
  rec = page + PAGE_NEW_INFIMUM;

  for (;;) {
   ulint rec_heap_no = rec_get_heap_no_new(rec);

   if (rec_heap_no == heap_no) {

    return(rec);
   } else if (rec_heap_no == PAGE_HEAP_NO_SUPREMUM) {

    return(NULL);
   }

   rec = page + rec_get_next_offs(rec, TRUE);
  }
 } else {
  rec = page + PAGE_OLD_INFIMUM;

  for (;;) {
   ulint rec_heap_no = rec_get_heap_no_old(rec);

   if (rec_heap_no == heap_no) {

    return(rec);
   } else if (rec_heap_no == PAGE_HEAP_NO_SUPREMUM) {

    return(NULL);
   }

   rec = page + rec_get_next_offs(rec, FALSE);
  }
 }
}

/** Get the last non-delete-marked record on a page.
@param[in] page index tree leaf page
@return the last record, not delete-marked
@retval infimum record if all records are delete-marked */
const rec_t *page_find_rec_last_not_deleted(const page_t *page)
{
  ut_ad(page_is_leaf(page));

  if (page_is_comp(page))
  {
    const rec_t *rec= page + PAGE_NEW_INFIMUM;
    const rec_t *prev_rec= rec;
    do
    {
      if (!(rec[-REC_NEW_INFO_BITS] &
            (REC_INFO_DELETED_FLAG | REC_INFO_MIN_REC_FLAG)))
        prev_rec= rec;
      if (!(rec= page_rec_next_get<true>(page, rec)))
        return page + PAGE_NEW_INFIMUM;
    } while (rec != page + PAGE_NEW_SUPREMUM);
    return prev_rec;
  }
  else
  {
    const rec_t *rec= page + PAGE_OLD_INFIMUM;
    const rec_t *prev_rec= rec;
    do
    {
      if (!(rec[-REC_OLD_INFO_BITS] &
            (REC_INFO_DELETED_FLAG | REC_INFO_MIN_REC_FLAG)))
        prev_rec= rec;
      if (!(rec= page_rec_next_get<false>(page, rec)))
        return page + PAGE_OLD_INFIMUM;
    } while (rec != page + PAGE_OLD_SUPREMUM);
    return prev_rec;
  }
}