/****************************************************** XtraBackup: hot backup tool for InnoDB (c) 2009-2012 Percona Inc. Originally Created 3/3/2009 Yasufumi Kinoshita Written by Alexey Kopytov, Aleksandr Kuzminsky, Stewart Smith, Vadim Tkachenko, Yasufumi Kinoshita, Ignacio Nin and Baron Schwartz. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; version 2 of the License. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA *******************************************************/ /* Changed page bitmap implementation */ #include "changed_page_bitmap.h" #include "common.h" #include "xtrabackup.h" #include "srv0srv.h" /* TODO: copy-pasted shared definitions from the XtraDB bitmap write code. Remove these on the first opportunity, i.e. single-binary XtraBackup. */ /* log0online.h */ /** Single bitmap file information */ struct log_online_bitmap_file_t { char name[FN_REFLEN]; /*!< Name with full path */ pfs_os_file_t file; /*!< Handle to opened file */ ib_uint64_t size; /*!< Size of the file */ ib_uint64_t offset; /*!< Offset of the next read, or count of already-read bytes */ }; /** A set of bitmap files containing some LSN range */ struct log_online_bitmap_file_range_t { size_t count; /*!< Number of files */ /*!< Dynamically-allocated array of info about individual files */ struct files_t { char name[FN_REFLEN];/*!< Name of a file */ lsn_t start_lsn; /*!< Starting LSN of data in this file */ ulong seq_num; /*!< Sequence number of this file */ } *files; }; /* log0online.c */ /** File name stem for bitmap files. */ static const char* bmp_file_name_stem = "ib_modified_log_"; /** The bitmap file block size in bytes. All writes will be multiples of this. */ enum { MODIFIED_PAGE_BLOCK_SIZE = 4096 }; /** Offsets in a file bitmap block */ enum { MODIFIED_PAGE_IS_LAST_BLOCK = 0,/* 1 if last block in the current write, 0 otherwise. */ MODIFIED_PAGE_START_LSN = 4, /* The starting tracked LSN of this and other blocks in the same write */ MODIFIED_PAGE_END_LSN = 12, /* The ending tracked LSN of this and other blocks in the same write */ MODIFIED_PAGE_SPACE_ID = 20, /* The space ID of tracked pages in this block */ MODIFIED_PAGE_1ST_PAGE_ID = 24, /* The page ID of the first tracked page in this block */ MODIFIED_PAGE_BLOCK_UNUSED_1 = 28,/* Unused in order to align the start of bitmap at 8 byte boundary */ MODIFIED_PAGE_BLOCK_BITMAP = 32,/* Start of the bitmap itself */ MODIFIED_PAGE_BLOCK_UNUSED_2 = MODIFIED_PAGE_BLOCK_SIZE - 8, /* Unused in order to align the end of bitmap at 8 byte boundary */ MODIFIED_PAGE_BLOCK_CHECKSUM = MODIFIED_PAGE_BLOCK_SIZE - 4 /* The checksum of the current block */ }; /** Length of the bitmap data in a block */ enum { MODIFIED_PAGE_BLOCK_BITMAP_LEN = MODIFIED_PAGE_BLOCK_UNUSED_2 - MODIFIED_PAGE_BLOCK_BITMAP }; /** Length of the bitmap data in a block in page ids */ enum { MODIFIED_PAGE_BLOCK_ID_COUNT = MODIFIED_PAGE_BLOCK_BITMAP_LEN * 8 }; typedef ib_uint64_t bitmap_word_t; /****************************************************************//** Calculate a bitmap block checksum. Algorithm borrowed from log_block_calc_checksum. @return checksum */ UNIV_INLINE ulint log_online_calc_checksum( /*=====================*/ const byte* block); /*! p2 */ static int log_online_compare_bmp_keys( /*========================*/ const void* p1, /*! k2_start_page ? 1 : 0; } return k1_space < k2_space ? -1 : 1; } /****************************************************************//** Calculate a bitmap block checksum. Algorithm borrowed from log_block_calc_checksum. @return checksum */ UNIV_INLINE ulint log_online_calc_checksum( /*=====================*/ const byte* block) /*! 24) { sh = 0; } } return sum; } /****************************************************************//** Read one bitmap data page and check it for corruption. @return TRUE if page read OK, FALSE if I/O error */ static ibool log_online_read_bitmap_page( /*========================*/ log_online_bitmap_file_t *bitmap_file, /*!size >= MODIFIED_PAGE_BLOCK_SIZE); ut_a(bitmap_file->offset <= bitmap_file->size - MODIFIED_PAGE_BLOCK_SIZE); ut_a(bitmap_file->offset % MODIFIED_PAGE_BLOCK_SIZE == 0); success = os_file_read(IORequestRead, bitmap_file->file, page, bitmap_file->offset, MODIFIED_PAGE_BLOCK_SIZE); if (UNIV_UNLIKELY(!success)) { /* The following call prints an error message */ os_file_get_last_error(TRUE); msg("InnoDB: Warning: failed reading changed page bitmap " "file \'%s\'\n", bitmap_file->name); return FALSE; } bitmap_file->offset += MODIFIED_PAGE_BLOCK_SIZE; ut_ad(bitmap_file->offset <= bitmap_file->size); checksum = mach_read_from_4(page + MODIFIED_PAGE_BLOCK_CHECKSUM); actual_checksum = log_online_calc_checksum(page); *checksum_ok = (checksum == actual_checksum); return TRUE; } /*********************************************************************//** Check the name of a given file if it's a changed page bitmap file and return file sequence and start LSN name components if it is. If is not, the values of output parameters are undefined. @return TRUE if a given file is a changed page bitmap file. */ static ibool log_online_is_bitmap_file( /*======================*/ const os_file_stat_t* file_info, /*!name) < OS_FILE_MAX_PATH); return ((file_info->type == OS_FILE_TYPE_FILE || file_info->type == OS_FILE_TYPE_LINK) && (sscanf(file_info->name, "%[a-z_]%lu_" LSN_PF ".xdb", stem, bitmap_file_seq_num, bitmap_file_start_lsn) == 3) && (!strcmp(stem, bmp_file_name_stem))); } /*********************************************************************//** List the bitmap files in srv_data_home and setup their range that contains the specified LSN interval. This range, if non-empty, will start with a file that has the greatest LSN equal to or less than the start LSN and will include all the files up to the one with the greatest LSN less than the end LSN. Caller must free bitmap_files->files when done if bitmap_files set to non-NULL and this function returned TRUE. Field bitmap_files->count might be set to a larger value than the actual count of the files, and space for the unused array slots will be allocated but cleared to zeroes. @return TRUE if succeeded */ static ibool log_online_setup_bitmap_file_range( /*===============================*/ log_online_bitmap_file_range_t *bitmap_files, /*!= range_start); bitmap_files->count = 0; bitmap_files->files = NULL; /* 1st pass: size the info array */ bitmap_dir = os_file_opendir(srv_data_home, FALSE); if (UNIV_UNLIKELY(!bitmap_dir)) { msg("InnoDB: Error: failed to open bitmap directory \'%s\'\n", srv_data_home); return FALSE; } while (!os_file_readdir_next_file(srv_data_home, bitmap_dir, &bitmap_dir_file_info)) { ulong file_seq_num; lsn_t file_start_lsn; if (!log_online_is_bitmap_file(&bitmap_dir_file_info, &file_seq_num, &file_start_lsn) || file_start_lsn >= range_end) { continue; } if (file_seq_num > last_file_seq_num) { last_file_seq_num = file_seq_num; } if (file_start_lsn >= range_start || file_start_lsn == first_file_start_lsn || first_file_start_lsn > range_start) { /* A file that falls into the range */ if (file_start_lsn < first_file_start_lsn) { first_file_start_lsn = file_start_lsn; } if (file_seq_num < first_file_seq_num) { first_file_seq_num = file_seq_num; } } else if (file_start_lsn > first_file_start_lsn) { /* A file that has LSN closer to the range start but smaller than it, replacing another such file */ first_file_start_lsn = file_start_lsn; first_file_seq_num = file_seq_num; } } if (UNIV_UNLIKELY(os_file_closedir(bitmap_dir))) { os_file_get_last_error(TRUE); msg("InnoDB: Error: cannot close \'%s\'\n",srv_data_home); return FALSE; } if (first_file_seq_num == ULONG_MAX && last_file_seq_num == 0) { bitmap_files->count = 0; return TRUE; } bitmap_files->count = last_file_seq_num - first_file_seq_num + 1; /* 2nd pass: get the file names in the file_seq_num order */ bitmap_dir = os_file_opendir(srv_data_home, FALSE); if (UNIV_UNLIKELY(!bitmap_dir)) { msg("InnoDB: Error: failed to open bitmap directory \'%s\'\n", srv_data_home); return FALSE; } bitmap_files->files = static_cast (malloc(bitmap_files->count * sizeof(bitmap_files->files[0]))); memset(bitmap_files->files, 0, bitmap_files->count * sizeof(bitmap_files->files[0])); while (!os_file_readdir_next_file(srv_data_home, bitmap_dir, &bitmap_dir_file_info)) { ulong file_seq_num; lsn_t file_start_lsn; size_t array_pos; if (!log_online_is_bitmap_file(&bitmap_dir_file_info, &file_seq_num, &file_start_lsn) || file_start_lsn >= range_end || file_start_lsn < first_file_start_lsn) { continue; } array_pos = file_seq_num - first_file_seq_num; if (UNIV_UNLIKELY(array_pos >= bitmap_files->count)) { msg("InnoDB: Error: inconsistent bitmap file " "directory\n"); free(bitmap_files->files); return FALSE; } if (file_seq_num > bitmap_files->files[array_pos].seq_num) { bitmap_files->files[array_pos].seq_num = file_seq_num; strncpy(bitmap_files->files[array_pos].name, bitmap_dir_file_info.name, FN_REFLEN); bitmap_files->files[array_pos].name[FN_REFLEN - 1] = '\0'; bitmap_files->files[array_pos].start_lsn = file_start_lsn; } } if (UNIV_UNLIKELY(os_file_closedir(bitmap_dir))) { os_file_get_last_error(TRUE); msg("InnoDB: Error: cannot close \'%s\'\n", srv_data_home); free(bitmap_files->files); return FALSE; } #ifdef UNIV_DEBUG ut_ad(bitmap_files->files[0].seq_num == first_file_seq_num); for (size_t i = 1; i < bitmap_files->count; i++) { if (!bitmap_files->files[i].seq_num) { break; } ut_ad(bitmap_files->files[i].seq_num > bitmap_files->files[i - 1].seq_num); ut_ad(bitmap_files->files[i].start_lsn >= bitmap_files->files[i - 1].start_lsn); } #endif return TRUE; } /****************************************************************//** Open a bitmap file for reading. @return whether opened successfully */ static bool log_online_open_bitmap_file_read_only( /*==================================*/ const char* name, /*!name, FN_REFLEN, "%s%s", srv_data_home, name); bitmap_file->file = os_file_create_simple_no_error_handling( 0, bitmap_file->name, OS_FILE_OPEN, OS_FILE_READ_ONLY, true, &success); if (UNIV_UNLIKELY(!success)) { /* Here and below assume that bitmap file names do not contain apostrophes, thus no need for ut_print_filename(). */ msg("InnoDB: Warning: error opening the changed page " "bitmap \'%s\'\n", bitmap_file->name); return success; } bitmap_file->size = os_file_get_size(bitmap_file->file); bitmap_file->offset = 0; #ifdef UNIV_LINUX posix_fadvise(bitmap_file->file, 0, 0, POSIX_FADV_SEQUENTIAL); posix_fadvise(bitmap_file->file, 0, 0, POSIX_FADV_NOREUSE); #endif return success; } /****************************************************************//** Diagnose one or both of the following situations if we read close to the end of bitmap file: 1) Warn if the remainder of the file is less than one page. 2) Error if we cannot read any more full pages but the last read page did not have the last-in-run flag set. @return FALSE for the error */ static ibool log_online_diagnose_bitmap_eof( /*===========================*/ const log_online_bitmap_file_t* bitmap_file, /*!< in: bitmap file */ ibool last_page_in_run)/*!< in: "last page in run" flag value in the last read page */ { /* Check if we are too close to EOF to read a full page */ if ((bitmap_file->size < MODIFIED_PAGE_BLOCK_SIZE) || (bitmap_file->offset > bitmap_file->size - MODIFIED_PAGE_BLOCK_SIZE)) { if (UNIV_UNLIKELY(bitmap_file->offset != bitmap_file->size)) { /* If we are not at EOF and we have less than one page to read, it's junk. This error is not fatal in itself. */ msg("InnoDB: Warning: junk at the end of changed " "page bitmap file \'%s\'.\n", bitmap_file->name); } if (UNIV_UNLIKELY(!last_page_in_run)) { /* We are at EOF but the last read page did not finish a run */ /* It's a "Warning" here because it's not a fatal error for the whole server */ msg("InnoDB: Warning: changed page bitmap " "file \'%s\' does not contain a complete run " "at the end.\n", bitmap_file->name); return FALSE; } } return TRUE; } /* End of copy-pasted definitions */ /** Iterator structure over changed page bitmap */ struct xb_page_bitmap_range_struct { const xb_page_bitmap *bitmap; /* Bitmap with data */ ulint space_id; /* Space id for this iterator */ ulint bit_i; /* Bit index of the iterator position in the current page */ const ib_rbt_node_t *bitmap_node; /* Current bitmap tree node */ const byte *bitmap_page; /* Current bitmap page */ ulint current_page_id;/* Current page id */ }; /****************************************************************//** Print a diagnostic message on missing bitmap data for an LSN range. */ static void xb_msg_missing_lsn_data( /*====================*/ lsn_t missing_interval_start, /*!size >= MODIFIED_PAGE_BLOCK_SIZE); *page_end_lsn = 0; while ((*page_end_lsn <= lsn) && (bitmap_file->offset <= bitmap_file->size - MODIFIED_PAGE_BLOCK_SIZE)) { next_to_last_page_ok = last_page_ok; if (!log_online_read_bitmap_page(bitmap_file, page, &last_page_ok)) { return FALSE; } *page_end_lsn = mach_read_from_8(page + MODIFIED_PAGE_END_LSN); } /* We check two pages here because the last read page already contains the required LSN data. If the next to the last one page is corrupted, then we have no way of telling if that page contained the required LSN range data too */ return last_page_ok && next_to_last_page_ok; } /****************************************************************//** Read the disk bitmap and build the changed page bitmap tree for the LSN interval incremental_lsn to checkpoint_lsn_start. @return the built bitmap tree or NULL if unable to read the full interval for any reason. */ xb_page_bitmap* xb_page_bitmap_init(void) /*=====================*/ { log_online_bitmap_file_t bitmap_file; lsn_t bmp_start_lsn = incremental_lsn; lsn_t bmp_end_lsn = checkpoint_lsn_start; byte page[MODIFIED_PAGE_BLOCK_SIZE]; lsn_t current_page_end_lsn; xb_page_bitmap *result; ibool last_page_in_run= FALSE; log_online_bitmap_file_range_t bitmap_files; size_t bmp_i; ibool last_page_ok = TRUE; if (UNIV_UNLIKELY(bmp_start_lsn > bmp_end_lsn)) { msg("mariabackup: incremental backup LSN " LSN_PF " is larger than than the last checkpoint LSN " LSN_PF "\n", bmp_start_lsn, bmp_end_lsn); return NULL; } if (!log_online_setup_bitmap_file_range(&bitmap_files, bmp_start_lsn, bmp_end_lsn)) { return NULL; } /* Only accept no bitmap files returned if start LSN == end LSN */ if (bitmap_files.count == 0 && bmp_end_lsn != bmp_start_lsn) { return NULL; } result = rbt_create(MODIFIED_PAGE_BLOCK_SIZE, log_online_compare_bmp_keys); if (bmp_start_lsn == bmp_end_lsn) { /* Empty range - empty bitmap */ return result; } bmp_i = 0; if (UNIV_UNLIKELY(bitmap_files.files[bmp_i].start_lsn > bmp_start_lsn)) { /* The 1st file does not have the starting LSN data */ xb_msg_missing_lsn_data(bmp_start_lsn, bitmap_files.files[bmp_i].start_lsn); rbt_free(result); free(bitmap_files.files); return NULL; } /* Skip any zero-sized files at the start */ while ((bmp_i < bitmap_files.count - 1) && (bitmap_files.files[bmp_i].start_lsn == bitmap_files.files[bmp_i + 1].start_lsn)) { bmp_i++; } /* Is the 1st bitmap file missing? */ if (UNIV_UNLIKELY(bitmap_files.files[bmp_i].name[0] == '\0')) { /* TODO: this is not the exact missing range */ xb_msg_missing_lsn_data(bmp_start_lsn, bmp_end_lsn); rbt_free(result); free(bitmap_files.files); return NULL; } /* Open the 1st bitmap file */ if (UNIV_UNLIKELY(!log_online_open_bitmap_file_read_only( bitmap_files.files[bmp_i].name, &bitmap_file))) { rbt_free(result); free(bitmap_files.files); return NULL; } /* If the 1st file is truncated, no data. Not merged with the case below because zero-length file indicates not a corruption but missing subsequent files instead. */ if (UNIV_UNLIKELY(bitmap_file.size < MODIFIED_PAGE_BLOCK_SIZE)) { xb_msg_missing_lsn_data(bmp_start_lsn, bmp_end_lsn); rbt_free(result); free(bitmap_files.files); os_file_close(bitmap_file.file); return NULL; } /* Find the start of the required LSN range in the file */ if (UNIV_UNLIKELY(!xb_find_lsn_in_bitmap_file(&bitmap_file, page, ¤t_page_end_lsn, bmp_start_lsn))) { msg("mariabackup: Warning: changed page bitmap file " "\'%s\' corrupted\n", bitmap_file.name); rbt_free(result); free(bitmap_files.files); os_file_close(bitmap_file.file); return NULL; } last_page_in_run = mach_read_from_4(page + MODIFIED_PAGE_IS_LAST_BLOCK); if (UNIV_UNLIKELY(!log_online_diagnose_bitmap_eof(&bitmap_file, last_page_in_run))) { rbt_free(result); free(bitmap_files.files); os_file_close(bitmap_file.file); return NULL; } if (UNIV_UNLIKELY(current_page_end_lsn < bmp_start_lsn)) { xb_msg_missing_lsn_data(current_page_end_lsn, bmp_start_lsn); rbt_free(result); free(bitmap_files.files); os_file_close(bitmap_file.file); return NULL; } /* 1st bitmap page found, add it to the tree. */ rbt_insert(result, page, page); /* Read next pages/files until all required data is read */ while (last_page_ok && (current_page_end_lsn < bmp_end_lsn || (current_page_end_lsn == bmp_end_lsn && !last_page_in_run))) { ib_rbt_bound_t tree_search_pos; /* If EOF, advance the file skipping over any empty files */ while (bitmap_file.size < MODIFIED_PAGE_BLOCK_SIZE || (bitmap_file.offset > bitmap_file.size - MODIFIED_PAGE_BLOCK_SIZE)) { os_file_close(bitmap_file.file); if (UNIV_UNLIKELY( !log_online_diagnose_bitmap_eof( &bitmap_file, last_page_in_run))) { rbt_free(result); free(bitmap_files.files); return NULL; } bmp_i++; if (UNIV_UNLIKELY(bmp_i == bitmap_files.count || (bitmap_files.files[bmp_i].seq_num == 0))) { xb_msg_missing_lsn_data(current_page_end_lsn, bmp_end_lsn); rbt_free(result); free(bitmap_files.files); return NULL; } /* Is the next file missing? */ if (UNIV_UNLIKELY(bitmap_files.files[bmp_i].name[0] == '\0')) { /* TODO: this is not the exact missing range */ xb_msg_missing_lsn_data(bitmap_files.files [bmp_i - 1].start_lsn, bmp_end_lsn); rbt_free(result); free(bitmap_files.files); return NULL; } if (UNIV_UNLIKELY( !log_online_open_bitmap_file_read_only( bitmap_files.files[bmp_i].name, &bitmap_file))) { rbt_free(result); free(bitmap_files.files); return NULL; } } if (UNIV_UNLIKELY( !log_online_read_bitmap_page(&bitmap_file, page, &last_page_ok))) { rbt_free(result); free(bitmap_files.files); os_file_close(bitmap_file.file); return NULL; } if (UNIV_UNLIKELY(!last_page_ok)) { msg("mariabackup: warning: changed page bitmap file " "\'%s\' corrupted.\n", bitmap_file.name); rbt_free(result); free(bitmap_files.files); os_file_close(bitmap_file.file); return NULL; } /* Merge the current page with an existing page or insert a new page into the tree */ if (!rbt_search(result, &tree_search_pos, page)) { /* Merge the bitmap pages */ byte *existing_page = rbt_value(byte, tree_search_pos.last); bitmap_word_t *bmp_word_1 = (bitmap_word_t *) (existing_page + MODIFIED_PAGE_BLOCK_BITMAP); bitmap_word_t *bmp_end = (bitmap_word_t *) (existing_page + MODIFIED_PAGE_BLOCK_UNUSED_2); bitmap_word_t *bmp_word_2 = (bitmap_word_t *) (page + MODIFIED_PAGE_BLOCK_BITMAP); while (bmp_word_1 < bmp_end) { *bmp_word_1++ |= *bmp_word_2++; } xb_a (bmp_word_1 == bmp_end); } else { /* Add a new page */ rbt_add_node(result, &tree_search_pos, page); } current_page_end_lsn = mach_read_from_8(page + MODIFIED_PAGE_END_LSN); last_page_in_run = mach_read_from_4(page + MODIFIED_PAGE_IS_LAST_BLOCK); } xb_a (current_page_end_lsn >= bmp_end_lsn); free(bitmap_files.files); os_file_close(bitmap_file.file); return result; } /****************************************************************//** Free the bitmap tree. */ void xb_page_bitmap_deinit( /*==================*/ xb_page_bitmap* bitmap) /*!bitmap_page has been already found/bumped by rbt_search()/rbt_next(). @return FALSE if no more bitmap data for the range space ID */ static ibool xb_page_bitmap_setup_next_page( /*===========================*/ xb_page_bitmap_range* bitmap_range) /*!bitmap_node == NULL) { bitmap_range->current_page_id = ULINT_UNDEFINED; return FALSE; } bitmap_range->bitmap_page = rbt_value(byte, bitmap_range->bitmap_node); new_space_id = mach_read_from_4(bitmap_range->bitmap_page + MODIFIED_PAGE_SPACE_ID); if (new_space_id != bitmap_range->space_id) { /* No more data for the current page id. */ xb_a(new_space_id > bitmap_range->space_id); bitmap_range->current_page_id = ULINT_UNDEFINED; return FALSE; } new_1st_page_id = mach_read_from_4(bitmap_range->bitmap_page + MODIFIED_PAGE_1ST_PAGE_ID); xb_a (new_1st_page_id >= bitmap_range->current_page_id || bitmap_range->current_page_id == ULINT_UNDEFINED); bitmap_range->current_page_id = new_1st_page_id; bitmap_range->bit_i = 0; return TRUE; } /** Find the node with the smallest key that greater than equal to search key. @param[in] tree red-black tree @param[in] key search key @return node with the smallest greater-than-or-equal key @retval NULL if none was found */ static const ib_rbt_node_t* rbt_lower_bound(const ib_rbt_t* tree, const void* key) { ut_ad(!tree->cmp_arg); const ib_rbt_node_t* ge = NULL; for (const ib_rbt_node_t *node = tree->root->left; node != tree->nil; ) { int result = tree->compare(node->value, key); if (result < 0) { node = node->right; } else { ge = node; if (result == 0) { break; } node = node->left; } } return(ge); } /****************************************************************//** Set up a new bitmap range iterator over a given space id changed pages in a given bitmap. @return bitmap range iterator */ xb_page_bitmap_range* xb_page_bitmap_range_init( /*======================*/ xb_page_bitmap* bitmap, /*!< in: bitmap to iterate over */ ulint space_id) /*!< in: space id */ { byte search_page[MODIFIED_PAGE_BLOCK_SIZE]; xb_page_bitmap_range *result = static_cast(malloc(sizeof(*result))); memset(result, 0, sizeof(*result)); result->bitmap = bitmap; result->space_id = space_id; result->current_page_id = ULINT_UNDEFINED; /* Search for the 1st page for the given space id */ /* This also sets MODIFIED_PAGE_1ST_PAGE_ID to 0, which is what we want. */ memset(search_page, 0, MODIFIED_PAGE_BLOCK_SIZE); mach_write_to_4(search_page + MODIFIED_PAGE_SPACE_ID, space_id); result->bitmap_node = rbt_lower_bound(result->bitmap, search_page); xb_page_bitmap_setup_next_page(result); return result; } /****************************************************************//** Get the value of the bitmap->range->bit_i bitmap bit @return the current bit value */ static inline ibool is_bit_set( /*=======*/ const xb_page_bitmap_range* bitmap_range) /*!< in: bitmap range */ { return ((*(((bitmap_word_t *)(bitmap_range->bitmap_page + MODIFIED_PAGE_BLOCK_BITMAP)) + (bitmap_range->bit_i >> 6))) & (1ULL << (bitmap_range->bit_i & 0x3F))) ? TRUE : FALSE; } /****************************************************************//** Get the next page id that has its bit set or cleared, i.e. equal to bit_value. @return page id */ ulint xb_page_bitmap_range_get_next_bit( /*==============================*/ xb_page_bitmap_range* bitmap_range, /*!< in/out: bitmap range */ ibool bit_value) /*!< in: bit value */ { if (UNIV_UNLIKELY(bitmap_range->current_page_id == ULINT_UNDEFINED)) { return ULINT_UNDEFINED; } do { while (bitmap_range->bit_i < MODIFIED_PAGE_BLOCK_ID_COUNT) { while (is_bit_set(bitmap_range) != bit_value && (bitmap_range->bit_i < MODIFIED_PAGE_BLOCK_ID_COUNT)) { bitmap_range->current_page_id++; bitmap_range->bit_i++; } if (bitmap_range->bit_i < MODIFIED_PAGE_BLOCK_ID_COUNT) { ulint result = bitmap_range->current_page_id; bitmap_range->current_page_id++; bitmap_range->bit_i++; return result; } } bitmap_range->bitmap_node = rbt_next(bitmap_range->bitmap, bitmap_range->bitmap_node); } while (xb_page_bitmap_setup_next_page(bitmap_range)); return ULINT_UNDEFINED; } /****************************************************************//** Free the bitmap range iterator. */ void xb_page_bitmap_range_deinit( /*========================*/ xb_page_bitmap_range* bitmap_range) /*! in/out: bitmap range */ { free(bitmap_range); }