fsp0fsp.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:108k
- /**********************************************************************
- File space management
- (c) 1995 Innobase Oy
- Created 11/29/1995 Heikki Tuuri
- ***********************************************************************/
- #include "fsp0fsp.h"
- #ifdef UNIV_NONINL
- #include "fsp0fsp.ic"
- #endif
- #include "buf0buf.h"
- #include "fil0fil.h"
- #include "sync0sync.h"
- #include "mtr0log.h"
- #include "fut0fut.h"
- #include "ut0byte.h"
- #include "srv0srv.h"
- #include "page0types.h"
- #include "ibuf0ibuf.h"
- #include "btr0btr.h"
- #include "btr0sea.h"
- #include "dict0boot.h"
- #include "dict0mem.h"
- #include "log0log.h"
- #define FSP_HEADER_OFFSET FIL_PAGE_DATA /* Offset of the space header
- within a file page */
- /* The data structures in files are defined just as byte strings in C */
- typedef byte fsp_header_t;
- typedef byte xdes_t;
- /* 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_SPACE_ID 0 /* space id */
- #define FSP_NOT_USED 4 /* this field contained a value up to
- which we know that the modifications
- in the database have been flushed to
- the file space; not used now */
- #define FSP_SIZE 8 /* Current size of the space in
- pages */
- #define FSP_FREE_LIMIT 12 /* Minimum page number for which the
- free list has not been initialized:
- the pages >= this limit are, by
- definition, free; note that in a
- single-table tablespace where size
- < 64 pages, this number is 64, i.e.,
- we have initialized the space
- about the first extent, but have not
- physically allocted those pages to the
- file */
- #define FSP_LOWEST_NO_WRITE 16 /* 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 20 /* number of used pages in the
- FSP_FREE_FRAG list */
- #define FSP_FREE 24 /* list of free extents */
- #define FSP_FREE_FRAG (24 + FLST_BASE_NODE_SIZE)
- /* list of partially free extents not
- belonging to any segment */
- #define FSP_FULL_FRAG (24 + 2 * FLST_BASE_NODE_SIZE)
- /* list of full extents not belonging
- to any segment */
- #define FSP_SEG_ID (24 + 3 * FLST_BASE_NODE_SIZE)
- /* 8 bytes which give the first unused
- segment id */
- #define FSP_SEG_INODES_FULL (32 + 3 * FLST_BASE_NODE_SIZE)
- /* list of pages containing segment
- headers, where all the segment inode
- slots are reserved */
- #define FSP_SEG_INODES_FREE (32 + 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 (32 + 5 * 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 */
-
- /* FILE SEGMENT INODE
- ==================
- Segment inode which is created for each segment in a tablespace. 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. */
- typedef byte fseg_inode_t;
- #define FSEG_INODE_PAGE_NODE FSEG_PAGE_DATA
- /* the list node for linking
- segment inode 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_INODE_SIZE (16 + 3 * FLST_BASE_NODE_SIZE + FSEG_FRAG_ARR_N_SLOTS * FSEG_FRAG_SLOT_SIZE)
- #define FSP_SEG_INODES_PER_PAGE ((UNIV_PAGE_SIZE - FSEG_ARR_OFFSET - 10) / FSEG_INODE_SIZE)
- /* Number of segment inodes 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_ARR_N_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 /* NOTE: currently not used!
- 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 */
- /* 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_inode_t* seg_inode, /* in: segment inode */
- 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_inode_t* header, /* in: segment inode */
- 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_inode_t* seg_inode,/* in: segment inode */
- ulint space, /* in: space id */
- ulint page, /* in: page offset */
- mtr_t* mtr); /* in: mtr */
- /**************************************************************************
- 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_inode_t* inode, /* in: segment inode */
- 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(
- /*===============*/
- ibool init_space, /* in: TRUE if this is a single-table
- tablespace and we are only initing
- the tablespace's first extent
- descriptor page and ibuf bitmap page;
- then we do not allocate more extents */
- ulint space, /* in: space */
- fsp_header_t* header, /* in: space header */
- mtr_t* mtr); /* in: mtr */
- /**************************************************************************
- Allocates a single free page from a segment. This function implements
- the intelligent allocation strategy which tries to minimize file space
- fragmentation. */
- static
- ulint
- fseg_alloc_free_page_low(
- /*=====================*/
- /* out: the allocated page number, FIL_NULL
- if no page could be allocated */
- ulint space, /* in: space */
- fseg_inode_t* seg_inode, /* in: segment inode */
- 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 */
- /**************************************************************************
- Reads the file space size stored in the header page. */
- ulint
- fsp_get_size_low(
- /*=============*/
- /* out: tablespace size stored in the space header */
- page_t* page) /* in: header page (page 0 in the tablespace) */
- {
- return(mach_read_from_4(page + FSP_HEADER_OFFSET + FSP_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 */
- {
- fsp_header_t* header;
- ut_ad(mtr);
- header = FSP_HEADER_OFFSET + buf_page_get(id, 0, RW_X_LATCH, mtr);
- #ifdef UNIV_SYNC_DEBUG
- buf_page_dbg_add_level(header, SYNC_FSP_PAGE);
- #endif /* UNIV_SYNC_DEBUG */
- return(header);
- }
- /**************************************************************************
- Gets a descriptor bit of a page. */
- UNIV_INLINE
- ibool
- 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_FIX));
- 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 */
- ibool 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_FIX));
- 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 */
- ibool 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_FIX));
- 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 */
- ibool 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_FIX));
- 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_FIX));
- 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
- ibool
- 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);
- }
- return(FALSE);
- }
- /**************************************************************************
- Returns true if extent contains no free pages. */
- UNIV_INLINE
- ibool
- 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);
- }
- 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_FIX));
- 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_FIX));
- return(mtr_read_ulint(descr + XDES_STATE, MLOG_4BYTES, mtr));
- }
- /**************************************************************************
- Inits an extent descriptor to the 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_FIX));
- ut_ad((XDES_SIZE - XDES_BITMAP) % 4 == 0);
- for (i = XDES_BITMAP; i < XDES_SIZE; i += 4) {
- mlog_write_ulint(descr + i, 0xFFFFFFFFUL, MLOG_4BYTES, 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;
- ulint descr_page_no;
- page_t* descr_page;
- ut_ad(mtr);
- ut_ad(mtr_memo_contains(mtr, fil_space_get_latch(space),
- 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(FALSE, 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 {
- descr_page = buf_page_get(space, descr_page_no, RW_X_LATCH,
- mtr);
- #ifdef UNIV_SYNC_DEBUG
- buf_page_dbg_add_level(descr_page, SYNC_FSP_PAGE);
- #endif /* UNIV_SYNC_DEBUG */
- }
- 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;
- sp_header = FSP_HEADER_OFFSET
- + buf_page_get(space, 0, RW_X_LATCH, mtr);
- #ifdef UNIV_SYNC_DEBUG
- buf_page_dbg_add_level(sp_header, SYNC_FSP_PAGE);
- #endif /* UNIV_SYNC_DEBUG */
- 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, fil_space_get_latch(space),
- MTR_MEMO_X_LOCK));
- descr = fut_get_ptr(space, lst_node, RW_X_LATCH, 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_frame_get_space_id(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 */
- {
- ut_ad(descr);
- return(buf_frame_get_page_no(descr)
- + ((descr - buf_frame_align(descr) - XDES_ARR_OFFSET)
- / XDES_SIZE)
- * FSP_EXTENT_SIZE);
- }
- /***************************************************************
- Inits a file page whose prior contents should be ignored. */
- static
- void
- fsp_init_file_page_low(
- /*=====================*/
- byte* ptr) /* in: pointer to a page */
- {
- page_t* page;
- page = buf_frame_align(ptr);
- buf_block_align(page)->check_index_page_at_flush = FALSE;
- #ifdef UNIV_BASIC_LOG_DEBUG
- memset(page, 0xff, UNIV_PAGE_SIZE);
- #endif
- mach_write_to_8(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
- ut_dulint_zero);
- mach_write_to_8(page + FIL_PAGE_LSN, ut_dulint_zero);
- }
- /***************************************************************
- Inits a file page whose prior contents should be ignored. */
- static
- void
- fsp_init_file_page(
- /*===============*/
- page_t* page, /* in: page */
- mtr_t* mtr) /* in: mtr */
- {
- fsp_init_file_page_low(page);
-
- mlog_write_initial_log_record(page, MLOG_INIT_FILE_PAGE, mtr);
- }
-
- /***************************************************************
- Parses a redo log record of a file page init. */
- byte*
- fsp_parse_init_file_page(
- /*=====================*/
- /* out: end of log record or NULL */
- byte* ptr, /* in: buffer */
- byte* end_ptr __attribute__((unused)), /* in: buffer end */
- page_t* page) /* in: page or NULL */
- {
- ut_ad(ptr && end_ptr);
- if (page) {
- fsp_init_file_page_low(page);
- }
-
- return(ptr);
- }
- /**************************************************************************
- Initializes the fsp system. */
- void
- fsp_init(void)
- /*==========*/
- {
- /* Does nothing at the moment */
- }
- /**************************************************************************
- Writes the space id to a tablespace header. This function is used past the
- buffer pool when we in fil0fil.c create a new single-table tablespace. */
- void
- fsp_header_write_space_id(
- /*======================*/
- page_t* page, /* in: first page in the space */
- ulint space_id) /* in: space id */
- {
- mach_write_to_4(page + FSP_HEADER_OFFSET + FSP_SPACE_ID, space_id);
- }
- /**************************************************************************
- Initializes the space header of a new created space and creates also the
- insert buffer tree root if space == 0. */
- 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;
- page_t* page;
-
- ut_ad(mtr);
- mtr_x_lock(fil_space_get_latch(space), mtr);
- page = buf_page_create(space, 0, mtr);
- buf_page_get(space, 0, RW_X_LATCH, mtr);
- #ifdef UNIV_SYNC_DEBUG
- buf_page_dbg_add_level(page, SYNC_FSP_PAGE);
- #endif /* UNIV_SYNC_DEBUG */
- /* The prior contents of the file page should be ignored */
- fsp_init_file_page(page, mtr);
- header = FSP_HEADER_OFFSET + page;
- mlog_write_ulint(header + FSP_SPACE_ID, space, MLOG_4BYTES, 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_INODES_FULL, mtr);
- flst_init(header + FSP_SEG_INODES_FREE, mtr);
- mlog_write_dulint(header + FSP_SEG_ID, ut_dulint_create(0, 1), mtr);
- if (space == 0) {
- fsp_fill_free_list(FALSE, space, header, mtr);
- btr_create(DICT_CLUSTERED | DICT_UNIVERSAL | DICT_IBUF, space,
- ut_dulint_add(DICT_IBUF_ID_MIN, space), mtr);
- } else {
- fsp_fill_free_list(TRUE, space, header, mtr);
- }
- }
- /**************************************************************************
- Reads the space id from the first page of a tablespace. */
- ulint
- fsp_header_get_space_id(
- /*====================*/
- /* out: space id, ULINT UNDEFINED if error */
- page_t* page) /* in: first page of a tablespace */
- {
- ulint fsp_id;
- ulint id;
- fsp_id = mach_read_from_4(FSP_HEADER_OFFSET + page + FSP_SPACE_ID);
- id = mach_read_from_4(page + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID);
- if (id != fsp_id) {
- fprintf(stderr,
- "InnoDB: Error: space id in fsp header %lu, but in the page header %lun",
- (ulong) fsp_id,
- (ulong) id);
- return(ULINT_UNDEFINED);
- }
- return(id);
- }
- /**************************************************************************
- 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(fil_space_get_latch(space), 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);
- }
- /**************************************************************************
- Gets the current free limit of a tablespace. The free limit means the
- place of the first page which has never been put to the the free list
- for allocation. The space above that address is initialized to zero.
- Sets also the global variable log_fsp_current_free_limit. */
- ulint
- fsp_header_get_free_limit(
- /*======================*/
- /* out: free limit in megabytes */
- ulint space) /* in: space id, must be 0 */
- {
- fsp_header_t* header;
- ulint limit;
- mtr_t mtr;
- ut_a(space == 0); /* We have only one log_fsp_current_... variable */
-
- mtr_start(&mtr);
- mtr_x_lock(fil_space_get_latch(space), &mtr);
- header = fsp_get_space_header(space, &mtr);
- limit = mtr_read_ulint(header + FSP_FREE_LIMIT, MLOG_4BYTES, &mtr);
- limit = limit / ((1024 * 1024) / UNIV_PAGE_SIZE);
-
- log_fsp_current_free_limit_set_and_checkpoint(limit);
- mtr_commit(&mtr);
- return(limit);
- }
- /**************************************************************************
- Gets the size of the tablespace from the tablespace header. If we do not
- have an auto-extending data file, this should be equal to the size of the
- data files. If there is an auto-extending data file, this can be smaller. */
- ulint
- fsp_header_get_tablespace_size(
- /*===========================*/
- /* out: size in pages */
- ulint space) /* in: space id, must be 0 */
- {
- fsp_header_t* header;
- ulint size;
- mtr_t mtr;
- ut_a(space == 0); /* We have only one log_fsp_current_... variable */
-
- mtr_start(&mtr);
- mtr_x_lock(fil_space_get_latch(space), &mtr);
- header = fsp_get_space_header(space, &mtr);
- size = mtr_read_ulint(header + FSP_SIZE, MLOG_4BYTES, &mtr);
- mtr_commit(&mtr);
- return(size);
- }
- /***************************************************************************
- Tries to extend a single-table tablespace so that a page would fit in the
- data file. */
- static
- ibool
- fsp_try_extend_data_file_with_pages(
- /*================================*/
- /* out: TRUE if success */
- ulint space, /* in: space */
- ulint page_no, /* in: page number */
- fsp_header_t* header, /* in: space header */
- mtr_t* mtr) /* in: mtr */
- {
- ibool success;
- ulint actual_size;
- ulint size;
- ut_a(space != 0);
- size = mtr_read_ulint(header + FSP_SIZE, MLOG_4BYTES, mtr);
-
- ut_a(page_no >= size);
- success = fil_extend_space_to_desired_size(&actual_size, space,
- page_no + 1);
- /* actual_size now has the space size in pages; it may be less than
- we wanted if we ran out of disk space */
-
- mlog_write_ulint(header + FSP_SIZE, actual_size, MLOG_4BYTES, mtr);
- return(success);
- }
- /***************************************************************************
- Tries to extend the last data file of a tablespace if it is auto-extending. */
- static
- ibool
- fsp_try_extend_data_file(
- /*=====================*/
- /* out: FALSE if not auto-extending */
- ulint* actual_increase,/* out: actual increase in pages, where
- we measure the tablespace size from
- what the header field says; it may be
- the actual file size rounded down to
- megabyte */
- ulint space, /* in: space */
- fsp_header_t* header, /* in: space header */
- mtr_t* mtr) /* in: mtr */
- {
- ulint size;
- ulint new_size;
- ulint old_size;
- ulint size_increase;
- ulint actual_size;
- ibool success;
- *actual_increase = 0;
- if (space == 0 && !srv_auto_extend_last_data_file) {
- return(FALSE);
- }
- size = mtr_read_ulint(header + FSP_SIZE, MLOG_4BYTES, mtr);
- old_size = size;
- if (space == 0 && srv_last_file_size_max != 0) {
- if (srv_last_file_size_max
- < srv_data_file_sizes[srv_n_data_files - 1]) {
- fprintf(stderr,
- "InnoDB: Error: Last data file size is %lu, max size allowed %lun",
- (ulong) srv_data_file_sizes[srv_n_data_files - 1],
- (ulong) srv_last_file_size_max);
- }
- size_increase = srv_last_file_size_max
- - srv_data_file_sizes[srv_n_data_files - 1];
- if (size_increase > SRV_AUTO_EXTEND_INCREMENT) {
- size_increase = SRV_AUTO_EXTEND_INCREMENT;
- }
- } else {
- if (space == 0) {
- size_increase = SRV_AUTO_EXTEND_INCREMENT;
- } else {
- /* We extend single-table tablespaces first one extent
- at a time, but for bigger tablespaces more. It is not
- enough to extend always by one extent, because some
- extents are frag page extents. */
- if (size < FSP_EXTENT_SIZE) {
- /* Let us first extend the file to 64 pages */
- success = fsp_try_extend_data_file_with_pages(
- space, FSP_EXTENT_SIZE - 1,
- header, mtr);
- if (!success) {
- new_size = mtr_read_ulint(
- header + FSP_SIZE, MLOG_4BYTES, mtr);
- *actual_increase = new_size - old_size;
- return(FALSE);
- }
- size = FSP_EXTENT_SIZE;
- }
- if (size < 32 * FSP_EXTENT_SIZE) {
- size_increase = FSP_EXTENT_SIZE;
- } else {
- /* Below in fsp_fill_free_list() we assume
- that we add at most FSP_FREE_ADD extents at
- a time */
- size_increase = FSP_FREE_ADD * FSP_EXTENT_SIZE;
- }
- }
- }
-
- if (size_increase == 0) {
- return(TRUE);
- }
-
- success = fil_extend_space_to_desired_size(&actual_size, space,
- size + size_increase);
- /* We ignore any fragments of a full megabyte when storing the size
- to the space header */
- mlog_write_ulint(header + FSP_SIZE,
- ut_calc_align_down(actual_size, (1024 * 1024) / UNIV_PAGE_SIZE),
- MLOG_4BYTES, mtr);
- new_size = mtr_read_ulint(header + FSP_SIZE, MLOG_4BYTES, mtr);
- *actual_increase = new_size - old_size;
- return(TRUE);
- }
- /**************************************************************************
- 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(
- /*===============*/
- ibool init_space, /* in: TRUE if this is a single-table
- tablespace and we are only initing
- the tablespace's first extent
- descriptor page and ibuf bitmap page;
- then we do not allocate more extents */
- ulint space, /* in: space */
- fsp_header_t* header, /* in: space header */
- mtr_t* mtr) /* in: mtr */
- {
- ulint limit;
- ulint size;
- xdes_t* descr;
- ulint count = 0;
- ulint frag_n_used;
- page_t* descr_page;
- page_t* ibuf_page;
- ulint actual_increase;
- ulint i;
- mtr_t ibuf_mtr;
- 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);
- if (space == 0 && srv_auto_extend_last_data_file
- && size < limit + FSP_EXTENT_SIZE * FSP_FREE_ADD) {
- /* Try to increase the last data file size */
- fsp_try_extend_data_file(&actual_increase, space, header, mtr);
- size = mtr_read_ulint(header + FSP_SIZE, MLOG_4BYTES, mtr);
- }
- if (space != 0 && !init_space
- && size < limit + FSP_EXTENT_SIZE * FSP_FREE_ADD) {
- /* Try to increase the .ibd file size */
- fsp_try_extend_data_file(&actual_increase, space, header, mtr);
- size = mtr_read_ulint(header + FSP_SIZE, MLOG_4BYTES, mtr);
- }
- i = limit;
-
- while ((init_space && i < 1)
- || ((i + FSP_EXTENT_SIZE <= size) && (count < FSP_FREE_ADD))) {
- mlog_write_ulint(header + FSP_FREE_LIMIT, i + FSP_EXTENT_SIZE,
- MLOG_4BYTES, mtr);
- /* Update the free limit info in the log system and make
- a checkpoint */
- if (space == 0) {
- log_fsp_current_free_limit_set_and_checkpoint(
- (i + FSP_EXTENT_SIZE)
- / ((1024 * 1024) / UNIV_PAGE_SIZE));
- }
- if (0 == i % XDES_DESCRIBED_PER_PAGE) {
- /* We are going to initialize a new descriptor page
- and a new ibuf bitmap page: the prior contents of the
- pages should be ignored. */
- if (i > 0) {
- descr_page = buf_page_create(space, i, mtr);
- buf_page_get(space, i, RW_X_LATCH, mtr);
- #ifdef UNIV_SYNC_DEBUG
- buf_page_dbg_add_level(descr_page,
- SYNC_FSP_PAGE);
- #endif /* UNIV_SYNC_DEBUG */
- fsp_init_file_page(descr_page, mtr);
- }
- /* Initialize the ibuf bitmap page in a separate
- mini-transaction because it is low in the latching
- order, and we must be able to release its latch
- before returning from the fsp routine */
-
- mtr_start(&ibuf_mtr);
- ibuf_page = buf_page_create(space,
- i + FSP_IBUF_BITMAP_OFFSET, &ibuf_mtr);
- buf_page_get(space, i + FSP_IBUF_BITMAP_OFFSET,
- RW_X_LATCH, &ibuf_mtr);
- #ifdef UNIV_SYNC_DEBUG
- buf_page_dbg_add_level(ibuf_page, SYNC_FSP_PAGE);
- #endif /* UNIV_SYNC_DEBUG */
- fsp_init_file_page(ibuf_page, &ibuf_mtr);
- ibuf_bitmap_page_init(ibuf_page, &ibuf_mtr);
- mtr_commit(&ibuf_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
- and the second is an ibuf bitmap page: mark them
- used */
- xdes_set_bit(descr, XDES_FREE_BIT, 0, FALSE, mtr);
- xdes_set_bit(descr, XDES_FREE_BIT,
- FSP_IBUF_BITMAP_OFFSET, 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 + 2, 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(FALSE, 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;
- page_t* page;
- ulint free;
- ulint frag_n_used;
- ulint page_no;
- ulint space_size;
- ibool success;
-
- 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
- the free extent anyway. */
-
- 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);
- if (free == ULINT_UNDEFINED) {
- ut_print_buf(stderr, ((byte*)descr) - 500, 1000);
- ut_error;
- }
- page_no = xdes_get_offset(descr) + free;
- space_size = mtr_read_ulint(header + FSP_SIZE, MLOG_4BYTES, mtr);
- if (space_size <= page_no) {
- /* It must be that we are extending a single-table tablespace
- whose size is still < 64 pages */
- ut_a(space != 0);
- if (page_no >= FSP_EXTENT_SIZE) {
- fprintf(stderr,
- "InnoDB: Error: trying to extend a single-table tablespace %lun"
- "InnoDB: by single page(s) though the space size %lu. Page no %lu.n",
- (ulong) space, (ulong) space_size, (ulong) page_no);
- return(FIL_NULL);
- }
- success = fsp_try_extend_data_file_with_pages(space, page_no,
- header, mtr);
- if (!success) {
- /* No disk space left */
- return(FIL_NULL);
- }
- }
- 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);
- }
- /* Initialize the allocated page to the buffer pool, so that it can
- be obtained immediately with buf_page_get without need for a disk
- read. */
-
- buf_page_create(space, page_no, mtr);
- page = buf_page_get(space, page_no, RW_X_LATCH, mtr);
- #ifdef UNIV_SYNC_DEBUG
- buf_page_dbg_add_level(page, SYNC_FSP_PAGE);
- #endif /* UNIV_SYNC_DEBUG */
- /* Prior contents of the page should be ignored */
- fsp_init_file_page(page, mtr);
-
- return(page_no);
- }
- /**************************************************************************
- 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);
- /* fprintf(stderr, "Freeing page %lu in space %lun", page, space); */
- header = fsp_get_space_header(space, mtr);
- descr = xdes_get_descriptor_with_space_hdr(header, space, page, mtr);
- state = xdes_get_state(descr, mtr);
-
- if (state != XDES_FREE_FRAG && state != XDES_FULL_FRAG) {
- fprintf(stderr,
- "InnoDB: Error: File space extent descriptor of page %lu has state %lun",
- (ulong) page,
- (ulong) state);
- fputs("InnoDB: Dump of descriptor: ", stderr);
- ut_print_buf(stderr, ((byte*)descr) - 50, 200);
- putc('n', stderr);
-
- if (state == XDES_FREE) {
- /* We put here some fault tolerance: if the page
- is already free, return without doing anything! */
- return;
- }
- ut_error;
- }
- if (xdes_get_bit(descr, XDES_FREE_BIT, page % FSP_EXTENT_SIZE, mtr)) {
- fprintf(stderr,
- "InnoDB: Error: File space extent descriptor of page %lu says it is freen"
- "InnoDB: Dump of descriptor: ", (ulong) page);
- ut_print_buf(stderr, ((byte*)descr) - 50, 200);
- putc('n', stderr);
- /* We put here some fault tolerance: if the page
- is already free, return without doing anything! */
- return;
- }
- 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);
- if (xdes_get_state(descr, mtr) == XDES_FREE) {
- ut_print_buf(stderr, (byte*)descr - 500, 1000);
- ut_error;
- }
- xdes_init(descr, mtr);
- flst_add_last(header + FSP_FREE, descr + XDES_FLST_NODE, mtr);
- }
- /**************************************************************************
- Returns the nth inode slot on an inode page. */
- UNIV_INLINE
- fseg_inode_t*
- fsp_seg_inode_page_get_nth_inode(
- /*=============================*/
- /* out: segment inode */
- page_t* page, /* in: segment inode page */
- ulint i, /* in: inode index on page */
- mtr_t* mtr __attribute__((unused))) /* in: mini-transaction handle */
- {
- ut_ad(i < FSP_SEG_INODES_PER_PAGE);
- ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
- MTR_MEMO_PAGE_X_FIX));
- return(page + FSEG_ARR_OFFSET + FSEG_INODE_SIZE * i);
- }
- /**************************************************************************
- Looks for a used segment inode on a segment inode page. */
- static
- ulint
- fsp_seg_inode_page_find_used(
- /*=========================*/
- /* out: segment inode index, or ULINT_UNDEFINED
- if not found */
- page_t* page, /* in: segment inode page */
- mtr_t* mtr) /* in: mini-transaction handle */
- {
- ulint i;
- fseg_inode_t* inode;
- for (i = 0; i < FSP_SEG_INODES_PER_PAGE; i++) {
- inode = fsp_seg_inode_page_get_nth_inode(page, i, mtr);
- if (ut_dulint_cmp(mach_read_from_8(inode + FSEG_ID),
- ut_dulint_zero) != 0) {
- /* This is used */
-
- return(i);
- }
- }
- return(ULINT_UNDEFINED);
- }
- /**************************************************************************
- Looks for an unused segment inode on a segment inode page. */
- static
- ulint
- fsp_seg_inode_page_find_free(
- /*=========================*/
- /* out: segment inode index, or ULINT_UNDEFINED
- if not found */
- page_t* page, /* in: segment inode page */
- ulint j, /* in: search forward starting from this index */
- mtr_t* mtr) /* in: mini-transaction handle */
- {
- ulint i;
- fseg_inode_t* inode;
- for (i = j; i < FSP_SEG_INODES_PER_PAGE; i++) {
- inode = fsp_seg_inode_page_get_nth_inode(page, i, mtr);
- if (ut_dulint_cmp(mach_read_from_8(inode + FSEG_ID),
- ut_dulint_zero) == 0) {
- /* This is unused */
-
- return(i);
- }
- }
- return(ULINT_UNDEFINED);
- }
- /**************************************************************************
- Allocates a new file segment inode page. */
- static
- ibool
- fsp_alloc_seg_inode_page(
- /*=====================*/
- /* out: TRUE if could be allocated */
- fsp_header_t* space_header, /* in: space header */
- mtr_t* mtr) /* in: mini-transaction handle */
- {
- fseg_inode_t* inode;
- page_t* page;
- ulint page_no;
- ulint space;
- ulint i;
- space = buf_frame_get_space_id(space_header);
-
- page_no = fsp_alloc_free_page(space, 0, mtr);
- if (page_no == FIL_NULL) {
- return(FALSE);
- }
- page = buf_page_get(space, page_no, RW_X_LATCH, mtr);
- buf_block_align(page)->check_index_page_at_flush = FALSE;
- fil_page_set_type(page, FIL_PAGE_INODE);
- #ifdef UNIV_SYNC_DEBUG
- buf_page_dbg_add_level(page, SYNC_FSP_PAGE);
- #endif /* UNIV_SYNC_DEBUG */
- for (i = 0; i < FSP_SEG_INODES_PER_PAGE; i++) {
- inode = fsp_seg_inode_page_get_nth_inode(page, i, mtr);
- mlog_write_dulint(inode + FSEG_ID, ut_dulint_zero, mtr);
- }
- flst_add_last(space_header + FSP_SEG_INODES_FREE,
- page + FSEG_INODE_PAGE_NODE, mtr);
- return(TRUE);
- }
- /**************************************************************************
- Allocates a new file segment inode. */
- static
- fseg_inode_t*
- fsp_alloc_seg_inode(
- /*================*/
- /* out: segment inode, or NULL if
- not enough space */
- fsp_header_t* space_header, /* in: space header */
- mtr_t* mtr) /* in: mini-transaction handle */
- {
- ulint page_no;
- page_t* page;
- fseg_inode_t* inode;
- ibool success;
- ulint n;
-
- if (flst_get_len(space_header + FSP_SEG_INODES_FREE, mtr) == 0) {
- /* Allocate a new segment inode page */
- success = fsp_alloc_seg_inode_page(space_header, mtr);
- if (!success) {
- return(NULL);
- }
- }
- page_no = flst_get_first(space_header + FSP_SEG_INODES_FREE, mtr).page;
- page = buf_page_get(buf_frame_get_space_id(space_header), page_no,
- RW_X_LATCH, mtr);
- #ifdef UNIV_SYNC_DEBUG
- buf_page_dbg_add_level(page, SYNC_FSP_PAGE);
- #endif /* UNIV_SYNC_DEBUG */
- n = fsp_seg_inode_page_find_free(page, 0, mtr);
- ut_a(n != ULINT_UNDEFINED);
- inode = fsp_seg_inode_page_get_nth_inode(page, n, mtr);
- if (ULINT_UNDEFINED == fsp_seg_inode_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_INODES_FREE,
- page + FSEG_INODE_PAGE_NODE, mtr);
- flst_add_last(space_header + FSP_SEG_INODES_FULL,
- page + FSEG_INODE_PAGE_NODE, mtr);
- }
- return(inode);
- }
- /**************************************************************************
- Frees a file segment inode. */
- static
- void
- fsp_free_seg_inode(
- /*===============*/
- ulint space, /* in: space id */
- fseg_inode_t* inode, /* in: segment inode */
- mtr_t* mtr) /* in: mini-transaction handle */
- {
- page_t* page;
- fsp_header_t* space_header;
-
- page = buf_frame_align(inode);
- space_header = fsp_get_space_header(space, mtr);
- ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE);
- if (ULINT_UNDEFINED == fsp_seg_inode_page_find_free(page, 0, mtr)) {
- /* Move the page to another list */
- flst_remove(space_header + FSP_SEG_INODES_FULL,
- page + FSEG_INODE_PAGE_NODE, mtr);
- flst_add_last(space_header + FSP_SEG_INODES_FREE,
- page + FSEG_INODE_PAGE_NODE, mtr);
- }
- mlog_write_dulint(inode + FSEG_ID, ut_dulint_zero, mtr);
- mlog_write_ulint(inode + FSEG_MAGIC_N, 0, MLOG_4BYTES, mtr);
-
- if (ULINT_UNDEFINED == fsp_seg_inode_page_find_used(page, mtr)) {
- /* There are no other used headers left on the page: free it */
- flst_remove(space_header + FSP_SEG_INODES_FREE,
- page + FSEG_INODE_PAGE_NODE, mtr);
- fsp_free_page(space, buf_frame_get_page_no(page), mtr);
- }
- }
- /**************************************************************************
- Returns the file segment inode, page x-latched. */
- static
- fseg_inode_t*
- fseg_inode_get(
- /*===========*/
- /* out: segment inode, page x-latched */
- fseg_header_t* header, /* in: segment header */
- mtr_t* mtr) /* in: mtr handle */
- {
- fil_addr_t inode_addr;
- fseg_inode_t* inode;
- inode_addr.page = mach_read_from_4(header + FSEG_HDR_PAGE_NO);
- inode_addr.boffset = mach_read_from_2(header + FSEG_HDR_OFFSET);
-
- inode = fut_get_ptr(mach_read_from_4(header + FSEG_HDR_SPACE),
- inode_addr, RW_X_LATCH, mtr);
-
- ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE);
- return(inode);
- }
- /**************************************************************************
- 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_inode_t* inode, /* in: segment inode */
- ulint n, /* in: slot index */
- mtr_t* mtr __attribute__((unused))) /* in: mtr handle */
- {
- ut_ad(inode && mtr);
- ut_ad(n < FSEG_FRAG_ARR_N_SLOTS);
- ut_ad(mtr_memo_contains(mtr, buf_block_align(inode),
- MTR_MEMO_PAGE_X_FIX));
- return(mach_read_from_4(inode + 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_inode_t* inode, /* in: segment inode */
- ulint n, /* in: slot index */
- ulint page_no,/* in: page number to set */
- mtr_t* mtr) /* in: mtr handle */
- {
- ut_ad(inode && mtr);
- ut_ad(n < FSEG_FRAG_ARR_N_SLOTS);
- ut_ad(mtr_memo_contains(mtr, buf_block_align(inode),
- MTR_MEMO_PAGE_X_FIX));
- mlog_write_ulint(inode + 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_inode_t* inode, /* in: segment inode */
- mtr_t* mtr) /* in: mtr handle */
- {
- ulint i;
- ulint page_no;
- ut_ad(inode && mtr);
- for (i = 0; i < FSEG_FRAG_ARR_N_SLOTS; i++) {
- page_no = fseg_get_nth_frag_page_no(inode, 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_inode_t* inode, /* in: segment inode */
- mtr_t* mtr) /* in: mtr handle */
- {
- ulint i;
- ulint page_no;
- ut_ad(inode && mtr);
- for (i = 0; i < FSEG_FRAG_ARR_N_SLOTS; i++) {
- page_no = fseg_get_nth_frag_page_no(inode,
- FSEG_FRAG_ARR_N_SLOTS - i - 1, mtr);
- if (page_no != FIL_NULL) {
- return(FSEG_FRAG_ARR_N_SLOTS - i - 1);
- }
- }
- return(ULINT_UNDEFINED);
- }
- /**************************************************************************
- Calculates reserved fragment page slots. */
- static
- ulint
- fseg_get_n_frag_pages(
- /*==================*/
- /* out: number of fragment pages */
- fseg_inode_t* inode, /* in: segment inode */
- mtr_t* mtr) /* in: mtr handle */
- {
- ulint i;
- ulint count = 0;
- ut_ad(inode && mtr);
- for (i = 0; i < FSEG_FRAG_ARR_N_SLOTS; i++) {
- if (FIL_NULL != fseg_get_nth_frag_page_no(inode, i, mtr)) {
- count++;
- }
- }
- return(count);
- }
- /**************************************************************************
- Creates a new segment. */
- page_t*
- fseg_create_general(
- /*================*/
- /* out: the page where the segment header is placed,
- x-latched, NULL if could not create segment
- because of lack of space */
- ulint space, /* in: space id */
- ulint page, /* in: page where the segment header is placed: if
- this is != 0, the page must belong to another segment,
- if this is 0, a new page will be allocated and it
- will belong to the created segment */
- ulint byte_offset, /* in: byte offset of the created segment header
- on the page */
- ibool has_done_reservation, /* in: TRUE if the caller has already
- done the reservation for the pages with
- fsp_reserve_free_extents (at least 2 extents: one for
- the inode and the other for the segment) then there is
- no need to do the check for this individual
- operation */
- mtr_t* mtr) /* in: mtr */
- {
- fsp_header_t* space_header;
- fseg_inode_t* inode;
- dulint seg_id;
- fseg_header_t* header = 0; /* remove warning */
- rw_lock_t* latch;
- ibool success;
- ulint n_reserved;
- page_t* ret = NULL;
- ulint i;
- ut_ad(mtr);
- if (page != 0) {
- header = byte_offset + buf_page_get(space, page, RW_X_LATCH,
- mtr);
- }
-
- #ifdef UNIV_SYNC_DEBUG
- ut_ad(!mutex_own(&kernel_mutex)
- || mtr_memo_contains(mtr, fil_space_get_latch(space),
- MTR_MEMO_X_LOCK));
- #endif /* UNIV_SYNC_DEBUG */
- latch = fil_space_get_latch(space);
- mtr_x_lock(latch, mtr);
- if (rw_lock_get_x_lock_count(latch) == 1) {
- /* This thread did not own the latch before this call: free
- excess pages from the insert buffer free list */
- if (space == 0) {
- ibuf_free_excess_pages(space);
- }
- }
- if (!has_done_reservation) {
- success = fsp_reserve_free_extents(&n_reserved, space, 2,
- FSP_NORMAL, mtr);
- if (!success) {
- return(NULL);
- }
- }
- space_header = fsp_get_space_header(space, mtr);
- inode = fsp_alloc_seg_inode(space_header, mtr);
- if (inode == NULL) {
- goto funct_exit;
- }
- /* 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, mtr);
- mlog_write_dulint(space_header + FSP_SEG_ID, ut_dulint_add(seg_id, 1),
- mtr);
- mlog_write_dulint(inode + FSEG_ID, seg_id, mtr);
- mlog_write_ulint(inode + FSEG_NOT_FULL_N_USED, 0, MLOG_4BYTES, mtr);
- flst_init(inode + FSEG_FREE, mtr);
- flst_init(inode + FSEG_NOT_FULL, mtr);
- flst_init(inode + FSEG_FULL, mtr);
- mlog_write_ulint(inode + 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(inode, i, FIL_NULL, mtr);
- }
- if (page == 0) {
- page = fseg_alloc_free_page_low(space, inode, 0, FSP_UP, mtr);
-
- if (page == FIL_NULL) {
- fsp_free_seg_inode(space, inode, mtr);
- goto funct_exit;
- }
- header = byte_offset
- + buf_page_get(space, page, RW_X_LATCH, mtr);
- }
- mlog_write_ulint(header + FSEG_HDR_OFFSET,
- inode - buf_frame_align(inode), MLOG_2BYTES, mtr);
- mlog_write_ulint(header + FSEG_HDR_PAGE_NO,
- buf_frame_get_page_no(inode), MLOG_4BYTES, mtr);
- mlog_write_ulint(header + FSEG_HDR_SPACE, space, MLOG_4BYTES, mtr);
- ret = buf_frame_align(header);
- funct_exit:
- if (!has_done_reservation) {
-
- fil_space_release_free_extents(space, n_reserved);
- }
-
- return(ret);
- }
- /**************************************************************************
- Creates a new segment. */
- page_t*
- fseg_create(
- /*========*/
- /* out: the page where the segment header is placed,
- x-latched, NULL if could not create segment
- because of lack of space */
- ulint space, /* in: space id */
- ulint page, /* in: page where the segment header is placed: if
- this is != 0, the page must belong to another segment,
- if this is 0, a new page will be allocated and it
- will belong to the created segment */
- ulint byte_offset, /* in: byte offset of the created segment header
- on the page */
- mtr_t* mtr) /* in: mtr */
- {
- return(fseg_create_general(space, page, byte_offset, FALSE, mtr));
- }
- /**************************************************************************
- 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_inode_t* inode, /* in: segment inode */
- ulint* used, /* out: number of pages used (<= reserved) */
- mtr_t* mtr) /* in: mtr handle */
- {
- ulint ret;
- ut_ad(inode && used && mtr);
- ut_ad(mtr_memo_contains(mtr, buf_block_align(inode),
- MTR_MEMO_PAGE_X_FIX));
-
- *used = mtr_read_ulint(inode + FSEG_NOT_FULL_N_USED, MLOG_4BYTES, mtr)
- + FSP_EXTENT_SIZE * flst_get_len(inode + FSEG_FULL, mtr)
- + fseg_get_n_frag_pages(inode, mtr);
- ret = fseg_get_n_frag_pages(inode, mtr)
- + FSP_EXTENT_SIZE * flst_get_len(inode + FSEG_FREE, mtr)
- + FSP_EXTENT_SIZE * flst_get_len(inode + FSEG_NOT_FULL, mtr)
- + FSP_EXTENT_SIZE * flst_get_len(inode + FSEG_FULL, mtr);
- return(ret);
- }
- /**************************************************************************
- 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;
- fseg_inode_t* inode;
- ulint space;
- space = buf_frame_get_space_id(header);
- #ifdef UNIV_SYNC_DEBUG
- ut_ad(!mutex_own(&kernel_mutex)
- || mtr_memo_contains(mtr, fil_space_get_latch(space),
- MTR_MEMO_X_LOCK));
- #endif /* UNIV_SYNC_DEBUG */
- mtr_x_lock(fil_space_get_latch(space), mtr);
- inode = fseg_inode_get(header, mtr);
-
- ret = fseg_n_reserved_pages_low(inode, used, 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 allow extents 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_inode_t* inode, /* in: segment inode */
- 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(inode && mtr);
- reserved = fseg_n_reserved_pages_low(inode, &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(inode + 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(inode + FSEG_ID, mtr);
- mlog_write_dulint(descr + XDES_ID, seg_id, mtr);
- flst_add_last(inode + 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 still resides in the segment free list, it is not yet 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_inode_t* inode, /* in: segment inode */
- ulint space, /* in: space id */
- mtr_t* mtr) /* in: mtr */
- {
- xdes_t* descr;
- dulint seg_id;
- fil_addr_t first;
-
- if (flst_get_len(inode + FSEG_FREE, mtr) > 0) {
- /* Segment free list is not empty, allocate from it */
-
- first = flst_get_first(inode + 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(inode + FSEG_ID, mtr);
-
- xdes_set_state(descr, XDES_FSEG, mtr);
- mlog_write_dulint(descr + XDES_ID, seg_id, mtr);
- flst_add_last(inode + FSEG_FREE, descr + XDES_FLST_NODE, mtr);
-
- /* Try to fill the segment free list */
- fseg_fill_free_list(inode, 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. */
- static
- ulint
- fseg_alloc_free_page_low(
- /*=====================*/
- /* out: the allocated page number, FIL_NULL
- if no page could be allocated */
- ulint space, /* in: space */
- fseg_inode_t* seg_inode, /* in: segment inode */
- 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 */
- {
- fsp_header_t* space_header;
- ulint space_size;
- dulint seg_id;
- 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 */
- xdes_t* ret_descr; /* the extent of the allocated page */
- page_t* page;
- ibool frag_page_allocated = FALSE;
- ibool success;
- ulint n;
-
- ut_ad(mtr);
- ut_ad((direction >= FSP_UP) && (direction <= FSP_NO_DIR));
- ut_ad(mach_read_from_4(seg_inode + FSEG_MAGIC_N) ==
- FSEG_MAGIC_N_VALUE);
- seg_id = mtr_read_dulint(seg_inode + FSEG_ID, mtr);
- ut_ad(ut_dulint_cmp(seg_id, ut_dulint_zero) > 0);
-
- reserved = fseg_n_reserved_pages_low(seg_inode, &used, mtr);
-
- space_header = fsp_get_space_header(space, mtr);
- descr = xdes_get_descriptor_with_space_hdr(space_header, 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,
- 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, mtr);
- flst_add_last(seg_inode + FSEG_FREE,
- ret_descr + XDES_FLST_NODE, mtr);
- /* Try to fill the segment free list */
- fseg_fill_free_list(seg_inode, 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_inode, 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,
- 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_inode + FSEG_NOT_FULL, mtr) > 0) {
- first = flst_get_first(seg_inode + FSEG_NOT_FULL,
- mtr);
- } else if (flst_get_len(seg_inode + FSEG_FREE, mtr) > 0) {
- first = flst_get_first(seg_inode + 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_inode, mtr);
- ut_a(n != FIL_NULL);
- fseg_set_nth_frag_page_no(seg_inode, n, ret_page,
- mtr);
- }
- /*-------------------------------------------------------------*/
- } else {
- /* 7. We allocate a new extent and take its first page
- ======================================================*/
- ret_descr = fseg_alloc_free_extent(seg_inode, 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);
- }
- if (space != 0) {
- space_size = fil_space_get_size(space);
- if (space_size <= ret_page) {
- /* It must be that we are extending a single-table
- tablespace whose size is still < 64 pages */
- if (ret_page >= FSP_EXTENT_SIZE) {
- fprintf(stderr,
- "InnoDB: Error (2): trying to extend a single-table tablespace %lun"
- "InnoDB: by single page(s) though the space size %lu. Page no %lu.n",
- (ulong) space, (ulong) space_size,
- (ulong) ret_page);
- return(FIL_NULL);
- }
-
- success = fsp_try_extend_data_file_with_pages(space,
- ret_page, space_header, mtr);
- if (!success) {
- /* No disk space left */
- return(FIL_NULL);
- }
- }
- }
- if (!frag_page_allocated) {
- /* Initialize the allocated page to buffer pool, so that it
- can be obtained immediately with buf_page_get without need
- for a disk read */
-
- page = buf_page_create(space, ret_page, mtr);
- ut_a(page == buf_page_get(space, ret_page, RW_X_LATCH, mtr));
- #ifdef UNIV_SYNC_DEBUG
- buf_page_dbg_add_level(page, SYNC_FSP_PAGE);
- #endif /* UNIV_SYNC_DEBUG */
- /* The prior contents of the page should be ignored */
- fsp_init_file_page(page, mtr);
-
- /* 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_inode, space, ret_page, mtr);
- }
- buf_reset_check_index_page_at_flush(space, ret_page);
-
- return(ret_page);
- }
- /**************************************************************************
- 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_general(
- /*=========================*/
- /* out: 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 */
- ibool has_done_reservation, /* in: TRUE if the caller has
- already done the reservation for the page
- with fsp_reserve_free_extents, then there
- is no need to do the check for this individual
- page */
- mtr_t* mtr) /* in: mtr handle */
- {
- fseg_inode_t* inode;
- ulint space;
- rw_lock_t* latch;
- ibool success;
- ulint page_no;
- ulint n_reserved;
- space = buf_frame_get_space_id(seg_header);
- #ifdef UNIV_SYNC_DEBUG
- ut_ad(!mutex_own(&kernel_mutex)
- || mtr_memo_contains(mtr, fil_space_get_latch(space),
- MTR_MEMO_X_LOCK));
- #endif /* UNIV_SYNC_DEBUG */
- latch = fil_space_get_latch(space);
- mtr_x_lock(latch, mtr);
-
- if (rw_lock_get_x_lock_count(latch) == 1) {
- /* This thread did not own the latch before this call: free
- excess pages from the insert buffer free list */
- if (space == 0) {
- ibuf_free_excess_pages(space);
- }
- }
- inode = fseg_inode_get(seg_header, mtr);
- if (!has_done_reservation) {
- success = fsp_reserve_free_extents(&n_reserved, space, 2,
- FSP_NORMAL, mtr);
- if (!success) {
- return(FIL_NULL);
- }
- }
- page_no = fseg_alloc_free_page_low(buf_frame_get_space_id(inode),
- inode, hint, direction, mtr);
- if (!has_done_reservation) {
- fil_space_release_free_extents(space, n_reserved);
- }
- return(page_no);
- }
- /**************************************************************************
- 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: 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 */
- {
- return(fseg_alloc_free_page_general(seg_header, hint, direction,
- FALSE, mtr));
- }
- /**************************************************************************
- Checks that we have at least 2 frag pages free in the first extent of a
- single-table tablespace, and they are also physically initialized to the data
- file. That is we have already extended the data file so that those pages are
- inside the data file. If not, this function extends the tablespace with
- pages. */
- static
- ibool
- fsp_reserve_free_pages(
- /*===================*/
- /* out: TRUE if there were >= 3 free
- pages, or we were able to extend */
- ulint space, /* in: space id, must be != 0 */
- fsp_header_t* space_header, /* in: header of that space,
- x-latched */
- ulint size, /* in: size of the tablespace in pages,
- must be < FSP_EXTENT_SIZE / 2 */
- mtr_t* mtr) /* in: mtr */
- {
- xdes_t* descr;
- ulint n_used;
- ut_a(space != 0);
- ut_a(size < FSP_EXTENT_SIZE / 2);
- descr = xdes_get_descriptor_with_space_hdr(space_header, space, 0,
- mtr);
- n_used = xdes_get_n_used(descr, mtr);
- ut_a(n_used <= size);
- if (size >= n_used + 2) {
- return(TRUE);
- }
- return(fsp_try_extend_data_file_with_pages(space, n_used + 1,
- space_header, mtr));
- }
- /**************************************************************************
- Reserves free pages from a tablespace. All mini-transactions which may
- use several pages from the tablespace should call this function beforehand
- and reserve enough free extents so that they certainly will be able
- to do their operation, like a B-tree page split, fully. Reservations
- must be released with function fil_space_release_free_extents!
- The alloc_type below has the following meaning: FSP_NORMAL means an
- operation which will probably result in more space usage, like an
- insert in a B-tree; FSP_UNDO means allocation to undo logs: if we are
- deleting rows, then this allocation will in the long run result in
- less space usage (after a purge); FSP_CLEANING means allocation done
- in a physical record delete (like in a purge) or other cleaning operation
- which will result in less space usage in the long run. We prefer the latter
- two types of allocation: when space is scarce, FSP_NORMAL allocations
- will not succeed, but the latter two allocations will succeed, if possible.
- The purpose is to avoid dead end where the database is full but the
- user cannot free any space because these freeing operations temporarily
- reserve some space.
- Single-table tablespaces whose size is < 32 pages are a special case. In this
- function we would liberally reserve several 64 page extents for every page
- split or merge in a B-tree. But we do not want to waste disk space if the table
- only occupies < 32 pages. That is why we apply different rules in that special
- case, just ensuring that there are 3 free pages available. */
- ibool
- fsp_reserve_free_extents(
- /*=====================*/
- /* out: TRUE if we were able to make the reservation */
- ulint* n_reserved,/* out: number of extents actually reserved; if we
- return TRUE and the tablespace size is < 64 pages,
- then this can be 0, otherwise it is n_ext */
- ulint space, /* in: space id */
- ulint n_ext, /* in: number of extents to reserve */
- ulint alloc_type,/* in: FSP_NORMAL, FSP_UNDO, or FSP_CLEANING */
- mtr_t* mtr) /* in: mtr */
- {
- fsp_header_t* space_header;
- rw_lock_t* latch;
- ulint n_free_list_ext;
- ulint free_limit;
- ulint size;
- ulint n_free;
- ulint n_free_up;
- ulint reserve;
- ibool success;
- ulint n_pages_added;
- ut_ad(mtr);
- #ifdef UNIV_SYNC_DEBUG
- ut_ad(!mutex_own(&kernel_mutex)
- || mtr_memo_contains(mtr, fil_space_get_latch(space),
- MTR_MEMO_X_LOCK));
- #endif /* UNIV_SYNC_DEBUG */
- *n_reserved = n_ext;
- latch = fil_space_get_latch(space);
- mtr_x_lock(latch, mtr);
- space_header = fsp_get_space_header(space, mtr);
- try_again:
- size = mtr_read_ulint(space_header + FSP_SIZE, MLOG_4BYTES, mtr);
-
- if (size < FSP_EXTENT_SIZE / 2) {
- /* Use different rules for small single-table tablespaces */
- *n_reserved = 0;
- return(fsp_reserve_free_pages(space, space_header, size, mtr));
- }
- n_free_list_ext = flst_get_len(space_header + FSP_FREE, mtr);
-
- free_limit = mtr_read_ulint(space_header + FSP_FREE_LIMIT,
- MLOG_4BYTES, mtr);
- /* Below we play safe when counting free extents above the free limit:
- some of them will contain extent descriptor pages, and therefore
- will not be free extents */
- n_free_up = (size - free_limit) / FSP_EXTENT_SIZE;
- if (n_free_up > 0) {
- n_free_up--;
- n_free_up = n_free_up - n_free_up
- / (XDES_DESCRIBED_PER_PAGE / FSP_EXTENT_SIZE);
- }
-
- n_free = n_free_list_ext + n_free_up;
- if (alloc_type == FSP_NORMAL) {
- /* We reserve 1 extent + 0.5 % of the space size to undo logs
- and 1 extent + 0.5 % to cleaning operations; NOTE: this source
- code is duplicated in the function below! */
- reserve = 2 + ((size / FSP_EXTENT_SIZE) * 2) / 200;
- if (n_free <= reserve + n_ext) {
- goto try_to_extend;
- }
- } else if (alloc_type == FSP_UNDO) {
- /* We reserve 0.5 % of the space size to cleaning operations */
- reserve = 1 + ((size / FSP_EXTENT_SIZE) * 1) / 200;
- if (n_free <= reserve + n_ext) {
- goto try_to_extend;
- }
- } else {
- ut_a(alloc_type == FSP_CLEANING);
- }
- success = fil_space_reserve_free_extents(space, n_free, n_ext);
- if (success) {
- return(TRUE);
- }
- try_to_extend:
- success = fsp_try_extend_data_file(&n_pages_added, space,
- space_header, mtr);
- if (success && n_pages_added > 0) {
- goto try_again;
- }
- return(FALSE);
- }
- /**************************************************************************
- This function should be used to get information on how much we still
- will be able to insert new data to the database without running out the
- tablespace. Only free extents are taken into account and we also subtract
- the safety margin required by the above function fsp_reserve_free_extents. */
- ulint
- fsp_get_available_space_in_free_extents(
- /*====================================*/
- /* out: available space in kB */
- ulint space) /* in: space id */
- {
- fsp_header_t* space_header;
- ulint n_free_list_ext;
- ulint free_limit;
- ulint size;
- ulint n_free;
- ulint n_free_up;
- ulint reserve;
- rw_lock_t* latch;
- mtr_t mtr;
-
- #ifdef UNIV_SYNC_DEBUG
- ut_ad(!mutex_own(&kernel_mutex));
- #endif /* UNIV_SYNC_DEBUG */
- mtr_start(&mtr);
-
- latch = fil_space_get_latch(space);
- mtr_x_lock(latch, &mtr);
- space_header = fsp_get_space_header(space, &mtr);
- size = mtr_read_ulint(space_header + FSP_SIZE, MLOG_4BYTES, &mtr);
-
- n_free_list_ext = flst_get_len(space_header + FSP_FREE, &mtr);
-
- free_limit = mtr_read_ulint(space_header + FSP_FREE_LIMIT,
- MLOG_4BYTES, &mtr);
- mtr_commit(&mtr);
- if (size < FSP_EXTENT_SIZE) {
- ut_a(space != 0); /* This must be a single-table
- tablespace */
- return(0); /* TODO: count free frag pages and return
- a value based on that */
- }
-
- /* Below we play safe when counting free extents above the free limit:
- some of them will contain extent descriptor pages, and therefore
- will not be free extents */
- n_free_up = (size - free_limit) / FSP_EXTENT_SIZE;
- if (n_free_up > 0) {
- n_free_up--;
- n_free_up = n_free_up - n_free_up
- / (XDES_DESCRIBED_PER_PAGE / FSP_EXTENT_SIZE);
- }
-
- n_free = n_free_list_ext + n_free_up;
- /* We reserve 1 extent + 0.5 % of the space size to undo logs
- and 1 extent + 0.5 % to cleaning operations; NOTE: this source
- code is duplicated in the function above! */
- reserve = 2 + ((size / FSP_EXTENT_SIZE) * 2) / 200;
- if (reserve > n_free) {
- return(0);
- }
- return(((n_free - reserve) * FSP_EXTENT_SIZE)
- * (UNIV_PAGE_SIZE / 1024));
- }
-
- /************************************************************************
- Marks a page used. The page must reside within the extents of the given
- segment. */
- static
- void
- fseg_mark_page_used(
- /*================*/
- fseg_inode_t* seg_inode,/* in: segment inode */
- 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_inode && mtr);
-
- descr = xdes_get_descriptor(space, page, mtr);
-
- ut_ad(mtr_read_ulint(seg_inode + 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_inode + FSEG_FREE, descr + XDES_FLST_NODE,
- mtr);
- flst_add_last(seg_inode + 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_inode + FSEG_NOT_FULL_N_USED,
- MLOG_4BYTES, mtr);
- not_full_n_used++;
- mlog_write_ulint(seg_inode + 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_inode + FSEG_NOT_FULL,
- descr + XDES_FLST_NODE, mtr);
- flst_add_last(seg_inode + FSEG_FULL,
- descr + XDES_FLST_NODE, mtr);
-
- mlog_write_ulint(seg_inode + FSEG_NOT_FULL_N_USED,
- not_full_n_used - FSP_EXTENT_SIZE,
- MLOG_4BYTES, mtr);
- }
- }
- /**************************************************************************
- Frees a single page of a segment. */
- static
- void
- fseg_free_page_low(
- /*===============*/
- fseg_inode_t* seg_inode, /* in: segment inode */
- ulint space, /* in: space id */
- ulint page, /* in: page offset */
- mtr_t* mtr) /* in: mtr handle */
- {
- xdes_t* descr;
- ulint not_full_n_used;
- ulint state;
- dulint descr_id;
- dulint seg_id;
- ulint i;
-
- ut_ad(seg_inode && mtr);
- ut_ad(mach_read_from_4(seg_inode + FSEG_MAGIC_N) ==
- FSEG_MAGIC_N_VALUE);
- /* Drop search system page hash index if the page is found in
- the pool and is hashed */
- btr_search_drop_page_hash_when_freed(space, page);
- descr = xdes_get_descriptor(space, page, mtr);
- ut_a(descr);
- if (xdes_get_bit(descr, XDES_FREE_BIT, page % FSP_EXTENT_SIZE, mtr)) {
- fputs("InnoDB: Dump of the tablespace extent descriptor: ",
- stderr);
- ut_print_buf(stderr, descr, 40);
- fprintf(stderr, "n"
- "InnoDB: Serious error! InnoDB is trying to free page %lun"
- "InnoDB: though it is already marked as free in the tablespace!n"
- "InnoDB: The tablespace free space info is corrupt.n"
- "InnoDB: You may need to dump your InnoDB tables and recreate the wholen"
- "InnoDB: database!n", (ulong) page);
- crash:
- fputs(
- "InnoDB: Please refer ton"
- "InnoDB: http://dev.mysql.com/doc/mysql/en/Forcing_recovery.htmln"
- "InnoDB: about forcing recovery.n", stderr);
- ut_error;
- }
-
- 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_inode, i, mtr)
- == page) {
- fseg_set_nth_frag_page_no(seg_inode, 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 */
- descr_id = mtr_read_dulint(descr + XDES_ID, mtr);
- seg_id = mtr_read_dulint(seg_inode + FSEG_ID, mtr);
- /*
- fprintf(stderr,
- "InnoDB: InnoDB is freeing space %lu page %lu,n"
- "InnoDB: which belongs to descr seg %lu %lun"
- "InnoDB: segment %lu %lu.n",
- space, page,
- ut_dulint_get_high(descr_id),
- ut_dulint_get_low(descr_id),
- ut_dulint_get_high(seg_id),
- ut_dulint_get_low(seg_id));
- */
- if (0 != ut_dulint_cmp(descr_id, seg_id)) {
- fputs("InnoDB: Dump of the tablespace extent descriptor: ",
- stderr);
- ut_print_buf(stderr, descr, 40);
- fputs("nInnoDB: Dump of the segment inode: ", stderr);
- ut_print_buf(stderr, seg_inode, 40);
- putc('n', stderr);
- fprintf(stderr,
- "InnoDB: Serious error: InnoDB is trying to free space %lu page %lu,n"
- "InnoDB: which does not belong to segment %lu %lu but belongsn"
- "InnoDB: to segment %lu %lu.n",
- (ulong) space, (ulong) page,
- (ulong) ut_dulint_get_high(descr_id),
- (ulong) ut_dulint_get_low(descr_id),
- (ulong) ut_dulint_get_high(seg_id),
- (ulong) ut_dulint_get_low(seg_id));
- goto crash;
- }
- not_full_n_used = mtr_read_ulint(seg_inode + 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_inode + FSEG_FULL,
- descr + XDES_FLST_NODE, mtr);
- flst_add_last(seg_inode + FSEG_NOT_FULL,
- descr + XDES_FLST_NODE, mtr);
- mlog_write_ulint(seg_inode + 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_inode + 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_inode + FSEG_NOT_FULL,
- descr + XDES_FLST_NODE, mtr);
- fsp_free_extent(space, page, 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 */
- {
- fseg_inode_t* seg_inode;
- #ifdef UNIV_SYNC_DEBUG
- ut_ad(!mutex_own(&kernel_mutex)
- || mtr_memo_contains(mtr, fil_space_get_latch(space),
- MTR_MEMO_X_LOCK));
- #endif /* UNIV_SYNC_DEBUG */
- mtr_x_lock(fil_space_get_latch(space), mtr);
- seg_inode = fseg_inode_get(seg_header, mtr);
- fseg_free_page_low(seg_inode, space, page, mtr);
- #ifdef UNIV_DEBUG_FILE_ACCESSES
- buf_page_set_file_page_was_freed(space, page);
- #endif
- }
- /**************************************************************************
- Frees an extent of a segment to the space free list. */
- static
- void
- fseg_free_extent(
- /*=============*/
- fseg_inode_t* seg_inode, /* in: segment inode */
- ulint space, /* in: space id */
- ulint page, /* in: a page in the extent */
- mtr_t* mtr) /* in: mtr handle */
- {
- ulint first_page_in_extent;
- xdes_t* descr;
- ulint not_full_n_used;
- ulint descr_n_used;
- ulint i;
-
- ut_ad(seg_inode && 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, mtr),
- mtr_read_dulint(seg_inode + FSEG_ID, mtr)));
- first_page_in_extent = page - (page % FSP_EXTENT_SIZE);
-
- for (i = 0; i < FSP_EXTENT_SIZE; i++) {
- if (FALSE == xdes_get_bit(descr, XDES_FREE_BIT, i, mtr)) {
- /* Drop search system page hash index if the page is
- found in the pool and is hashed */
- btr_search_drop_page_hash_when_freed(space,
- first_page_in_extent + i);
- }
- }
- if (xdes_is_full(descr, mtr)) {
- flst_remove(seg_inode + FSEG_FULL,
- descr + XDES_FLST_NODE, mtr);
- } else if (xdes_is_free(descr, mtr)) {
- flst_remove(seg_inode + FSEG_FREE,
- descr + XDES_FLST_NODE, mtr);
- } else {
- flst_remove(seg_inode + FSEG_NOT_FULL,
- descr + XDES_FLST_NODE, mtr);
- not_full_n_used = mtr_read_ulint(
- seg_inode + 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_inode + FSEG_NOT_FULL_N_USED,
- not_full_n_used - descr_n_used,
- MLOG_4BYTES, mtr);
- }
- fsp_free_extent(space, page, mtr);
- #ifdef UNIV_DEBUG_FILE_ACCESSES
- for (i = 0; i < FSP_EXTENT_SIZE; i++) {
- buf_page_set_file_page_was_freed(space,
- first_page_in_extent + i);
- }
- #endif
- }
- /**************************************************************************
- 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. */
- ibool
- fseg_free_step(
- /*===========*/
- /* out: TRUE if freeing completed */
- fseg_header_t* header, /* in, own: segment header; NOTE: if the header
- resides on the first page of the frag list
- of the segment, this pointer becomes obsolete
- after the last freeing step */
- mtr_t* mtr) /* in: mtr */
- {
- ulint n;
- ulint page;
- xdes_t* descr;
- fseg_inode_t* inode;
- ulint space;
- space = buf_frame_get_space_id(header);
- #ifdef UNIV_SYNC_DEBUG
- ut_ad(!mutex_own(&kernel_mutex)
- || mtr_memo_contains(mtr, fil_space_get_latch(space),
- MTR_MEMO_X_LOCK));
- #endif /* UNIV_SYNC_DEBUG */
- mtr_x_lock(fil_space_get_latch(space), mtr);
- descr = xdes_get_descriptor(space, buf_frame_get_page_no(header), mtr);
- /* Check that the header resides on a page which has not been
- freed yet */
- ut_a(descr);
- ut_a(xdes_get_bit(descr, XDES_FREE_BIT, buf_frame_get_page_no(header)
- % FSP_EXTENT_SIZE, mtr) == FALSE);
- inode = fseg_inode_get(header, mtr);
- descr = fseg_get_first_extent(inode, mtr);
- if (descr != NULL) {
- /* Free the extent held by the segment */
- page = xdes_get_offset(descr);
- fseg_free_extent(inode, space, page, mtr);
-
- return(FALSE);
- }
- /* Free a frag page */
- n = fseg_find_last_used_frag_page_slot(inode, mtr);
- if (n == ULINT_UNDEFINED) {
- /* Freeing completed: free the segment inode */
- fsp_free_seg_inode(space, inode, mtr);
- return(TRUE);
- }
- fseg_free_page_low(inode, space,
- fseg_get_nth_frag_page_no(inode, n, mtr), mtr);
- n = fseg_find_last_used_frag_page_slot(inode, mtr);
- if (n == ULINT_UNDEFINED) {
- /* Freeing completed: free the segment inode */
- fsp_free_seg_inode(space, inode, mtr);
- return(TRUE);
- }
- return(FALSE);
- }
- /**************************************************************************
- Frees part of a segment. Differs from fseg_free_step because this function
- leaves the header page unfreed. */
- ibool
- fseg_free_step_not_header(
- /*======================*/
- /* out: TRUE if freeing completed, except the
- header page */
- fseg_header_t* header, /* in: segment header which must reside on
- the first fragment page of the segment */
- mtr_t* mtr) /* in: mtr */
- {
- ulint n;
- ulint page;
- xdes_t* descr;
- fseg_inode_t* inode;
- ulint space;
- ulint page_no;
- space = buf_frame_get_space_id(header);
-
- #ifdef UNIV_SYNC_DEBUG
- ut_ad(!mutex_own(&kernel_mutex)
- || mtr_memo_contains(mtr, fil_space_get_latch(space),
- MTR_MEMO_X_LOCK));
- #endif /* UNIV_SYNC_DEBUG */
- mtr_x_lock(fil_space_get_latch(space), mtr);
- inode = fseg_inode_get(header, mtr);
- descr = fseg_get_first_extent(inode, mtr);
- if (descr != NULL) {
- /* Free the extent held by the segment */
- page = xdes_get_offset(descr);
- fseg_free_extent(inode, space, page, mtr);
-
- return(FALSE);
- }
- /* Free a frag page */
- n = fseg_find_last_used_frag_page_slot(inode, mtr);
- if (n == ULINT_UNDEFINED) {
- ut_error;
- }
- page_no = fseg_get_nth_frag_page_no(inode, n, mtr);
-
- if (page_no == buf_frame_get_page_no(header)) {
- return(TRUE);
- }
-
- fseg_free_page_low(inode, space, page_no, 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;
- ibool finished;
- fseg_header_t* header;
- fil_addr_t addr;
- addr.page = page_no;
- addr.boffset = offset;
- for (;;) {
- mtr_start(&mtr);
- header = fut_get_ptr(space, addr, RW_X_LATCH, &mtr);
- finished = fseg_free_step(header, &mtr);
-
- mtr_commit(&mtr);
- if (finished) {
- return;
- }
- }
- }
- /**************************************************************************
- 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_inode_t* inode, /* in: segment inode */
- mtr_t* mtr) /* in: mtr */
- {
- fil_addr_t first;
- ulint space;
- xdes_t* descr;
-
- ut_ad(inode && mtr);
- space = buf_frame_get_space_id(inode);
- first = fil_addr_null;
-
- if (flst_get_len(inode + FSEG_FULL, mtr) > 0) {
- first = flst_get_first(inode + FSEG_FULL, mtr);
- } else if (flst_get_len(inode + FSEG_NOT_FULL, mtr) > 0) {
- first = flst_get_first(inode + FSEG_NOT_FULL, mtr);
- } else if (flst_get_len(inode + FSEG_FREE, mtr) > 0) {
- first = flst_get_first(inode + FSEG_FREE, mtr);
- }
- if (first.page == FIL_NULL) {
- return(NULL);
- }
- descr = xdes_lst_get_descriptor(space, first, mtr);
- return(descr);
- }
- /***********************************************************************
- Validates a segment. */
- static
- ibool
- fseg_validate_low(
- /*==============*/
- /* out: TRUE if ok */
- fseg_inode_t* inode, /* in: segment inode */
- 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;
-
- ut_ad(mtr_memo_contains(mtr2, buf_block_align(inode),
- MTR_MEMO_PAGE_X_FIX));
- ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE);
- space = buf_frame_get_space_id(inode);
-
- seg_id = mtr_read_dulint(inode + FSEG_ID, mtr2);
- n_used = mtr_read_ulint(inode + FSEG_NOT_FULL_N_USED,
- MLOG_4BYTES, mtr2);
- flst_validate(inode + FSEG_FREE, mtr2);
- flst_validate(inode + FSEG_NOT_FULL, mtr2);
- flst_validate(inode + FSEG_FULL, mtr2);
- /* Validate FSEG_FREE list */
- node_addr = flst_get_first(inode + FSEG_FREE, mtr2);
- while (!fil_addr_is_null(node_addr)) {
- mtr_start(&mtr);
- mtr_x_lock(fil_space_get_latch(space), &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, &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(inode + FSEG_NOT_FULL, mtr2);
- while (!fil_addr_is_null(node_addr)) {
- mtr_start(&mtr);
- mtr_x_lock(fil_space_get_latch(space), &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, &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(inode + FSEG_FULL, mtr2);
- while (!fil_addr_is_null(node_addr)) {
- mtr_start(&mtr);
- mtr_x_lock(fil_space_get_latch(space), &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, &mtr), seg_id));
- node_addr = flst_get_next_addr(descr + XDES_FLST_NODE, &mtr);
- mtr_commit(&mtr);
- }
- ut_a(n_used == n_used2);
- return(TRUE);
- }
-
- /***********************************************************************
- Validates a segment. */
- ibool
- fseg_validate(
- /*==========*/
- /* out: TRUE if ok */
- fseg_header_t* header, /* in: segment header */
- mtr_t* mtr2) /* in: mtr */
- {
- fseg_inode_t* inode;
- ibool ret;
- ulint space;
- space = buf_frame_get_space_id(header);
- mtr_x_lock(fil_space_get_latch(space), mtr2);
- inode = fseg_inode_get(header, mtr2);
- ret = fseg_validate_low(inode, mtr2);
- return(ret);
- }
- /***********************************************************************
- Writes info of a segment. */
- static
- void
- fseg_print_low(
- /*===========*/
- fseg_inode_t* inode, /* in: segment inode */
- 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;
- dulint d_var;
-
- ut_ad(mtr_memo_contains(mtr, buf_block_align(inode),
- MTR_MEMO_PAGE_X_FIX));
- space = buf_frame_get_space_id(inode);
- page_no = buf_frame_get_page_no(inode);
- reserved = fseg_n_reserved_pages_low(inode, &used, mtr);
- d_var = mtr_read_dulint(inode + FSEG_ID, mtr);
- seg_id_low = ut_dulint_get_low(d_var);
- seg_id_high = ut_dulint_get_high(d_var);
-
- n_used = mtr_read_ulint(inode + FSEG_NOT_FULL_N_USED,
- MLOG_4BYTES, mtr);
- n_frag = fseg_get_n_frag_pages(inode, mtr);
- n_free = flst_get_len(inode + FSEG_FREE, mtr);
- n_not_full = flst_get_len(inode + FSEG_NOT_FULL, mtr);
- n_full = flst_get_len(inode + FSEG_FULL, mtr);
- fprintf(stderr,
- "SEGMENT id %lu %lu space %lu; page %lu; res %lu used %lu; full ext %lun"
- "fragm pages %lu; free extents %lu; not full extents %lu: pages %lun",
- (ulong) seg_id_high, (ulong) seg_id_low, (ulong) space, (ulong) page_no,
- (ulong) reserved, (ulong) used, (ulong) n_full,
- (ulong) n_frag, (ulong) n_free, (ulong) n_not_full,
- (ulong) n_used);
- }
- /***********************************************************************
- Writes info of a segment. */
- void
- fseg_print(
- /*=======*/
- fseg_header_t* header, /* in: segment header */
- mtr_t* mtr) /* in: mtr */
- {
- fseg_inode_t* inode;
- ulint space;
- space = buf_frame_get_space_id(header);
- mtr_x_lock(fil_space_get_latch(space), mtr);
- inode = fseg_inode_get(header, mtr);
- fseg_print_low(inode, mtr);
- }
- /***********************************************************************
- Validates the file space system and its segments. */
- ibool
- fsp_validate(
- /*=========*/
- /* out: TRUE if ok */
- ulint space) /* in: space id */
- {
- fsp_header_t* header;
- fseg_inode_t* seg_inode;
- page_t* seg_inode_page;
- ulint size;
- ulint free_limit;
- ulint frag_n_used;
- mtr_t mtr;
- mtr_t mtr2;
- xdes_t* descr;
- fil_addr_t node_addr;
- fil_addr_t next_node_addr;
- ulint descr_count = 0;
- ulint n_used = 0;
- ulint n_used2 = 0;
- ulint n_full_frag_pages;
- ulint n;
- ulint seg_inode_len_free;
- ulint seg_inode_len_full;
-
- /* Start first a mini-transaction mtr2 to lock out all other threads
- from the fsp system */
- mtr_start(&mtr2);
- mtr_x_lock(fil_space_get_latch(space), &mtr2);
-
- mtr_start(&mtr);
- mtr_x_lock(fil_space_get_latch(space), &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 || (space != 0 && size < FSP_EXTENT_SIZE));
-
- flst_validate(header + FSP_FREE, &mtr);
- flst_validate(header + FSP_FREE_FRAG, &mtr);
- flst_validate(header + FSP_FULL_FRAG, &mtr);
- mtr_commit(&mtr);
- /* Validate FSP_FREE list */
- mtr_start(&mtr);
- mtr_x_lock(fil_space_get_latch(space), &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(fil_space_get_latch(space), &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(fil_space_get_latch(space), &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(fil_space_get_latch(space), &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(fil_space_get_latch(space), &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(fil_space_get_latch(space), &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(fil_space_get_latch(space), &mtr);
- header = fsp_get_space_header(space, &mtr);
- node_addr = flst_get_first(header + FSP_SEG_INODES_FULL, &mtr);
- seg_inode_len_full = flst_get_len(header + FSP_SEG_INODES_FULL, &mtr);
- mtr_commit(&mtr);
- while (!fil_addr_is_null(node_addr)) {
- for (n = 0; n < FSP_SEG_INODES_PER_PAGE; n++) {
- mtr_start(&mtr);
- mtr_x_lock(fil_space_get_latch(space), &mtr);
- seg_inode_page = fut_get_ptr(space, node_addr, RW_X_LATCH,
- &mtr) - FSEG_INODE_PAGE_NODE;
- seg_inode = fsp_seg_inode_page_get_nth_inode(seg_inode_page,
- n, &mtr);
- ut_a(ut_dulint_cmp(mach_read_from_8(seg_inode + FSEG_ID),
- ut_dulint_zero) != 0);
- fseg_validate_low(seg_inode, &mtr);
- descr_count += flst_get_len(seg_inode + FSEG_FREE, &mtr);
- descr_count += flst_get_len(seg_inode + FSEG_FULL, &mtr);
- descr_count += flst_get_len(seg_inode + FSEG_NOT_FULL, &mtr);
- n_used2 += fseg_get_n_frag_pages(seg_inode, &mtr);
- next_node_addr = flst_get_next_addr(seg_inode_page
- + FSEG_INODE_PAGE_NODE, &mtr);
- mtr_commit(&mtr);
- }
- node_addr = next_node_addr;
- }
- mtr_start(&mtr);
- mtr_x_lock(fil_space_get_latch(space), &mtr);
- header = fsp_get_space_header(space, &mtr);
- node_addr = flst_get_first(header + FSP_SEG_INODES_FREE, &mtr);
- seg_inode_len_free = flst_get_len(header + FSP_SEG_INODES_FREE, &mtr);
-
- mtr_commit(&mtr);
- while (!fil_addr_is_null(node_addr)) {
- for (n = 0; n < FSP_SEG_INODES_PER_PAGE; n++) {
- mtr_start(&mtr);
- mtr_x_lock(fil_space_get_latch(space), &mtr);
- seg_inode_page = fut_get_ptr(space, node_addr, RW_X_LATCH,
- &mtr) - FSEG_INODE_PAGE_NODE;
- seg_inode = fsp_seg_inode_page_get_nth_inode(seg_inode_page,
- n, &mtr);
- if (ut_dulint_cmp(mach_read_from_8(seg_inode + FSEG_ID),
- ut_dulint_zero) != 0) {
- fseg_validate_low(seg_inode, &mtr);
- descr_count += flst_get_len(seg_inode + FSEG_FREE,
- &mtr);
- descr_count += flst_get_len(seg_inode + FSEG_FULL,
- &mtr);
- descr_count += flst_get_len(seg_inode + FSEG_NOT_FULL,
- &mtr);
- n_used2 += fseg_get_n_frag_pages(seg_inode, &mtr);
- }
- next_node_addr = flst_get_next_addr(seg_inode_page
- + FSEG_INODE_PAGE_NODE, &mtr);
- mtr_commit(&mtr);
- }
- node_addr = next_node_addr;
- }
-
- ut_a(descr_count * FSP_EXTENT_SIZE == free_limit);
- ut_a(n_used + n_full_frag_pages
- == n_used2 + 2* ((free_limit + XDES_DESCRIBED_PER_PAGE - 1)
- / XDES_DESCRIBED_PER_PAGE)
- + seg_inode_len_full + seg_inode_len_free);
- 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_inode_t* seg_inode;
- page_t* seg_inode_page;
- ulint size;
- ulint free_limit;
- ulint frag_n_used;
- fil_addr_t node_addr;
- fil_addr_t next_node_addr;
- ulint n_free;
- ulint n_free_frag;
- ulint n_full_frag;
- ulint seg_id_low;
- ulint seg_id_high;
- ulint n;
- ulint n_segs = 0;
- dulint d_var;
- mtr_t mtr;
- mtr_t mtr2;
-
- /* Start first a mini-transaction mtr2 to lock out all other threads
- from the fsp system */
- mtr_start(&mtr2);
- mtr_x_lock(fil_space_get_latch(space), &mtr2);
- mtr_start(&mtr);
- mtr_x_lock(fil_space_get_latch(space), &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);
- d_var = mtr_read_dulint(header + FSP_SEG_ID, &mtr);
- seg_id_low = ut_dulint_get_low(d_var);
- seg_id_high = ut_dulint_get_high(d_var);
- fprintf(stderr,
- "FILE SPACE INFO: id %lun"
- "size %lu, free limit %lu, free extents %lun"
- "not full frag extents %lu: used pages %lu, full frag extents %lun"
- "first seg id not used %lu %lun",
- (long) space,
- (ulong) size, (ulong) free_limit, (ulong) n_free,
- (ulong) n_free_frag, (ulong) frag_n_used, (ulong) n_full_frag,
- (ulong) seg_id_high, (ulong) seg_id_low);
- mtr_commit(&mtr);
- /* Print segments */
- mtr_start(&mtr);
- mtr_x_lock(fil_space_get_latch(space), &mtr);
- header = fsp_get_space_header(space, &mtr);
- node_addr = flst_get_first(header + FSP_SEG_INODES_FULL, &mtr);
- mtr_commit(&mtr);
- while (!fil_addr_is_null(node_addr)) {
- for (n = 0; n < FSP_SEG_INODES_PER_PAGE; n++) {
- mtr_start(&mtr);
- mtr_x_lock(fil_space_get_latch(space), &mtr);
- seg_inode_page = fut_get_ptr(space, node_addr, RW_X_LATCH,
- &mtr) - FSEG_INODE_PAGE_NODE;
- seg_inode = fsp_seg_inode_page_get_nth_inode(seg_inode_page,
- n, &mtr);
- ut_a(ut_dulint_cmp(mach_read_from_8(seg_inode + FSEG_ID),
- ut_dulint_zero) != 0);
- fseg_print_low(seg_inode, &mtr);
- n_segs++;
-
- next_node_addr = flst_get_next_addr(seg_inode_page
- + FSEG_INODE_PAGE_NODE, &mtr);
- mtr_commit(&mtr);
- }
- node_addr = next_node_addr;
- }
- mtr_start(&mtr);
- mtr_x_lock(fil_space_get_latch(space), &mtr);
- header = fsp_get_space_header(space, &mtr);
- node_addr = flst_get_first(header + FSP_SEG_INODES_FREE, &mtr);
- mtr_commit(&mtr);
- while (!fil_addr_is_null(node_addr)) {
- for (n = 0; n < FSP_SEG_INODES_PER_PAGE; n++) {
- mtr_start(&mtr);
- mtr_x_lock(fil_space_get_latch(space), &mtr);
- seg_inode_page = fut_get_ptr(space, node_addr, RW_X_LATCH,
- &mtr) - FSEG_INODE_PAGE_NODE;
- seg_inode = fsp_seg_inode_page_get_nth_inode(seg_inode_page,
- n, &mtr);
- if (ut_dulint_cmp(mach_read_from_8(seg_inode + FSEG_ID),
- ut_dulint_zero) != 0) {
- fseg_print_low(seg_inode, &mtr);
- n_segs++;
- }
- next_node_addr = flst_get_next_addr(seg_inode_page
- + FSEG_INODE_PAGE_NODE, &mtr);
- mtr_commit(&mtr);
- }
- node_addr = next_node_addr;
- }
-
- mtr_commit(&mtr2);
- fprintf(stderr, "NUMBER of file segments: %lun", (ulong) n_segs);
- }