diff options
Diffstat (limited to 'innobase/fsp/trash/FSP0FSP.C')
| -rw-r--r-- | innobase/fsp/trash/FSP0FSP.C | 3100 |
1 files changed, 3100 insertions, 0 deletions
diff --git a/innobase/fsp/trash/FSP0FSP.C b/innobase/fsp/trash/FSP0FSP.C new file mode 100644 index 00000000000..b0add437bff --- /dev/null +++ b/innobase/fsp/trash/FSP0FSP.C @@ -0,0 +1,3100 @@ +/********************************************************************** +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); +} + |