29 #define IBUF_BITS_PER_PAGE 4
30 #if IBUF_BITS_PER_PAGE % 2
31 # error "IBUF_BITS_PER_PAGE must be an even number!"
34 #define IBUF_BITMAP PAGE_DATA
37 #include "ibuf0ibuf.ic"
40 #ifndef UNIV_HOTBACKUP
188 #define IBUF_POOL_SIZE_PER_MAX_SIZE 2
191 #define IBUF_TABLE_NAME "SYS_IBUF_TABLE"
196 #if defined UNIV_DEBUG || defined UNIV_IBUF_DEBUG
198 UNIV_INTERN uint ibuf_debug;
202 UNIV_INTERN ibuf_t* ibuf = NULL;
205 UNIV_INTERN ulint ibuf_flush_count = 0;
207 #ifdef UNIV_PFS_MUTEX
208 UNIV_INTERN mysql_pfs_key_t ibuf_pessimistic_insert_mutex_key;
209 UNIV_INTERN mysql_pfs_key_t ibuf_mutex_key;
210 UNIV_INTERN mysql_pfs_key_t ibuf_bitmap_mutex_key;
213 #ifdef UNIV_IBUF_COUNT_DEBUG
215 #define IBUF_COUNT_N_SPACES 4
217 #define IBUF_COUNT_N_PAGES 130000
220 static ulint ibuf_counts[IBUF_COUNT_N_SPACES][IBUF_COUNT_N_PAGES];
231 if (space_id < IBUF_COUNT_N_SPACES && page_no < IBUF_COUNT_N_PAGES) {
236 "InnoDB: UNIV_IBUF_COUNT_DEBUG limits space_id and page_no\n"
237 "InnoDB: and breaks crash recovery.\n"
238 "InnoDB: space_id=%lu, should be 0<=space_id<%lu\n"
239 "InnoDB: page_no=%lu, should be 0<=page_no<%lu\n",
240 (ulint) space_id, (ulint) IBUF_COUNT_N_SPACES,
241 (ulint) page_no, (ulint) IBUF_COUNT_N_PAGES);
248 #define IBUF_BITMAP_FREE 0
250 #define IBUF_BITMAP_BUFFERED 2
252 #define IBUF_BITMAP_IBUF 3
266 #define IBUF_REC_INFO_SIZE 4
268 #if IBUF_REC_INFO_SIZE >= DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE
269 # error "IBUF_REC_INFO_SIZE >= DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE"
273 #define IBUF_REC_OFFSET_COUNTER 0
274 #define IBUF_REC_OFFSET_TYPE 2
275 #define IBUF_REC_OFFSET_FLAGS 3
278 #define IBUF_REC_COMPACT 0x1
285 static mutex_t ibuf_pessimistic_insert_mutex;
291 static mutex_t ibuf_bitmap_mutex;
294 #define IBUF_MERGE_AREA 8
299 #define IBUF_MERGE_THRESHOLD 4
303 #define IBUF_MAX_N_PAGES_MERGED IBUF_MERGE_AREA
308 #define IBUF_CONTRACT_ON_INSERT_NON_SYNC 0
313 #define IBUF_CONTRACT_ON_INSERT_SYNC 5
318 #define IBUF_CONTRACT_DO_NOT_INSERT 10
338 ut_ad(*ptr == FALSE);
380 ibuf_header_page_get(
386 ut_ad(!ibuf_inside());
389 IBUF_SPACE_ID, 0, FSP_IBUF_HEADER_PAGE_NO, RW_X_LATCH, mtr);
390 buf_block_dbg_add_level(block, SYNC_IBUF_HEADER);
392 return(buf_block_get_frame(block));
407 ut_ad(ibuf_inside());
408 ut_ad(mutex_own(&ibuf_mutex));
413 IBUF_SPACE_ID, 0, FSP_IBUF_TREE_ROOT_PAGE_NO, RW_X_LATCH, mtr);
415 buf_block_dbg_add_level(block, SYNC_TREE_NODE);
417 root = buf_block_get_frame(block);
426 #ifdef UNIV_IBUF_COUNT_DEBUG
438 ibuf_count_check(space, page_no);
440 return(ibuf_counts[space][page_no]);
453 ibuf_count_check(space, page_no);
454 ut_a(val < UNIV_PAGE_SIZE);
456 ibuf_counts[space][page_no] = val;
467 mutex_free(&ibuf_pessimistic_insert_mutex);
468 memset(&ibuf_pessimistic_insert_mutex,
469 0x0,
sizeof(ibuf_pessimistic_insert_mutex));
471 mutex_free(&ibuf_mutex);
472 memset(&ibuf_mutex, 0x0,
sizeof(ibuf_mutex));
474 mutex_free(&ibuf_bitmap_mutex);
475 memset(&ibuf_bitmap_mutex, 0x0,
sizeof(ibuf_mutex));
491 ut_ad(mutex_own(&ibuf_mutex));
494 + PAGE_BTR_IBUF_FREE_LIST, mtr);
499 ibuf->size = ibuf->seg_size - (1 + ibuf->free_list_len);
507 ibuf_init_at_db_start(
void)
519 ibuf =
static_cast<ibuf_t *
>(mem_alloc(
sizeof(ibuf_t)));
521 memset(ibuf, 0,
sizeof(*ibuf));
528 / IBUF_POOL_SIZE_PER_MAX_SIZE,
529 srv_ibuf_max_size / UNIV_PAGE_SIZE);
530 srv_ibuf_max_size = ibuf->max_size * UNIV_PAGE_SIZE;
532 mutex_create(ibuf_pessimistic_insert_mutex_key,
533 &ibuf_pessimistic_insert_mutex,
534 SYNC_IBUF_PESS_INSERT_MUTEX);
536 mutex_create(ibuf_mutex_key,
537 &ibuf_mutex, SYNC_IBUF_MUTEX);
539 mutex_create(ibuf_bitmap_mutex_key,
540 &ibuf_bitmap_mutex, SYNC_IBUF_BITMAP_MUTEX);
544 mutex_enter(&ibuf_mutex);
546 mtr_x_lock(fil_space_get_latch(IBUF_SPACE_ID, NULL), &mtr);
548 header_page = ibuf_header_page_get(&mtr);
550 fseg_n_reserved_pages(header_page + IBUF_HEADER + IBUF_TREE_SEG_HEADER,
556 ibuf->seg_size = n_used;
562 IBUF_SPACE_ID, 0, FSP_IBUF_TREE_ROOT_PAGE_NO,
564 buf_block_dbg_add_level(block, SYNC_TREE_NODE);
566 root = buf_block_get_frame(block);
569 ibuf_size_update(root, &mtr);
570 mutex_exit(&ibuf_mutex);
580 table = dict_mem_table_create(IBUF_TABLE_NAME, IBUF_SPACE_ID, 1, 0);
582 dict_mem_table_add_col(table, heap,
"DUMMY_COLUMN", DATA_BINARY, 0, 0);
584 table->
id = DICT_IBUF_ID_MIN + IBUF_SPACE_ID;
586 dict_table_add_to_cache(table, heap);
589 index = dict_mem_index_create(
590 IBUF_TABLE_NAME,
"CLUST_IND",
593 dict_mem_index_add_field(index,
"DUMMY_COLUMN", 0);
595 index->
id = DICT_IBUF_ID_MIN + IBUF_SPACE_ID;
597 error = dict_index_add_to_cache(table, index,
598 FSP_IBUF_TREE_ROOT_PAGE_NO, FALSE);
599 ut_a(error == DB_SUCCESS);
601 ibuf->index = dict_table_get_first_index(table);
608 ibuf_bitmap_page_init(
619 page = buf_block_get_frame(block);
626 * IBUF_BITS_PER_PAGE);
631 memset(page + IBUF_BITMAP, 0, byte_offset);
635 #ifndef UNIV_HOTBACKUP
645 ibuf_parse_bitmap_init(
652 ut_ad(ptr && end_ptr);
655 ibuf_bitmap_page_init(block, mtr);
660 #ifndef UNIV_HOTBACKUP
666 ibuf_bitmap_page_get_bits(
683 ut_ad(bit < IBUF_BITS_PER_PAGE);
684 #if IBUF_BITS_PER_PAGE % 2
685 # error "IBUF_BITS_PER_PAGE % 2 != 0"
688 ut_ad(mtr_memo_contains_page(mtr, page, MTR_MEMO_PAGE_X_FIX));
691 bit_offset = (page_no % UNIV_PAGE_SIZE) * IBUF_BITS_PER_PAGE
694 bit_offset = (page_no & (zip_size - 1)) * IBUF_BITS_PER_PAGE
698 byte_offset = bit_offset / 8;
699 bit_offset = bit_offset % 8;
701 ut_ad(byte_offset + IBUF_BITMAP < UNIV_PAGE_SIZE);
707 if (bit == IBUF_BITMAP_FREE) {
708 ut_ad(bit_offset + 1 < 8);
720 ibuf_bitmap_page_set_bits(
734 ut_ad(bit < IBUF_BITS_PER_PAGE);
735 #if IBUF_BITS_PER_PAGE % 2
736 # error "IBUF_BITS_PER_PAGE % 2 != 0"
739 ut_ad(mtr_memo_contains_page(mtr, page, MTR_MEMO_PAGE_X_FIX));
740 #ifdef UNIV_IBUF_COUNT_DEBUG
741 ut_a((bit != IBUF_BITMAP_BUFFERED) || (val != FALSE)
746 bit_offset = (page_no % UNIV_PAGE_SIZE) * IBUF_BITS_PER_PAGE
749 bit_offset = (page_no & (zip_size - 1)) * IBUF_BITS_PER_PAGE
753 byte_offset = bit_offset / 8;
754 bit_offset = bit_offset % 8;
756 ut_ad(byte_offset + IBUF_BITMAP < UNIV_PAGE_SIZE);
760 if (bit == IBUF_BITMAP_FREE) {
761 ut_ad(bit_offset + 1 < 8);
780 ibuf_bitmap_page_no_calc(
789 return(FSP_IBUF_BITMAP_OFFSET
790 + (page_no & ~(UNIV_PAGE_SIZE - 1)));
792 return(FSP_IBUF_BITMAP_OFFSET
793 + (page_no & ~(zip_size - 1)));
805 ibuf_bitmap_get_map_page_func(
817 block = buf_page_get_gen(space, zip_size,
818 ibuf_bitmap_page_no_calc(zip_size, page_no),
821 buf_block_dbg_add_level(block, SYNC_IBUF_BITMAP);
823 return(buf_block_get_frame(block));
836 #define ibuf_bitmap_get_map_page(space, page_no, zip_size, mtr) \
837 ibuf_bitmap_get_map_page_func(space, page_no, zip_size, \
838 __FILE__, __LINE__, mtr)
847 ibuf_set_free_bits_low(
868 bitmap_page = ibuf_bitmap_get_map_page(space, page_no, zip_size, mtr);
869 #ifdef UNIV_IBUF_DEBUG
872 "Setting space %lu page %lu free bits to %lu should be %lu\n",
874 ibuf_index_page_calc_free(zip_size, block));
877 ut_a(val <= ibuf_index_page_calc_free(zip_size, block));
879 ibuf_bitmap_page_set_bits(bitmap_page, page_no, zip_size,
880 IBUF_BITMAP_FREE, val, mtr);
890 ibuf_set_free_bits_func(
894 #ifdef UNIV_IBUF_DEBUG
908 page = buf_block_get_frame(block);
920 bitmap_page = ibuf_bitmap_get_map_page(space, page_no, zip_size, &mtr);
922 #ifdef UNIV_IBUF_DEBUG
923 if (max_val != ULINT_UNDEFINED) {
926 old_val = ibuf_bitmap_page_get_bits(
927 bitmap_page, page_no, zip_size,
928 IBUF_BITMAP_FREE, &mtr);
930 if (old_val != max_val) {
932 "Ibuf: page %lu old val %lu max val %lu\n",
938 ut_a(old_val <= max_val);
941 fprintf(stderr,
"Setting page no %lu free bits to %lu should be %lu\n",
943 ibuf_index_page_calc_free(zip_size, block));
946 ut_a(val <= ibuf_index_page_calc_free(zip_size, block));
948 ibuf_bitmap_page_set_bits(bitmap_page, page_no, zip_size,
949 IBUF_BITMAP_FREE, val, &mtr);
964 ibuf_reset_free_bits(
970 ibuf_set_free_bits(block, 0, ULINT_UNDEFINED);
983 ibuf_update_free_bits_low(
998 before = ibuf_index_page_calc_free_bits(0, max_ins_size);
1000 after = ibuf_index_page_calc_free(0, block);
1006 if (before != after) {
1007 ibuf_set_free_bits_low(0, block, after, mtr);
1021 ibuf_update_free_bits_zip(
1039 bitmap_page = ibuf_bitmap_get_map_page(space, page_no, zip_size, mtr);
1041 after = ibuf_index_page_calc_free_zip(zip_size, block);
1049 buf_page_make_young(&block->
page);
1052 ibuf_bitmap_page_set_bits(bitmap_page, page_no, zip_size,
1053 IBUF_BITMAP_FREE, after, mtr);
1065 ibuf_update_free_bits_for_two_pages_low(
1079 mutex_enter(&ibuf_bitmap_mutex);
1081 state = ibuf_index_page_calc_free(zip_size, block1);
1083 ibuf_set_free_bits_low(zip_size, block1, state, mtr);
1085 state = ibuf_index_page_calc_free(zip_size, block2);
1087 ibuf_set_free_bits_low(zip_size, block2, state, mtr);
1089 mutex_exit(&ibuf_bitmap_mutex);
1097 ibuf_fixed_addr_page(
1104 return((space == IBUF_SPACE_ID && page_no == IBUF_TREE_ROOT_PAGE_NO)
1133 if (ibuf_fixed_addr_page(space, zip_size, page_no)) {
1136 }
else if (space != IBUF_SPACE_ID) {
1148 bitmap_page = ibuf_bitmap_get_map_page(space, page_no, zip_size, mtr);
1150 ret = ibuf_bitmap_page_get_bits(bitmap_page, page_no, zip_size,
1151 IBUF_BITMAP_IBUF, mtr);
1153 if (mtr == &local_mtr) {
1165 ibuf_rec_get_page_no(
1172 ut_ad(ibuf_inside());
1175 field = rec_get_nth_field_old(rec, 1, &len);
1179 ut_a(trx_sys_multiple_tablespace_format);
1181 field = rec_get_nth_field_old(rec, 2, &len);
1183 ut_a(trx_doublewrite_must_reset_space_ids);
1184 ut_a(!trx_sys_multiple_tablespace_format);
1186 field = rec_get_nth_field_old(rec, 0, &len);
1207 ut_ad(ibuf_inside());
1210 field = rec_get_nth_field_old(rec, 1, &len);
1215 ut_a(trx_sys_multiple_tablespace_format);
1216 field = rec_get_nth_field_old(rec, 0, &len);
1222 ut_a(trx_doublewrite_must_reset_space_ids);
1223 ut_a(!trx_sys_multiple_tablespace_format);
1249 ulint info_len_local;
1250 ulint counter_local;
1252 ut_ad(ibuf_inside());
1256 types = rec_get_nth_field_old(rec, 3, &len);
1258 info_len_local = len % DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE;
1260 switch (info_len_local) {
1263 op_local = IBUF_OP_INSERT;
1264 comp_local = info_len_local;
1266 counter_local = ULINT_UNDEFINED;
1269 case IBUF_REC_INFO_SIZE:
1270 op_local = (ibuf_op_t)types[IBUF_REC_OFFSET_TYPE];
1271 comp_local = types[IBUF_REC_OFFSET_FLAGS] & IBUF_REC_COMPACT;
1273 types + IBUF_REC_OFFSET_COUNTER);
1280 ut_a(op_local < IBUF_OP_COUNT);
1281 ut_a((len - info_len_local) ==
1282 (fields - 4) * DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE);
1293 *info_len = info_len_local;
1297 *counter = counter_local;
1306 ibuf_rec_get_op_type(
1312 ut_ad(ibuf_inside());
1315 (void) rec_get_nth_field_old(rec, 1, &len);
1320 return(IBUF_OP_INSERT);
1324 ibuf_rec_get_info(rec, &op, NULL, NULL, NULL);
1337 ibuf_rec_get_counter(
1346 return(ULINT_UNDEFINED);
1349 ptr = rec_get_nth_field_old(rec, 3, &len);
1356 return(ULINT_UNDEFINED);
1373 #ifndef HAVE_ATOMIC_BUILTINS
1374 ut_ad(mutex_own(&ibuf_mutex));
1377 for (i = 0; i < IBUF_OP_COUNT; i++) {
1378 #ifdef HAVE_ATOMIC_BUILTINS
1379 os_atomic_increment_ulint(&arr[i], ops[i]);
1395 static const char* op_names[] = {
1402 ut_a(UT_ARR_SIZE(op_names) == IBUF_OP_COUNT);
1404 for (i = 0; i < IBUF_OP_COUNT; i++) {
1405 fprintf(file,
"%s %lu%s", op_names[i],
1406 (ulong) ops[i], (i < (IBUF_OP_COUNT - 1)) ?
", " :
"");
1417 ibuf_dummy_index_create(
1425 table = dict_mem_table_create(
"IBUF_DUMMY",
1429 index = dict_mem_index_create(
"IBUF_DUMMY",
"IBUF_DUMMY",
1430 DICT_HDR_SPACE, 0, n);
1432 index->
table = table;
1443 ibuf_dummy_index_add_col(
1450 dict_mem_table_add_col(index->
table, NULL, NULL,
1454 dict_index_add_col(index, index->
table,
1455 dict_table_get_nth_col(index->
table, i), len);
1461 ibuf_dummy_index_free(
1467 dict_mem_index_free(index);
1468 dict_mem_table_free(table);
1481 ibuf_build_entry_pre_4_1_x(
1483 const rec_t* ibuf_rec,
1494 ut_a(trx_doublewrite_must_reset_space_ids);
1495 ut_a(!trx_sys_multiple_tablespace_format);
1499 types = rec_get_nth_field_old(ibuf_rec, 1, &len);
1501 ut_a(len == n_fields * DATA_ORDER_NULL_TYPE_BUF_SIZE);
1503 for (i = 0; i < n_fields; i++) {
1507 field = dtuple_get_nth_field(tuple, i);
1509 data = rec_get_nth_field_old(ibuf_rec, i + 2, &len);
1514 dfield_get_type(field),
1515 types + i * DATA_ORDER_NULL_TYPE_BUF_SIZE);
1518 *pindex = ibuf_dummy_index_create(n_fields, FALSE);
1541 ibuf_build_entry_from_ibuf_rec(
1543 const rec_t* ibuf_rec,
1559 data = rec_get_nth_field_old(ibuf_rec, 1, &len);
1564 return(ibuf_build_entry_pre_4_1_x(ibuf_rec, heap, pindex));
1569 ut_a(trx_sys_multiple_tablespace_format);
1577 types = rec_get_nth_field_old(ibuf_rec, 3, &len);
1579 ibuf_rec_get_info(ibuf_rec, NULL, &comp, &info_len, NULL);
1581 index = ibuf_dummy_index_create(n_fields, comp);
1586 ut_a(len == n_fields * DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE);
1588 for (i = 0; i < n_fields; i++) {
1589 field = dtuple_get_nth_field(tuple, i);
1591 data = rec_get_nth_field_old(ibuf_rec, i + 4, &len);
1596 dfield_get_type(field),
1597 types + i * DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE);
1599 ibuf_dummy_index_add_col(index, dfield_get_type(field), len);
1636 types_offset = DATA_ORDER_NULL_TYPE_BUF_SIZE;
1639 types_offset = DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE;
1642 for (i = 0; i < n_fields; i++) {
1648 if (len != UNIV_SQL_NULL) {
1650 }
else if (pre_4_1) {
1660 types += types_offset;
1673 ibuf_rec_get_volume(
1675 const rec_t* ibuf_rec)
1685 ut_ad(ibuf_inside());
1688 data = rec_get_nth_field_old(ibuf_rec, 1, &len);
1689 pre_4_1 = (len > 1);
1694 ut_a(trx_doublewrite_must_reset_space_ids);
1695 ut_a(!trx_sys_multiple_tablespace_format);
1699 types = rec_get_nth_field_old(ibuf_rec, 1, &len);
1701 ut_ad(len == n_fields * DATA_ORDER_NULL_TYPE_BUF_SIZE);
1708 ut_a(trx_sys_multiple_tablespace_format);
1711 types = rec_get_nth_field_old(ibuf_rec, 3, &len);
1713 ibuf_rec_get_info(ibuf_rec, &op, &comp, &info_len, NULL);
1715 if (op == IBUF_OP_DELETE_MARK || op == IBUF_OP_DELETE) {
1729 entry = ibuf_build_entry_from_ibuf_rec(
1730 ibuf_rec, heap, &dummy_index);
1734 ibuf_dummy_index_free(dummy_index);
1744 data_size = ibuf_rec_get_size(ibuf_rec, types, n_fields, pre_4_1, comp);
1781 ut_ad(counter != ULINT_UNDEFINED || op == IBUF_OP_INSERT);
1782 ut_ad(counter == ULINT_UNDEFINED || counter <= 0xFFFF);
1783 ut_ad(op < IBUF_OP_COUNT);
1800 field = dtuple_get_nth_field(tuple, 0);
1810 field = dtuple_get_nth_field(tuple, 1);
1822 field = dtuple_get_nth_field(tuple, 2);
1832 if (counter == ULINT_UNDEFINED) {
1835 ut_ad(counter <= 0xFFFF);
1836 i = IBUF_REC_INFO_SIZE;
1839 ti = type_info =
static_cast<byte *
>(
mem_heap_alloc(heap, i + n_fields
1840 * DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE));
1852 ut_ad(op == IBUF_OP_INSERT);
1854 case IBUF_REC_INFO_SIZE:
1857 ti[IBUF_REC_OFFSET_TYPE] = (byte) op;
1859 ? IBUF_REC_COMPACT : 0;
1860 ti += IBUF_REC_INFO_SIZE;
1866 for (i = 0; i < n_fields; i++) {
1873 field = dtuple_get_nth_field(tuple, i + 4);
1874 entry_field = dtuple_get_nth_field(entry, i);
1877 ifield = dict_index_get_nth_field(index, i);
1888 ut_ad(fixed_len <= (ulint)
1889 dfield_get_type(entry_field)->len);
1893 ut_ad(fixed_len == (ulint)
1894 dfield_get_type(entry_field)->len);
1900 ti, dfield_get_type(entry_field), fixed_len);
1901 ti += DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE;
1906 field = dtuple_get_nth_field(tuple, 3);
1923 ibuf_search_tuple_build(
1934 ut_a(trx_doublewrite_must_reset_space_ids);
1935 ut_a(!trx_sys_multiple_tablespace_format);
1941 field = dtuple_get_nth_field(tuple, 0);
1960 ibuf_new_search_tuple_build(
1970 ut_a(trx_sys_multiple_tablespace_format);
1976 field = dtuple_get_nth_field(tuple, 0);
1986 field = dtuple_get_nth_field(tuple, 1);
1996 field = dtuple_get_nth_field(tuple, 2);
2015 ibuf_data_enough_free_for_insert(
void)
2018 ut_ad(mutex_own(&ibuf_mutex));
2026 return(ibuf->free_list_len >= (ibuf->size / 2) + 3 * ibuf->height);
2035 ibuf_data_too_much_free(
void)
2038 ut_ad(mutex_own(&ibuf_mutex));
2040 return(ibuf->free_list_len >= 3 + (ibuf->size / 2) + 3 * ibuf->height);
2049 ibuf_add_free_page(
void)
2065 mtr_x_lock(fil_space_get_latch(IBUF_SPACE_ID, &flags), &mtr);
2068 header_page = ibuf_header_page_get(&mtr);
2080 page_no = fseg_alloc_free_page(
2081 header_page + IBUF_HEADER + IBUF_TREE_SEG_HEADER, 0, FSP_UP,
2084 if (UNIV_UNLIKELY(page_no ==
FIL_NULL)) {
2094 IBUF_SPACE_ID, 0, page_no, RW_X_LATCH, &mtr);
2096 buf_block_dbg_add_level(block, SYNC_TREE_NODE_NEW);
2099 page = buf_block_get_frame(block);
2104 mutex_enter(&ibuf_mutex);
2106 root = ibuf_tree_root_get(&mtr);
2110 flst_add_last(root + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST,
2111 page + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST_NODE, &mtr);
2117 ibuf->free_list_len++;
2122 bitmap_page = ibuf_bitmap_get_map_page(
2123 IBUF_SPACE_ID, page_no, zip_size, &mtr);
2125 mutex_exit(&ibuf_mutex);
2127 ibuf_bitmap_page_set_bits(
2128 bitmap_page, page_no, zip_size, IBUF_BITMAP_IBUF, TRUE, &mtr);
2141 ibuf_remove_free_page(
void)
2158 mtr_x_lock(fil_space_get_latch(IBUF_SPACE_ID, &flags), &mtr);
2161 header_page = ibuf_header_page_get(&mtr);
2165 mutex_enter(&ibuf_pessimistic_insert_mutex);
2166 mutex_enter(&ibuf_mutex);
2168 if (!ibuf_data_too_much_free()) {
2170 mutex_exit(&ibuf_mutex);
2171 mutex_exit(&ibuf_pessimistic_insert_mutex);
2182 root = ibuf_tree_root_get(&mtr2);
2184 mutex_exit(&ibuf_mutex);
2186 page_no =
flst_get_last(root + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST,
2203 fseg_free_page(header_page + IBUF_HEADER + IBUF_TREE_SEG_HEADER,
2204 IBUF_SPACE_ID, page_no, &mtr);
2206 #ifdef UNIV_DEBUG_FILE_ACCESSES
2207 buf_page_reset_file_page_was_freed(IBUF_SPACE_ID, page_no);
2212 mutex_enter(&ibuf_mutex);
2214 root = ibuf_tree_root_get(&mtr);
2217 + PAGE_BTR_IBUF_FREE_LIST, &mtr).page);
2223 IBUF_SPACE_ID, 0, page_no, RW_X_LATCH, &mtr);
2225 buf_block_dbg_add_level(block, SYNC_TREE_NODE);
2228 page = buf_block_get_frame(block);
2233 flst_remove(root + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST,
2234 page + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST_NODE, &mtr);
2236 mutex_exit(&ibuf_pessimistic_insert_mutex);
2239 ibuf->free_list_len--;
2244 bitmap_page = ibuf_bitmap_get_map_page(
2245 IBUF_SPACE_ID, page_no, zip_size, &mtr);
2247 mutex_exit(&ibuf_mutex);
2249 ibuf_bitmap_page_set_bits(
2250 bitmap_page, page_no, zip_size, IBUF_BITMAP_IBUF, FALSE, &mtr);
2252 #ifdef UNIV_DEBUG_FILE_ACCESSES
2253 buf_page_set_file_page_was_freed(IBUF_SPACE_ID, page_no);
2266 ibuf_free_excess_pages(
void)
2271 #ifdef UNIV_SYNC_DEBUG
2272 ut_ad(rw_lock_own(fil_space_get_latch(IBUF_SPACE_ID, NULL),
2277 fil_space_get_latch(IBUF_SPACE_ID, NULL)) == 1);
2279 ut_ad(!ibuf_inside());
2295 for (i = 0; i < 4; i++) {
2297 ibool too_much_free;
2299 mutex_enter(&ibuf_mutex);
2300 too_much_free = ibuf_data_too_much_free();
2301 mutex_exit(&ibuf_mutex);
2303 if (!too_much_free) {
2307 ibuf_remove_free_page();
2317 ibuf_get_merge_page_nos(
2326 ib_int64_t* space_versions,
2336 ulint prev_space_id;
2337 ulint first_page_no;
2338 ulint first_space_id;
2342 ulint volume_for_page;
2366 first_page_no = ibuf_rec_get_page_no(rec);
2367 first_space_id = ibuf_rec_get_space(rec);
2378 rec_page_no = ibuf_rec_get_page_no(rec);
2379 rec_space_id = ibuf_rec_get_space(rec);
2381 if (rec_space_id != first_space_id
2382 || (rec_page_no / IBUF_MERGE_AREA)
2383 != (first_page_no / IBUF_MERGE_AREA)) {
2388 if (rec_page_no != prev_page_no
2389 || rec_space_id != prev_space_id) {
2393 prev_page_no = rec_page_no;
2394 prev_space_id = rec_space_id;
2408 volume_for_page = 0;
2410 while (*n_stored < limit) {
2417 rec_page_no = ibuf_rec_get_page_no(rec);
2418 rec_space_id = ibuf_rec_get_space(rec);
2419 ut_ad(rec_page_no > IBUF_TREE_ROOT_PAGE_NO);
2422 #ifdef UNIV_IBUF_DEBUG
2423 ut_a(*n_stored < IBUF_MAX_N_PAGES_MERGED);
2425 if ((rec_space_id != prev_space_id
2426 || rec_page_no != prev_page_no)
2427 && (prev_space_id != 0 || prev_page_no != 0)) {
2429 if ((prev_page_no == first_page_no
2430 && prev_space_id == first_space_id)
2433 > ((IBUF_MERGE_THRESHOLD - 1)
2434 * 4 * UNIV_PAGE_SIZE
2435 / IBUF_PAGE_SIZE_PER_FREE_SPACE)
2436 / IBUF_MERGE_THRESHOLD)) {
2438 space_ids[*n_stored] = prev_space_id;
2439 space_versions[*n_stored]
2440 = fil_space_get_version(prev_space_id);
2441 page_nos[*n_stored] = prev_page_no;
2445 sum_volumes += volume_for_page;
2448 if (rec_space_id != first_space_id
2449 || rec_page_no / IBUF_MERGE_AREA
2450 != first_page_no / IBUF_MERGE_AREA) {
2455 volume_for_page = 0;
2458 if (rec_page_no == 1 && rec_space_id == 0) {
2464 rec_volume = ibuf_rec_get_volume(rec);
2466 volume_for_page += rec_volume;
2468 prev_page_no = rec_page_no;
2469 prev_space_id = rec_space_id;
2474 #ifdef UNIV_IBUF_DEBUG
2475 ut_a(*n_stored <= IBUF_MAX_N_PAGES_MERGED);
2478 fprintf(stderr,
"Ibuf merge batch %lu pages %lu volume\n",
2479 *n_stored, sum_volumes);
2481 return(sum_volumes);
2499 ulint page_nos[IBUF_MAX_N_PAGES_MERGED];
2500 ulint space_ids[IBUF_MAX_N_PAGES_MERGED];
2501 ib_int64_t space_versions[IBUF_MAX_N_PAGES_MERGED];
2506 ut_ad(!ibuf_inside());
2513 if (UNIV_UNLIKELY(ibuf->empty)
2522 trx_sys_set_ibuf_format(TRX_SYS_IBUF_EMPTY);
2554 == FSP_IBUF_TREE_ROOT_PAGE_NO);
2565 space_ids, space_versions,
2568 fprintf(stderr,
"Ibuf contract sync %lu pages %lu volume %lu\n",
2569 sync, *n_pages, sum_sizes);
2576 buf_read_ibuf_merge_pages(sync, space_ids, space_versions, page_nos,
2579 return(sum_sizes + 1);
2597 return(ibuf_contract_ext(&n_pages, sync));
2607 ibuf_contract_for_n_pages(
2616 ulint sum_bytes = 0;
2617 ulint sum_pages = 0;
2624 while (sum_pages < n_pages) {
2625 n_bytes = ibuf_contract_ext(&n_pag2, sync);
2631 sum_bytes += n_bytes;
2632 sum_pages += n_pag2;
2642 ibuf_contract_after_insert(
2660 max_size = ibuf->max_size;
2662 if (srv_ibuf_active_contract ==
false
2663 && size < max_size + IBUF_CONTRACT_ON_INSERT_NON_SYNC) {
2667 sync = (size >= max_size + IBUF_CONTRACT_ON_INSERT_SYNC);
2675 size = ibuf_contract(sync);
2677 }
while (size > 0 && sum_sizes < entry_size);
2685 ibuf_get_volume_buffered_hash(
2703 hash += (fold / (8 *
sizeof *hash)) % size;
2704 bitmask = 1 << (fold % (8 *
sizeof *hash));
2706 if (*hash & bitmask) {
2724 ibuf_get_volume_buffered_count(
2737 ut_ad(ibuf_inside());
2738 ut_ad(n_fields > 4);
2746 ut_ad(trx_sys_multiple_tablespace_format);
2748 types = rec_get_nth_field_old(rec, 3, &len);
2750 switch (UNIV_EXPECT(len % DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE,
2751 IBUF_REC_INFO_SIZE)) {
2760 len = ibuf_rec_get_size(rec, types, n_fields, FALSE, 0);
2770 goto get_volume_comp;
2772 case IBUF_REC_INFO_SIZE:
2773 ibuf_op = (ibuf_op_t) types[IBUF_REC_OFFSET_TYPE];
2778 case IBUF_OP_INSERT:
2782 case IBUF_OP_DELETE_MARK:
2785 if (n_recs && ibuf_get_volume_buffered_hash(
2786 rec, types + IBUF_REC_INFO_SIZE,
2788 types[IBUF_REC_OFFSET_FLAGS] & IBUF_REC_COMPACT,
2793 if (ibuf_op == IBUF_OP_DELETE_MARK) {
2799 case IBUF_OP_DELETE:
2812 ut_ad(ibuf_op == IBUF_OP_INSERT);
2821 entry = ibuf_build_entry_from_ibuf_rec(
2822 rec, heap, &dummy_index);
2826 ibuf_dummy_index_free(dummy_index);
2841 ibuf_get_volume_buffered(
2862 ulint hash_bitmap[128 /
sizeof(ulint)];
2864 ut_a(trx_sys_multiple_tablespace_format);
2875 memset(hash_bitmap, 0,
sizeof hash_bitmap);
2892 if (page_no != ibuf_rec_get_page_no(rec)
2893 || space != ibuf_rec_get_space(rec)) {
2898 volume += ibuf_get_volume_buffered_count(
2899 rec, hash_bitmap, UT_ARR_SIZE(hash_bitmap), n_recs);
2918 IBUF_SPACE_ID, 0, prev_page_no, RW_X_LATCH, mtr);
2920 buf_block_dbg_add_level(block, SYNC_TREE_NODE);
2923 prev_page = buf_block_get_frame(block);
2927 #ifdef UNIV_BTR_DEBUG
2932 rec = page_get_supremum_rec(prev_page);
2942 return(UNIV_PAGE_SIZE);
2945 if (page_no != ibuf_rec_get_page_no(rec)
2946 || space != ibuf_rec_get_space(rec)) {
2951 volume += ibuf_get_volume_buffered_count(
2952 rec, hash_bitmap, UT_ARR_SIZE(hash_bitmap), n_recs);
2971 if (page_no != ibuf_rec_get_page_no(rec)
2972 || space != ibuf_rec_get_space(rec)) {
2977 volume += ibuf_get_volume_buffered_count(
2978 rec, hash_bitmap, UT_ARR_SIZE(hash_bitmap), n_recs);
2996 IBUF_SPACE_ID, 0, next_page_no, RW_X_LATCH, mtr);
2998 buf_block_dbg_add_level(block, SYNC_TREE_NODE);
3001 next_page = buf_block_get_frame(block);
3005 #ifdef UNIV_BTR_DEBUG
3009 rec = page_get_infimum_rec(next_page);
3017 return(UNIV_PAGE_SIZE);
3020 if (page_no != ibuf_rec_get_page_no(rec)
3021 || space != ibuf_rec_get_space(rec)) {
3026 volume += ibuf_get_volume_buffered_count(
3027 rec, hash_bitmap, UT_ARR_SIZE(hash_bitmap), n_recs);
3039 ibuf_update_max_tablespace_id(
void)
3060 btr_pcur_move_to_prev(&pcur, &mtr);
3069 field = rec_get_nth_field_old(rec, 0, &len);
3081 fil_set_max_space_id_if_bigger(max_space_id);
3091 ibuf_get_entry_counter_low(
3101 ut_ad(ibuf_inside());
3104 field = rec_get_nth_field_old(rec, 1, &len);
3106 if (UNIV_UNLIKELY(len != 1)) {
3108 ut_a(trx_doublewrite_must_reset_space_ids);
3109 ut_a(!trx_sys_multiple_tablespace_format);
3111 return(ULINT_UNDEFINED);
3114 ut_a(trx_sys_multiple_tablespace_format);
3117 field = rec_get_nth_field_old(rec, 0, &len);
3126 field = rec_get_nth_field_old(rec, 2, &len);
3135 field = rec_get_nth_field_old(rec, 3, &len);
3137 switch (len % DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE) {
3142 return(ULINT_UNDEFINED);
3144 case IBUF_REC_INFO_SIZE:
3146 ut_a(counter < 0xFFFF);
3147 return(counter + 1);
3157 ibuf_set_entry_counter(
3165 ibool is_optimistic,
3177 counter = ibuf_get_entry_counter_low(
3180 if (UNIV_UNLIKELY(counter == ULINT_UNDEFINED)) {
3195 btr_cur_t* cursor = btr_pcur_get_btr_cur(pcur);
3213 ut_a(cursor->ibuf_cnt != ULINT_UNDEFINED);
3221 IBUF_SPACE_ID, 0, prev_page_no,
3224 buf_block_dbg_add_level(block, SYNC_TREE_NODE);
3226 prev_page = buf_block_get_frame(block);
3229 page_get_supremum_rec(prev_page));
3233 counter = ibuf_get_entry_counter_low(
3234 rec, space, page_no);
3236 if (UNIV_UNLIKELY(counter == ULINT_UNDEFINED)) {
3244 if (counter < cursor->ibuf_cnt) {
3247 if (is_optimistic) {
3255 ibuf->index, rec, block,
3256 btr_pcur_get_btr_cur(pcur));
3283 field = dtuple_get_nth_field(entry, 3);
3284 data =
static_cast<byte *
>(dfield_get_data(field));
3322 ibool old_bit_value;
3328 ulint space_ids[IBUF_MAX_N_PAGES_MERGED];
3329 ib_int64_t space_versions[IBUF_MAX_N_PAGES_MERGED];
3330 ulint page_nos[IBUF_MAX_N_PAGES_MERGED];
3338 ut_ad(!no_counter || op == IBUF_OP_INSERT);
3339 ut_a(op < IBUF_OP_COUNT);
3341 ut_a(trx_sys_multiple_tablespace_format);
3352 if (ibuf->size >= ibuf->max_size + IBUF_CONTRACT_DO_NOT_INSERT) {
3357 #ifdef UNIV_IBUF_DEBUG
3358 fputs(
"Ibuf too big\n", stderr);
3361 ibuf_contract(TRUE);
3363 return(DB_STRONG_FAIL);
3376 ibuf_entry = ibuf_entry_build(
3377 op, index, entry, space, page_no,
3378 no_counter ? ULINT_UNDEFINED : 0xFFFF, heap);
3387 mutex_enter(&ibuf_pessimistic_insert_mutex);
3388 mutex_enter(&ibuf_mutex);
3390 if (UNIV_LIKELY(ibuf_data_enough_free_for_insert())) {
3395 mutex_exit(&ibuf_mutex);
3396 mutex_exit(&ibuf_pessimistic_insert_mutex);
3399 if (UNIV_UNLIKELY(!ibuf_add_free_page())) {
3402 return(DB_STRONG_FAIL);
3411 btr_pcur_open(ibuf->index, ibuf_entry, PAGE_CUR_LE, mode, &pcur, &mtr);
3417 buffered = ibuf_get_volume_buffered(&pcur, space, page_no,
3418 op == IBUF_OP_DELETE
3422 if (op == IBUF_OP_DELETE
3424 || buf_pool_watch_occurred(space, page_no))) {
3444 mutex_exit(&ibuf_mutex);
3445 mutex_exit(&ibuf_pessimistic_insert_mutex);
3448 err = DB_STRONG_FAIL;
3461 #ifdef UNIV_IBUF_COUNT_DEBUG
3462 ut_a((buffered == 0) || ibuf_count_get(space, page_no));
3466 bitmap_page = ibuf_bitmap_get_map_page(space, page_no,
3467 zip_size, &bitmap_mtr);
3477 if (op == IBUF_OP_INSERT) {
3478 ulint bits = ibuf_bitmap_page_get_bits(
3479 bitmap_page, page_no, zip_size, IBUF_BITMAP_FREE,
3483 > ibuf_index_page_calc_free_from_bits(zip_size, bits)) {
3490 ibuf_get_merge_page_nos(
3492 space_ids, space_versions,
3493 page_nos, &n_stored);
3503 && !ibuf_set_entry_counter(ibuf_entry, space, page_no, &pcur,
3514 old_bit_value = ibuf_bitmap_page_get_bits(
3515 bitmap_page, page_no, zip_size,
3516 IBUF_BITMAP_BUFFERED, &bitmap_mtr);
3518 if (!old_bit_value) {
3519 ibuf_bitmap_page_set_bits(bitmap_page, page_no, zip_size,
3520 IBUF_BITMAP_BUFFERED, TRUE,
3526 cursor = btr_pcur_get_btr_cur(&pcur);
3529 err = btr_cur_optimistic_insert(BTR_NO_LOCKING_FLAG, cursor,
3530 ibuf_entry, &ins_rec,
3531 &dummy_big_rec, 0, thr, &mtr);
3537 == FSP_IBUF_TREE_ROOT_PAGE_NO)) {
3538 const page_t* page_root = buf_block_get_frame(block);
3542 == FSP_IBUF_TREE_ROOT_PAGE_NO);
3554 root = ibuf_tree_root_get(&mtr);
3556 err = btr_cur_pessimistic_insert(BTR_NO_LOCKING_FLAG
3557 | BTR_NO_UNDO_LOG_FLAG,
3559 ibuf_entry, &ins_rec,
3560 &dummy_big_rec, 0, thr, &mtr);
3561 mutex_exit(&ibuf_pessimistic_insert_mutex);
3562 ibuf_size_update(root, &mtr);
3563 mutex_exit(&ibuf_mutex);
3570 if (err == DB_SUCCESS && op != IBUF_OP_DELETE) {
3577 #ifdef UNIV_IBUF_COUNT_DEBUG
3578 if (err == DB_SUCCESS) {
3580 "Incrementing ibuf count of space %lu page %lu\n"
3581 "from %lu by 1\n", space, page_no,
3582 ibuf_count_get(space, page_no));
3584 ibuf_count_set(space, page_no,
3585 ibuf_count_get(space, page_no) + 1);
3596 ibuf_contract_after_insert(entry_size);
3600 #ifdef UNIV_IBUF_DEBUG
3601 ut_a(n_stored <= IBUF_MAX_N_PAGES_MERGED);
3603 buf_read_ibuf_merge_pages(FALSE, space_ids, space_versions,
3604 page_nos, n_stored);
3640 no_counter = use <= IBUF_USE_INSERT;
3643 case IBUF_OP_INSERT:
3646 case IBUF_USE_DELETE:
3647 case IBUF_USE_DELETE_MARK:
3649 case IBUF_USE_INSERT:
3650 case IBUF_USE_INSERT_DELETE_MARK:
3653 case IBUF_USE_COUNT:
3657 case IBUF_OP_DELETE_MARK:
3660 case IBUF_USE_INSERT:
3662 case IBUF_USE_DELETE_MARK:
3663 case IBUF_USE_DELETE:
3664 case IBUF_USE_INSERT_DELETE_MARK:
3668 case IBUF_USE_COUNT:
3672 case IBUF_OP_DELETE:
3675 case IBUF_USE_INSERT:
3676 case IBUF_USE_INSERT_DELETE_MARK:
3678 case IBUF_USE_DELETE_MARK:
3679 case IBUF_USE_DELETE:
3683 case IBUF_USE_COUNT:
3716 if (UNIV_LIKELY_NULL(bpage)) {
3739 index, space, zip_size, page_no, thr);
3740 if (err == DB_FAIL) {
3743 index, space, zip_size, page_no, thr);
3746 if (err == DB_SUCCESS) {
3747 #ifdef UNIV_IBUF_DEBUG
3754 ut_a(err == DB_STRONG_FAIL);
3765 ibuf_insert_to_index_page_low(
3779 const page_t* bitmap_page;
3789 btr_page_reorganize(block, index, mtr);
3799 page = buf_block_get_frame(block);
3804 " InnoDB: Error: Insert buffer insert fails;"
3805 " page free %lu, dtuple size %lu\n",
3808 fputs(
"InnoDB: Cannot insert index record ", stderr);
3809 dtuple_print(stderr, entry);
3810 fputs(
"\nInnoDB: The table where this index record belongs\n"
3811 "InnoDB: is now probably corrupt. Please run CHECK TABLE on\n"
3812 "InnoDB: that table.\n", stderr);
3818 bitmap_page = ibuf_bitmap_get_map_page(space, page_no, zip_size, mtr);
3819 old_bits = ibuf_bitmap_page_get_bits(bitmap_page, page_no, zip_size,
3820 IBUF_BITMAP_FREE, mtr);
3823 "InnoDB: space %lu, page %lu, zip_size %lu, bitmap bits %lu\n",
3824 (ulong) space, (ulong) page_no,
3825 (ulong) zip_size, (ulong) old_bits);
3827 fputs(
"InnoDB: Submit a detailed bug report"
3828 " to http://bugs.mysql.com\n", stderr);
3836 ibuf_insert_to_index_page(
3846 page_t* page = buf_block_get_frame(block);
3849 ut_ad(ibuf_inside());
3851 ut_ad(!buf_block_align(page)->is_hashed);
3855 fputs(
"InnoDB: Trying to insert a record from"
3856 " the insert buffer to an index page\n"
3857 "InnoDB: but the 'compact' flag does not match!\n",
3865 fputs(
"InnoDB: Trying to insert a record from"
3866 " the insert buffer to an index page\n"
3867 "InnoDB: but the index page is empty!\n",
3874 fputs(
"InnoDB: Trying to insert a record from"
3875 " the insert buffer to an index page\n"
3876 "InnoDB: but the number of fields does not match!\n",
3879 buf_page_print(page, 0);
3881 dtuple_print(stderr, entry);
3883 fputs(
"InnoDB: The table where where"
3884 " this index record belongs\n"
3885 "InnoDB: is now probably corrupt."
3886 " Please run CHECK TABLE on\n"
3887 "InnoDB: your tables.\n"
3888 "InnoDB: Submit a detailed bug report to"
3889 " http://bugs.mysql.com!\n", stderr);
3895 PAGE_CUR_LE, &page_cur);
3903 rec = page_cur_get_rec(&page_cur);
3911 offsets = rec_get_offsets(rec, index, NULL, ULINT_UNDEFINED,
3914 index, entry, rec, NULL, heap);
3922 btr_cur_set_deleted_flag_for_ibuf(
3923 rec, page_zip, FALSE, mtr);
3931 update->
info_bits &= ~REC_INFO_DELETED_FLAG;
3938 && (!page_zip || btr_cur_update_alloc_zip(
3939 page_zip, block, index,
3945 goto updated_in_place;
3972 ibuf_insert_to_index_page_low(entry, block, index, mtr,
3976 ibuf_insert_to_index_page_low(entry, block, index, mtr,
3996 ut_ad(ibuf_inside());
4000 block, index, entry, PAGE_CUR_LE, &page_cur);
4006 rec = page_cur_get_rec(&page_cur);
4007 page_zip = page_cur_get_page_zip(&page_cur);
4018 btr_cur_set_deleted_flag_for_ibuf(rec, page_zip,
4023 fputs(
" InnoDB: unable to find a record to delete-mark\n",
4025 fputs(
"InnoDB: tuple ", stderr);
4026 dtuple_print(stderr, entry);
4028 "InnoDB: record ", stderr);
4029 rec_print(stderr, page_cur_get_rec(&page_cur), index);
4032 "InnoDB: Submit a detailed bug report"
4033 " to http://bugs.mysql.com\n", stderr);
4053 ut_ad(ibuf_inside());
4057 block, index, entry, PAGE_CUR_LE, &page_cur);
4061 page_t* page = buf_block_get_frame(block);
4062 rec_t* rec = page_cur_get_rec(&page_cur);
4067 ulint offsets_[REC_OFFS_NORMAL_SIZE];
4068 ulint* offsets = offsets_;
4072 rec_offs_init(offsets_);
4074 offsets = rec_get_offsets(
4075 rec, index, offsets, ULINT_UNDEFINED, &heap);
4081 ut_ad(REC_INFO_DELETED_FLAG
4091 #ifdef UNIV_ZIP_DEBUG
4092 ut_a(!page_zip || page_zip_validate(page_zip, page));
4095 #ifdef UNIV_ZIP_DEBUG
4096 ut_a(!page_zip || page_zip_validate(page_zip, page));
4100 ibuf_update_free_bits_zip(block, mtr);
4102 ibuf_update_free_bits_low(block, max_ins_size, mtr);
4105 if (UNIV_LIKELY_NULL(heap)) {
4116 static __attribute__((nonnull))
4132 if (btr_pcur_restore_position(mode, pcur, mtr)) {
4137 if (fil_space_get_flags(space) == ULINT_UNDEFINED) {
4144 "InnoDB: ERROR: Submit the output to"
4145 " http://bugs.mysql.com\n"
4146 "InnoDB: ibuf cursor restoration fails!\n"
4147 "InnoDB: ibuf record inserted to page %lu:%lu\n",
4148 (ulong) space, (ulong) page_no);
4152 rec_print_old(stderr, pcur->old_rec);
4153 dtuple_print(stderr, search_tuple);
4155 rec_print_old(stderr,
4161 fputs(
"InnoDB: Validating insert buffer tree:\n", stderr);
4162 if (!btr_validate_index(ibuf->index, NULL)) {
4166 fprintf(stderr,
"InnoDB: ibuf tree ok\n");
4195 ut_ad(ibuf_inside());
4200 success = btr_cur_optimistic_delete(btr_pcur_get_btr_cur(pcur), mtr);
4211 == FSP_IBUF_TREE_ROOT_PAGE_NO);
4215 ut_ad(!ibuf->empty);
4219 #ifdef UNIV_IBUF_COUNT_DEBUG
4221 "Decrementing ibuf count of space %lu page %lu\n"
4222 "from %lu by 1\n", space, page_no,
4223 ibuf_count_get(space, page_no));
4224 ibuf_count_set(space, page_no,
4225 ibuf_count_get(space, page_no) - 1);
4235 btr_pcur_store_position(pcur, mtr);
4239 mutex_enter(&ibuf_mutex);
4243 if (!ibuf_restore_pos(space, page_no, search_tuple,
4246 mutex_exit(&ibuf_mutex);
4250 root = ibuf_tree_root_get(mtr);
4252 btr_cur_pessimistic_delete(&err, TRUE, btr_pcur_get_btr_cur(pcur),
4254 ut_a(err == DB_SUCCESS);
4256 #ifdef UNIV_IBUF_COUNT_DEBUG
4257 ibuf_count_set(space, page_no, ibuf_count_get(space, page_no) - 1);
4259 ibuf_size_update(root, mtr);
4260 mutex_exit(&ibuf_mutex);
4280 ibuf_merge_or_delete_for_page(
4289 ibool update_ibuf_bitmap)
4298 #ifdef UNIV_IBUF_DEBUG
4302 ibool tablespace_being_deleted = FALSE;
4303 ibool corruption_noticed = FALSE;
4307 ulint mops[IBUF_OP_COUNT];
4308 ulint dops[IBUF_OP_COUNT];
4329 if (ibuf_fixed_addr_page(space, 0, page_no)
4334 if (UNIV_LIKELY(update_ibuf_bitmap)) {
4337 if (ibuf_fixed_addr_page(space, zip_size, page_no)
4347 tablespace_being_deleted = fil_inc_pending_ibuf_merges(space);
4349 if (UNIV_UNLIKELY(tablespace_being_deleted)) {
4354 update_ibuf_bitmap = FALSE;
4360 bitmap_page = ibuf_bitmap_get_map_page(
4361 space, page_no, zip_size, &mtr);
4363 if (!ibuf_bitmap_page_get_bits(bitmap_page, page_no,
4365 IBUF_BITMAP_BUFFERED,
4370 if (!tablespace_being_deleted) {
4371 fil_decr_pending_ibuf_merges(space);
4379 && (ibuf_fixed_addr_page(space, zip_size, page_no)
4391 search_tuple = ibuf_search_tuple_build(space, page_no, heap);
4393 search_tuple = ibuf_new_search_tuple_build(space, page_no,
4406 if (UNIV_UNLIKELY(fil_page_get_type(block->
frame)
4412 corruption_noticed = TRUE;
4418 fputs(
" InnoDB: Dump of the ibuf bitmap page:\n",
4421 bitmap_page = ibuf_bitmap_get_map_page(space, page_no,
4423 buf_page_print(bitmap_page, 0);
4427 fputs(
"\nInnoDB: Dump of the page:\n", stderr);
4429 buf_page_print(block->
frame, 0);
4432 "InnoDB: Error: corruption in the tablespace."
4433 " Bitmap shows insert\n"
4434 "InnoDB: buffer records to page n:o %lu"
4435 " though the page\n"
4436 "InnoDB: type is %lu, which is"
4437 " not an index leaf page!\n"
4438 "InnoDB: We try to resolve the problem"
4439 " by skipping the insert buffer\n"
4440 "InnoDB: merge for this page."
4441 " Please run CHECK TABLE on your tables\n"
4442 "InnoDB: to determine if they are corrupt"
4444 "InnoDB: Please submit a detailed bug report"
4445 " to http://bugs.mysql.com\n\n",
4448 fil_page_get_type(block->
frame));
4452 memset(mops, 0,
sizeof(mops));
4453 memset(dops, 0,
sizeof(dops));
4461 success = buf_page_get_known_nowait(
4467 buf_block_dbg_add_level(block, SYNC_TREE_NODE);
4472 btr_pcur_open_on_user_rec(
4490 if (ibuf_rec_get_page_no(rec) != page_no
4491 || ibuf_rec_get_space(rec) != space) {
4495 block->
frame, page_zip, &mtr);
4501 if (UNIV_UNLIKELY(corruption_noticed)) {
4502 fputs(
"InnoDB: Discarding record\n ", stderr);
4503 rec_print_old(stderr, rec);
4504 fputs(
"\nInnoDB: from the insert buffer!\n\n", stderr);
4514 ibuf_op_t op = ibuf_rec_get_op_type(rec);
4522 entry = ibuf_build_entry_from_ibuf_rec(
4523 rec, heap, &dummy_index);
4529 case IBUF_OP_INSERT:
4530 #ifdef UNIV_IBUF_DEBUG
4532 dummy_index, entry, 0);
4536 ut_a(volume <= 4 * UNIV_PAGE_SIZE
4537 / IBUF_PAGE_SIZE_PER_FREE_SPACE);
4539 ibuf_insert_to_index_page(
4540 entry, block, dummy_index, &mtr);
4543 case IBUF_OP_DELETE_MARK:
4545 entry, block, dummy_index, &mtr);
4548 case IBUF_OP_DELETE:
4549 ibuf_delete(entry, block, dummy_index, &mtr);
4556 ut_ad(ibuf_rec_get_page_no(rec) == page_no);
4557 ut_ad(ibuf_rec_get_space(rec) == space);
4559 btr_pcur_store_position(&pcur, &mtr);
4564 success = buf_page_get_known_nowait(
4567 __FILE__, __LINE__, &mtr);
4570 buf_block_dbg_add_level(block, SYNC_TREE_NODE);
4572 if (!ibuf_restore_pos(space, page_no,
4579 ibuf_dummy_index_free(dummy_index);
4590 ibuf_dummy_index_free(dummy_index);
4592 dops[ibuf_rec_get_op_type(rec)]++;
4596 if (ibuf_delete_rec(space, page_no, &pcur, search_tuple,
4611 if (UNIV_LIKELY(update_ibuf_bitmap)) {
4614 bitmap_page = ibuf_bitmap_get_map_page(
4615 space, page_no, zip_size, &mtr);
4617 ibuf_bitmap_page_set_bits(
4618 bitmap_page, page_no, zip_size,
4619 IBUF_BITMAP_BUFFERED, FALSE, &mtr);
4622 ulint old_bits = ibuf_bitmap_page_get_bits(
4623 bitmap_page, page_no, zip_size,
4624 IBUF_BITMAP_FREE, &mtr);
4626 ulint new_bits = ibuf_index_page_calc_free(
4629 if (old_bits != new_bits) {
4630 ibuf_bitmap_page_set_bits(
4631 bitmap_page, page_no, zip_size,
4632 IBUF_BITMAP_FREE, new_bits, &mtr);
4641 #ifdef HAVE_ATOMIC_BUILTINS
4642 os_atomic_increment_ulint(&ibuf->n_merges, 1);
4643 ibuf_add_ops(ibuf->n_merged_ops, mops);
4644 ibuf_add_ops(ibuf->n_discarded_ops, dops);
4647 mutex_enter(&ibuf_mutex);
4650 ibuf_add_ops(ibuf->n_merged_ops, mops);
4651 ibuf_add_ops(ibuf->n_discarded_ops, dops);
4653 mutex_exit(&ibuf_mutex);
4656 if (update_ibuf_bitmap && !tablespace_being_deleted) {
4658 fil_decr_pending_ibuf_merges(space);
4663 #ifdef UNIV_IBUF_COUNT_DEBUG
4664 ut_a(ibuf_count_get(space, page_no) == 0);
4675 ibuf_delete_for_discarded_space(
4688 ulint dops[IBUF_OP_COUNT];
4695 search_tuple = ibuf_new_search_tuple_build(space, 0, heap);
4697 memset(dops, 0,
sizeof(dops));
4705 btr_pcur_open_on_user_rec(
4721 if (ibuf_rec_get_space(ibuf_rec) != space) {
4726 page_no = ibuf_rec_get_page_no(ibuf_rec);
4728 dops[ibuf_rec_get_op_type(ibuf_rec)]++;
4731 closed = ibuf_delete_rec(space, page_no, &pcur, search_tuple,
4756 #ifdef HAVE_ATOMIC_BUILTINS
4757 ibuf_add_ops(ibuf->n_discarded_ops, dops);
4760 mutex_enter(&ibuf_mutex);
4761 ibuf_add_ops(ibuf->n_discarded_ops, dops);
4762 mutex_exit(&ibuf_mutex);
4785 mutex_enter(&ibuf_mutex);
4786 root = ibuf_tree_root_get(&mtr);
4787 mutex_exit(&ibuf_mutex);
4793 ut_a(is_empty == ibuf->empty);
4806 #ifdef UNIV_IBUF_COUNT_DEBUG
4811 mutex_enter(&ibuf_mutex);
4814 "Ibuf: size %lu, free list len %lu,"
4815 " seg size %lu, %lu merges\n",
4817 (ulong) ibuf->free_list_len,
4818 (ulong) ibuf->seg_size,
4819 (ulong) ibuf->n_merges);
4821 fputs(
"merged operations:\n ", file);
4822 ibuf_print_ops(ibuf->n_merged_ops, file);
4824 fputs(
"discarded operations:\n ", file);
4825 ibuf_print_ops(ibuf->n_discarded_ops, file);
4827 #ifdef UNIV_IBUF_COUNT_DEBUG
4828 for (i = 0; i < IBUF_COUNT_N_SPACES; i++) {
4829 for (j = 0; j < IBUF_COUNT_N_PAGES; j++) {
4830 ulint count = ibuf_count_get(i, j);
4834 "Ibuf count for space/page %lu/%lu"
4836 (ulong) i, (ulong) j, (ulong) count);
4842 mutex_exit(&ibuf_mutex);