28 #include "page0page.ic"
35 #ifndef UNIV_HOTBACKUP
94 register uint16 rec_offs_bytes;
95 register const page_dir_slot_t* slot;
96 register const page_dir_slot_t* first_slot;
97 register const rec_t* r = rec;
102 first_slot = page_dir_get_nth_slot(page, 0);
108 ut_ad(r >= page + PAGE_NEW_SUPREMUM);
109 ut_ad(r < page + (UNIV_PAGE_SIZE - PAGE_DIR));
114 ut_ad(r >= page + PAGE_OLD_SUPREMUM);
115 ut_ad(r < page + (UNIV_PAGE_SIZE - PAGE_DIR));
121 while (UNIV_LIKELY(*(uint16*) slot != rec_offs_bytes)) {
123 if (UNIV_UNLIKELY(slot == first_slot)) {
125 "InnoDB: Probable data corruption on"
127 "InnoDB: Original record ",
131 fputs(
"(compact record)", stderr);
137 "InnoDB: on that page.\n"
138 "InnoDB: Cannot find the dir slot for record ",
141 fputs(
"(compact record)", stderr);
147 "InnoDB: on that page!\n", stderr);
149 buf_page_print(page, 0);
154 slot += PAGE_DIR_SLOT_SIZE;
157 return(((ulint) (first_slot - slot)) / PAGE_DIR_SLOT_SIZE);
167 page_dir_slot_t* slot)
179 ut_a(slot <= page_dir_get_nth_slot(page, 0));
180 ut_a(slot >= page_dir_get_nth_slot(page, n_slots - 1));
190 if (slot == page_dir_get_nth_slot(page, 0)) {
192 }
else if (slot == page_dir_get_nth_slot(page, n_slots - 1)) {
194 ut_a(n_owned <= PAGE_DIR_SLOT_MAX_N_OWNED);
196 ut_a(n_owned >= PAGE_DIR_SLOT_MIN_N_OWNED);
197 ut_a(n_owned <= PAGE_DIR_SLOT_MAX_N_OWNED);
214 page_t* page = buf_block_get_frame(block);
215 #ifndef UNIV_HOTBACKUP
216 const ibool is_hashed = block->
is_hashed;
222 ut_ad(!mtr || mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
229 if (UNIV_LIKELY_NULL(page_zip)) {
232 page + (PAGE_HEADER + PAGE_MAX_TRX_ID),
234 #ifndef UNIV_HOTBACKUP
243 #ifndef UNIV_HOTBACKUP
269 ut_ad(page && heap_no);
273 if (avl_space >= need) {
288 #ifndef UNIV_HOTBACKUP
293 page_create_write_log(
305 # define page_create_write_log(frame,mtr,comp) ((void) 0)
321 ut_ad(ptr && end_ptr);
343 page_dir_slot_t* slot;
355 #if PAGE_BTR_IBUF_FREE_LIST + FLST_BASE_NODE_SIZE > PAGE_DATA
356 # error "PAGE_BTR_IBUF_FREE_LIST + FLST_BASE_NODE_SIZE > PAGE_DATA"
358 #if PAGE_BTR_IBUF_FREE_LIST_NODE + FLST_NODE_SIZE > PAGE_DATA
359 # error "PAGE_BTR_IBUF_FREE_LIST_NODE + FLST_NODE_SIZE > PAGE_DATA"
363 if (UNIV_LIKELY(comp)) {
364 index = dict_ind_compact;
366 index = dict_ind_redundant;
372 page = buf_block_get_frame(block);
383 field = dtuple_get_nth_field(tuple, 0);
387 DATA_VARCHAR, DATA_ENGLISH | DATA_NOT_NULL, 8);
391 heap_top = page + PAGE_DATA;
395 if (UNIV_LIKELY(comp)) {
396 ut_a(infimum_rec == page + PAGE_NEW_INFIMUM);
401 ut_a(infimum_rec == page + PAGE_OLD_INFIMUM);
407 offsets = rec_get_offsets(infimum_rec, index, NULL,
408 ULINT_UNDEFINED, &heap);
416 field = dtuple_get_nth_field(tuple, 0);
420 DATA_VARCHAR, DATA_ENGLISH | DATA_NOT_NULL, comp ? 8 : 9);
424 if (UNIV_LIKELY(comp)) {
425 ut_a(supremum_rec == page + PAGE_NEW_SUPREMUM);
430 ut_a(supremum_rec == page + PAGE_OLD_SUPREMUM);
436 offsets = rec_get_offsets(supremum_rec, index, offsets,
437 ULINT_UNDEFINED, &heap);
440 ut_ad(heap_top == page
441 + (comp ? PAGE_NEW_SUPREMUM_END : PAGE_OLD_SUPREMUM_END));
450 ? 0x8000 | PAGE_HEAP_NO_USER_LOW
451 : PAGE_HEAP_NO_USER_LOW);
459 memset(heap_top, 0, UNIV_PAGE_SIZE - PAGE_EMPTY_DIR_START
466 slot = page_dir_get_nth_slot(page, 0);
469 slot = page_dir_get_nth_slot(page, 1);
474 if (UNIV_LIKELY(comp)) {
497 page_create_write_log(buf_block_get_frame(block), mtr, comp);
498 return(page_create_low(block, comp));
522 page = page_create_low(block, TRUE);
547 page_t* new_page = buf_block_get_frame(new_block);
551 ulint offsets_[REC_OFFS_NORMAL_SIZE];
552 ulint* offsets = offsets_;
553 rec_offs_init(offsets_);
566 (
page_is_comp(new_page) ? PAGE_NEW_INFIMUM : PAGE_OLD_INFIMUM));
568 cur2 = page_get_infimum_rec(buf_block_get_frame(new_block));
573 rec_t* cur1_rec = page_cur_get_rec(&cur1);
575 offsets = rec_get_offsets(cur1_rec, index, offsets,
576 ULINT_UNDEFINED, &heap);
578 cur1_rec, offsets, mtr);
579 if (UNIV_UNLIKELY(!ins_rec)) {
583 buf_page_print(new_page, 0);
588 "InnoDB: rec offset %lu, cur1 offset %lu,"
589 " cur2 offset %lu\n",
600 if (UNIV_LIKELY_NULL(heap)) {
605 #ifndef UNIV_HOTBACKUP
622 page_t* new_page = buf_block_get_frame(new_block);
626 page_get_infimum_rec(new_page));
629 #ifdef UNIV_ZIP_DEBUG
638 ut_a(page_zip_validate_low(page_zip, page, TRUE));
641 ut_ad(buf_block_get_frame(block) == page);
647 if (UNIV_LIKELY_NULL(new_page_zip)) {
667 if (UNIV_LIKELY_NULL(new_page_zip)) {
696 ret = new_page + PAGE_NEW_INFIMUM;
709 btr_search_move_or_delete_hash_entries(new_block, block, index);
730 page_t* new_page = buf_block_get_frame(new_block);
738 ulint offsets_[REC_OFFS_NORMAL_SIZE];
739 ulint* offsets = offsets_;
740 rec_offs_init(offsets_);
750 if (UNIV_LIKELY_NULL(new_page_zip)) {
761 while (page_cur_get_rec(&cur1) != rec) {
762 rec_t* cur1_rec = page_cur_get_rec(&cur1);
763 offsets = rec_get_offsets(cur1_rec, index, offsets,
764 ULINT_UNDEFINED, &heap);
766 cur1_rec, offsets, mtr);
772 if (UNIV_LIKELY_NULL(heap)) {
786 if (UNIV_LIKELY_NULL(new_page_zip)) {
814 ret = new_page + PAGE_NEW_INFIMUM;
827 btr_search_move_or_delete_hash_entries(new_block, block, index);
836 page_delete_rec_list_write_log(
858 # define page_delete_rec_list_write_log(rec,index,type,mtr) ((void) 0)
888 if (end_ptr < ptr + 2) {
901 page = buf_block_get_frame(block);
908 ULINT_UNDEFINED, ULINT_UNDEFINED,
934 page_dir_slot_t*slot;
942 ulint offsets_[REC_OFFS_NORMAL_SIZE];
943 ulint* offsets = offsets_;
944 rec_offs_init(offsets_);
946 ut_ad(size == ULINT_UNDEFINED || size < UNIV_PAGE_SIZE);
948 #ifdef UNIV_ZIP_DEBUG
949 ut_a(!page_zip || page_zip_validate(page_zip, page));
971 page_delete_rec_list_write_log(rec, index,
page_is_comp(page)
975 if (UNIV_LIKELY_NULL(page_zip)) {
987 offsets = rec_get_offsets(rec, index, offsets,
988 ULINT_UNDEFINED, &heap);
990 #ifdef UNIV_ZIP_DEBUG
991 ut_a(page_zip_validate(page_zip, page));
996 if (UNIV_LIKELY_NULL(heap)) {
1010 if ((size == ULINT_UNDEFINED) || (n_recs == ULINT_UNDEFINED)) {
1018 offsets = rec_get_offsets(rec2, index, offsets,
1019 ULINT_UNDEFINED, &heap);
1023 ut_ad(size + s < UNIV_PAGE_SIZE);
1030 if (UNIV_LIKELY_NULL(heap)) {
1035 ut_ad(size < UNIV_PAGE_SIZE);
1055 slot = page_dir_get_nth_slot(page, slot_index);
1070 slot = page_dir_get_nth_slot(page, slot_index);
1107 ulint offsets_[REC_OFFS_NORMAL_SIZE];
1108 ulint* offsets = offsets_;
1112 rec_offs_init(offsets_);
1116 #ifdef UNIV_ZIP_DEBUG
1119 page_t* page = buf_block_get_frame(block);
1126 ut_a(!page_zip || page_zip_validate_low(page_zip, page, TRUE));
1141 page_delete_rec_list_write_log(rec, index, type, mtr);
1150 while (page_cur_get_rec(&cur1) != rec) {
1151 offsets = rec_get_offsets(page_cur_get_rec(&cur1), index,
1152 offsets, ULINT_UNDEFINED, &heap);
1156 if (UNIV_LIKELY_NULL(heap)) {
1165 #ifndef UNIV_HOTBACKUP
1181 page_t* new_page = buf_block_get_frame(new_block);
1182 ulint old_data_size;
1183 ulint new_data_size;
1189 #ifdef UNIV_ZIP_DEBUG
1195 ut_a(!new_page_zip == !page_zip);
1197 || page_zip_validate(new_page_zip, new_page));
1199 || page_zip_validate(page_zip,
page_align(split_rec)));
1204 split_rec, index, mtr))) {
1211 ut_ad(new_data_size >= old_data_size);
1214 new_n_recs - old_n_recs,
1215 new_data_size - old_data_size, mtr);
1235 split_rec, index, mtr))) {
1259 data = rec_get_nth_field_old(rec, i, &len);
1273 page_dir_delete_slot(
1279 page_dir_slot_t* slot;
1292 slot = page_dir_get_nth_slot(page, slot_no);
1298 slot = page_dir_get_nth_slot(page, slot_no + 1);
1303 for (i = slot_no + 1; i < n_slots; i++) {
1304 rec_t* rec = (rec_t*)
1329 page_dir_slot_t* slot;
1334 ut_ad(start < n_slots - 1);
1340 slot = page_dir_get_nth_slot(page, n_slots);
1341 memmove(slot, slot + PAGE_DIR_SLOT_SIZE,
1342 (n_slots - 1 - start) * PAGE_DIR_SLOT_SIZE);
1357 page_dir_slot_t* new_slot;
1358 page_dir_slot_t* prev_slot;
1359 page_dir_slot_t* slot;
1367 slot = page_dir_get_nth_slot(page, slot_no);
1370 ut_ad(n_owned == PAGE_DIR_SLOT_MAX_N_OWNED + 1);
1375 prev_slot = page_dir_get_nth_slot(page, slot_no - 1);
1378 for (i = 0; i < n_owned / 2; i++) {
1382 ut_ad(n_owned / 2 >= PAGE_DIR_SLOT_MIN_N_OWNED);
1387 page_dir_add_slot(page, page_zip, slot_no - 1);
1392 new_slot = page_dir_get_nth_slot(page, slot_no);
1393 slot = page_dir_get_nth_slot(page, slot_no + 1);
1418 page_dir_slot_t* slot;
1419 page_dir_slot_t* up_slot;
1429 slot = page_dir_get_nth_slot(page, slot_no);
1439 up_slot = page_dir_get_nth_slot(page, slot_no + 1);
1444 ut_ad(n_owned == PAGE_DIR_SLOT_MIN_N_OWNED - 1);
1448 ut_ad(2 * PAGE_DIR_SLOT_MIN_N_OWNED - 1 <= PAGE_DIR_SLOT_MAX_N_OWNED);
1450 if (up_n_owned > PAGE_DIR_SLOT_MIN_N_OWNED) {
1473 page_dir_delete_slot(page, page_zip, slot_no);
1477 #ifndef UNIV_HOTBACKUP
1488 page_dir_slot_t* slot;
1502 slot = page_dir_get_nth_slot(page, i);
1505 if (count + n_owned > middle) {
1513 slot = page_dir_get_nth_slot(page, i - 1);
1519 for (i = 0; i < middle - count; i++) {
1537 const page_dir_slot_t* slot;
1538 const rec_t* slot_rec;
1553 for (i = 0; ; i++) {
1554 slot = page_dir_get_nth_slot(page, i);
1559 if (rec == slot_rec) {
1571 for (i = 0; ; i++) {
1572 slot = page_dir_get_nth_slot(page, i);
1577 if (rec == slot_rec) {
1591 #ifndef UNIV_HOTBACKUP
1600 const ulint* offsets)
1606 " n_owned: %lu; heap_no: %lu; next rec: %lu\n",
1612 " n_owned: %lu; heap_no: %lu; next rec: %lu\n",
1634 page_dir_slot_t* slot;
1638 fprintf(stderr,
"--------------------------------\n"
1641 "Directory stack top at offs: %lu; number of slots: %lu\n",
1642 page, (ulong)
page_offset(page_dir_get_nth_slot(page, n - 1)),
1644 for (i = 0; i < n; i++) {
1645 slot = page_dir_get_nth_slot(page, i);
1646 if ((i == pr_n) && (i < n - pr_n)) {
1647 fputs(
" ... \n", stderr);
1649 if ((i < pr_n) || (i >= n - pr_n)) {
1651 "Contents of slot: %lu: n_owned: %lu,"
1659 fprintf(stderr,
"Total of %lu records\n"
1660 "--------------------------------\n",
1680 ulint offsets_[REC_OFFS_NORMAL_SIZE];
1681 ulint* offsets = offsets_;
1682 rec_offs_init(offsets_);
1687 "--------------------------------\n"
1688 "PAGE RECORD LIST\n"
1689 "Page address %p\n", page);
1696 offsets = rec_get_offsets(cur.
rec, index, offsets,
1697 ULINT_UNDEFINED, &heap);
1700 if (count == pr_n) {
1710 if (n_recs > 2 * pr_n) {
1711 fputs(
" ... \n", stderr);
1717 if (count + pr_n >= n_recs) {
1718 offsets = rec_get_offsets(cur.
rec, index, offsets,
1719 ULINT_UNDEFINED, &heap);
1726 "Total of %lu records \n"
1727 "--------------------------------\n",
1728 (ulong) (count + 1));
1730 if (UNIV_LIKELY_NULL(heap)) {
1744 "--------------------------------\n"
1745 "PAGE HEADER INFO\n"
1746 "Page address %p, n records %lu (%s)\n"
1747 "n dir slots %lu, heap top %lu\n"
1748 "Page n heap %lu, free %lu, garbage %lu\n"
1749 "Page last insert %lu, direction %lu, n direction %lu\n",
1751 page_is_comp(page) ?
"compact format" :
"original format",
1794 const ulint* offsets)
1814 if (UNIV_UNLIKELY(!(n_owned <= PAGE_DIR_SLOT_MAX_N_OWNED))) {
1816 "InnoDB: Dir slot of rec %lu, n owned too big %lu\n",
1823 "InnoDB: Heap no of rec %lu too big %lu %lu\n",
1832 #ifndef UNIV_HOTBACKUP
1845 ulint supremum_offs;
1855 "InnoDB: Page directory corruption:"
1856 " infimum not pointed to\n");
1857 buf_page_print(page, 0);
1863 "InnoDB: Page directory corruption:"
1864 " supremum not pointed to\n");
1865 buf_page_print(page, 0);
1881 page_dir_slot_t* slot;
1897 if (UNIV_UNLIKELY(n_slots > UNIV_PAGE_SIZE / 4)) {
1899 "InnoDB: Nonsensical number %lu of page dir slots\n",
1907 if (UNIV_UNLIKELY(rec_heap_top
1908 > page_dir_get_nth_slot(page, n_slots - 1))) {
1911 "InnoDB: Record heap and dir overlap on a page,"
1912 " heap top %lu, dir %lu\n",
1915 page_offset(page_dir_get_nth_slot(page, n_slots - 1)));
1926 slot = page_dir_get_nth_slot(page, slot_no);
1928 rec = page_get_infimum_rec(page);
1931 if (UNIV_UNLIKELY(rec > rec_heap_top)) {
1933 "InnoDB: Record %lu is above"
1934 " rec heap top %lu\n",
1935 (ulong)(rec - page),
1936 (ulong)(rec_heap_top - page));
1947 "InnoDB: Wrong owned count %lu, %lu,"
1951 (ulong)(rec - page));
1959 "InnoDB: Dir slot does not point"
1960 " to right rec %lu\n",
1961 (ulong)(rec - page));
1970 slot = page_dir_get_nth_slot(page, slot_no);
1983 "InnoDB: Next record offset"
1984 " nonsensical %lu for rec %lu\n",
1986 (ulong) (rec - page));
1993 if (UNIV_UNLIKELY(count > UNIV_PAGE_SIZE)) {
1995 "InnoDB: Page record list appears"
1996 " to be circular %lu\n",
2006 fprintf(stderr,
"InnoDB: n owned is zero in a supremum rec\n");
2011 if (UNIV_UNLIKELY(slot_no != n_slots - 1)) {
2012 fprintf(stderr,
"InnoDB: n slots wrong %lu, %lu\n",
2013 (ulong) slot_no, (ulong) (n_slots - 1));
2018 + PAGE_HEAP_NO_USER_LOW
2020 fprintf(stderr,
"InnoDB: n recs wrong %lu %lu\n",
2022 + PAGE_HEAP_NO_USER_LOW,
2023 (ulong) (count + 1));
2031 while (rec != NULL) {
2033 || rec >= page + UNIV_PAGE_SIZE)) {
2035 "InnoDB: Free list record has"
2036 " a nonsensical offset %lu\n",
2037 (ulong) (rec - page));
2042 if (UNIV_UNLIKELY(rec > rec_heap_top)) {
2044 "InnoDB: Free list record %lu"
2045 " is above rec heap top %lu\n",
2046 (ulong) (rec - page),
2047 (ulong) (rec_heap_top - page));
2054 if (UNIV_UNLIKELY(count > UNIV_PAGE_SIZE)) {
2056 "InnoDB: Page free list appears"
2057 " to be circular %lu\n",
2067 fprintf(stderr,
"InnoDB: N heap is wrong %lu, %lu\n",
2069 (ulong) (count + 1));
2091 page_dir_slot_t* slot;
2107 if (UNIV_UNLIKELY(n_slots > UNIV_PAGE_SIZE / 4)) {
2109 "InnoDB: Nonsensical number %lu"
2110 " of page dir slots\n", (ulong) n_slots);
2117 if (UNIV_UNLIKELY(rec_heap_top
2118 > page_dir_get_nth_slot(page, n_slots - 1))) {
2121 "InnoDB: Record heap and dir overlap on a page,"
2122 " heap top %lu, dir %lu\n",
2125 page_offset(page_dir_get_nth_slot(page, n_slots - 1)));
2136 slot = page_dir_get_nth_slot(page, slot_no);
2138 rec = page_get_infimum_rec(page);
2141 if (UNIV_UNLIKELY(rec > rec_heap_top)) {
2143 "InnoDB: Record %lu is above rec"
2157 "InnoDB: Wrong owned count %lu, %lu,"
2169 "InnoDB: Dir slot does not point"
2170 " to right rec %lu\n",
2180 slot = page_dir_get_nth_slot(page, slot_no);
2193 "InnoDB: Next record offset nonsensical %lu"
2203 if (UNIV_UNLIKELY(count > UNIV_PAGE_SIZE)) {
2205 "InnoDB: Page record list appears"
2206 " to be circular %lu\n",
2216 fprintf(stderr,
"InnoDB: n owned is zero"
2217 " in a supremum rec\n");
2222 if (UNIV_UNLIKELY(slot_no != n_slots - 1)) {
2223 fprintf(stderr,
"InnoDB: n slots wrong %lu, %lu\n",
2224 (ulong) slot_no, (ulong) (n_slots - 1));
2229 + PAGE_HEAP_NO_USER_LOW
2231 fprintf(stderr,
"InnoDB: n recs wrong %lu %lu\n",
2233 + PAGE_HEAP_NO_USER_LOW,
2234 (ulong) (count + 1));
2242 while (rec != NULL) {
2244 || rec >= page + UNIV_PAGE_SIZE)) {
2246 "InnoDB: Free list record has"
2247 " a nonsensical offset %lu\n",
2253 if (UNIV_UNLIKELY(rec > rec_heap_top)) {
2255 "InnoDB: Free list record %lu"
2256 " is above rec heap top %lu\n",
2265 if (UNIV_UNLIKELY(count > UNIV_PAGE_SIZE)) {
2267 "InnoDB: Page free list appears"
2268 " to be circular %lu\n",
2278 fprintf(stderr,
"InnoDB: N heap is wrong %lu, %lu\n",
2280 (ulong) (count + 1));
2302 page_dir_slot_t*slot= NULL;
2307 ulint rec_own_count= 0;
2311 rec_t* old_rec = NULL;
2316 ulint* offsets = NULL;
2317 ulint* old_offsets = NULL;
2318 void* buf_ptr= NULL;
2322 fputs(
"InnoDB: 'compact format' flag mismatch\n", stderr);
2341 buf =
static_cast<byte *
>(buf_ptr);
2349 <= page_dir_get_nth_slot(page, n_slots - 1)))) {
2352 "InnoDB: Record heap and dir overlap"
2353 " on space %lu page %lu index %s, %p, %p\n",
2357 page_dir_get_nth_slot(page, n_slots - 1));
2368 slot = page_dir_get_nth_slot(page, slot_no);
2370 rec = page_get_infimum_rec(page);
2373 offsets = rec_get_offsets(rec, index, offsets,
2374 ULINT_UNDEFINED, &heap);
2379 fputs(
"InnoDB: node_ptr flag mismatch\n", stderr);
2387 #ifndef UNIV_HOTBACKUP
2389 if (UNIV_LIKELY(count >= PAGE_HEAP_NO_USER_LOW)
2393 offsets, old_offsets, index))) {
2395 "InnoDB: Records in wrong order"
2396 " on space %lu page %lu index %s\n",
2400 fputs(
"\nInnoDB: previous record ", stderr);
2402 fputs(
"\nInnoDB: record ", stderr);
2418 if (UNIV_UNLIKELY(offs + i >= UNIV_PAGE_SIZE)) {
2419 fputs(
"InnoDB: record offset out of bounds\n", stderr);
2424 if (UNIV_UNLIKELY(buf[offs + i])) {
2427 fputs(
"InnoDB: Record overlaps another\n",
2441 if (UNIV_UNLIKELY(rec_own_count)) {
2443 if (UNIV_UNLIKELY(rec_own_count != own_count)) {
2445 "InnoDB: Wrong owned count %lu, %lu\n",
2446 (ulong) rec_own_count,
2452 fputs(
"InnoDB: Dir slot does not"
2453 " point to right rec\n",
2458 page_dir_slot_check(slot);
2463 slot = page_dir_get_nth_slot(page, slot_no);
2478 ulint* tmp_offs = old_offsets;
2479 old_offsets = offsets;
2491 fputs(
"InnoDB: n owned is zero\n", stderr);
2495 if (UNIV_UNLIKELY(slot_no != n_slots - 1)) {
2496 fprintf(stderr,
"InnoDB: n slots wrong %lu %lu\n",
2497 (ulong) slot_no, (ulong) (n_slots - 1));
2502 + PAGE_HEAP_NO_USER_LOW
2504 fprintf(stderr,
"InnoDB: n recs wrong %lu %lu\n",
2506 + PAGE_HEAP_NO_USER_LOW,
2507 (ulong) (count + 1));
2513 "InnoDB: Summed data size %lu, returned by func %lu\n",
2521 while (rec != NULL) {
2522 offsets = rec_get_offsets(rec, index, offsets,
2523 ULINT_UNDEFINED, &heap);
2532 if (UNIV_UNLIKELY(offs + i >= UNIV_PAGE_SIZE)) {
2533 fputs(
"InnoDB: record offset out of bounds\n", stderr);
2539 if (UNIV_UNLIKELY(buf[offs + i])) {
2540 fputs(
"InnoDB: Record overlaps another"
2541 " in free list\n", stderr);
2552 fprintf(stderr,
"InnoDB: N heap is wrong %lu %lu\n",
2563 if (UNIV_UNLIKELY(ret == FALSE)) {
2566 "InnoDB: Apparent corruption"
2567 " in space %lu page %lu index %s\n",
2571 buf_page_print(page, 0);
2577 #ifndef UNIV_HOTBACKUP
2591 rec = page + PAGE_NEW_INFIMUM;
2596 if (rec_heap_no == heap_no) {
2599 }
else if (rec_heap_no == PAGE_HEAP_NO_SUPREMUM) {
2607 rec = page + PAGE_OLD_INFIMUM;
2612 if (rec_heap_no == heap_no) {
2615 }
else if (rec_heap_no == PAGE_HEAP_NO_SUPREMUM) {