Remove unnecessary files and functions

innobase/srv/srv0srv.c:
  Removed unused code
BitKeeper/deleted/.del-FSP0FSP.C~f1c7e596cadd429:
  Delete: innobase/fsp/trash/FSP0FSP.C
BitKeeper/deleted/.del-log0trsh.c~ebdd6ce463d8bf0:
  Delete: innobase/log/trash/log0trsh.c
BitKeeper/deleted/.del-os0fileold.c~7be518438162e2f:
  Delete: innobase/os/os0fileold.c
innobase/include/usr0sess.h:
  Remove unused functions
innobase/lock/lock0lock.c:
  Remove commented-out call to deleted function sess_raise_error_low()
innobase/trx/trx0trx.c:
  Remove commented-out or unreachable calls to deleted function sess_raise_error_low()
innobase/usr/usr0sess.c:
  Remove unused functions

1 files changed, 0 insertions, 3100 deletions

diff --git a/innobase/fsp/trash/FSP0FSP.C b/innobase/fsp/trash/FSP0FSP.C
deleted file mode 100644
index b0add437bff..00000000000
--- a/innobase/fsp/trash/FSP0FSP.C
+++ /dev/null
@@ -1,3100 +0,0 @@
-/**********************************************************************
-File-space management
-
-(c) 1995 Innobase Oy
-
-Created 11/29/1995 Heikki Tuuri
-***********************************************************************/
-
-#include "fsp0fsp.h"
-
-#include "buf0buf.h"
-#include "fil0fil.h"
-#include "sync0sync.h"
-#include "mtr0log.h"
-#include "fut0fut.h"
-#include "ut0byte.h"
-
-/* The data structures in files are defined just as byte strings in C */
-typedef	byte	fsp_header_t;
-typedef	byte	xdes_t;		
-typedef byte	fseg_page_header_t;
-
-/* Rw-latch protecting the whole file space system */
-rw_lock_t	fsp_latch;
-
-
-/*			SPACE HEADER		
-			============
-
-File space header data structure: this data structure
-is contained in the first page of a space. The space for this header
-is reserved in every extent descriptor page, but used only in the first. */
-#define FSP_HEADER_OFFSET	FIL_PAGE_DATA	/* Offset of the space header
-						within a file page */
-/*-------------------------------------*/
-#define	FSP_SIZE		0	/* Current
-					size of the space in pages */
-#define	FSP_FREE_LIMIT		4	/* Minimum page number for which
-					the free list has not been initialized:
-					the pages >= this limit are, by
-					definition, free */
-#define	FSP_LOWEST_NO_WRITE	8	/* The lowest page offset for which
-					the page has not been written to disk
-					(if it has been written, we know
-					that the OS has really reserved
-					the physical space for the page) */
-#define	FSP_FRAG_N_USED		12	/* number of used pages in
-					the FSP_FREE_FRAG list */
-#define	FSP_FREE		16	/* list of free extents */
-#define	FSP_FREE_FRAG		(16 + FLST_BASE_NODE_SIZE)
-					/* list of partially free extents not
-					belonging to any segment */
-#define	FSP_FULL_FRAG		(16 + 2 * FLST_BASE_NODE_SIZE)
-					/* list of full extents not belonging
-					to any segment */
-#define FSP_SEG_ID		(16 + 3 * FLST_BASE_NODE_SIZE)
-					/* 8 bytes which give the first
-#define FSP_SEG_HDRS_FULL	(24 + 3 * FLST_BASE_NODE_SIZE)
-					/* list of pages containing segment
-					headers, where all the segment header
-					slots are reserved */
-#define FSP_SEG_HDRS_FREE	(24 + 4 * FLST_BASE_NODE_SIZE)
-					/* list of pages containing segment
-					headers, where not all the segment
-					header slots are reserved */
-/*-------------------------------------*/
-/* File space header size */
-#define	FSP_HEADER_SIZE		(24 + 4 * FLST_BASE_NODE_SIZE)
-
-#define	FSP_FREE_ADD		4	/* this many free extents are added
-					to the free list from above
-					FSP_FREE_LIMIT at a time */
-
-					
-/*			SEGMENT HEADER
-			==============
-
-Segment header which is created for each segment in a tablespace, on a
-page of its own. NOTE: in purge we assume that a segment having only one
-currently used page can be freed in a few steps, so that the freeing cannot
-fill the file buffer with bufferfixed file pages. */
-
-#define FSEG_HDR_PAGE_NODE	FSEG_PAGE_DATA
-					/* the list node for linking
-					segment header pages */
-
-#define FSEG_ARR_OFFSET		(FSEG_PAGE_DATA + FLST_NODE_SIZE)
-/*-------------------------------------*/
-#define	FSEG_ID			0	/* 8 bytes of segment id: if this is
-					ut_dulint_zero, it means that the
-					header is unused */
-#define FSEG_NOT_FULL_N_USED	8
-					/* number of used segment pages in
-					the FSEG_NOT_FULL list */
-#define	FSEG_FREE		12
-					/* list of free extents of this
-					segment */
-#define	FSEG_NOT_FULL		(12 + FLST_BASE_NODE_SIZE)
-					/* list of partially free extents */
-#define	FSEG_FULL		(12 + 2 * FLST_BASE_NODE_SIZE)
-					/* list of full extents */
-#define	FSEG_MAGIC_N		(12 + 3 * FLST_BASE_NODE_SIZE)
-					/* magic number used in debugging */
-#define	FSEG_FRAG_ARR		(16 + 3 * FLST_BASE_NODE_SIZE)
-					/* array of individual pages
-					belonging to this segment in fsp
-					fragment extent lists */
-#define FSEG_FRAG_ARR_N_SLOTS	(FSP_EXTENT_SIZE / 2)
-					/* number of slots in the array for
-					the fragment pages */
-#define	FSEG_FRAG_SLOT_SIZE	4	/* a fragment page slot contains its
-					page number within space, FIL_NULL
-					means that the slot is not in use */
-/*-------------------------------------*/
-#define FSEG_HEADER_SIZE	(16 + 3 * FLST_BASE_NODE_SIZE +\
-				FSEG_FRAG_ARR_N_SLOTS * FSEG_FRAG_SLOT_SIZE)
-
-#define FSP_SEG_HDRS_PER_PAGE	((UNIV_PAGE_SIZE - FSEG_ARR_OFFSET - 10)\
-				 / FSEG_HEADER_SIZE)
-				/* Number of segment headers which fit on a
-				single page */
-
-#define FSEG_MAGIC_N_VALUE	97937874
-					
-#define	FSEG_FILLFACTOR		8	/* If this value is x, then if
-					the number of unused but reserved
-					pages in a segment is less than
-					reserved pages * 1/x, and there are
-					at least FSEG_FRAG_LIMIT used pages,
-					then we allow a new empty extent to
-					be added to the segment in
-					fseg_alloc_free_page. Otherwise, we
-					use unused pages of the segment. */
-					
-#define FSEG_FRAG_LIMIT		FSEG_FRAG_N_ARR_SLOTS
-					/* If the segment has >= this many
-					used pages, it may be expanded by
-					allocating extents to the segment;
-					until that only individual fragment
-					pages are allocated from the space */
-
-#define	FSEG_FREE_LIST_LIMIT	40	/* If the reserved size of a segment
-					is at least this many extents, we
-					allow extents to be put to the free
-					list of the extent: at most
-					FSEG_FREE_LIST_MAX_LEN many */
-#define	FSEG_FREE_LIST_MAX_LEN	4
-					
-
-/*			EXTENT DESCRIPTOR
-			=================
-
-File extent descriptor data structure: contains bits to tell
-which pages in the extent are free and which contain old tuple
-version to clean. */
-
-/*-------------------------------------*/
-#define	XDES_ID			0	/* The identifier of the segment
-					to which this extent belongs */
-#define XDES_FLST_NODE		8	/* The list node data structure
-					for the descriptors */
-#define	XDES_STATE		(FLST_NODE_SIZE + 8)
-					/* contains state information
-					of the extent */
-#define	XDES_BITMAP		(FLST_NODE_SIZE + 12)
-					/* Descriptor bitmap of the pages
-					in the extent*/
-/*-------------------------------------*/
-					
-#define	XDES_BITS_PER_PAGE	2	/* How many bits are there per page */
-#define	XDES_FREE_BIT		0	/* Index of the bit which tells if
-					the page is free */
-#define	XDES_CLEAN_BIT		1	/* Index of the bit which tells if
-					there are old versions of tuples
-					on the page */
-/* States of a descriptor */
-#define	XDES_FREE		1	/* extent is in free list of space */
-#define	XDES_FREE_FRAG		2	/* extent is in free fragment list of
-					space */
-#define	XDES_FULL_FRAG		3	/* extent is in full fragment list of
-					space */
-#define	XDES_FSEG		4	/* extent belongs to a segment*/
-
-/* Number of pages described in a single descriptor page:
-currently each page description takes less than
-1 byte. */
-#define XDES_DESCRIBED_PER_PAGE		UNIV_PAGE_SIZE
-
-/* File extent data structure size in bytes. The "+ 7 ) / 8"
-part in the definition rounds the number of bytes upward. */
-#define	XDES_SIZE	(XDES_BITMAP +\
-			 (FSP_EXTENT_SIZE * XDES_BITS_PER_PAGE + 7) / 8)
-
-/* Offset of the descriptor array on a descriptor page */
-#define	XDES_ARR_OFFSET		(FSP_HEADER_OFFSET + FSP_HEADER_SIZE)
-					
-/**************************************************************************
-Returns an extent to the free list of a space. */
-static
-void
-fsp_free_extent(
-/*============*/
-	ulint		space,	/* in: space id */
-	ulint		page,	/* in: page offset in the extent */
-	mtr_t*		mtr);	/* in: mtr */
-/**************************************************************************
-Frees an extent of a segment to the space free list. */
-static
-void
-fseg_free_extent(
-/*=============*/
-	fseg_header_t*	seg_header, /* in: segment header */
-	ulint		space,	/* in: space id */
-	ulint		page,	/* in: page offset in the extent */
-	mtr_t*		mtr);	/* in: mtr handle */
-/**************************************************************************
-Calculates the number of pages reserved by a segment, and how
-many pages are currently used. */
-static
-ulint
-fseg_n_reserved_pages_low(
-/*======================*/
-				/* out: number of reserved pages */
-	fseg_header_t* 	header,	/* in: segment header */
-	ulint*		used,	/* out: number of pages used (<= reserved) */
-	mtr_t*		mtr);	/* in: mtr handle */
-/************************************************************************
-Marks a page used. The page must reside within the extents of the given
-segment. */
-static
-void
-fseg_mark_page_used(
-/*================*/
-	fseg_header_t*	seg_header,/* in: segment header */
-	ulint		space,	/* in: space id */
-	ulint		page,	/* in: page offset */
-	mtr_t*		mtr);	/* in: mtr */
-/**************************************************************************
-Frees a single page of a segment. */
-static
-void
-fseg_free_page_low(
-/*===============*/
-	fseg_header_t*	seg_header, /* in: segment header */
-	ulint		space,	/* in: space id */
-	ulint		page,	/* in: page offset */
-	mtr_t*		mtr);	/* in: mtr handle */
-/**************************************************************************
-Returns the first extent descriptor for a segment. We think of the extent
-lists of the segment catenated in the order FSEG_FULL -> FSEG_NOT_FULL
--> FSEG_FREE. */
-static
-xdes_t*
-fseg_get_first_extent(
-/*==================*/
-				/* out: the first extent descriptor, or NULL if
-				none */
-	fseg_header_t*	header,	/* in: segment header */
-	mtr_t*		mtr);	/* in: mtr */
-/**************************************************************************
-Puts new extents to the free list if
-there are free extents above the free limit. If an extent happens
-to contain an extent descriptor page, the extent is put to
-the FSP_FREE_FRAG list with the page marked as used. */
-static
-void
-fsp_fill_free_list(
-/*===============*/
-	ulint		space,	/* in: space */
-	fsp_header_t*	header,	/* in: space header */
-	mtr_t*		mtr);	/* in: mtr */
-
-/**************************************************************************
-Gets a descriptor bit of a page. */
-UNIV_INLINE
-bool
-xdes_get_bit(
-/*=========*/
-				/* out: TRUE if free */
-	xdes_t*		descr,	/* in: descriptor */
-	ulint		bit,	/* in: XDES_FREE_BIT or XDES_CLEAN_BIT */
-	ulint		offset,	/* in: page offset within extent:
-				0 ... FSP_EXTENT_SIZE - 1 */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	ulint	index;
-	ulint	byte_index;
-	ulint	bit_index;
-
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(descr),
-				MTR_MEMO_PAGE_X_LOCK));
-	ut_ad((bit == XDES_FREE_BIT) || (bit == XDES_CLEAN_BIT));
-	ut_ad(offset < FSP_EXTENT_SIZE);
-	
-	index = bit + XDES_BITS_PER_PAGE * offset;
-
-	byte_index = index / 8;
-	bit_index = index % 8;
-		
-	return(ut_bit_get_nth(
-		   mtr_read_ulint(descr + XDES_BITMAP + byte_index,
-				  MLOG_1BYTE, mtr),
-		   bit_index));	  
-}	
-
-/**************************************************************************
-Sets a descriptor bit of a page. */
-UNIV_INLINE
-void
-xdes_set_bit(
-/*=========*/
-	xdes_t*		descr,	/* in: descriptor */
-	ulint		bit,	/* in: XDES_FREE_BIT or XDES_CLEAN_BIT */
-	ulint		offset,	/* in: page offset within extent:
-				0 ... FSP_EXTENT_SIZE - 1 */
-	bool		val,	/* in: bit value */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	ulint	index;
-	ulint	byte_index;
-	ulint	bit_index;
-	ulint	descr_byte;
-	
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(descr),
-				MTR_MEMO_PAGE_X_LOCK));
-	ut_ad((bit == XDES_FREE_BIT) || (bit == XDES_CLEAN_BIT));
-	ut_ad(offset < FSP_EXTENT_SIZE);
-
-	index = bit + XDES_BITS_PER_PAGE * offset;
-
-	byte_index = index / 8;
-	bit_index = index % 8;
-
-	descr_byte = mtr_read_ulint(descr + XDES_BITMAP + byte_index,
-				  MLOG_1BYTE, mtr);
-		
-	descr_byte = ut_bit_set_nth(descr_byte, bit_index, val);
-
-	mlog_write_ulint(descr + XDES_BITMAP + byte_index,
-				  descr_byte, MLOG_1BYTE, mtr);
-}	
-
-/**************************************************************************
-Looks for a descriptor bit having the desired value. Starts from hint
-and scans upward; at the end of the extent the search is wrapped to
-the start of the extent. */
-UNIV_INLINE
-ulint
-xdes_find_bit(
-/*==========*/
-				/* out: bit index of the bit,
-				ULINT_UNDEFINED if not found */
-	xdes_t*		descr,	/* in: descriptor */
-	ulint		bit,	/* in: XDES_FREE_BIT or XDES_CLEAN_BIT */
-	bool		val,	/* in: desired bit value */
-	ulint		hint,	/* in: hint of which bit position would be
-				desirable */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	ulint	i;
-	
-	ut_ad(descr && mtr);
-	ut_ad(val <= TRUE);
-	ut_ad(hint < FSP_EXTENT_SIZE);
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(descr),
-				MTR_MEMO_PAGE_X_LOCK));
-
-	for (i = hint; i < FSP_EXTENT_SIZE; i++) {
-		if (val == xdes_get_bit(descr, bit, i, mtr)) {
-			return(i);
-		}
-	}
-
-	for (i = 0; i < hint; i++) {
-		if (val == xdes_get_bit(descr, bit, i, mtr)) {
-			return(i);
-		}
-	}
-	
-	return(ULINT_UNDEFINED);			
-}	
-
-/**************************************************************************
-Looks for a descriptor bit having the desired value. Scans the extent in
-a direction opposite to xdes_find_bit. */
-UNIV_INLINE
-ulint
-xdes_find_bit_downward(
-/*===================*/
-				/* out: bit index of the bit,
-				ULINT_UNDEFINED if not found */
-	xdes_t*		descr,	/* in: descriptor */
-	ulint		bit,	/* in: XDES_FREE_BIT or XDES_CLEAN_BIT */
-	bool		val,	/* in: desired bit value */
-	ulint		hint,	/* in: hint of which bit position would be
-				desirable */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	ulint	i;
-	
-	ut_ad(descr && mtr);
-	ut_ad(val <= TRUE);
-	ut_ad(hint < FSP_EXTENT_SIZE);
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(descr),
-				MTR_MEMO_PAGE_X_LOCK));
-
-	for (i = hint + 1; i > 0; i--) {
-		if (val == xdes_get_bit(descr, bit, i - 1, mtr)) {
-			return(i - 1);
-		}
-	}
-
-	for (i = FSP_EXTENT_SIZE - 1; i > hint; i--) {
-		if (val == xdes_get_bit(descr, bit, i, mtr)) {
-			return(i);
-		}
-	}
-	
-	return(ULINT_UNDEFINED);			
-}	
-
-/**************************************************************************
-Returns the number of used pages in a descriptor. */
-UNIV_INLINE
-ulint
-xdes_get_n_used(
-/*============*/
-				/* out: number of pages used */
-	xdes_t*		descr,	/* in: descriptor */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	ulint	i;
-	ulint	count	= 0;
-	
-	ut_ad(descr && mtr);
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(descr),
-				MTR_MEMO_PAGE_X_LOCK));
-
-	for (i = 0; i < FSP_EXTENT_SIZE; i++) {
-		if (FALSE == xdes_get_bit(descr, XDES_FREE_BIT, i, mtr)) {
-			count++;
-		}
-	}
-
-	return(count);			
-}	
-
-/**************************************************************************
-Returns true if extent contains no used pages. */
-UNIV_INLINE
-bool
-xdes_is_free(
-/*=========*/
-				/* out: TRUE if totally free */
-	xdes_t*		descr,	/* in: descriptor */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	if (0 == xdes_get_n_used(descr, mtr)) {
-		return(TRUE);
-	} else {
-		return(FALSE);
-	}
-}
-
-/**************************************************************************
-Returns true if extent contains no free pages. */
-UNIV_INLINE
-bool
-xdes_is_full(
-/*=========*/
-				/* out: TRUE if full */
-	xdes_t*		descr,	/* in: descriptor */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	if (FSP_EXTENT_SIZE == xdes_get_n_used(descr, mtr)) {
-		return(TRUE);
-	} else {
-		return(FALSE);
-	}
-}
-
-/**************************************************************************
-Sets the state of an xdes. */
-UNIV_INLINE
-void
-xdes_set_state(
-/*===========*/
-	xdes_t*		descr,	/* in: descriptor */
-	ulint		state,	/* in: state to set */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	ut_ad(descr && mtr);
-	ut_ad(state >= XDES_FREE);
-	ut_ad(state <= XDES_FSEG);
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(descr),
-				MTR_MEMO_PAGE_X_LOCK));
-
-	mlog_write_ulint(descr + XDES_STATE, state, MLOG_4BYTES, mtr); 
-}
-
-/**************************************************************************
-Gets the state of an xdes. */
-UNIV_INLINE
-ulint
-xdes_get_state(
-/*===========*/
-				/* out: state */
-	xdes_t*		descr,	/* in: descriptor */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	ut_ad(descr && mtr);
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(descr),
-				MTR_MEMO_PAGE_X_LOCK));
-
-	return(mtr_read_ulint(descr + XDES_STATE, MLOG_4BYTES, mtr)); 
-}
-
-/**************************************************************************
-Inits an extent descriptor to free and clean state. */
-UNIV_INLINE
-void
-xdes_init(
-/*======*/
-	xdes_t*		descr,	/* in: descriptor */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	ulint	i;
-
-	ut_ad(descr && mtr);
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(descr),
-				MTR_MEMO_PAGE_X_LOCK));
-
-	for (i = 0; i < FSP_EXTENT_SIZE; i++) {
-		xdes_set_bit(descr, XDES_FREE_BIT, i, TRUE, mtr);
-		xdes_set_bit(descr, XDES_CLEAN_BIT, i, TRUE, mtr);
-	}
-
-	xdes_set_state(descr, XDES_FREE, mtr);
-}	
-
-/************************************************************************
-Calculates the page where the descriptor of a page resides. */
-UNIV_INLINE
-ulint
-xdes_calc_descriptor_page(
-/*======================*/
-				/* out: descriptor page offset */
-	ulint	offset)		/* in: page offset */
-{
-	ut_ad(UNIV_PAGE_SIZE > XDES_ARR_OFFSET
-		+ (XDES_DESCRIBED_PER_PAGE / FSP_EXTENT_SIZE) * XDES_SIZE);
-
-	return(ut_2pow_round(offset, XDES_DESCRIBED_PER_PAGE));
-}
-
-/************************************************************************
-Calculates the descriptor index within a descriptor page. */
-UNIV_INLINE
-ulint
-xdes_calc_descriptor_index(
-/*=======================*/
-				/* out: descriptor index */
-	ulint	offset)		/* in: page offset */
-{
-	return(ut_2pow_remainder(offset, XDES_DESCRIBED_PER_PAGE) /
-					FSP_EXTENT_SIZE);
-}
-
-/************************************************************************
-Gets pointer to a the extent descriptor of a page. The page where the
-extent descriptor resides is x-locked. If the page offset is equal to the free
-limit of the space, adds new extents from above the free limit
-to the space free list, if not free limit == space size. This adding
-is necessary to make the descriptor defined, as they are uninitialized
-above the free limit. */
-UNIV_INLINE
-xdes_t*
-xdes_get_descriptor_with_space_hdr(
-/*===============================*/
-				/* out: pointer to the extent descriptor,
-				NULL if the page does not exist in the
-				space or if offset > free limit */
-	fsp_header_t*	sp_header,/* in: space header, x-latched */
-	ulint		space,	/* in: space id */
-	ulint		offset,	/* in: page offset; 
-				if equal to the free limit,
-				we try to add new extents to
-				the space free list */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	ulint		limit;
-	ulint		size;
-	buf_block_t*	buf_page;
-	ulint		descr_page_no;
-	page_t*		descr_page;
-
-	ut_ad(mtr);
-	ut_ad(mtr_memo_contains(mtr, &fsp_latch, MTR_MEMO_X_LOCK));
-
-	/* Read free limit and space size */
-	limit = mtr_read_ulint(sp_header + FSP_FREE_LIMIT, MLOG_4BYTES, mtr);
-	size  = mtr_read_ulint(sp_header + FSP_SIZE, MLOG_4BYTES, mtr);
-
-	/* If offset is >= size or > limit, return NULL */
-	if ((offset >= size) || (offset > limit)) {
-		return(NULL);
-	}
-
-	/* If offset is == limit, fill free list of the space. */
-	if (offset == limit) {
-		fsp_fill_free_list(space, sp_header, mtr);
-	}
-
-	descr_page_no = xdes_calc_descriptor_page(offset);
-
-	if (descr_page_no == 0) {
-		/* It is on the space header page */
-
-		descr_page = buf_frame_align(sp_header);
-	} else {
-	
-		buf_page = buf_page_get(space, descr_page_no, mtr);
-		buf_page_x_lock(buf_page, mtr);
-		descr_page = buf_block_get_frame(buf_page);
-	}	
-
-	return(descr_page + XDES_ARR_OFFSET
-	       + XDES_SIZE * xdes_calc_descriptor_index(offset));
-}
-
-/************************************************************************
-Gets pointer to a the extent descriptor of a page. The page where the
-extent descriptor resides is x-locked. If the page offset is equal to the free
-limit of the space, adds new extents from above the free limit
-to the space free list, if not free limit == space size. This adding
-is necessary to make the descriptor defined, as they are uninitialized
-above the free limit. */
-static
-xdes_t*
-xdes_get_descriptor(
-/*================*/
-				/* out: pointer to the extent descriptor,
-				NULL if the page does not exist in the
-				space or if offset > free limit */
-	ulint		space,	/* in: space id */
-	ulint		offset,	/* in: page offset; 
-				if equal to the free limit,
-				we try to add new extents to
-				the space free list */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	fsp_header_t*	sp_header;
-	buf_block_t*	block;
-
-	block = buf_page_get(space, 0, mtr); /* get space header */
-	sp_header = FSP_HEADER_OFFSET + buf_block_get_frame(block);
-	buf_page_x_lock(block, mtr);
-	
-	return(xdes_get_descriptor_with_space_hdr(sp_header, space, offset,
-									mtr));
-}
-
-/************************************************************************
-Gets pointer to a the extent descriptor if the file address
-of the descriptor list node is known. The page where the
-extent descriptor resides is x-locked. */
-UNIV_INLINE
-xdes_t*
-xdes_lst_get_descriptor(
-/*====================*/
-				/* out: pointer to the extent descriptor */
-	ulint		space,	/* in: space id */
-	fil_addr_t	lst_node,/* in: file address of the list node
-				contained in the descriptor */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	xdes_t*		descr;
-
-	ut_ad(mtr);
-	ut_ad(mtr_memo_contains(mtr, &fsp_latch, MTR_MEMO_X_LOCK));
-	
-	descr = fut_get_ptr_x_lock(space, lst_node, mtr) - XDES_FLST_NODE;
-
-	return(descr);
-}
-
-/************************************************************************
-Gets pointer to the next descriptor in a descriptor list and x-locks
-its page. */
-UNIV_INLINE
-xdes_t*
-xdes_lst_get_next(
-/*==============*/
-	xdes_t*		descr,	/* in: pointer to a descriptor */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	ulint	space;
-
-	ut_ad(mtr && descr);
-
-	space = buf_page_get_space(buf_block_align(descr));
-
-	return(xdes_lst_get_descriptor(space,
-		flst_get_next_addr(descr + XDES_FLST_NODE, mtr), mtr));
-}
-
-/************************************************************************
-Returns page offset of the first page in extent described by a descriptor.
-*/
-UNIV_INLINE
-ulint
-xdes_get_offset(
-/*============*/
-				/* out: offset of the first page in extent */
-	xdes_t*		descr)	/* in: extent descriptor */
-{
-	buf_block_t*	buf_page;
-
-	ut_ad(descr);
-
-	buf_page = buf_block_align(descr);
-
-	return(buf_page_get_offset(buf_page)
-		+ ((descr - buf_frame_align(descr) - XDES_ARR_OFFSET)
-		   / XDES_SIZE)
-		  * FSP_EXTENT_SIZE);
-}
-
-/**************************************************************************
-Gets a pointer to the space header and x-locks its page. */
-UNIV_INLINE
-fsp_header_t*
-fsp_get_space_header(
-/*=================*/
-			/* out: pointer to the space header, page x-locked */
-	ulint	id,	/* in: space id */
-	mtr_t*	mtr)	/* in: mtr */
-{
-	buf_block_t*	block;
-	
-	ut_ad(mtr);
-	
-	block = buf_page_get(id, 0, mtr);
-
-	buf_page_x_lock(block, mtr);	
-
-	return(FSP_HEADER_OFFSET + buf_block_get_frame(block));
-}
-
-/**************************************************************************
-Initializes the file space system mutex. */
-
-void
-fsp_init(void)
-/*==========*/
-{
-	rw_lock_create(&fsp_latch);
-}
-
-/**************************************************************************
-Initializes the space header of a new created space. */
-
-void
-fsp_header_init(
-/*============*/
-	ulint		space,	/* in: space id */
-	ulint		size,	/* in: current size in blocks */
-	mtr_t*		mtr)	/* in: mini-transaction handle */	
-{
-	fsp_header_t*	header;
-	
-	ut_ad(mtr);
-
-	mtr_x_lock(&fsp_latch, mtr);	
-
-	header = fsp_get_space_header(space, mtr);
-
-	mlog_write_ulint(header + FSP_SIZE, size, MLOG_4BYTES, mtr); 
-	mlog_write_ulint(header + FSP_FREE_LIMIT, 0, MLOG_4BYTES, mtr); 
-	mlog_write_ulint(header + FSP_LOWEST_NO_WRITE, 0, MLOG_4BYTES, mtr); 
-	mlog_write_ulint(header + FSP_FRAG_N_USED, 0, MLOG_4BYTES, mtr); 
-	
-	flst_init(header + FSP_FREE, mtr);
-	flst_init(header + FSP_FREE_FRAG, mtr);
-	flst_init(header + FSP_FULL_FRAG, mtr);
-	flst_init(header + FSP_SEG_HDRS_FULL, mtr);
-	flst_init(header + FSP_SEG_HDRS_FREE, mtr);
-
-	mlog_write_dulint(header + FSP_SEG_ID, ut_dulint_create(0, 1),
-							MLOG_8BYTES, mtr); 
-}
-
-/**************************************************************************
-Increases the space size field of a space. */
-
-void
-fsp_header_inc_size(
-/*================*/
-	ulint		space,	/* in: space id */
-	ulint		size_inc,/* in: size increment in pages */
-	mtr_t*		mtr)	/* in: mini-transaction handle */	
-{
-	fsp_header_t*	header;
-	ulint		size;
-	
-	ut_ad(mtr);
-
-	mtr_x_lock(&fsp_latch, mtr);	
-
-	header = fsp_get_space_header(space, mtr);
-
-	size = mtr_read_ulint(header + FSP_SIZE, MLOG_4BYTES, mtr);
-	mlog_write_ulint(header + FSP_SIZE, size + size_inc, MLOG_4BYTES, mtr); 
-}
-
-/**************************************************************************
-Puts new extents to the free list if there are free extents above the free
-limit. If an extent happens to contain an extent descriptor page, the extent
-is put to the FSP_FREE_FRAG list with the page marked as used. */
-static
-void
-fsp_fill_free_list(
-/*===============*/
-	ulint		space,	/* in: space */
-	fsp_header_t*	header,	/* in: space header */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	ulint		limit;
-	ulint		size;
-	ulint		i;
-	xdes_t*		descr;
-	ulint		count 	= 0;
-	ulint		frag_n_used;
-
-	ut_ad(header && mtr);
-	
-	/* Check if we can fill free list from above the free list limit */
-	size  = mtr_read_ulint(header + FSP_SIZE, MLOG_4BYTES, mtr);
-	limit = mtr_read_ulint(header + FSP_FREE_LIMIT, MLOG_4BYTES, mtr);
-
-	i = limit;		
-	while ((i + FSP_EXTENT_SIZE <= size) && (count < FSP_FREE_ADD)) {
-		mlog_write_ulint(header + FSP_FREE_LIMIT,
-					i + FSP_EXTENT_SIZE, MLOG_4BYTES, mtr); 
-
-		descr = xdes_get_descriptor_with_space_hdr(header, space, i,
-									mtr);
-		xdes_init(descr, mtr);
-
-		ut_ad(XDES_DESCRIBED_PER_PAGE % FSP_EXTENT_SIZE == 0);
-
-		if (0 == i % XDES_DESCRIBED_PER_PAGE) {
-			/* The first page in the extent is a descriptor page:
-			mark it used */
-			xdes_set_bit(descr, XDES_FREE_BIT, 0, FALSE, mtr);
-			xdes_set_state(descr, XDES_FREE_FRAG, mtr);
-			flst_add_last(header + FSP_FREE_FRAG,
-					descr + XDES_FLST_NODE, mtr);
-			frag_n_used = mtr_read_ulint(header + FSP_FRAG_N_USED,
-						     MLOG_4BYTES, mtr);
-			mlog_write_ulint(header + FSP_FRAG_N_USED,
-					frag_n_used + 1,
-					MLOG_4BYTES, mtr);
-		} else {
-			flst_add_last(header + FSP_FREE,
-					descr + XDES_FLST_NODE, mtr);
-			count++;
-		}
-		i += FSP_EXTENT_SIZE;
-	}
-}	
-
-/**************************************************************************
-Allocates a new free extent. */
-static
-xdes_t*
-fsp_alloc_free_extent(
-/*==================*/
-				/* out: extent descriptor, NULL if cannot
-				be allocated */
-	ulint		space,	/* in: space id */
-	ulint		hint,	/* in: hint of which extent would be
-				desirable: any page offset in the extent
-				goes; the hint must not be > FSP_FREE_LIMIT */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	fsp_header_t*	header;
-	fil_addr_t	first;
-	xdes_t*		descr;
-	
-	ut_ad(mtr);
-
-	header = fsp_get_space_header(space, mtr);
-
-	descr = xdes_get_descriptor_with_space_hdr(header, space, hint, mtr);
-
-	if (descr && (xdes_get_state(descr, mtr) == XDES_FREE)) {
-		/* Ok, we can take this extent */
-	} else {	
-		/* Take the first extent in the free list */
-		first = flst_get_first(header + FSP_FREE, mtr);
-
-		if (fil_addr_is_null(first)) {
-			fsp_fill_free_list(space, header, mtr);
-			first = flst_get_first(header + FSP_FREE, mtr);
-		}
-
-		if (fil_addr_is_null(first)) {
-			return(NULL);	/* No free extents left */
-		}
-	
-		descr = xdes_lst_get_descriptor(space, first, mtr);
-	}
-
-	flst_remove(header + FSP_FREE, descr + XDES_FLST_NODE, mtr);
-
-	return(descr);
-}
-
-/**************************************************************************
-Allocates a single free page from a space. The page is marked as used. */
-static
-ulint
-fsp_alloc_free_page(
-/*================*/
-			/* out: the page offset, FIL_NULL
-			if no page could be allocated */
-	ulint	space,	/* in: space id */
-	ulint	hint,	/* in: hint of which page would be desirable */
-	mtr_t*	mtr)	/* in: mtr handle */
-{
-	fsp_header_t*	header;
-	fil_addr_t	first;
-	xdes_t*		descr;
-	ulint		free;
-	ulint		frag_n_used;
-	
-	ut_ad(mtr);
-
-	header = fsp_get_space_header(space, mtr);
-
-	/* Get the hinted descriptor */
-	descr = xdes_get_descriptor_with_space_hdr(header, space, hint, mtr);
-
-	if (descr && (xdes_get_state(descr, mtr) == XDES_FREE_FRAG)) {
-		/* Ok, we can take this extent */
-	} else {
-		/* Else take the first extent in free_frag list */
-		first = flst_get_first(header + FSP_FREE_FRAG, mtr);
-
-		if (fil_addr_is_null(first)) {
-			/* There are no partially full fragments: allocate
-			a free extent and add it to the FREE_FRAG
-			list. NOTE that the allocation may have as a
-			side-effect that an extent containing a descriptor
-			page is added to the FREE_FRAG list. But we will
-			allocate our page from the allocated free extent. */
-			
-			descr = fsp_alloc_free_extent(space, hint, mtr);
-
-			if (descr == NULL) {
-				/* No free space left */
-				return(FIL_NULL);
-			}
-
-			xdes_set_state(descr, XDES_FREE_FRAG, mtr);
-			flst_add_last(header + FSP_FREE_FRAG,
-				descr + XDES_FLST_NODE, mtr);
-		} else {
-			descr = xdes_lst_get_descriptor(space, first, mtr);
-		}
-
-		/* Reset the hint */
-		hint = 0;
-	}
-
-	/* Now we have in descr an extent with at least one free page.
-	Look for a free page in the extent. */
-	free = xdes_find_bit(descr, XDES_FREE_BIT, TRUE,
-				hint % FSP_EXTENT_SIZE, mtr);
-	ut_a(free != ULINT_UNDEFINED);
-
-	xdes_set_bit(descr, XDES_FREE_BIT, free, FALSE, mtr);
-
-	/* Update the FRAG_N_USED field */
-	frag_n_used = mtr_read_ulint(header + FSP_FRAG_N_USED,
-					MLOG_4BYTES, mtr);
-	frag_n_used++;
-	mlog_write_ulint(header + FSP_FRAG_N_USED, frag_n_used,
-				MLOG_4BYTES, mtr);
-	
-	if (xdes_is_full(descr, mtr)) {
-		/* The fragment is full: move it to another list */
-		flst_remove(header + FSP_FREE_FRAG,
-				descr + XDES_FLST_NODE, mtr);
-		xdes_set_state(descr, XDES_FULL_FRAG, mtr);
-		flst_add_last(header + FSP_FULL_FRAG,
-				descr + XDES_FLST_NODE, mtr);
-		mlog_write_ulint(header + FSP_FRAG_N_USED,
-				frag_n_used - FSP_EXTENT_SIZE,
-				MLOG_4BYTES, mtr);
-	}
-	return(xdes_get_offset(descr) + free);
-}
-
-/**************************************************************************
-Frees a single page of a space. The page is marked as free and clean. */
-static
-void
-fsp_free_page(
-/*==========*/
-	ulint	space,	/* in: space id */
-	ulint	page,	/* in: page offset */
-	mtr_t*	mtr)	/* in: mtr handle */
-{
-	fsp_header_t*	header;
-	xdes_t*		descr;
-	ulint		state;
-	ulint		frag_n_used;
-	
-	ut_ad(mtr);
-
-	header = fsp_get_space_header(space, mtr);
-
-	descr = xdes_get_descriptor_with_space_hdr(header, space, page, mtr);
-
-	state = xdes_get_state(descr, mtr);
-	
-	ut_a((state == XDES_FREE_FRAG) || (state == XDES_FULL_FRAG));
-
-	ut_a(xdes_get_bit(descr, XDES_FREE_BIT, page % FSP_EXTENT_SIZE, mtr)
-		== FALSE);
-
-	xdes_set_bit(descr, XDES_FREE_BIT, page % FSP_EXTENT_SIZE, TRUE, mtr);
-	xdes_set_bit(descr, XDES_CLEAN_BIT, page % FSP_EXTENT_SIZE, TRUE, mtr);
-
-	frag_n_used = mtr_read_ulint(header + FSP_FRAG_N_USED,
-					MLOG_4BYTES, mtr);
-
-	if (state == XDES_FULL_FRAG) {
-		/* The fragment was full: move it to another list */
-		flst_remove(header + FSP_FULL_FRAG,
-				descr + XDES_FLST_NODE, mtr);
-		xdes_set_state(descr, XDES_FREE_FRAG, mtr);
-		flst_add_last(header + FSP_FREE_FRAG,
-				descr + XDES_FLST_NODE, mtr);
-		mlog_write_ulint(header + FSP_FRAG_N_USED,
-				frag_n_used + FSP_EXTENT_SIZE - 1,
-				MLOG_4BYTES, mtr);
-	} else {
-		ut_a(frag_n_used > 0);
-		mlog_write_ulint(header + FSP_FRAG_N_USED, frag_n_used - 1,
-				MLOG_4BYTES, mtr);
-	}
-
-	if (xdes_is_free(descr, mtr)) {
-	    	/* The extent has become free: move it to another list */
-		flst_remove(header + FSP_FREE_FRAG,
-				descr + XDES_FLST_NODE, mtr);
-		fsp_free_extent(space, page, mtr);
-	}		
-}
-
-/**************************************************************************
-Returns an extent to the free list of a space. */
-static
-void
-fsp_free_extent(
-/*============*/
-	ulint		space,	/* in: space id */
-	ulint		page,	/* in: page offset in the extent */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	fsp_header_t*	header;
-	xdes_t*		descr;
-	
-	ut_ad(mtr);
-
-	header = fsp_get_space_header(space, mtr);
-
-	descr = xdes_get_descriptor_with_space_hdr(header, space, page, mtr);
-
-	ut_a(xdes_get_state(descr, mtr) != XDES_FREE);
-
-	xdes_init(descr, mtr);
-
-	flst_add_last(header + FSP_FREE, descr + XDES_FLST_NODE, mtr);
-}
-
-/**************************************************************************
-Looks for an unused segment header on a segment header page. */ 
-UNIV_INLINE
-fseg_header_t*
-fsp_seg_hdr_page_get_nth_hdr(
-/*=========================*/
-			/* out: segment header */
-	page_t*	page,	/* in: segment header page */
-	ulint	i,	/* in: search forward starting from this index */
-	mtr_t*	mtr)	/* in: mini-transaction handle */
-{
-	ut_ad(i < FSP_SEG_HDRS_PER_PAGE);
-	ut_ad(mtr_memo_contains(mtr, page, MTR_MEMO_PAGE_X_LOCK));
-
-	return(page + FSEG_ARR_OFFSET + FSEG_HEADER_SIZE * i);
-}
-
-/**************************************************************************
-Looks for a used segment header on a segment header page. */ 
-static
-ulint
-fsp_seg_hdr_page_find_used(
-/*=======================*/
-			/* out: segment header index, or ULINT_UNDEFINED
-			if not found */
-	page_t*	page,	/* in: segment header page */
-	mtr_t*	mtr)	/* in: mini-transaction handle */
-{
-	ulint		i;
-	fseg_header_t*	header;
-
-	for (i = 0; i < FSP_SEG_HDRS_PER_PAGE; i++) {
-
-		header = fsp_seg_hdr_page_get_nth_hdr(page, i, mtr);
-
-		if (ut_dulint_cmp(mach_read_from_8(header + FSEG_ID),
-						ut_dulint_zero) != 0) {
-			/* This is used */
-			
-			return(i);
-		}
-	}
-
-	return(ULINT_UNDEFINED);
-}
-
-/**************************************************************************
-Looks for an unused segment header on a segment header page. */ 
-static
-ulint
-fsp_seg_hdr_page_find_free(
-/*=======================*/
-			/* out: segment header index, or ULINT_UNDEFINED
-			if not found */
-	page_t*	page,	/* in: segment header page */
-	ulint	j,	/* in: search forward starting from this index */
-	mtr_t*	mtr)	/* in: mini-transaction handle */
-{
-	ulint		i;
-	fseg_header_t*	header;
-
-	for (i = j; i < FSP_SEG_HDRS_PER_PAGE; i++) {
-
-		header = fsp_seg_hdr_page_get_nth_hdr(page, i, mtr);
-
-		if (ut_dulint_cmp(mach_read_from_8(header + FSEG_ID),
-						ut_dulint_zero) == 0) {
-			/* This is unused */
-			
-			return(i);
-		}
-	}
-
-	return(ULINT_UNDEFINED);
-}
-
-/**************************************************************************
-Allocates a new file segment header page. */
-static
-bool
-fsp_alloc_seg_hdr_page(
-/*===================*/
-					/* out: TRUE if could be allocated */
-	fsp_header_t*	space_header,	/* in: space header */
-	mtr_t*		mtr)		/* in: mini-transaction handle */
-{
-	buf_block_t*	block;
-	ulint		page_no;
-	page_t*		page;
-	fseg_header_t*	header;
-	ulint		i;
-	
-	page_no = fsp_alloc_free_page(buf_frame_get_space(space_header),
-								0, mtr);
-	if (page_no == FIL_NULL) {
-
-		return(FALSE);
-	}
-
-	block = buf_page_get(buf_frame_get_space(space_header), page_no, mtr);
-
-	buf_page_x_lock(block, mtr);
-
-	page = buf_block_get_frame(block);
-
-	for (i = 0; i < FSP_SEG_HDRS_PER_PAGE; i++) {
-
-		header = fsp_seg_hdr_page_get_nth_hdr(page, i, mtr);
-
-		mlog_write_dulint(header + FSEG_ID, ut_dulint_zero,
-					MLOG_8BYTES, mtr);
-	}
-
-	flst_add_last(space_header + FSP_SEG_HDRS_FREE,
-				page + FSEG_HDR_PAGE_NODE, mtr);
-	return(TRUE);
-}
-
-/**************************************************************************
-Allocates a new file segment header. */
-static
-fseg_header_t*
-fsp_alloc_seg_header(
-/*=================*/
-					/* out: segment header, or NULL if
-					not enough space */
-	fsp_header_t*	space_header,	/* in: space header */
-	mtr_t*		mtr)		/* in: mini-transaction handle */
-{
-	buf_block_t*	block;
-	ulint		page_no;
-	page_t*		page;
-	fseg_header_t*	header;
-	ulint		n;
-	bool		success;
-	
-	if (flst_get_len(space_header + FSP_SEG_HDRS_FREE, mtr) == 0) {
-		/* Allocate a new segment header page */
-
-		success = fsp_alloc_seg_hdr_page(space_header, mtr);
-
-		if (!success) {
-
-			return(NULL);
-		}
-	}
-
-	page_no = flst_get_first(space_header + FSP_SEG_HDRS_FREE, mtr).page;
-
-	block = buf_page_get(buf_frame_get_space(space_header), page_no, mtr);
-
-	buf_page_x_lock(block, mtr);
-
-	page = buf_block_get_frame(block);
-
-	n = fsp_seg_hdr_page_find_free(page, 0, mtr);
-
-	ut_a(n != ULINT_UNDEFINED);
-
-	header = fsp_seg_hdr_page_get_nth_hdr(page, n, mtr);
-
-	if (ULINT_UNDEFINED == fsp_seg_hdr_page_find_free(page, n + 1, mtr)) {
-
-		/* There are no other unused headers left on the page: move it
-		to another list */
-
-		flst_remove(space_header + FSP_SEG_HDRS_FREE,
-				page + FSEG_HDR_PAGE_NODE, mtr);
-
-		flst_add_last(space_header + FSP_SEG_HDRS_FULL,
-				page + FSEG_HDR_PAGE_NODE, mtr);
-	}
-
-	return(header);	
-}
-
-/**************************************************************************
-Frees a file segment header. */
-static
-void
-fsp_free_seg_header(
-/*================*/
-	ulint		space,	/* in: space id */
-	fseg_header_t*	header,	/* in: segment header */
-	mtr_t*		mtr)	/* in: mini-transaction handle */
-{
-	page_t*		page;
-	fsp_header_t*	space_header;
-	
-	page = buf_frame_align(header);
-
-	space_header = fsp_get_space_header(space, mtr);
-
-	ut_ad(mach_read_from_4(header + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE);
-
-	if (ULINT_UNDEFINED == fsp_seg_hdr_page_find_free(page, mtr)) {
-
-		/* Move the page to another list */
-
-		flst_remove(space_header + FSP_SEG_HDRS_FULL,
-				page + FSEG_HDR_PAGE_NODE, mtr);
-
-		flst_add_last(space_header + FSP_SEG_HDRS_FREE,
-				page + FSEG_HDR_PAGE_NODE, mtr);
-	}
-
-	mlog_write_dulint(header + FSEG_ID, ut_dulint_zero, MLOG_8BYTES, mtr); 
-	mlog_write_ulint(header + FSEG_MAGIC_N, 0, MLOG_4BYTES, mtr); 
-	
-	if (ULINT_UNDEFINED == fsp_seg_hdr_page_find_used(page, mtr)) {
-
-		/* There are no other used headers left on the page: free it */
-
-		flst_remove(space_header + FSP_SEG_HDRS_FREE,
-				page + FSEG_HDR_PAGE_NODE, mtr);
-
-		fsp_free_page(space, page_no, mtr);		
-	}
-}
-
-/**************************************************************************
-Gets the page number from the nth fragment page slot. */
-UNIV_INLINE
-ulint
-fseg_get_nth_frag_page_no(
-/*======================*/
-				/* out: page number, FIL_NULL if not in use */
-	fseg_header_t* 	header,	/* in: segment header */
-	ulint		n,	/* in: slot index */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	ut_ad(header && mtr);
-	ut_ad(n < FSEG_FRAG_ARR_N_SLOTS);
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(header),
-							MTR_MEMO_PAGE_X_LOCK));
-
-	return(mach_read_from_4(header + FSEG_FRAG_ARR
-				+ n * FSEG_FRAG_SLOT_SIZE));
-}
-
-/**************************************************************************
-Sets the page number in the nth fragment page slot. */
-UNIV_INLINE
-void
-fseg_set_nth_frag_page_no(
-/*======================*/
-	fseg_header_t* 	header,	/* in: segment header */
-	ulint		n,	/* in: slot index */
-	ulint		page_no,/* in: page number to set */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	ut_ad(header && mtr);
-	ut_ad(n < FSEG_FRAG_ARR_N_SLOTS);
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(header),
-							MTR_MEMO_PAGE_X_LOCK));
-
-	mlog_write_ulint(header + FSEG_FRAG_ARR + n * FSEG_FRAG_SLOT_SIZE,
-						page_no, MLOG_4BYTES, mtr);
-}
-
-/**************************************************************************
-Finds a fragment page slot which is free. */
-static
-ulint
-fseg_find_free_frag_page_slot(
-/*==========================*/
-				/* out: slot index; ULINT_UNDEFINED if none
-				found */
-	fseg_header_t* 	header,	/* in: segment header */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	ulint	i;
-	ulint	page_no;
-
-	ut_ad(header && mtr);
-
-	for (i = 0; i < FSEG_FRAG_ARR_N_SLOTS; i++) {
-		page_no = fseg_get_nth_frag_page_no(header, i, mtr);
-
-		if (page_no == FIL_NULL) {
-
-			return(i);
-		}
-	}
-	return(ULINT_UNDEFINED);
-}
-
-/**************************************************************************
-Finds a fragment page slot which is used and last in the array. */
-static
-ulint
-fseg_find_last_used_frag_page_slot(
-/*===============================*/
-				/* out: slot index; ULINT_UNDEFINED if none
-				found */
-	fseg_header_t* 	header,	/* in: segment header */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	ulint	i;
-	ulint	page_no;
-
-	ut_ad(header && mtr);
-
-	for (i = 0; i < FSEG_FRAG_ARR_N_SLOTS; i++) {
-		page_no = fseg_get_nth_frag_page_no(header,
-					FSEG_ARR_N_SLOTS - i - 1, mtr);
-
-		if (page_no != FIL_NULL) {
-
-			return(i);
-		}
-	}
-	return(ULINT_UNDEFINED);
-}
-
-/**************************************************************************
-Calculates reserved fragment page slots. */
-static
-ulint
-fseg_get_n_frag_pages(
-/*==================*/
-				/* out: number of fragment pages */
-	fseg_header_t* 	header,	/* in: segment header */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	ulint	i;
-	ulint	count	= 0;
-
-	ut_ad(header && mtr);
-
-	for (i = 0; i < FSEG_FRAG_ARR_N_SLOTS; i++) {
-		if (FIL_NULL != fseg_get_nth_frag_page_no(header, i, mtr)) {
-			count++;
-		}
-	}
-	return(count);
-}
-
-/**************************************************************************
-Creates a new segment. */
-
-ulint
-fseg_create(
-/*========*/
-			/* out: the page number where the segment header is
-			placed, FIL_NULL if could not create segment because
-			lack of space */
-	ulint	space,	/* in: space id */
-	ulint*	offset,	/* out: byte offset of the segment header on its
-			page */
-	mtr_t*	mtr)	/* in: mtr */
-{
-	buf_block_t*	block;
-	buf_frame_t*	frame;
-	fsp_header_t*	space_header;
-	fseg_header_t*	header;
-	dulint		seg_id;
-	ulint		i;
-
-	ut_ad(mtr);
-
-	mtr_x_lock(&fsp_latch, mtr);	
-
-	space_header = fsp_get_space_header(space, mtr);
-
-	header = fsp_alloc_seg_header(space_header, mtr);
-
-	if (header == NULL) {
-
-		return(FIL_NULL);
-	}
-
-	/* Read the next segment id from space header and increment the
-	value in space header */
-
-	seg_id = mtr_read_dulint(space_header + FSP_SEG_ID, MLOG_8BYTES, mtr);
-
-	mlog_write_dulint(space_header + FSP_SEG_ID, ut_dulint_add(seg_id, 1),
-							MLOG_8BYTES, mtr);
-
-	mlog_write_dulint(header + FSEG_ID, seg_id, MLOG_8BYTES, mtr); 
-	mlog_write_ulint(header + FSEG_NOT_FULL_N_USED, 0, MLOG_4BYTES, mtr); 
-
-	flst_init(header + FSEG_FREE, mtr);
-	flst_init(header + FSEG_NOT_FULL, mtr);
-	flst_init(header + FSEG_FULL, mtr);
-
-	mlog_write_ulint(header + FSEG_MAGIC_N, FSEG_MAGIC_N_VALUE,
-							MLOG_4BYTES, mtr); 
-	for (i = 0; i < FSEG_FRAG_ARR_N_SLOTS; i++) {
-		fseg_set_nth_frag_page_no(header, i, FIL_NULL, mtr);
-	}
-
-	*offset = header - buf_frame_align(header);
-	return(buf_frame_get_page(buf_frame_align(header)));	
-}
-
-/**************************************************************************
-Calculates the number of pages reserved by a segment, and how
-many pages are currently used. */
-
-ulint
-fseg_n_reserved_pages(
-/*==================*/
-				/* out: number of reserved pages */
-	fseg_header_t* 	header,	/* in: segment header */
-	ulint*		used,	/* out: number of pages used (<= reserved) */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	ulint	ret;
-
-	mtr_x_lock(&fsp_latch, mtr);	
-
-	ret = fseg_n_reserved_pages_low(header, used, mtr);
-
-	return(ret);
-}
-
-/**************************************************************************
-Calculates the number of pages reserved by a segment, and how
-many pages are currently used. */
-static
-ulint
-fseg_n_reserved_pages_low(
-/*======================*/
-				/* out: number of reserved pages */
-	fseg_header_t* 	header,	/* in: segment header */
-	ulint*		used,	/* out: number of pages used (<= reserved) */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	ulint	ret;
-
-	ut_ad(header && used && mtr);
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(header),
-				MTR_MEMO_BUF_FIX));
-	
-	buf_page_x_lock(buf_block_align(header), mtr);
-
-	*used = mtr_read_ulint(header + FSEG_NOT_FULL_N_USED, MLOG_4BYTES, mtr)
-		+ FSP_EXTENT_SIZE * flst_get_len(header + FSEG_FULL, mtr)
-		+ fseg_get_n_frag_pages(header, mtr);
-
-	ret = fseg_get_n_frag_pages(header, mtr)
-		+ FSP_EXTENT_SIZE * flst_get_len(header + FSEG_FREE, mtr)
-		+ FSP_EXTENT_SIZE * flst_get_len(header + FSEG_NOT_FULL, mtr)
-		+ FSP_EXTENT_SIZE * flst_get_len(header + FSEG_FULL, mtr);
-
-	return(ret);
-}
-
-/*************************************************************************
-Tries to fill the free list of a segment with consecutive free extents.
-This happens if the segment is big enough to allowextents in the free list,
-the free list is empty, and the extents can be allocated consecutively from
-the hint onward. */
-static
-void
-fseg_fill_free_list(
-/*================*/
-	fseg_header_t*	header,	/* in: segment header */
-	ulint		space,	/* in: space id */
-	ulint		hint,	/* in: hint which extent would be good as
-				the first extent */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	xdes_t*	descr;
-	ulint	i;
-	dulint	seg_id;
-	ulint	reserved;
-	ulint	used;
-		
-	ut_ad(header && mtr);
-
-	buf_page_x_lock(buf_block_align(header), mtr);
-
-	reserved = fseg_n_reserved_pages_low(header, &used, mtr);
-
-	if (reserved < FSEG_FREE_LIST_LIMIT * FSP_EXTENT_SIZE) {
-		/* The segment is too small to allow extents in free list */
-
-		return;
-	}
-
-	if (flst_get_len(header + FSEG_FREE, mtr) > 0) {
-		/* Free list is not empty */
-
-		return;
-	}
-		
-	for (i = 0; i < FSEG_FREE_LIST_MAX_LEN; i++) {
-		descr = xdes_get_descriptor(space, hint, mtr);
-
-		if ((descr == NULL) ||
-		    (XDES_FREE != xdes_get_state(descr, mtr))) {
-			/* We cannot allocate the desired extent: stop */
-
-		    	return;
-		}
-
-		descr = fsp_alloc_free_extent(space, hint, mtr);
-		
-		xdes_set_state(descr, XDES_FSEG, mtr);
-		
-		seg_id = mtr_read_dulint(header + FSEG_ID, MLOG_8BYTES, mtr);
-		mlog_write_dulint(descr + XDES_ID, seg_id, MLOG_8BYTES, mtr);
-
-		flst_add_last(header + FSEG_FREE, descr + XDES_FLST_NODE, mtr);
-		hint += FSP_EXTENT_SIZE;
-	}
-}
-
-/*************************************************************************
-Allocates a free extent for the segment: looks first in the
-free list of the segment, then tries to allocate from the space free
-list. NOTE that the extent returned is still placed in the segment free
-list, not taken off it! */
-static
-xdes_t*
-fseg_alloc_free_extent(
-/*===================*/
-				/* out: allocated extent, still placed in the
-				segment free list, NULL if could
-				not be allocated */
-	fseg_header_t*	header,	/* in: segment header */
-	ulint		space,	/* in: space id */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	xdes_t*		descr;
-	dulint		seg_id;
-	fil_addr_t 	first;
-		
-	buf_page_x_lock(buf_block_align(header), mtr);
-
-	if (flst_get_len(header + FSEG_FREE, mtr) > 0) {
-		/* Segment free list is not empty, allocate from it */
-		
-		first = flst_get_first(header + FSEG_FREE, mtr);
-
-		descr = xdes_lst_get_descriptor(space, first, mtr);
-	} else {
-		/* Segment free list was empty, allocate from space */
-		descr = fsp_alloc_free_extent(space, 0, mtr);
-
-		if (descr == NULL) {
-			return(NULL);
-		}
-
-		seg_id = mtr_read_dulint(header + FSEG_ID, MLOG_8BYTES, mtr);
-		
-		xdes_set_state(descr, XDES_FSEG, mtr);
-		mlog_write_dulint(descr + XDES_ID, seg_id, MLOG_8BYTES, mtr);
-		flst_add_last(header + FSEG_FREE,
-				descr + XDES_FLST_NODE, mtr);
-		
-		/* Try to fill the segment free list */
-		fseg_fill_free_list(header, space,
-			xdes_get_offset(descr) + FSP_EXTENT_SIZE, mtr);
-	}
-
-	return(descr);
-}
-
-/**************************************************************************
-Allocates a single free page from a segment. This function implements
-the intelligent allocation strategy which tries to minimize file space
-fragmentation. */
-
-ulint
-fseg_alloc_free_page(
-/*=================*/
-				/* out: the allocated page offset
-				FIL_NULL if no page could be allocated */
-	fseg_header_t*	seg_header, /* in: segment header */
-	ulint		hint,	/* in: hint of which page would be desirable */
-	byte		direction, /* in: if the new page is needed because
-				of an index page split, and records are
-				inserted there in order, into which
-				direction they go alphabetically: FSP_DOWN,
-				FSP_UP, FSP_NO_DIR */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	buf_block_t*	block;
-	dulint		seg_id;
-	fseg_page_header_t* page_header;
-	ulint		space;
-	ulint		used;
-	ulint		reserved;
-	fil_addr_t	first;
-	xdes_t*		descr;		/* extent of the hinted page */
-	ulint		ret_page;	/* the allocated page offset, FIL_NULL
-					if could not be allocated */
-	buf_block_t*	ret_buf_page;	
-	buf_frame_t*	ret_frame;
-	xdes_t*		ret_descr;	/* the extent of the allocated page */
-	ulint		n;
-	bool		frag_page_allocated = FALSE;
-					
-	ut_ad(seg_header && mtr);
-	ut_ad((direction >= FSP_UP) && (direction <= FSP_NO_DIR));
-
-	mtr_x_lock(&fsp_latch, mtr);	
-
-	block = buf_block_align(seg_header);
-	buf_page_x_lock(block, mtr);
-
-	space = buf_page_get_space(block);
-
-	seg_id = mtr_read_dulint(seg_header + FSEG_ID, MLOG_8BYTES, mtr);
-
-	ut_ad(ut_dulint_cmp(seg_id, ut_dulint_zero) > 0);
-	
-	reserved = fseg_n_reserved_pages_low(seg_header, &used, mtr);
-	
-	descr = xdes_get_descriptor(space, hint, mtr);
-
-	if (descr == NULL) {
-		/* Hint outside space or too high above free limit:
-		reset hint */
-		hint = 0;
-		descr = xdes_get_descriptor(space, hint, mtr);
-	}
- 
-	/* In the big if-else below we look for ret_page and ret_descr */
-	/*-------------------------------------------------------------*/ 
-	if ((xdes_get_state(descr, mtr) == XDES_FSEG)
-	           && (0 == ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID,
-							MLOG_8BYTES, mtr),
-							seg_id))
-	           && (xdes_get_bit(descr, XDES_FREE_BIT,
-				hint % FSP_EXTENT_SIZE, mtr) == TRUE)) {
-
-		/* 1. We can take the hinted page
-		=================================*/
-		ret_descr = descr;
-		ret_page = hint;
-	/*-------------------------------------------------------------*/ 
-	} else if ((xdes_get_state(descr, mtr) == XDES_FREE)
-		   && ((reserved - used) < reserved / FSEG_FILLFACTOR)
-		   && (used >= FSEG_FRAG_LIMIT)) {
-
-		/* 2. We allocate the free extent from space and can take
-		=========================================================
-		the hinted page
-		===============*/
-		ret_descr = fsp_alloc_free_extent(space, hint, mtr);
-
-		ut_a(ret_descr == descr);
-		
-		xdes_set_state(ret_descr, XDES_FSEG, mtr);
-		mlog_write_dulint(ret_descr + XDES_ID, seg_id, MLOG_8BYTES,
-									mtr);
-		flst_add_last(seg_header + FSEG_FREE,
-				ret_descr + XDES_FLST_NODE, mtr);
-
-		/* Try to fill the segment free list */
-		fseg_fill_free_list(seg_header, space,
-					hint + FSP_EXTENT_SIZE, mtr);
-		ret_page = hint;
-	/*-------------------------------------------------------------*/ 
-	} else if ((direction != FSP_NO_DIR)
-		   && ((reserved - used) < reserved / FSEG_FILLFACTOR)
-		   && (used >= FSEG_FRAG_LIMIT)
-		   && (NULL != (ret_descr =
-			fseg_alloc_free_extent(seg_header, space, mtr)))) {
-
-		/* 3. We take any free extent (which was already assigned above
-		===============================================================
-		in the if-condition to ret_descr) and take the lowest or
-		========================================================
-		highest page in it, depending on the direction
-		==============================================*/
-		ret_page = xdes_get_offset(ret_descr);	
-		if (direction == FSP_DOWN) {
-			ret_page += FSP_EXTENT_SIZE - 1;
-		}
-	/*-------------------------------------------------------------*/ 
-	} else if ((xdes_get_state(descr, mtr) == XDES_FSEG)
-	           && (0 == ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID,
-							MLOG_8BYTES, mtr),
-						seg_id))
-	           && (!xdes_is_full(descr, mtr))) {
-
-		/* 4. We can take the page from the same extent as the
-		======================================================
-		hinted page (and the extent already belongs to the
-		==================================================
-		segment)
-		========*/
-		ret_descr = descr;
-		ret_page = xdes_get_offset(ret_descr) +
-				xdes_find_bit(ret_descr, XDES_FREE_BIT, TRUE,
-					hint % FSP_EXTENT_SIZE, mtr);
-	/*-------------------------------------------------------------*/ 
-	} else if (reserved - used > 0) {
-		/* 5. We take any unused page from the segment
-		==============================================*/
-		if (flst_get_len(seg_header + FSEG_NOT_FULL, mtr) > 0) {
-			first = flst_get_first(seg_header + FSEG_NOT_FULL,
-						mtr);
-		} else if (flst_get_len(seg_header + FSEG_FREE, mtr) > 0) {
-			first = flst_get_first(seg_header + FSEG_FREE, mtr);
-		} else {
-			ut_error;
-		}
-
-		ret_descr = xdes_lst_get_descriptor(space, first, mtr);
-		ret_page = xdes_get_offset(ret_descr) +
-				xdes_find_bit(ret_descr, XDES_FREE_BIT, TRUE,
-					 0, mtr);
-	/*-------------------------------------------------------------*/ 
-	} else if (used < FSEG_FRAG_LIMIT) {
-		/* 6. We allocate an individual page from the space
-		===================================================*/
-		ret_page = fsp_alloc_free_page(space, hint, mtr);
-		ret_descr = NULL;
-		
-		frag_page_allocated = TRUE;
-		
-		if (ret_page != FIL_NULL) {
-			/* Put the page in the fragment page array of the
-			segment */
-			n = fseg_find_free_frag_page_slot(seg_header, mtr);
-			ut_a(n != FIL_NULL);
-
-			fseg_set_nth_frag_page_no(seg_header, n, ret_page,
-									mtr);
-		}
-	/*-------------------------------------------------------------*/ 
-	} else {
-		/* 7. We allocate a new extent and take its first page
-		======================================================*/
-		ret_descr = fseg_alloc_free_extent(seg_header, space, mtr);
-
-		if (ret_descr == NULL) {
-			ret_page = FIL_NULL;
-		} else {
-			ret_page = xdes_get_offset(ret_descr);
-		}	
-	}
-	
-	if (ret_page == FIL_NULL) {
-		/* Page could not be allocated */
-	
-		return(FIL_NULL);
-	}
-
-	/* Initialize the allocated page to buffer pool, so that it can be
-	obtained immediately with buf_page_get without need for disk read */
-	
-	ret_buf_page = buf_page_create(space, ret_page, mtr);
-
-	if (!frag_page_allocated) {
-		/* At this point we know the extent and the page offset.
-		The extent is still in the appropriate list (FSEG_NOT_FULL or
-		FSEG_FREE), and the page is not yet marked as used. */
-		
-		ut_ad(xdes_get_descriptor(space, ret_page, mtr) == ret_descr);
-		ut_ad(xdes_get_bit(ret_descr, XDES_FREE_BIT,
-				ret_page % FSP_EXTENT_SIZE, mtr) == TRUE);
-		
-		fseg_mark_page_used(seg_header, space, ret_page, mtr);
-	}
-
-	return(ret_page);	
-}
-
-/************************************************************************
-Marks a page used. The page must reside within the extents of the given
-segment. */
-static
-void
-fseg_mark_page_used(
-/*================*/
-	fseg_header_t*	seg_header,/* in: segment header */
-	ulint		space,	/* in: space id */
-	ulint		page,	/* in: page offset */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	xdes_t*	descr;
-	ulint	not_full_n_used;
-
-	ut_ad(seg_header && mtr);
-	
-	descr = xdes_get_descriptor(space, page, mtr);
-	
-	ut_ad(mtr_read_ulint(seg_header + FSEG_ID, MLOG_4BYTES, mtr) ==
-		mtr_read_ulint(descr + XDES_ID, MLOG_4BYTES, mtr));
-
-	if (xdes_is_free(descr, mtr)) {
-		/* We move the extent from the free list to the
-		NOT_FULL list */
-		flst_remove(seg_header + FSEG_FREE,
-				descr + XDES_FLST_NODE, mtr);
-		flst_add_last(seg_header + FSEG_NOT_FULL,
-				descr + XDES_FLST_NODE, mtr);
-	}
-
-	ut_ad(xdes_get_bit(descr, XDES_FREE_BIT, page % FSP_EXTENT_SIZE, mtr)
-		== TRUE);
-
-	/* We mark the page as used */
-	xdes_set_bit(descr, XDES_FREE_BIT, page % FSP_EXTENT_SIZE, FALSE, mtr);
-
-	not_full_n_used = mtr_read_ulint(seg_header + FSEG_NOT_FULL_N_USED,
-						MLOG_4BYTES, mtr);
-
-	not_full_n_used++;
-	mlog_write_ulint(seg_header + FSEG_NOT_FULL_N_USED,
-					not_full_n_used, MLOG_4BYTES, mtr);
-
-	if (xdes_is_full(descr, mtr)) {
-		/* We move the extent from the NOT_FULL list to the
-		FULL list */
-		flst_remove(seg_header + FSEG_NOT_FULL,
-				descr + XDES_FLST_NODE, mtr);
-		flst_add_last(seg_header + FSEG_FULL,
-				descr + XDES_FLST_NODE, mtr);
-			
-		mlog_write_ulint(seg_header + FSEG_NOT_FULL_N_USED,
-				not_full_n_used - FSP_EXTENT_SIZE,
-				MLOG_4BYTES, mtr);
-	}
-}
-
-/**************************************************************************
-Frees a single page of a segment. */
-
-void
-fseg_free_page(
-/*===========*/
-	fseg_header_t*	seg_header, /* in: segment header */
-	ulint		space,	/* in: space id */
-	ulint		page,	/* in: page offset */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	mtr_x_lock(&fsp_latch, mtr);	
-
-	fseg_free_page_low(seg_header, space, page, mtr);
-}
-
-/**************************************************************************
-Frees a single page of a segment. */
-static
-void
-fseg_free_page_low(
-/*===============*/
-	fseg_header_t*	seg_header, /* in: segment header */
-	ulint		space,	/* in: space id */
-	ulint		page,	/* in: page offset */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	buf_block_t*	block;
-	xdes_t*		descr;
-	ulint		used;
-	ulint		not_full_n_used;
-	ulint		state;
-	buf_block_t*	buf_page;
-	buf_frame_t*	buf_frame;
-	ulint		i;
-	
-	ut_ad(seg_header && mtr);
-
-	block = buf_block_align(seg_header);
-	buf_page_x_lock(block, mtr);	
-
-	descr = xdes_get_descriptor(space, page, mtr);
-
-	ut_a(descr);
-	ut_a(xdes_get_bit(descr, XDES_FREE_BIT, page % FSP_EXTENT_SIZE, mtr)
-		== FALSE);
-
-	state = xdes_get_state(descr, mtr);
-
-	if (state != XDES_FSEG) {
-		/* The page is in the fragment pages of the segment */
-
-		for (i = 0;; i++) {
-			if (fseg_get_nth_frag_page_no(seg_header, i, mtr)
-			    == page) {
-
-				fseg_set_nth_frag_page_no(seg_header, i,
-							FIL_NULL, mtr);
-				break;
-			}
-		}
-
-		fsp_free_page(space, page, mtr);
-				
-		return;
-	}
-
-	/* If we get here, the page is in some extent of the segment */	
-	ut_a(0 == ut_dulint_cmp(
-		mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES, mtr),
-		mtr_read_dulint(seg_header + FSEG_ID, MLOG_8BYTES, mtr)));
-
-	not_full_n_used = mtr_read_ulint(seg_header + FSEG_NOT_FULL_N_USED,
-					MLOG_4BYTES, mtr);
-	if (xdes_is_full(descr, mtr)) {
-		/* The fragment is full: move it to another list */
-		flst_remove(seg_header + FSEG_FULL,
-				descr + XDES_FLST_NODE, mtr);
-		flst_add_last(seg_header + FSEG_NOT_FULL,
-				descr + XDES_FLST_NODE, mtr);
-		mlog_write_ulint(seg_header + FSEG_NOT_FULL_N_USED,
-				not_full_n_used + FSP_EXTENT_SIZE - 1,
-				MLOG_4BYTES, mtr);
-	} else {
-		ut_a(not_full_n_used > 0);
-		mlog_write_ulint(seg_header + FSEG_NOT_FULL_N_USED,
-				not_full_n_used - 1,
-				MLOG_4BYTES, mtr);
-	}
-
-	xdes_set_bit(descr, XDES_FREE_BIT, page % FSP_EXTENT_SIZE, TRUE, mtr);
-	xdes_set_bit(descr, XDES_CLEAN_BIT, page % FSP_EXTENT_SIZE, TRUE, mtr);
-
-	if (xdes_is_free(descr, mtr)) {
-	    	/* The extent has become free: free it to space */
-		flst_remove(seg_header + FSEG_NOT_FULL,
-				descr + XDES_FLST_NODE, mtr);
-		fsp_free_extent(space, page, mtr);
-	}		
-}
-
-/**************************************************************************
-Frees an extent of a segment to the space free list. */
-static
-void
-fseg_free_extent(
-/*=============*/
-	fseg_header_t*	seg_header, /* in: segment header */
-	ulint		space,	/* in: space id */
-	ulint		page,	/* in: page offset in the extent */
-	mtr_t*		mtr)	/* in: mtr handle */
-{
-	buf_block_t*	block;
-	xdes_t*		descr;
-	ulint		not_full_n_used;
-	ulint		descr_n_used;
-	
-	ut_ad(seg_header && mtr);
-
-	block = buf_block_align(seg_header);
-	buf_page_x_lock(block, mtr);	
-
-	descr = xdes_get_descriptor(space, page, mtr);
-
-	ut_a(xdes_get_state(descr, mtr) == XDES_FSEG);
-	ut_a(0 == ut_dulint_cmp(
-		mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES, mtr),
-	     	mtr_read_dulint(seg_header + FSEG_ID, MLOG_8BYTES, mtr)));
-
-	if (xdes_is_full(descr, mtr)) {
-		flst_remove(seg_header + FSEG_FULL,
-				descr + XDES_FLST_NODE, mtr);
-	} else if (xdes_is_free(descr, mtr)) {
-		flst_remove(seg_header + FSEG_FREE,
-				descr + XDES_FLST_NODE, mtr);
-	} else {
-		flst_remove(seg_header + FSEG_NOT_FULL,
-				descr + XDES_FLST_NODE, mtr);
-
-		not_full_n_used = mtr_read_ulint(
-					seg_header + FSEG_NOT_FULL_N_USED,
-					MLOG_4BYTES, mtr);
-
-		descr_n_used = xdes_get_n_used(descr, mtr);
-		ut_a(not_full_n_used >= descr_n_used);
-		mlog_write_ulint(seg_header + FSEG_NOT_FULL_N_USED,
-				not_full_n_used - descr_n_used,
-				MLOG_4BYTES, mtr);
-	}
-	fsp_free_extent(space, page, mtr);
-}
-
-/**************************************************************************
-Frees part of a segment. This function can be used to free a segment
-by repeatedly calling this function in different mini-transactions.
-Doing the freeing in a single mini-transaction might result in too big
-a mini-transaction. */
-
-bool
-fseg_free_step(
-/*===========*/
-			/* out: TRUE if freeing completed */
-	ulint	space,	/* in: segment space id */
-	ulint	page_no,/* in: segment header page number */
-	ulint	offset,	/* in: segment header byte offset on page */
-	mtr_t*	mtr)	/* in: mtr */
-{
-	buf_block_t*	block;
-	ulint		n;
-	ulint		page;
-	xdes_t*		descr;
-	fseg_header_t*	header;
-	fil_addr_t	header_addr;
-
-	header_addr.page = page_no;
-	header_addr.boffset = offset;
-	
-	mtr_x_lock(&fsp_latch, mtr);
-
-	header = fut_get_ptr_x_lock(space, header_addr, mtr);
-	
-	descr = fseg_get_first_extent(header, mtr);
-
-	if (descr != NULL) {
-		/* Free the extent held by the segment */
-		page = xdes_get_offset(descr);
-
-		fseg_free_extent(header, space, page, mtr);
-	
-		return(FALSE);
-	}
-
-	/* Free a frag page */
-
-	n = fseg_get_last_used_frag_page_slot(header, mtr);
-
-	if (n == ULINT_UNDEFINED) {
-		/* Freeing completed: free the segment header */
-		fsp_free_seg_header(space, header, mtr);
-
-		return(TRUE);
-	}
-
-	fseg_free_page_low(header, space,
-			fseg_get_nth_frag_page_no(header, n, mtr), mtr);
-
-	return(FALSE);
-}
-
-/***********************************************************************
-Frees a segment. The freeing is performed in several mini-transactions,
-so that there is no danger of bufferfixing too many buffer pages. */
-
-void
-fseg_free(
-/*======*/
-	ulint	space,	/* in: space id */
-	ulint	page_no,/* in: page number where the segment header is
-			placed */
-	ulint	offset)	/* in: byte offset of the segment header on that
-			page */
-{
-	mtr_t		mtr;
-	buf_block_t*	block;
-	bool		finished;
-
-	for (;;) {
-		mtr_start(&mtr);
-
-		block = buf_page_get(space, page_no, &mtr);
-	
-		finished = fseg_free_step(space, page_no, offset, &mtr);
-	
-		mtr_commit(&mtr);
-
-		if (finished) {
-			break;
-		}
-	}
-}
-
-/**************************************************************************
-Returns the first extent descriptor for a segment. We think of the extent
-lists of the segment catenated in the order FSEG_FULL -> FSEG_NOT_FULL
--> FSEG_FREE. */
-static
-xdes_t*
-fseg_get_first_extent(
-/*==================*/
-				/* out: the first extent descriptor, or NULL if
-				none */
-	fseg_header_t*	header,	/* in: segment header */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	buf_block_t*	block;
-	fil_addr_t	first;
-	ulint		space;
-	xdes_t*		descr;
-	
-	ut_ad(header && mtr);
-
-	block = buf_block_align(header);	
-	buf_page_x_lock(block, mtr);
-
-	space = buf_page_get_space(block);
-
-	first = fil_addr_null;
-	
-	if (flst_get_len(header + FSEG_FULL, mtr) > 0) {
-		first = flst_get_first(header + FSEG_FULL, mtr);
-	} else if (flst_get_len(header + FSEG_NOT_FULL, mtr) > 0) {
-		first = flst_get_first(header + FSEG_NOT_FULL, mtr);
-	} else if (flst_get_len(header + FSEG_FREE, mtr) > 0) {
-		first = flst_get_first(header + FSEG_FREE, mtr);
-	}
-
-	if (first.page == FIL_NULL) {
-		return(NULL);
-	} else {
-		descr = xdes_lst_get_descriptor(space, first, mtr);
-		return(descr);
-	}
-}
-
-#ifdef notdefined
-
-/**************************************************************************
-Returns the last non-free extent descriptor for a segment. We think of
-the extent lists of the segment catenated in the order FSEG_FULL ->
-FSEG_NOT_FULL -> FSEG_FREE. */
-static
-xdes_t*
-fseg_get_last_non_free_extent(
-/*==========================*/
-				/* out: the last extent descriptor, or NULL if
-				none */
-	fseg_header_t*	header,	/* in: segment header */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	buf_block_t*	block;
-	fil_addr_t	last;
-	ulint		space;
-	xdes_t*		descr;
-	
-	ut_ad(header && mtr);
-
-	block = buf_block_align(header);	
-	buf_page_x_lock(block, mtr);
-
-	space = buf_page_get_space(block);
-
-	last = fil_addr_null;
-	
-	if (flst_get_len(header + FSEG_NOT_FULL, mtr) > 0) {
-		last = flst_get_last(header + FSEG_NOT_FULL, mtr);
-	} else if (flst_get_len(header + FSEG_FULL, mtr) > 0) {
-		last = flst_get_last(header + FSEG_FULL, mtr);
-	}
-
-	if (last.page == FIL_NULL) {
-		return(NULL);
-	} else {
-		descr = xdes_lst_get_descriptor(space, last, mtr);
-		return(descr);
-	}
-}
-
-/**************************************************************************
-Returns the next extent descriptor for a segment. We think of the extent
-lists of the segment catenated in the order FSEG_FULL -> FSEG_NOT_FULL
--> FSEG_FREE. */
-static
-xdes_t*
-fseg_get_next_extent(
-/*=================*/
-				/* out: next extent descriptor, or NULL if
-				none */
-	fseg_header_t*	header,	/* in: segment header */
-	xdes_t*		descr,	/* in: previous extent descriptor */
-	mtr_t*		mtr)	/* in: mtr */
-{	
-	fil_addr_t	next_addr;
-	buf_block_t*	block;
-	ulint		space;
-	
-	ut_ad(header && descr && mtr);
-	
-	block = buf_block_align(header);	
-	buf_page_x_lock(block, mtr);
-
-	space = buf_page_get_space(block);
-	
-	next_addr = flst_get_next_addr(descr + XDES_FLST_NODE, mtr);
-
-	if (next_addr.page == FIL_NULL) {
-		 /* This is the last extent in the list. */
-		 if (xdes_is_full(descr, mtr)) {
-		 	/* descr is in FSEG_FULL list */
-			if (flst_get_len(header + FSEG_NOT_FULL, mtr) > 0) {
-				next_addr = flst_get_first(header
-							+ FSEG_NOT_FULL, mtr);
-			} else if (flst_get_len(header + FSEG_FREE, mtr) > 0) {
-				next_addr = flst_get_first(header
-							+ FSEG_FREE, mtr);
-			}
-		 } else if (!xdes_is_full(descr, mtr)
-			    && !xdes_is_free(descr, mtr)) {
-			/* descr is in FSEG_NOT_FULL list */
-		 	if (flst_get_len(header + FSEG_FREE, mtr) > 0) {
-				next_addr = flst_get_first(header
-							+ FSEG_FREE, mtr);
-			}
-		 }
-	}
-
-	if (next_addr.page != FIL_NULL) {
-		descr = xdes_lst_get_descriptor(space, next_addr, mtr);
-		ut_ad(descr);
-		return(descr);
-	} else {
-		return(NULL);
-	}
-}
-
-/**************************************************************************
-Returns the previous extent descriptor for a segment. We think of the extent
-lists of the segment catenated in the order FSEG_FULL -> FSEG_NOT_FULL
--> FSEG_FREE. */
-static
-xdes_t*
-fseg_get_prev_extent(
-/*=================*/
-				/* out: previous extent descriptor, or NULL if
-				none */
-	fseg_header_t*	header,	/* in: segment header */
-	xdes_t*		descr,	/* in: extent descriptor */
-	mtr_t*		mtr)	/* in: mtr */
-{	
-	fil_addr_t	prev_addr;
-	buf_block_t*	block;
-	ulint		space;
-	
-	ut_ad(header && descr && mtr);	
-
-	block = buf_block_align(header);	
-	buf_page_x_lock(block, mtr);
-
-	space = buf_page_get_space(block);
-	
-	prev_addr = flst_get_prev_addr(descr + XDES_FLST_NODE, mtr);
-
-	if (prev_addr.page == FIL_NULL) {
-		 /* This is the first extent in the list. */
-		 if (xdes_is_free(descr, mtr)) {
-		 	/* descr is in FSEG_FREE list */
-			if (flst_get_len(header + FSEG_NOT_FULL, mtr) > 0) {
-				prev_addr = flst_get_last(header
-							+ FSEG_NOT_FULL, mtr);
-			} else if (flst_get_len(header + FSEG_FULL, mtr) > 0) {
-				prev_addr = flst_get_last(header
-							+ FSEG_FULL, mtr);
-			}
-		 } else if (!xdes_is_full(descr, mtr)
-			    && !xdes_is_free(descr, mtr)) {
-			/* descr is in FSEG_NOT_FULL list */
-		 	if (flst_get_len(header + FSEG_FULL, mtr) > 0) {
-				prev_addr = flst_get_last(header
-							+ FSEG_FULL, mtr);
-			}
-		 }
-	}
-
-	if (prev_addr.page != FIL_NULL) {
-		descr = xdes_lst_get_descriptor(space, prev_addr, mtr);
-		ut_ad(descr);
-		return(descr);
-	} else {
-		return(NULL);
-	}
-}
-
-/*************************************************************************
-Gets the first used page number in the given extent assigned to a
-specific segment, or its successors, in the order defined in
-fsp_get_next_extent. */
-static
-ulint
-fseg_extent_get_next_page_no(
-/*=========================*/
-				/* next used page number in the given extent
-				or a successor of it, FIL_NULL if no page
-				found */
-	fseg_header_t*	header,	/* in: segment header */
-	xdes_t*		descr,	/* in: extent descriptor, if this is NULL, the
-				function returns FIL_NULL */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	ulint	bit;
-
-	UT_NOT_USED(header);
-	ut_ad((descr == NULL) || (xdes_get_state(descr, mtr) == XDES_FSEG));
-
-	for (;;) {
-		if (descr == NULL) {
-			return(FIL_NULL);
-		}
-
-		bit = xdes_find_bit(descr, XDES_FREE_BIT, FALSE, 0, mtr);
-					
-		if (bit == ULINT_UNDEFINED) {
-			/* No page found in this extent: the extent is in
-			FSEG_FREE list, thus, no used page can be found
-			in successors */
-			return(FIL_NULL);
-		} else {
-			return(xdes_get_offset(descr) + bit);
-		}
-	}
-}
-
-/*************************************************************************
-Gets the last used page number in the given extent assigned to a
-specific segment, or its predecessor extents, in the order defined in
-fsp_get_next_extent. If the page cannot be found from the extents,
-the last page of the fragment list is returned, or FIL_NULL if it is
-empty.*/
-static
-ulint
-fseg_extent_get_prev_page_no(
-/*=========================*/
-				/* previous used page number in the given
-				extent or a predecessor, FIL_NULL
-				if no page found */
-	fseg_header_t*	header,	/* in: segment header */
-	xdes_t*		descr,	/* in: extent descriptor, if this is NULL, the
-				function returns the last page of the fragment
-				list, if any */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	ulint		prev_page_no;
-	ulint		bit;
-	fil_addr_t	last_frag_page_addr;
-
-	ut_ad((descr == NULL) || (xdes_get_state(descr, mtr) == XDES_FSEG));
-
-	for (;;) {
-		if (descr == NULL) {
-			prev_page_no = FIL_NULL;
-			break;
-		}
-
-		bit = xdes_find_bit_downward(descr, XDES_FREE_BIT, FALSE,
-						FSP_EXTENT_SIZE - 1, mtr);
-					
-		if (bit == ULINT_UNDEFINED) {
-			descr = fseg_get_prev_extent(header, descr, mtr);
-		} else {
-			prev_page_no = xdes_get_offset(descr) + bit;
-			break;
-		}
-	}
-
-	if (prev_page_no == FIL_NULL) {
-		last_frag_page_addr = flst_get_last(header + FSEG_FRAG, mtr);
-		prev_page_no = last_frag_page_addr.page;
-	}
-
-	return(prev_page_no);
-}
-
-/**************************************************************************
-Returns the page number of the first segment page. If no pages have been
-freed from the segment, and the pages were allocated with the hint page
-number always one greater than previous page, then it is guaranteed that
-this function returns the first allocated page. */
-
-ulint
-fseg_get_first_page_no(
-/*===================*/
-				/* out: page number, FIL_NULL if no
-				page found */
-	fseg_header_t*	header,	/* in: segment header */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	buf_block_t*	block;
-	ulint		first_page_no;
-	xdes_t*		descr;
-	fil_addr_t	first_frag_page_addr;
-	
-	ut_ad(header);
-
-	mtr_x_lock(&fsp_latch, mtr);	
-
-	block = buf_block_align(header);	
-	buf_page_x_lock(block, mtr);
-
-	/* Find first page */
-	first_frag_page_addr = flst_get_first(header + FSEG_FRAG, mtr);
-	first_page_no = first_frag_page_addr.page;
-	
-	if (first_page_no == FIL_NULL) {
-		descr = fseg_get_first_extent(header, mtr);
-		first_page_no = fseg_extent_get_next_page_no(header, descr,
-								mtr);
-	}
-		
-	return(first_page_no);
-}
-
-/**************************************************************************
-Returns the page number of the last segment page. If no pages have been
-freed from the segment, and the pages were allocated with the hint page
-number always one greater than previous page, then it is guaranteed that
-this function returns the last allocated page. */
-
-ulint
-fseg_get_last_page_no(
-/*==================*/
-				/* out: page number, FIL_NULL if no
-				page found */
-	fseg_header_t*	header,	/* in: segment header */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	buf_block_t*	block;
-	ulint		last_page_no;
-	xdes_t*		descr;
-	
-	ut_ad(header);
-
-	mtr_x_lock(&fsp_latch, mtr);	
-
-	block = buf_block_align(header);	
-	buf_page_x_lock(block, mtr);
-
-	descr = fseg_get_last_non_free_extent(header, mtr);
-	last_page_no = fseg_extent_get_prev_page_no(header, descr, mtr);
-		
-	return(last_page_no);
-}
-
-/**************************************************************************
-Returns the page number of the next segment page. If no pages have been
-freed from the segment, and the pages were allocated with the hint page
-number always one greater than previous page, then it is guaranteed that
-this function steps the pages through in the order they were allocated
-to the segment. */
-
-ulint
-fseg_get_next_page_no(
-/*==================*/
-				/* out: page number, FIL_NULL if no
-				page left */
-	fseg_header_t*	header,	/* in: segment header */
-	ulint		page_no,/* in: previous page number */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	buf_block_t*	block;
-	buf_frame_t*	frame;
-	ulint		space;
-	ulint		next_page_no;
-	xdes_t*		descr;
-	ulint		bit;
-	fil_addr_t	next_frag_page_addr;
-	fseg_page_header_t* page_header;
-	
-	ut_ad(header);
-
-	mtr_x_lock(&fsp_latch, mtr);	
-
-	block = buf_block_align(header);	
-	buf_page_x_lock(block, mtr);
-
-	space = buf_page_get_space(block);
-
-	descr = xdes_get_descriptor(space, page_no, mtr);
-	ut_ad(xdes_get_bit(descr, XDES_FREE_BIT,
-	      		   page_no % FSP_EXTENT_SIZE, mtr) == FALSE);
-	      		   
-	if (xdes_get_state(descr, mtr) == XDES_FSEG) {
-		/* The extent of the current page belongs to the segment */
-		bit = xdes_find_bit(descr, XDES_FREE_BIT, FALSE,
-				    (page_no + 1) % FSP_EXTENT_SIZE,
-				    mtr);
-		if ((bit == ULINT_UNDEFINED)
-		    || (bit <= (page_no % FSP_EXTENT_SIZE))) {       
-		    	/* No higher address pages in this extent */
-			descr = fseg_get_next_extent(header, descr, mtr);
-			next_page_no = fseg_extent_get_next_page_no(
-						header, descr, mtr);
-		} else {
-			next_page_no = xdes_get_offset(descr) + bit;
-		}
-	} else {
-		/* Current page is a fragment page */
-		block = buf_page_get(space, page_no, mtr);
-		buf_page_x_lock(block, mtr);
-		frame = buf_block_get_frame(block);
-		page_header = frame + FSEG_PAGE_HEADER_OFFSET;
-		next_frag_page_addr = flst_get_next_addr(
-					page_header + FSEG_PAGE_FRAG_NODE,
-					mtr);
-			
-		next_page_no = next_frag_page_addr.page;
-		if (next_page_no == FIL_NULL) {
-			descr = fseg_get_first_extent(header, mtr);
-			next_page_no = fseg_extent_get_next_page_no(
-						header, descr, mtr);
-		}
-	}	
-	return(next_page_no);
-}
-
-/**************************************************************************
-Returns the page number of the previous segment page. If no pages have been
-freed from the segment, and the pages were allocated with the hint page
-number always one greater than the previous page, then it is guaranteed that
-this function steps through the pages in the order opposite to the allocation
-order of the pages. */
-
-ulint
-fseg_get_prev_page_no(
-/*==================*/
-				/* out: page number, FIL_NULL if no page
-				left */
-	fseg_header_t*	header,	/* in: segment header */
-	ulint		page_no,/* in: page number */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	buf_block_t*	block;
-	buf_frame_t*	frame;
-	ulint		space;
-	ulint		prev_page_no;
-	xdes_t*		descr;
-	ulint		bit;
-	fil_addr_t	prev_frag_page_addr;
-	fseg_page_header_t* page_header;
-	
-	ut_ad(header);
-
-	mtr_x_lock(&fsp_latch, mtr);	
-
-	block = buf_block_align(header);	
-	buf_page_x_lock(block, mtr);
-
-	space = buf_page_get_space(block);
-
-	descr = xdes_get_descriptor(space, page_no, mtr);
-	ut_ad(xdes_get_bit(descr, XDES_FREE_BIT,
-	      		   page_no % FSP_EXTENT_SIZE, mtr) == FALSE);
-	      		   
-	if (xdes_get_state(descr, mtr) == XDES_FSEG) {
-		/* The extent of the current page belongs to the segment */
-		bit = xdes_find_bit_downward(descr, XDES_FREE_BIT, FALSE,
-				    (page_no - 1) % FSP_EXTENT_SIZE,
-				    mtr);
-		if ((bit == ULINT_UNDEFINED)
-		    || (bit >= (page_no % FSP_EXTENT_SIZE))) {       
-		    	/* No lower address pages in this extent */
-			descr = fseg_get_prev_extent(header, descr, mtr);
-			prev_page_no = fseg_extent_get_prev_page_no(
-						header, descr, mtr);
-		} else {
-			prev_page_no = xdes_get_offset(descr) + bit;
-		}
-	} else {
-		/* Current page is a fragment page */
-		block = buf_page_get(space, page_no, mtr);
-		buf_page_x_lock(block, mtr);
-		frame = buf_block_get_frame(block);
-		page_header = frame + FSEG_PAGE_HEADER_OFFSET;
-		prev_frag_page_addr = flst_get_prev_addr(
-					page_header + FSEG_PAGE_FRAG_NODE,
-					mtr);
-			
-		prev_page_no = prev_frag_page_addr.page;
-	}	
-	return(prev_page_no);
-}
-
-#endif
-
-/***********************************************************************
-Validates a segment. */
-static
-bool
-fseg_validate_low(
-/*==============*/
-				/* out: TRUE if ok */
-	fseg_header_t*	header, /* in: segment header */
-	mtr_t*		mtr2)	/* in: mtr */
-{
-	ulint		space;
-	dulint		seg_id;
-	mtr_t		mtr;
-	xdes_t*		descr;
-	fil_addr_t	node_addr;
-	ulint		n_used		= 0;
-	ulint		n_used2		= 0;
-	flst_node_t*	node;
-	buf_frame_t*	frame;
-	fseg_page_header_t*	page_header;
-	
-	ut_ad(mtr_memo_contains(mtr2, buf_block_align(header),
-				MTR_MEMO_BUF_FIX));
-	buf_page_x_lock(buf_block_align(header), mtr2);
-
-	space = buf_page_get_space(buf_block_align(header));
-	
-	seg_id = mtr_read_dulint(header + FSEG_ID, MLOG_8BYTES, mtr2); 
-	n_used = mtr_read_ulint(header + FSEG_NOT_FULL_N_USED,
-					MLOG_4BYTES, mtr2); 
-
-	flst_validate(header + FSEG_FRAG, mtr2);
-	flst_validate(header + FSEG_FREE, mtr2);
-	flst_validate(header + FSEG_NOT_FULL, mtr2);
-	flst_validate(header + FSEG_FULL, mtr2);
-
-	/* Validate FSEG_FREE list */
-	node_addr = flst_get_first(header + FSEG_FREE, mtr2);
-
-	while (!fil_addr_is_null(node_addr)) {
-		mtr_start(&mtr);
-		mtr_x_lock(&fsp_latch, &mtr);	
-
-		descr = xdes_lst_get_descriptor(space, node_addr, &mtr);
-
-		ut_a(xdes_get_n_used(descr, &mtr) == 0);
-		ut_a(xdes_get_state(descr, &mtr) == XDES_FSEG);
-		ut_a(0 == ut_dulint_cmp(
-			mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES,
-					&mtr), seg_id));
-
-		node_addr = flst_get_next_addr(descr + XDES_FLST_NODE, &mtr);
-		mtr_commit(&mtr);
-	}
-
-	/* Validate FSEG_NOT_FULL list */
-
-	node_addr = flst_get_first(header + FSEG_NOT_FULL, mtr2);
-
-	while (!fil_addr_is_null(node_addr)) {
-		mtr_start(&mtr);
-		mtr_x_lock(&fsp_latch, &mtr);	
-
-		descr = xdes_lst_get_descriptor(space, node_addr, &mtr);
-
-		ut_a(xdes_get_n_used(descr, &mtr) > 0);
-		ut_a(xdes_get_n_used(descr, &mtr) < FSP_EXTENT_SIZE);
-		ut_a(xdes_get_state(descr, &mtr) == XDES_FSEG);
-		ut_a(0 == ut_dulint_cmp(
-			mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES,
-					&mtr), seg_id));
-
-		n_used2 += xdes_get_n_used(descr, &mtr);
-
-		node_addr = flst_get_next_addr(descr + XDES_FLST_NODE, &mtr);
-		mtr_commit(&mtr);
-	}
-
-	/* Validate FSEG_FULL list */
-
-	node_addr = flst_get_first(header + FSEG_FULL, mtr2);
-
-	while (!fil_addr_is_null(node_addr)) {
-		mtr_start(&mtr);
-		mtr_x_lock(&fsp_latch, &mtr);	
-
-		descr = xdes_lst_get_descriptor(space, node_addr, &mtr);
-
-		ut_a(xdes_get_n_used(descr, &mtr) == FSP_EXTENT_SIZE);
-		ut_a(xdes_get_state(descr, &mtr) == XDES_FSEG);
-		ut_a(0 == ut_dulint_cmp(
-			mtr_read_dulint(descr + XDES_ID, MLOG_8BYTES,
-					&mtr), seg_id));
-
-		node_addr = flst_get_next_addr(descr + XDES_FLST_NODE, &mtr);
-		mtr_commit(&mtr);
-	}
-
-	/* Validate FSEG_FRAG list */
-	node_addr = flst_get_first(header + FSEG_FRAG, mtr2);
-
-	while (!fil_addr_is_null(node_addr)) {
-		mtr_start(&mtr);
-		mtr_x_lock(&fsp_latch, &mtr);	
-
-		node = fut_get_ptr_x_lock(space, node_addr, &mtr);
-		frame = buf_frame_align(node);
-		page_header = frame + FSEG_PAGE_HEADER_OFFSET;
-		ut_a(0 == ut_dulint_cmp(
-			mtr_read_dulint(page_header + FSEG_PAGE_SEG_ID,
-					MLOG_8BYTES, &mtr), seg_id));
-
-		node_addr = flst_get_next_addr(node, &mtr);
-		mtr_commit(&mtr);
-	}
-	
-	ut_a(n_used == n_used2);
-
-	return(TRUE);
-}
-	
-/***********************************************************************
-Validates a segment. */
-
-bool
-fseg_validate(
-/*==========*/
-				/* out: TRUE if ok */
-	fseg_header_t*	header, /* in: segment header */
-	mtr_t*		mtr2)	/* in: mtr */
-{
-	bool	ret;
-
-	mtr_x_lock(&fsp_latch, mtr2);	
-	ret = fseg_validate_low(header, mtr2);
-
-	return(ret);
-}
-
-/***********************************************************************
-Writes info of a segment. */
-static
-void
-fseg_print_low(
-/*===========*/
-	fseg_header_t*	header, /* in: segment header */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	ulint		space;
-	ulint		seg_id_low;
-	ulint		seg_id_high;
-	ulint		n_used;
-	ulint		n_frag;
-	ulint		n_free;
-	ulint		n_not_full;
-	ulint		n_full;
-	ulint		reserved;
-	ulint		used;
-	ulint		page_no;
-	
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(header),
-				MTR_MEMO_BUF_FIX));
-	buf_page_x_lock(buf_block_align(header), mtr);
-
-	space = buf_page_get_space(buf_block_align(header));
-	page_no = buf_page_get_offset(buf_block_align(header));
-
-	reserved = fseg_n_reserved_pages_low(header, &used, mtr);
-	
-	seg_id_low = ut_dulint_get_low(mtr_read_dulint(header + FSEG_ID,
-						MLOG_8BYTES, mtr));
-	seg_id_high = ut_dulint_get_high(mtr_read_dulint(header + FSEG_ID,
-						MLOG_8BYTES, mtr));
-	
-	n_used = mtr_read_ulint(header + FSEG_NOT_FULL_N_USED,
-					MLOG_4BYTES, mtr); 
-
-	n_frag = flst_get_len(header + FSEG_FRAG, mtr);
-	n_free = flst_get_len(header + FSEG_FREE, mtr);
-	n_not_full = flst_get_len(header + FSEG_NOT_FULL, mtr);
-	n_full = flst_get_len(header + FSEG_FULL, mtr);
-
-	printf(
-    "SEGMENT id %lu %lu space %lu; page %lu; res %lu used %lu; full ext %lu\n",
-		seg_id_high, seg_id_low, space, page_no, reserved, used,
-		n_full);
-	printf(
-    "fragm pages %lu; free extents %lu; not full extents %lu: pages %lu\n",
-		n_frag, n_free, n_not_full, n_used);
-}
-
-/***********************************************************************
-Writes info of a segment. */
-
-void
-fseg_print(
-/*=======*/
-	fseg_header_t*	header, /* in: segment header */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	mtr_x_lock(&fsp_latch, mtr);
-
-	fseg_print_low(header, mtr);
-}
-
-/***********************************************************************
-Validates the file space system and its segments. */
-
-bool
-fsp_validate(
-/*=========*/
-				/* out: TRUE if ok */
-	ulint		space)	/* in: space id */
-{
-	fsp_header_t*	header;
-	fseg_header_t*	seg_header;
-	ulint		size;
-	ulint		free_limit;
-	ulint		frag_n_used;
-	mtr_t		mtr;
-	mtr_t		mtr2;
-	xdes_t*		descr;
-	fil_addr_t	node_addr;
-	ulint		descr_count	= 0;
-	ulint		n_used		= 0;
-	ulint		n_used2		= 0;
-	ulint		n_full_frag_pages;
-
-	/* Start first a mini-transaction mtr2 to lock out all other threads
-	from the fsp system */
-	mtr_start(&mtr2);
-	mtr_x_lock(&fsp_latch, &mtr2);	
-	
-	mtr_start(&mtr);
-	mtr_x_lock(&fsp_latch, &mtr);	
-	
-	header = fsp_get_space_header(space, &mtr);
-
-	size = mtr_read_ulint(header + FSP_SIZE, MLOG_4BYTES, &mtr); 
-	free_limit = mtr_read_ulint(header + FSP_FREE_LIMIT,
-					MLOG_4BYTES, &mtr); 
-	frag_n_used = mtr_read_ulint(header + FSP_FRAG_N_USED,
-					MLOG_4BYTES, &mtr); 
-
-	n_full_frag_pages = FSP_EXTENT_SIZE *
-				flst_get_len(header + FSP_FULL_FRAG, &mtr);
-					
-	ut_a(free_limit <= size);
-					
-	flst_validate(header + FSP_FREE, &mtr);
-	flst_validate(header + FSP_FREE_FRAG, &mtr);
-	flst_validate(header + FSP_FULL_FRAG, &mtr);
-	flst_validate(header + FSP_SEGS, &mtr);
-
-	mtr_commit(&mtr);
-
-	/* Validate FSP_FREE list */
-	mtr_start(&mtr);
-	mtr_x_lock(&fsp_latch, &mtr);	
-
-	header = fsp_get_space_header(space, &mtr);
-	node_addr = flst_get_first(header + FSP_FREE, &mtr);
-
-	mtr_commit(&mtr);
-
-	while (!fil_addr_is_null(node_addr)) {
-		mtr_start(&mtr);
-		mtr_x_lock(&fsp_latch, &mtr);	
-
-		descr_count++;
-		descr = xdes_lst_get_descriptor(space, node_addr, &mtr);
-
-		ut_a(xdes_get_n_used(descr, &mtr) == 0);
-		ut_a(xdes_get_state(descr, &mtr) == XDES_FREE);
-
-		node_addr = flst_get_next_addr(descr + XDES_FLST_NODE, &mtr);
-		mtr_commit(&mtr);
-	}
-
-	/* Validate FSP_FREE_FRAG list */
-	mtr_start(&mtr);
-	mtr_x_lock(&fsp_latch, &mtr);	
-
-	header = fsp_get_space_header(space, &mtr);
-	node_addr = flst_get_first(header + FSP_FREE_FRAG, &mtr);
-
-	mtr_commit(&mtr);
-
-	while (!fil_addr_is_null(node_addr)) {
-		mtr_start(&mtr);
-		mtr_x_lock(&fsp_latch, &mtr);	
-
-		descr_count++;
-		descr = xdes_lst_get_descriptor(space, node_addr, &mtr);
-
-		ut_a(xdes_get_n_used(descr, &mtr) > 0);
-		ut_a(xdes_get_n_used(descr, &mtr) < FSP_EXTENT_SIZE);
-		ut_a(xdes_get_state(descr, &mtr) == XDES_FREE_FRAG);
-
-		n_used += xdes_get_n_used(descr, &mtr);
-		node_addr = flst_get_next_addr(descr + XDES_FLST_NODE, &mtr);
-
-		mtr_commit(&mtr);
-	}
-
-	/* Validate FSP_FULL_FRAG list */
-	mtr_start(&mtr);
-	mtr_x_lock(&fsp_latch, &mtr);	
-
-	header = fsp_get_space_header(space, &mtr);
-	node_addr = flst_get_first(header + FSP_FULL_FRAG, &mtr);
-
-	mtr_commit(&mtr);
-
-	while (!fil_addr_is_null(node_addr)) {
-		mtr_start(&mtr);
-		mtr_x_lock(&fsp_latch, &mtr);	
-
-		descr_count++;
-		descr = xdes_lst_get_descriptor(space, node_addr, &mtr);
-
-		ut_a(xdes_get_n_used(descr, &mtr) == FSP_EXTENT_SIZE);
-		ut_a(xdes_get_state(descr, &mtr) == XDES_FULL_FRAG);
-
-		node_addr = flst_get_next_addr(descr + XDES_FLST_NODE, &mtr);
-		mtr_commit(&mtr);
-	}
-	
-	/* Validate segments */
-	mtr_start(&mtr);
-	mtr_x_lock(&fsp_latch, &mtr);	
-
-	header = fsp_get_space_header(space, &mtr);
-	node_addr = flst_get_first(header + FSP_SEGS, &mtr);
-
-	mtr_commit(&mtr);
-
-	while (!fil_addr_is_null(node_addr)) {
-		mtr_start(&mtr);
-		mtr_x_lock(&fsp_latch, &mtr);	
-
-		seg_header = fut_get_ptr_x_lock(space, node_addr,
-						&mtr) - FSEG_FLST_NODE;
-		fseg_validate_low(seg_header, &mtr);
-
-		descr_count += flst_get_len(seg_header + FSEG_FREE, &mtr);
-		descr_count += flst_get_len(seg_header + FSEG_FULL, &mtr);
-		descr_count += flst_get_len(seg_header + FSEG_NOT_FULL, &mtr);
-
-		n_used2 += flst_get_len(seg_header + FSEG_FRAG, &mtr);
-		
-		node_addr = flst_get_next_addr(seg_header + FSEG_FLST_NODE,
-						&mtr);
-		mtr_commit(&mtr);
-	}
-	
-	ut_a(descr_count * FSP_EXTENT_SIZE == free_limit);
-	ut_a(n_used + n_full_frag_pages
-		== n_used2 + (free_limit + XDES_DESCRIBED_PER_PAGE - 1)
-				 / XDES_DESCRIBED_PER_PAGE);
-	ut_a(frag_n_used == n_used);
-
-	mtr_commit(&mtr2);
-	return(TRUE);
-}
-
-/***********************************************************************
-Prints info of a file space. */
-
-void
-fsp_print(
-/*======*/
-	ulint		space)	/* in: space id */
-{
-	fsp_header_t*	header;
-	fseg_header_t*	seg_header;
-	ulint		size;
-	ulint		free_limit;
-	ulint		frag_n_used;
-	mtr_t		mtr;
-	mtr_t		mtr2;
-	fil_addr_t	node_addr;
-	ulint		n_free;
-	ulint		n_free_frag;
-	ulint		n_full_frag;
-	ulint		n_segs;
-	ulint		seg_id_low;
-	ulint		seg_id_high;
-	
-	/* Start first a mini-transaction mtr2 to lock out all other threads
-	from the fsp system */
-	mtr_start(&mtr2);
-	mtr_x_lock(&fsp_latch, &mtr2);	
-
-	mtr_start(&mtr);
-	mtr_x_lock(&fsp_latch, &mtr);	
-	
-	header = fsp_get_space_header(space, &mtr);
-
-	size = mtr_read_ulint(header + FSP_SIZE, MLOG_4BYTES, &mtr); 
-	free_limit = mtr_read_ulint(header + FSP_FREE_LIMIT,
-					MLOG_4BYTES, &mtr); 
-	frag_n_used = mtr_read_ulint(header + FSP_FRAG_N_USED,
-					MLOG_4BYTES, &mtr); 
-
-	n_free = flst_get_len(header + FSP_FREE, &mtr);
-	n_free_frag = flst_get_len(header + FSP_FREE_FRAG, &mtr);
-	n_full_frag = flst_get_len(header + FSP_FULL_FRAG, &mtr);
-	n_segs = flst_get_len(header + FSP_SEGS, &mtr);
-	seg_id_low = ut_dulint_get_low(mtr_read_dulint(header + FSP_SEG_ID,
-						MLOG_8BYTES, &mtr));
-	seg_id_high = ut_dulint_get_high(mtr_read_dulint(header + FSP_SEG_ID,
-						MLOG_8BYTES, &mtr));
-	
-	printf("FILE SPACE INFO: id %lu\n", space);
-
-	printf("size %lu, free limit %lu, free extents %lu\n",
-		size, free_limit, n_free);
-	printf(
-	"not full frag extents %lu: used pages %lu, full frag extents %lu\n",
-		n_free_frag, frag_n_used, n_full_frag);
-
-	printf("number of segments %lu, first seg id not used %lu %lu\n",
-		n_segs, seg_id_high, seg_id_low);
-	
-	/* Print segments */
-	node_addr = flst_get_first(header + FSP_SEGS, &mtr);
-
-	mtr_commit(&mtr);
-
-	while (!fil_addr_is_null(node_addr)) {
-		mtr_start(&mtr);
-		mtr_x_lock(&fsp_latch, &mtr);	
-
-		seg_header = fut_get_ptr_x_lock(space, node_addr,
-						&mtr) - FSEG_FLST_NODE;
-		fseg_print_low(seg_header, &mtr);
-		
-		node_addr = flst_get_next_addr(seg_header + FSEG_FLST_NODE,
-						&mtr);
-		mtr_commit(&mtr);
-	}
-	
-	mtr_commit(&mtr2);	
-}
-