29 #include "log0recv.ic"
45 #include "xtrabackup_api.h"
46 #ifndef UNIV_HOTBACKUP
58 UNIV_INTERN ibool recv_replay_file_ops = TRUE;
61 #include <boost/scoped_array.hpp>
63 #include <drizzled/errmsg_print.h>
67 #define RECV_DATA_BLOCK_SIZE (MEM_MAX_ALLOC_IN_BUF - sizeof(recv_data_t))
70 #define RECV_READ_AHEAD_AREA 32
78 #ifdef UNIV_LOG_ARCHIVE
80 UNIV_INTERN ibool recv_recovery_from_backup_on;
83 #ifndef UNIV_HOTBACKUP
89 UNIV_INTERN ibool recv_no_log_write = FALSE;
105 static ibool recv_log_scan_is_startup_type;
118 # define recv_is_making_a_backup FALSE
120 # define recv_is_from_backup FALSE
122 # define recv_needed_recovery FALSE
124 UNIV_INTERN ibool recv_is_making_a_backup = FALSE;
126 UNIV_INTERN ibool recv_is_from_backup = FALSE;
127 # define buf_pool_get_curr_size() (5 * 1024 * 1024)
131 static ulint recv_scan_print_counter;
134 static ulint recv_previous_parsed_rec_type;
136 static ulint recv_previous_parsed_rec_offset;
138 static ulint recv_previous_parsed_rec_is_multi;
154 UNIV_INTERN ib_uint64_t recv_max_page_lsn;
156 #ifdef UNIV_PFS_THREAD
157 UNIV_INTERN mysql_pfs_key_t trx_rollback_clean_thread_key;
160 #ifdef UNIV_PFS_MUTEX
161 UNIV_INTERN mysql_pfs_key_t recv_sys_mutex_key;
166 #ifndef UNIV_HOTBACKUP
172 recv_init_crash_recovery(
void);
191 mutex_create(recv_sys_mutex_key, &
recv_sys->
mutex, SYNC_RECV);
257 #ifndef UNIV_HOTBACKUP
271 #ifdef UNIV_LOG_ARCHIVE
272 recv_recovery_from_backup_on = FALSE;
279 recv_log_scan_is_startup_type = FALSE;
283 recv_scan_print_counter = 0;
285 recv_previous_parsed_rec_type = 999999;
287 recv_previous_parsed_rec_offset = 0;
289 recv_previous_parsed_rec_is_multi = 0;
295 recv_max_page_lsn = 0;
305 ulint available_memory)
312 #ifndef UNIV_HOTBACKUP
317 #ifndef UNIV_HOTBACKUP
326 recv_is_from_backup = TRUE;
351 recv_max_page_lsn = 0;
360 recv_sys_empty_hash(
void)
366 drizzled::errmsg_printf(drizzled::error::ERROR,
367 "InnoDB: Error: %lu pages with log records were left unprocessed!\n"
368 "InnoDB: Maximum page number with log records on it %lu\n",
380 #ifndef UNIV_HOTBACKUP
381 # ifndef UNIV_LOG_DEBUG
386 recv_sys_debug_free(
void)
415 ib_uint64_t recovered_lsn,
417 ib_uint64_t limit_lsn,
419 ib_uint64_t checkpoint_lsn,
421 ib_uint64_t archived_lsn)
424 ib_uint64_t start_lsn;
426 ib_uint64_t finish_lsn1;
427 ib_uint64_t finish_lsn2;
428 ib_uint64_t finish_lsn;
432 if (archived_lsn == IB_ULONGLONG_MAX) {
434 archived_lsn = checkpoint_lsn;
445 if (limit_lsn != IB_ULONGLONG_MAX) {
449 finish_lsn = finish_lsn1;
452 finish_lsn = finish_lsn1 < finish_lsn2
453 ? finish_lsn1 : finish_lsn2;
456 ut_a(RECV_SCAN_SIZE <= log_sys->buf_size);
461 *(log_sys->
buf + i) =
'\0';
467 if (start_lsn != recovered_lsn) {
474 (ulint) (recovered_lsn - start_lsn));
477 if (start_lsn >= finish_lsn) {
485 if (end_lsn > finish_lsn) {
487 end_lsn = finish_lsn;
490 len = (ulint) (end_lsn - start_lsn);
493 if (end_lsn >= finish_lsn) {
501 *(log_sys->
buf + i) =
'\0';
519 ib_uint64_t recovered_lsn)
522 ib_uint64_t start_lsn;
531 ut_a(RECV_SCAN_SIZE <= log_sys->buf_size);
538 if (end_lsn > recovered_lsn) {
544 up_to_date_group, start_lsn, end_lsn);
546 len = (ulint) (end_lsn - start_lsn);
550 if (end_lsn >= recovered_lsn) {
566 recv_synchronize_groups(
572 ib_uint64_t start_lsn;
574 ib_uint64_t recovered_lsn;
585 ut_a(start_lsn != end_lsn);
588 up_to_date_group, start_lsn, end_lsn);
593 if (group != up_to_date_group) {
597 recv_copy_group(group, up_to_date_group,
616 mutex_exit(&(log_sys->
mutex));
622 mutex_enter(&(log_sys->
mutex));
630 recv_check_cp_is_consistent(
639 buf + LOG_CHECKPOINT_CHECKSUM_1)) {
644 LOG_CHECKPOINT_CHECKSUM_2 - LOG_CHECKPOINT_LSN);
647 buf + LOG_CHECKPOINT_CHECKSUM_2)) {
654 #ifndef UNIV_HOTBACKUP
659 recv_find_max_checkpoint(
667 ib_uint64_t checkpoint_no;
680 group->
state = LOG_GROUP_CORRUPTED;
682 for (field = LOG_CHECKPOINT_1; field <= LOG_CHECKPOINT_2;
683 field += LOG_CHECKPOINT_2 - LOG_CHECKPOINT_1) {
687 if (!recv_check_cp_is_consistent(buf)) {
689 if (log_debug_writes) {
690 drizzled::errmsg_printf(drizzled::error::INFO,
691 "InnoDB: Checkpoint in group %lu at %lu invalid, %lu\n",
696 + LOG_CHECKPOINT_CHECKSUM_1));
703 group->
state = LOG_GROUP_OK;
706 buf + LOG_CHECKPOINT_LSN);
708 #ifdef UNIV_LOG_ARCHIVE
709 #error "UNIV_LOG_ARCHIVE could not be enabled"
713 buf + LOG_CHECKPOINT_ARCHIVED_LSN);
714 if (
sizeof(ulint) != 4
715 && tmp_lsn_offset != IB_ULONGLONG_MAX) {
719 buf + LOG_CHECKPOINT_OFFSET);
724 buf + LOG_CHECKPOINT_NO);
727 if (log_debug_writes) {
728 drizzled::errmsg_printf(drizzled::error::INFO,
729 "InnoDB: Checkpoint number %lu found in group %lu\n",
730 (ulong) checkpoint_no,
735 if (checkpoint_no >= max_no) {
738 max_no = checkpoint_no;
748 if (*max_group == NULL) {
750 drizzled::errmsg_printf(drizzled::error::ERROR,
751 "InnoDB: No valid checkpoint found. If this error appears when you are"
752 " creating an InnoDB database,InnoDB: the problem may be that during"
753 " an earlier attempt you managed to create the InnoDB data files,"
754 " but log file creation failed. If that is the case, please refer to\n"
755 "InnoDB: " REFMAN
"error-creating-innodb.html\n");
767 recv_read_cp_info_for_backup(
777 ib_uint64_t* first_header_lsn)
782 ib_uint64_t max_cp_no = 0;
785 cp_buf = hdr + LOG_CHECKPOINT_1;
787 if (recv_check_cp_is_consistent(cp_buf)) {
789 max_cp = LOG_CHECKPOINT_1;
792 cp_buf = hdr + LOG_CHECKPOINT_2;
794 if (recv_check_cp_is_consistent(cp_buf)) {
796 max_cp = LOG_CHECKPOINT_2;
804 cp_buf = hdr + max_cp;
812 == LOG_CHECKPOINT_FSP_MAGIC_N_VAL) {
815 cp_buf + LOG_CHECKPOINT_FSP_FREE_LIMIT);
817 if (*fsp_limit == 0) {
818 *fsp_limit = 1000000000;
821 *fsp_limit = 1000000000;
841 log_block_checksum_is_ok_or_old_format(
845 #ifdef UNIV_LOG_DEBUG
859 "InnoDB: Scanned old format < InnoDB-3.23.52"
860 " log block number %lu\n",
869 #ifdef UNIV_HOTBACKUP
875 recv_scan_log_seg_for_backup(
879 ib_uint64_t* scanned_lsn,
881 ulint* scanned_checkpoint_no,
885 ulint* n_bytes_scanned)
893 *n_bytes_scanned = 0;
895 for (log_block = buf; log_block < buf + buf_len;
901 fprintf(stderr,
"Log block header no %lu\n", no);
905 || !log_block_checksum_is_ok_or_old_format(log_block)) {
908 "Log block n:o %lu, scanned lsn n:o %lu\n",
916 "Next log block n:o %lu\n",
922 if (*scanned_checkpoint_no > 0
924 < *scanned_checkpoint_no
925 && *scanned_checkpoint_no
933 "Scanned cp n:o %lu, block cp n:o %lu\n",
934 *scanned_checkpoint_no,
942 *scanned_checkpoint_no
944 *scanned_lsn += data_len;
946 *n_bytes_scanned += data_len;
952 fprintf(stderr,
"Log block data len %lu\n",
967 recv_parse_or_apply_log_rec_body(
986 ut_ad(!block == !mtr);
999 #ifdef UNIV_LOG_LSN_DEBUG
1007 && end_ptr >= ptr + 2) {
1027 || offs == IBUF_TREE_SEG_HEADER
1028 + IBUF_HEADER + FSEG_HDR_OFFSET
1029 || offs == PAGE_BTR_IBUF_FREE_LIST
1030 + PAGE_HEADER + FIL_ADDR_BYTE
1031 || offs == PAGE_BTR_IBUF_FREE_LIST
1032 + PAGE_HEADER + FIL_ADDR_BYTE
1034 || offs == PAGE_BTR_SEG_LEAF
1035 + PAGE_HEADER + FSEG_HDR_OFFSET
1036 || offs == PAGE_BTR_SEG_TOP
1037 + PAGE_HEADER + FSEG_HDR_OFFSET
1038 || offs == PAGE_BTR_IBUF_FREE_LIST_NODE
1039 + PAGE_HEADER + FIL_ADDR_BYTE
1041 || offs == PAGE_BTR_IBUF_FREE_LIST_NODE
1042 + PAGE_HEADER + FIL_ADDR_BYTE
1050 || offs == IBUF_TREE_SEG_HEADER
1051 + IBUF_HEADER + FSEG_HDR_SPACE
1052 || offs == IBUF_TREE_SEG_HEADER
1053 + IBUF_HEADER + FSEG_HDR_PAGE_NO
1054 || offs == PAGE_BTR_IBUF_FREE_LIST
1056 || offs == PAGE_BTR_IBUF_FREE_LIST
1057 + PAGE_HEADER + FIL_ADDR_PAGE
1058 || offs == PAGE_BTR_IBUF_FREE_LIST
1059 + PAGE_HEADER + FIL_ADDR_PAGE
1061 || offs == PAGE_BTR_SEG_LEAF
1062 + PAGE_HEADER + FSEG_HDR_PAGE_NO
1063 || offs == PAGE_BTR_SEG_LEAF
1064 + PAGE_HEADER + FSEG_HDR_SPACE
1065 || offs == PAGE_BTR_SEG_TOP
1066 + PAGE_HEADER + FSEG_HDR_PAGE_NO
1067 || offs == PAGE_BTR_SEG_TOP
1068 + PAGE_HEADER + FSEG_HDR_SPACE
1069 || offs == PAGE_BTR_IBUF_FREE_LIST_NODE
1070 + PAGE_HEADER + FIL_ADDR_PAGE
1072 || offs == PAGE_BTR_IBUF_FREE_LIST_NODE
1073 + PAGE_HEADER + FIL_ADDR_PAGE
1106 ptr, end_ptr, page, page_zip, index);
1166 ptr, end_ptr, block, index, mtr);
1323 recv_get_fil_addr_struct(
1331 recv_hash(space, page_no)));
1333 if ((recv_addr->
space == space)
1334 && (recv_addr->
page_no == page_no)) {
1349 recv_add_to_hash_table(
1356 ib_uint64_t start_lsn,
1357 ib_uint64_t end_lsn)
1372 len = rec_end - body;
1376 recv->
len = rec_end - body;
1380 recv_addr = recv_get_fil_addr_struct(space, page_no);
1382 if (recv_addr == NULL) {
1385 recv_addr->
space = space;
1392 recv_fold(space, page_no), recv_addr);
1395 fprintf(stderr,
"Inserting log rec for space %lu, page %lu\n",
1402 prev_field = &(recv->
data);
1408 while (rec_end > body) {
1410 len = rec_end - body;
1412 if (len > RECV_DATA_BLOCK_SIZE) {
1413 len = RECV_DATA_BLOCK_SIZE;
1418 *prev_field = recv_data;
1420 memcpy(recv_data + 1, body, len);
1422 prev_field = &(recv_data->
next);
1434 recv_data_copy_to_buf(
1444 recv_data = recv->
data;
1447 if (len > RECV_DATA_BLOCK_SIZE) {
1448 part_len = RECV_DATA_BLOCK_SIZE;
1458 recv_data = recv_data->
next;
1470 #ifndef UNIV_HOTBACKUP
1482 ib_uint64_t start_lsn;
1483 ib_uint64_t end_lsn;
1484 ib_uint64_t page_lsn;
1485 ib_uint64_t page_newest_lsn;
1486 ibool modification_to_page;
1487 #ifndef UNIV_HOTBACKUP
1506 if ((recv_addr == NULL)
1516 fprintf(stderr,
"Recovering space %lu, page %lu\n",
1527 page = block->frame;
1530 #ifndef UNIV_HOTBACKUP
1546 buf_block_dbg_add_level(block, SYNC_NO_ORDER_CHECK);
1552 #ifndef UNIV_HOTBACKUP
1558 if (page_newest_lsn) {
1560 page_lsn = page_newest_lsn;
1564 page_newest_lsn = 0;
1567 modification_to_page = FALSE;
1568 start_lsn = end_lsn = 0;
1575 if (recv->
len > RECV_DATA_BLOCK_SIZE) {
1579 buf =
static_cast<byte *
>(mem_alloc(recv->
len));
1581 recv_data_copy_to_buf(buf, recv);
1587 page_lsn = page_newest_lsn;
1600 ib_uint64_t page_end_lsn;
1602 if (!modification_to_page) {
1604 modification_to_page = TRUE;
1609 if (log_debug_writes) {
1611 "InnoDB: Applying log rec"
1613 " to space %lu page no %lu\n",
1614 (ulong) recv->
type, (ulong) recv->
len,
1615 (ulong) recv_addr->
space,
1620 recv_parse_or_apply_log_rec_body(recv->
type, buf,
1628 + page, page_end_lsn);
1632 + page_zip->
data, page_end_lsn);
1636 if (recv->
len > RECV_DATA_BLOCK_SIZE) {
1643 #ifdef UNIV_ZIP_DEBUG
1648 ut_a(page_zip_validate_low(page_zip, page, FALSE));
1655 if (recv_max_page_lsn < page_lsn) {
1656 recv_max_page_lsn = page_lsn;
1666 #ifndef UNIV_HOTBACKUP
1667 if (modification_to_page) {
1679 mtr.modifications = FALSE;
1684 #ifndef UNIV_HOTBACKUP
1698 ulint page_nos[RECV_READ_AHEAD_AREA];
1702 low_limit = page_no - (page_no % RECV_READ_AHEAD_AREA);
1706 for (page_no = low_limit; page_no < low_limit + RECV_READ_AHEAD_AREA;
1708 recv_addr = recv_get_fil_addr_struct(space, page_no);
1717 page_nos[n] = page_no;
1753 ibool has_printed = FALSE;
1767 ut_ad(!allow_ibuf == mutex_own(&log_sys->
mutex));
1781 ulint space = recv_addr->
space;
1783 ulint page_no = recv_addr->
page_no;
1788 fputs(
" InnoDB: Starting an"
1789 " apply batch of log records"
1790 " to the database...\n"
1791 "InnoDB: Progress in percents: ",
1804 space, zip_size, page_no,
1806 buf_block_dbg_add_level(
1807 block, SYNC_NO_ORDER_CHECK);
1812 recv_read_in_area(space, zip_size,
1827 fprintf(stderr,
"%lu ", (ulong)
1846 fprintf(stderr,
"\n");
1853 ut_d(recv_no_log_write = TRUE);
1855 mutex_exit(&(log_sys->
mutex));
1858 ut_a(n_pages != ULINT_UNDEFINED);
1864 mutex_enter(&(log_sys->
mutex));
1866 ut_d(recv_no_log_write = FALSE);
1874 recv_sys_empty_hash();
1877 fprintf(stderr,
"InnoDB: Apply batch completed\n");
1887 recv_apply_log_recs_for_backup(
void)
1901 block = back_block1;
1903 fputs(
"InnoDB: Starting an apply batch of log records"
1904 " to the database...\n"
1905 "InnoDB: Progress in percents: ", stderr);
1909 for (i = 0; i < n_hash_cells; i++) {
1913 while (recv_addr != NULL) {
1918 if (zip_size == ULINT_UNDEFINED) {
1921 "InnoDB: Warning: cannot apply"
1923 " tablespace %lu page %lu,\n"
1924 "InnoDB: because tablespace with"
1925 " that id does not exist.\n",
1933 goto skip_this_recv_addr;
1940 buf_page_init_for_backup_restore(
1954 "InnoDB: Fatal error: cannot extend"
1955 " tablespace %lu to hold %lu pages\n",
1966 recv_addr->
space, zip_size,
1967 recv_addr->
page_no, 0, zip_size,
1969 if (error == DB_SUCCESS
1975 recv_addr->
space, 0,
1978 block->
frame, NULL);
1981 if (error != DB_SUCCESS) {
1983 "InnoDB: Fatal error: cannot read"
1985 " %lu page number %lu\n",
1986 (ulong) recv_addr->
space,
2003 error =
fil_io(OS_FILE_WRITE, TRUE,
2004 recv_addr->
space, zip_size,
2009 error =
fil_io(OS_FILE_WRITE, TRUE,
2010 recv_addr->
space, 0,
2013 block->
frame, NULL);
2015 skip_this_recv_addr:
2019 if ((100 * i) / n_hash_cells
2020 != (100 * (i + 1)) / n_hash_cells) {
2021 fprintf(stderr,
"%lu ",
2022 (ulong) ((100 * i) / n_hash_cells));
2027 recv_sys_empty_hash();
2049 if (ptr == end_ptr) {
2064 *space = ULINT_UNDEFINED - 1;
2073 if (UNIV_UNLIKELY(!new_ptr)) {
2078 #ifdef UNIV_LOG_LSN_DEBUG
2079 if (*type == MLOG_LSN) {
2080 ib_uint64_t lsn = (ib_uint64_t) *space << 32 | *page_no;
2081 # ifdef UNIV_LOG_DEBUG
2089 new_ptr = recv_parse_or_apply_log_rec_body(*type, new_ptr, end_ptr,
2091 if (UNIV_UNLIKELY(new_ptr == NULL)) {
2100 return(new_ptr - ptr);
2107 recv_calc_lsn_on_data_add(
2117 - LOG_BLOCK_HDR_SIZE;
2119 - LOG_BLOCK_TRL_SIZE);
2120 lsn_len = (ulint) len;
2121 lsn_len += (lsn_len + frag_len)
2123 - LOG_BLOCK_TRL_SIZE)
2124 * (LOG_BLOCK_HDR_SIZE + LOG_BLOCK_TRL_SIZE);
2126 return(lsn + lsn_len);
2129 #ifdef UNIV_LOG_DEBUG
2135 recv_check_incomplete_log_recs(
2146 for (i = 0; i < len; i++) {
2147 ut_a(0 == recv_parse_log_rec(ptr, ptr + i, &type, &space,
2157 recv_report_corrupt_log(
2165 "InnoDB: ############### CORRUPT LOG RECORD FOUND\n"
2166 "InnoDB: Log record type %lu, space id %lu, page number %lu\n"
2167 "InnoDB: Log parsing proceeded successfully up to %"PRIu64
"\n"
2168 "InnoDB: Previous log record type %lu, is multi %lu\n"
2169 "InnoDB: Recv offset %lu, prev %lu\n",
2170 (ulong) type, (ulong) space, (ulong) page_no,
2172 (ulong) recv_previous_parsed_rec_type,
2173 (ulong) recv_previous_parsed_rec_is_multi,
2175 (ulong) recv_previous_parsed_rec_offset);
2178 > recv_previous_parsed_rec_offset
2180 - recv_previous_parsed_rec_offset)
2182 fputs(
"InnoDB: Hex dump of corrupt log starting"
2183 " 100 bytes before the start\n"
2184 "InnoDB: of the previous log rec,\n"
2185 "InnoDB: and ending 100 bytes after the start"
2186 " of the corrupt rec:\n",
2191 + recv_previous_parsed_rec_offset - 100,
2193 - recv_previous_parsed_rec_offset);
2197 #ifndef UNIV_HOTBACKUP
2198 if (!srv_force_recovery) {
2199 fputs(
"InnoDB: Set innodb_force_recovery"
2200 " to ignore this error.\n", stderr);
2205 fputs(
"InnoDB: WARNING: the log file may have been corrupt and it\n"
2206 "InnoDB: is possible that the log scan did not proceed\n"
2207 "InnoDB: far enough in recovery! Please run CHECK TABLE\n"
2208 "InnoDB: on your InnoDB tables to check that they are ok!\n"
2209 "InnoDB: If mysqld crashes after this recovery, look at\n"
2210 "InnoDB: " REFMAN
"forcing-innodb-recovery.html\n"
2211 "InnoDB: about forcing recovery.\n", stderr);
2222 recv_parse_log_recs(
2224 ibool store_to_hash)
2233 ib_uint64_t new_recovered_lsn;
2234 ib_uint64_t old_lsn;
2248 if (ptr == end_ptr) {
2263 len = recv_parse_log_rec(ptr, end_ptr, &type, &space,
2269 recv_report_corrupt_log(ptr,
2270 type, space, page_no);
2276 new_recovered_lsn = recv_calc_lsn_on_data_add(old_lsn, len);
2286 recv_previous_parsed_rec_type = (ulint)type;
2288 recv_previous_parsed_rec_is_multi = 0;
2294 if (log_debug_writes) {
2296 "InnoDB: Parsed a single log rec"
2297 " type %lu len %lu space %lu page no %lu\n",
2298 (ulong) type, (ulong) len, (ulong) space,
2306 }
else if (!store_to_hash) {
2310 #ifdef UNIV_LOG_DEBUG
2311 recv_check_incomplete_log_recs(ptr, len);
2319 #ifdef UNIV_HOTBACKUP
2320 if (recv_replay_file_ops) {
2328 body, end_ptr, type,
2331 "InnoDB: Error: file op"
2332 " log record of type %lu"
2333 " space %lu not complete in\n"
2334 "InnoDB: the replay phase."
2345 #ifdef UNIV_LOG_LSN_DEBUG
2346 }
else if (type == MLOG_LSN) {
2352 recv_add_to_hash_table(type, space, page_no, body,
2364 len = recv_parse_log_rec(ptr, end_ptr, &type, &space,
2370 recv_report_corrupt_log(
2371 ptr, type, space, page_no);
2377 recv_previous_parsed_rec_type = (ulint)type;
2378 recv_previous_parsed_rec_offset
2380 recv_previous_parsed_rec_is_multi = 1;
2382 #ifdef UNIV_LOG_DEBUG
2384 recv_check_incomplete_log_recs(ptr, len);
2389 if (log_debug_writes) {
2391 "InnoDB: Parsed a multi log rec"
2393 " space %lu page no %lu\n",
2394 (ulong) type, (ulong) len,
2395 (ulong) space, (ulong) page_no);
2412 new_recovered_lsn = recv_calc_lsn_on_data_add(
2429 len = recv_parse_log_rec(ptr, end_ptr, &type, &space,
2433 recv_report_corrupt_log(ptr,
2434 type, space, page_no);
2442 = recv_calc_lsn_on_data_add(old_lsn, len);
2451 #ifdef UNIV_LOG_LSN_DEBUG
2455 recv_add_to_hash_table(type, space, page_no,
2474 recv_sys_add_to_parsing_buf(
2476 const byte* log_block,
2477 ib_uint64_t scanned_lsn)
2510 if (more_len == 0) {
2515 ut_ad(data_len >= more_len);
2517 start_offset = data_len - more_len;
2519 if (start_offset < LOG_BLOCK_HDR_SIZE) {
2520 start_offset = LOG_BLOCK_HDR_SIZE;
2523 end_offset = data_len;
2529 ut_ad(start_offset <= end_offset);
2531 if (start_offset < end_offset) {
2533 log_block + start_offset, end_offset - start_offset);
2547 recv_sys_justify_left_parsing_buf(
void)
2569 ulint available_memory,
2571 ibool store_to_hash,
2578 ib_uint64_t start_lsn,
2579 ib_uint64_t* contiguous_lsn,
2582 ib_uint64_t* group_scanned_lsn)
2585 const byte* log_block;
2587 ib_uint64_t scanned_lsn;
2595 ut_a(store_to_hash <= TRUE);
2600 scanned_lsn = start_lsn;
2612 || !log_block_checksum_is_ok_or_old_format(log_block)) {
2615 && !log_block_checksum_is_ok_or_old_format(
2618 "InnoDB: Log block no %lu at"
2619 " lsn %"PRIu64
" has\n"
2620 "InnoDB: ok header, but checksum field"
2621 " contains %lu, should be %lu\n",
2645 if (scanned_lsn > *contiguous_lsn) {
2646 *contiguous_lsn = scanned_lsn;
2665 #ifdef UNIV_LOG_DEBUG
2686 scanned_lsn += data_len;
2694 #ifndef UNIV_HOTBACKUP
2695 if (recv_log_scan_is_startup_type
2699 "InnoDB: Log scan progressed"
2700 " past the checkpoint lsn %"PRIu64
"\n",
2702 recv_init_crash_recovery();
2713 "InnoDB: Error: log parsing"
2715 " Recovery may have failed!\n");
2719 #ifndef UNIV_HOTBACKUP
2720 if (!srv_force_recovery) {
2722 " innodb_force_recovery"
2723 " to ignore this error.\n",
2730 more_data = recv_sys_add_to_parsing_buf(
2731 log_block, scanned_lsn);
2747 }
while (log_block < buf + len && !finished);
2749 *group_scanned_lsn = scanned_lsn;
2752 || (recv_is_from_backup && !recv_is_making_a_backup)) {
2753 recv_scan_print_counter++;
2755 if (finished || (recv_scan_print_counter % 80 == 0)) {
2757 drizzled::errmsg_printf(drizzled::error::INFO,
2758 "InnoDB: Doing recovery: scanned up to log sequence number %"PRIu64
" ",
2759 *group_scanned_lsn);
2766 recv_parse_log_recs(store_to_hash);
2768 #ifndef UNIV_HOTBACKUP
2785 recv_sys_justify_left_parsing_buf();
2792 #ifndef UNIV_HOTBACKUP
2798 recv_group_scan_log_recs(
2801 ib_uint64_t* contiguous_lsn,
2804 ib_uint64_t* group_scanned_lsn)
2808 ib_uint64_t start_lsn;
2809 ib_uint64_t end_lsn;
2813 start_lsn = *contiguous_lsn;
2819 group, start_lsn, end_lsn);
2825 TRUE, log_sys->
buf, RECV_SCAN_SIZE,
2826 start_lsn, contiguous_lsn, group_scanned_lsn);
2827 start_lsn = end_lsn;
2831 if (log_debug_writes) {
2832 drizzled::errmsg_printf(drizzled::error::INFO,
2833 "InnoDB: Scanned group %lu up to log sequence number %"PRIu64
" ", (ulong) group->
id, *group_scanned_lsn);
2843 recv_init_crash_recovery(
void)
2853 " InnoDB: Database was not"
2854 " shut down normally!\n"
2855 "InnoDB: Starting crash recovery.\n");
2858 "InnoDB: Reading tablespace information"
2859 " from the .ibd files...\n");
2871 "InnoDB: Restoring possible"
2872 " half-written data pages from"
2873 " the doublewrite\n"
2874 "InnoDB: buffer...\n");
2889 #ifdef UNIV_LOG_ARCHIVE
2892 ib_uint64_t limit_lsn,
2895 ib_uint64_t min_flushed_lsn,
2897 ib_uint64_t max_flushed_lsn)
2904 ulint log_hdr_log_block_size;
2905 ib_uint64_t checkpoint_lsn;
2906 ib_uint64_t checkpoint_no;
2907 ib_uint64_t old_scanned_lsn;
2908 ib_uint64_t group_scanned_lsn= 0;
2909 ib_uint64_t contiguous_lsn;
2910 #ifdef UNIV_LOG_ARCHIVE
2911 ib_uint64_t archived_lsn;
2914 boost::scoped_array<byte> log_hdr_buf_base(
2920 #ifdef UNIV_LOG_ARCHIVE
2921 ut_ad(type != LOG_CHECKPOINT || limit_lsn == IB_ULONGLONG_MAX);
2923 # define TYPE_CHECKPOINT (type == LOG_CHECKPOINT)
2925 # define LIMIT_LSN limit_lsn
2928 # define TYPE_CHECKPOINT 1
2930 # define LIMIT_LSN IB_ULONGLONG_MAX
2933 if (TYPE_CHECKPOINT) {
2939 drizzled::errmsg_printf(drizzled::error::INFO,
2940 "InnoDB: The user has set SRV_FORCE_NO_LOG_REDO on Skipping log redo.");
2949 mutex_enter(&(log_sys->
mutex));
2953 err = recv_find_max_checkpoint(&max_cp_group, &max_cp_field);
2955 if (err != DB_SUCCESS) {
2957 mutex_exit(&(log_sys->
mutex));
2968 #ifdef UNIV_LOG_ARCHIVE
2976 0, 0, LOG_FILE_HDR_SIZE,
2977 log_hdr_buf, max_cp_group);
2979 if (0 ==
ut_memcmp(log_hdr_buf + LOG_FILE_WAS_CREATED_BY_HOT_BACKUP,
2980 (byte*)
"ibbackup", (
sizeof "ibbackup") - 1)) {
2984 drizzled::errmsg_printf(drizzled::error::INFO,
2985 "InnoDB: The log file was created by ibbackup --apply-log at %s\n",
2986 log_hdr_buf + LOG_FILE_WAS_CREATED_BY_HOT_BACKUP);
2987 drizzled::errmsg_printf(drizzled::error::INFO,
2988 "InnoDB: NOTE: the following crash recovery is part of a normal restore.\n");
2992 memset(log_hdr_buf + LOG_FILE_WAS_CREATED_BY_HOT_BACKUP,
2995 fil_io(OS_FILE_WRITE | OS_FILE_LOG, TRUE,
2998 log_hdr_buf, max_cp_group);
3001 log_hdr_log_block_size
3003 if (log_hdr_log_block_size == 0) {
3005 log_hdr_log_block_size = 512;
3007 if (log_hdr_log_block_size != srv_log_block_size) {
3008 drizzled::errmsg_printf(drizzled::error::ERROR,
3009 "InnoDB: Error: The block size of ib_logfile (%lu) "
3010 "is not equal to innodb_log_block_size.\n"
3011 "InnoDB: Error: Suggestion - Recreate log files.\n",
3012 log_hdr_log_block_size);
3016 #ifdef UNIV_LOG_ARCHIVE
3021 &(group->archived_file_no),
3022 &(group->archived_offset));
3028 if (TYPE_CHECKPOINT) {
3043 if (TYPE_CHECKPOINT) {
3044 up_to_date_group = max_cp_group;
3045 #ifdef UNIV_LOG_ARCHIVE
3058 mutex_exit(&(log_sys->
mutex));
3066 recv_group_scan_log_recs(group, &contiguous_lsn,
3067 &group_scanned_lsn);
3070 mutex_exit(&(log_sys->
mutex));
3080 up_to_date_group = group;
3084 ut_ad(RECV_SCAN_SIZE <= log_sys->buf_size);
3088 #ifdef UNIV_LOG_ARCHIVE
3089 if ((type == LOG_ARCHIVE) && (group ==
recv_sys->archive_group)) {
3095 recv_log_scan_is_startup_type = TYPE_CHECKPOINT;
3099 recv_group_scan_log_recs(group, &contiguous_lsn,
3100 &group_scanned_lsn);
3103 if (old_scanned_lsn < group_scanned_lsn) {
3106 up_to_date_group = group;
3109 #ifdef UNIV_LOG_ARCHIVE
3110 if ((type == LOG_ARCHIVE)
3111 && (group ==
recv_sys->archive_group)) {
3120 recv_log_scan_is_startup_type = FALSE;
3121 if (TYPE_CHECKPOINT) {
3126 if (checkpoint_lsn != max_flushed_lsn
3127 || checkpoint_lsn != min_flushed_lsn) {
3129 if (checkpoint_lsn < max_flushed_lsn) {
3130 drizzled::errmsg_printf(drizzled::error::ERROR,
3131 "InnoDB: #########################"
3132 "#################################\n"
3135 "InnoDB: The log sequence number"
3136 " in ibdata files is higher\n"
3137 "InnoDB: than the log sequence number"
3138 " in the ib_logfiles! Are you sure\n"
3139 "InnoDB: you are using the right"
3140 " ib_logfiles to start up"
3142 "InnoDB: Log sequence number in"
3143 " ib_logfiles is %"PRIu64
", log\n"
3144 "InnoDB: sequence numbers stamped"
3145 " to ibdata file headers are between\n"
3146 "InnoDB: %"PRIu64
" and %"PRIu64
".\n"
3147 "InnoDB: #########################"
3148 "#################################\n",
3155 drizzled::errmsg_printf(drizzled::error::ERROR,
3156 "InnoDB: The log sequence number in ibdata files does not match the log sequence number in the ib_logfiles!");
3157 recv_init_crash_recovery();
3168 if (group_scanned_lsn < checkpoint_lsn) {
3169 drizzled::errmsg_printf(drizzled::error::ERROR,
3170 "InnoDB: ERROR: We were only able to scan the log up to %"PRIu64
", but a checkpoint was at %"PRIu64
". "
3171 "It is possible that the database is now corrupt!",
3176 if (group_scanned_lsn < recv_max_page_lsn) {
3177 drizzled::errmsg_printf(drizzled::error::ERROR,
3178 "InnoDB: ERROR: We were only able to scan the log up to %"PRIu64
" "
3179 " but a database page a had an lsn %"PRIu64
". It is possible that the database is now corrupt!",
3186 mutex_exit(&(log_sys->
mutex));
3204 #ifdef UNIV_LOG_ARCHIVE
3205 log_sys->archived_lsn = archived_lsn;
3208 recv_synchronize_groups(up_to_date_group);
3229 #ifdef UNIV_LOG_ARCHIVE
3230 if (archived_lsn == IB_ULONGLONG_MAX) {
3232 log_sys->archiving_state = LOG_ARCH_OFF;
3242 mutex_exit(&(log_sys->
mutex));
3252 #undef TYPE_CHECKPOINT
3271 if (log_debug_writes) {
3272 drizzled::errmsg_printf(drizzled::error::INFO,
3273 "InnoDB: Log records applied to the database.");
3278 drizzled::errmsg_printf(drizzled::error::ERROR,
3279 "InnoDB: WARNING: the log file may have been corrupt and it\n"
3280 "InnoDB: is possible that the log scan or parsing did not proceed\n"
3281 "InnoDB: far enough in recovery. Please run CHECK TABLE on your InnoDB tables to check that they are ok! "
3282 "InnoDB: It may be safest to recover your database from a backup!");
3289 #ifndef UNIV_LOG_DEBUG
3290 recv_sys_debug_free();
3296 if (! srv_apply_log_only)
3309 #ifdef UNIV_SYNC_DEBUG
3315 sync_order_checks_on = TRUE;
3342 #ifdef UNIV_LOG_ARCHIVE
3345 ibool new_logs_created)
3359 group->
lsn = log_sys->
lsn;
3361 #ifdef UNIV_LOG_ARCHIVE
3362 group->archived_file_no = arch_log_no;
3363 group->archived_offset = 0;
3366 if (!new_logs_created) {
3367 recv_truncate_group(group, group->
lsn, group->
lsn,
3381 #ifdef UNIV_LOG_ARCHIVE
3382 log_sys->archived_lsn = log_sys->
lsn;
3388 log_sys->
buf_free = LOG_BLOCK_HDR_SIZE;
3389 log_sys->
lsn += LOG_BLOCK_HDR_SIZE;
3391 mutex_exit(&(log_sys->
mutex));
3398 mutex_enter(&(log_sys->
mutex));
3402 #ifdef UNIV_HOTBACKUP
3407 recv_reset_log_files_for_backup(
3409 const char* log_dir,
3411 ulint log_file_size,
3421 static const char ib_logfile_basename[] =
"ib_logfile";
3423 log_dir_len = strlen(log_dir);
3427 ut_a(log_dir_len + strlen(ib_logfile_basename) + 11 <
sizeof(name));
3432 for (i = 0; i < n_log_files; i++) {
3434 sprintf(name,
"%s%s%lu", log_dir,
3435 ib_logfile_basename, (ulong)i);
3437 log_file = os_file_create_simple(innodb_file_log_key,
3438 name, OS_FILE_CREATE,
3442 drizzled::errmsg_printf(drizzled::error::ERROR,
3443 "InnoDB: Cannot create %s. Check that the file does not exist yet.\n", name);
3448 drizzled::errmsg_printf(drizzled::error::INFO,
3449 "Setting log file size to %lu %lu\n",
3451 (ulong) log_file_size & 0xFFFFFFFFUL);
3454 log_file_size & 0xFFFFFFFFUL,
3458 drizzled::errmsg_printf(drizzled::error::ERROR,
3459 "InnoDB: Cannot set %s size to %lu %lu\n",
3461 (ulong) (log_file_size & 0xFFFFFFFFUL));
3465 os_file_flush(log_file);
3466 os_file_close(log_file);
3471 log_reset_first_header_and_checkpoint(buf, lsn);
3475 LOG_BLOCK_HDR_SIZE);
3476 sprintf(name,
"%s%s%lu", log_dir, ib_logfile_basename, (ulong)0);
3478 log_file = os_file_create_simple(innodb_file_log_key,
3480 OS_FILE_READ_WRITE, &success);
3482 drizzled::errmsg_printf(drizzled::error::ERROR,
"InnoDB: Cannot open %s.\n", name);
3487 os_file_write(name, log_file, buf, 0, 0,
3489 os_file_flush(log_file);
3490 os_file_close(log_file);
3496 #ifdef UNIV_LOG_ARCHIVE
3503 log_group_recover_from_archive_file(
3508 ib_uint64_t start_lsn;
3509 ib_uint64_t file_end_lsn;
3510 ib_uint64_t dummy_lsn;
3511 ib_uint64_t scanned_lsn;
3517 ulint file_size_high;
3530 file_handle = os_file_create(innodb_file_log_key,
3532 OS_FILE_LOG, OS_FILE_AIO, &ret);
3537 "InnoDB: Do you want to copy additional"
3538 " archived log files\n"
3539 "InnoDB: to the directory\n");
3541 "InnoDB: or were these all the files needed"
3544 "InnoDB: (Y == copy more files; N == this is all)?");
3546 input_char = getchar();
3548 if (input_char == (
int)
'N') {
3551 }
else if (input_char == (
int)
'Y') {
3553 goto try_open_again;
3562 ut_a(file_size_high == 0);
3564 drizzled::errmsg_printf(drizzled::error::INFO,
3565 "InnoDB: Opened archived log file %s\n", name);
3567 ret = os_file_close(file_handle);
3569 if (file_size < LOG_FILE_HDR_SIZE) {
3570 drizzled::errmsg_printf(drizzled::error::ERROR,
3571 "InnoDB: Archive file header incomplete %s\n", name);
3581 group->archive_space_id, FALSE);
3582 #if RECV_SCAN_SIZE < LOG_FILE_HDR_SIZE
3583 # error "RECV_SCAN_SIZE < LOG_FILE_HDR_SIZE"
3588 LOG_FILE_HDR_SIZE, buf, NULL);
3594 != group->archived_file_no) {
3595 drizzled::errmsg_printf(drizzled::error::ERROR,
3596 "InnoDB: Archive file header inconsistent %s\n", name);
3602 drizzled::errmsg_printf(drizzled::error::ERROR,
3603 "InnoDB: Archive file not completely written %s\n",
3615 drizzled::errmsg_printf(drizzled::error::ERROR,
3616 "InnoDB: Archive log file %s starts from too big a lsn\n", name);
3625 drizzled::errmsg_printf(drizzled::error::ERROR,
3626 "InnoDB: Archive log file %s starts from a wrong lsn\n", name);
3630 read_offset = LOG_FILE_HDR_SIZE;
3635 if (read_offset + len > file_size) {
3646 if (log_debug_writes) {
3647 drizzled::errmsg_printf(drizzled::error::INFO,
3648 "InnoDB: Archive read starting at lsn %"PRIu64
", len %lu from file %s\n",
3649 start_lsn, (ulong) len, name);
3654 group->archive_space_id, read_offset / UNIV_PAGE_SIZE,
3655 read_offset % UNIV_PAGE_SIZE, len, buf, NULL);
3660 * UNIV_PAGE_SIZE, TRUE, buf, len, start_lsn,
3661 &dummy_lsn, &scanned_lsn);
3663 if (scanned_lsn == file_end_lsn) {
3669 drizzled::errmsg_printf(drizzled::error::ERROR,
3670 "InnoDB: Archive log file %s does not scan right.", name);
3677 ut_ad(start_lsn == scanned_lsn);
3688 recv_recovery_from_archive_start(
3690 ib_uint64_t min_flushed_lsn,
3692 ib_uint64_t limit_lsn,
3712 recv_recovery_from_backup_on = TRUE;
3721 if (group->
id == group_id) {
3730 drizzled::errmsg_printf(drizzled::error::ERROR,
3731 "InnoDB: There is no log group defined with id %lu!\n",
3736 group->archived_file_no = first_log_no;
3748 mutex_enter(&(log_sys->
mutex));
3751 ret = log_group_recover_from_archive_file(group);
3756 trunc_len = UNIV_PAGE_SIZE
3758 if (trunc_len > 0) {
3759 fil_space_truncate_start(group->archive_space_id,
3763 group->archived_file_no++;
3773 mutex_exit(&(log_sys->
mutex));
3779 if (err != DB_SUCCESS) {
3784 mutex_enter(&(log_sys->
mutex));
3787 if (limit_lsn != IB_ULONGLONG_MAX) {
3794 mutex_exit(&(log_sys->
mutex));
3803 recv_recovery_from_archive_finish(
void)
3808 recv_recovery_from_backup_on = FALSE;
UNIV_INTERN byte * trx_undo_parse_erase_page_end(byte *ptr, byte *end_ptr, page_t *page, mtr_t *mtr)
ulint recv_max_parsed_page_no
UNIV_INLINE ulint page_is_comp(const page_t *page)
UNIV_INTERN void recv_reset_logs(ib_uint64_t lsn, ibool new_logs_created)
UNIV_INTERN ibool fil_extend_space_to_desired_size(ulint *actual_size, ulint space_id, ulint size_after_extend)
ib_uint64_t written_to_some_lsn
#define UT_LIST_GET_NEXT(NAME, N)
#define MLOG_DUMMY_RECORD
UNIV_INLINE void * ut_memmove(void *dest, const void *sour, ulint n)
UNIV_INTERN ulint fil_io(ulint type, ibool sync, ulint space_id, ulint zip_size, ulint block_offset, ulint byte_offset, ulint len, void *buf, void *message)
UNIV_INTERN byte * mlog_parse_nbytes(ulint type, byte *ptr, byte *end_ptr, byte *page, void *page_zip)
UNIV_INTERN void recv_sys_mem_free(void)
#define MLOG_UNDO_HDR_CREATE
UNIV_INTERN void log_make_checkpoint_at(ib_uint64_t lsn, ibool write_always)
UNIV_INTERN void trx_sys_doublewrite_init_or_restore_pages(ibool restore_corrupt_pages)
UNIV_INLINE ibool log_block_get_flush_bit(const byte *log_block)
byte * last_block_buf_start
UNIV_INTERN byte * btr_cur_parse_update_in_place(byte *ptr, byte *end_ptr, page_t *page, page_zip_des_t *page_zip, dict_index_t *index)
UNIV_INTERN void buf_flush_init_flush_rbt(void)
UNIV_INLINE ulint mtr_set_log_mode(mtr_t *mtr, ulint mode)
UNIV_INTERN void buf_flush_free_flush_rbt(void)
#define FIL_PAGE_TYPE_ALLOCATED
UNIV_INLINE ulint log_block_get_checkpoint_no(const byte *log_block)
UNIV_INTERN void log_group_read_checkpoint_info(log_group_t *group, ulint field)
UNIV_INTERN byte * page_parse_copy_rec_list_to_created_page(byte *ptr, byte *end_ptr, buf_block_t *block, dict_index_t *index, mtr_t *mtr)
#define MLOG_COMP_PAGE_CREATE
UNIV_INTERN ibool os_file_get_size(os_file_t file, ulint *size, ulint *size_high)
UNIV_INLINE ib_uint64_t buf_page_get_newest_modification(const buf_page_t *bpage)
UNIV_INTERN byte * page_zip_parse_write_header(byte *ptr, byte *end_ptr, page_t *page, page_zip_des_t *page_zip)
UNIV_INLINE ulint mem_heap_get_size(mem_heap_t *heap)
UNIV_INTERN os_thread_t os_thread_create(os_posix_f_t start_f, void *arg, os_thread_id_t *thread_id)
UNIV_INLINE void buf_flush_recv_note_modification(buf_block_t *block, ib_uint64_t start_lsn, ib_uint64_t end_lsn)
UNIV_INLINE ulint hash_calc_hash(ulint fold, hash_table_t *table)
#define MLOG_COMP_REC_SEC_DELETE_MARK
UNIV_INLINE ibool buf_page_peek(ulint space, ulint offset)
UNIV_INTERN void log_group_read_log_seg(ulint type, byte *buf, log_group_t *group, ib_uint64_t start_lsn, ib_uint64_t end_lsn)
UNIV_INTERN ulint ut_get_high32(ulint a)
UNIV_INLINE void * ut_memcpy(void *dest, const void *sour, ulint n)
UNIV_INTERN void ut_print_buf(FILE *file, const void *buf, ulint len)
UNIV_INTERN byte * page_cur_parse_delete_rec(byte *ptr, byte *end_ptr, buf_block_t *block, dict_index_t *index, mtr_t *mtr)
UNIV_INTERN void * ut_malloc(ulint n)
UNIV_INLINE ibool dict_table_is_comp(const dict_table_t *table)
UNIV_INTERN void row_merge_drop_temp_indexes(void)
UNIV_INLINE void mach_write_to_8(byte *b, ib_uint64_t n)
#define MLOG_INIT_FILE_PAGE
UNIV_INTERN byte * fil_op_log_parse_or_replay(byte *ptr, byte *end_ptr, ulint type, ulint space_id, ulint log_flags)
UNIV_INTERN void dict_mem_table_free(dict_table_t *table)
UNIV_INLINE ulint log_block_convert_lsn_to_no(ib_uint64_t lsn)
UNIV_INLINE void log_block_init_in_old_format(byte *log_block, ib_uint64_t lsn)
ulint recv_n_pool_free_frames
UNIV_INTERN void fil_node_create(const char *name, ulint size, ulint id, ibool is_raw)
UNIV_INTERN hash_table_t * hash_create(ulint n)
UNIV_INTERN void log_group_write_buf(log_group_t *group, byte *buf, ulint len, ib_uint64_t start_lsn, ulint new_data_offset)
#define recv_recover_page(jri, block)
UNIV_INTERN ulint fil_space_get_zip_size(ulint id)
UNIV_INTERN byte * trx_undo_parse_discard_latest(byte *ptr, byte *end_ptr, page_t *page, mtr_t *mtr)
UNIV_INTERN void recv_recovery_rollback_active(void)
#define MLOG_LIST_END_DELETE
#define mem_heap_free(heap)
UNIV_INTERN byte * page_cur_parse_insert_rec(ibool is_short, byte *ptr, byte *end_ptr, buf_block_t *block, dict_index_t *index, mtr_t *mtr)
#define MLOG_COMP_REC_CLUST_DELETE_MARK
#define log_flush_order_mutex_enter()
ib_uint64_t next_checkpoint_no
UNIV_INTERN void buf_flush_init_for_writing(byte *page, void *page_zip_, ib_uint64_t newest_lsn)
#define MLOG_UNDO_HDR_DISCARD
ib_uint64_t recovered_lsn
UNIV_INTERN byte * mlog_parse_string(byte *ptr, byte *end_ptr, byte *page, void *page_zip)
#define MLOG_COMP_LIST_START_DELETE
#define MLOG_PAGE_REORGANIZE
#define MLOG_REC_UPDATE_IN_PLACE
#define MLOG_IBUF_BITMAP_INIT
#define MLOG_COMP_REC_INSERT
UNIV_INTERN void recv_sys_close(void)
#define HASH_INSERT(TYPE, NAME, TABLE, FOLD, DATA)
#define mem_heap_create_in_buffer(N)
UNIV_INTERN byte * fsp_parse_init_file_page(byte *ptr, byte *end_ptr, buf_block_t *block)
UNIV_INLINE void log_block_set_first_rec_group(byte *log_block, ulint offset)
UNIV_INTERN byte * page_parse_delete_rec_list(byte type, byte *ptr, byte *end_ptr, buf_block_t *block, dict_index_t *index, mtr_t *mtr)
#define HASH_GET_NEXT(NAME, DATA)
UNIV_INTERN void hash_table_free(hash_table_t *table)
UNIV_INLINE void log_block_set_data_len(byte *log_block, ulint len)
#define recv_recovery_from_checkpoint_start(type, lim, min, max)
UNIV_INTERN byte * ibuf_parse_bitmap_init(byte *ptr, byte *end_ptr, buf_block_t *block, mtr_t *mtr)
UNIV_INLINE ulint buf_block_get_page_no(const buf_block_t *block) __attribute__((pure))
#define MLOG_WRITE_STRING
#define MLOG_COMP_PAGE_REORGANIZE
UNIV_INTERN void mtr_commit(mtr_t *mtr) __attribute__((nonnull))
#define OS_FILE_LOG_BLOCK_SIZE
UNIV_INLINE ulint log_block_get_data_len(const byte *log_block)
#define MLOG_REC_SEC_DELETE_MARK
#define MLOG_LIST_START_DELETE
#define MLOG_FILE_CREATE2
UNIV_INLINE ulint ut_fold_ulint_pair(ulint n1, ulint n2) __attribute__((const ))
UNIV_INTERN void recv_recover_page_func(ibool just_read_in, buf_block_t *block)
UNIV_INTERN void recv_sys_create(void)
#define MLOG_MULTI_REC_END
#define MLOG_COMP_REC_MIN_MARK
UNIV_INLINE void log_block_init(byte *log_block, ib_uint64_t lsn)
UNIV_INTERN ibool buf_page_get_known_nowait(ulint rw_latch, buf_block_t *block, ulint mode, const char *file, ulint line, mtr_t *mtr)
UNIV_INLINE void * ut_align(const void *ptr, ulint align_no)
#define HASH_GET_FIRST(TABLE, HASH_VAL)
UNIV_INLINE ulint log_block_get_first_rec_group(const byte *log_block)
UNIV_INTERN void buf_pool_invalidate(void)
#define MLOG_COMP_LIST_END_COPY_CREATED
UNIV_INTERN void os_thread_sleep(ulint tm)
#define MLOG_REC_MIN_MARK
UNIV_INLINE ib_uint64_t ut_uint64_align_up(ib_uint64_t n, ulint align_no)
UNIV_INTERN void recv_apply_hashed_log_recs(ibool allow_ibuf)
ib_uint64_t next_checkpoint_lsn
#define ut_calc_align_down(n, m)
ib_uint64_t written_to_all_lsn
#define buf_block_get_page_zip(block)
#define MLOG_ZIP_WRITE_HEADER
ibool recv_needed_recovery
UNIV_INLINE ulint buf_pool_get_n_pages(void)
#define MLOG_REC_CLUST_DELETE_MARK
ib_uint64_t srv_start_lsn
UNIV_INLINE ulint log_block_get_checksum(const byte *log_block)
UNIV_INLINE void * mem_heap_alloc(mem_heap_t *heap, ulint n)
UNIV_INTERN byte * btr_parse_set_min_rec_mark(byte *ptr, byte *end_ptr, ulint comp, page_t *page, mtr_t *mtr)
#define mem_heap_create(N)
UNIV_INTERN ulint fil_space_get_size(ulint id)
ib_uint64_t last_checkpoint_lsn
UNIV_INTERN byte * trx_undo_parse_add_undo_rec(byte *ptr, byte *end_ptr, page_t *page)
UNIV_INTERN void rw_lock_x_lock_move_ownership(rw_lock_t *lock)
UNIV_INTERN void recv_sys_init(ulint available_memory)
UNIV_INTERN ulint fil_page_get_type(const byte *page)
UNIV_INLINE ib_uint64_t ut_uint64_align_down(ib_uint64_t n, ulint align_no)
#define MLOG_ZIP_PAGE_COMPRESS
enum recv_addr_state state
UNIV_INTERN ulint buf_flush_list(ulint min_n, ib_uint64_t lsn_limit)
#define UT_LIST_ADD_LAST(NAME, BASE, N)
#define UT_LIST_GET_FIRST(BASE)
#define MLOG_ZIP_WRITE_NODE_PTR
UNIV_INTERN byte * btr_cur_parse_del_mark_set_sec_rec(byte *ptr, byte *end_ptr, page_t *page, page_zip_des_t *page_zip)
UNIV_INLINE void mem_heap_empty(mem_heap_t *heap)
UNIV_INTERN ulint log_group_get_capacity(const log_group_t *group)
#define rw_lock_s_lock(M)
#define MLOG_COMP_REC_UPDATE_IN_PLACE
UNIV_INTERN byte * page_parse_create(byte *ptr, byte *end_ptr, ulint comp, buf_block_t *block, mtr_t *mtr)
UNIV_INLINE ulint ut_fold_binary(const byte *str, ulint len) __attribute__((pure))
UNIV_INTERN void log_group_set_fields(log_group_t *group, ib_uint64_t lsn)
ib_uint64_t parse_start_lsn
UNIV_INTERN void dict_mem_index_free(dict_index_t *index)
UNIV_INTERN void log_archived_file_name_gen(char *buf, ulint id, ulint file_no)
#define MLOG_UNDO_ERASE_END
UNIV_INTERN ibool recv_scan_log_recs(ulint available_memory, ibool store_to_hash, const byte *buf, ulint len, ib_uint64_t start_lsn, ib_uint64_t *contiguous_lsn, ib_uint64_t *group_scanned_lsn)
UNIV_INTERN byte * page_zip_parse_write_blob_ptr(byte *ptr, byte *end_ptr, page_t *page, page_zip_des_t *page_zip)
UNIV_INTERN ibool buf_zip_decompress(buf_block_t *block, ibool check)
#define MLOG_COMP_REC_DELETE
UNIV_INTERN ibool os_file_set_size(const char *name, os_file_t file, ulint size, ulint size_high)
UNIV_INTERN void ut_free(void *ptr)
#define UT_LIST_INIT(BASE)
UNIV_INLINE hash_cell_t * hash_get_nth_cell(hash_table_t *table, ulint n)
#define MLOG_UNDO_HDR_REUSE
#define log_flush_order_mutex_exit()
ulint scanned_checkpoint_no
UNIV_INLINE ulint buf_block_get_space(const buf_block_t *block) __attribute__((pure))
UNIV_INTERN void buf_read_recv_pages(ibool sync, ulint space, ulint zip_size, const ulint *page_nos, ulint n_stored)
ibool recv_no_ibuf_operations
UNIV_INTERN void buf_flush_wait_batch_end(buf_pool_t *buf_pool, enum buf_flush type)
UNIV_INLINE ulint mach_read_from_4(const byte *b) __attribute__((nonnull
UNIV_INTERN void recv_recovery_from_checkpoint_finish(void)
UNIV_INTERN void ut_print_timestamp(FILE *file)
#define FIL_PAGE_UNDO_LOG
UNIV_INTERN os_thread_ret_t trx_rollback_or_clean_all_recovered(void *arg)
UNIV_INTERN byte * mlog_parse_initial_log_record(byte *ptr, byte *end_ptr, byte *type, ulint *space, ulint *page_no)
#define RECV_PARSING_BUF_SIZE
UNIV_INTERN byte * page_zip_parse_compress(byte *ptr, byte *end_ptr, page_t *page, page_zip_des_t *page_zip) __attribute__((nonnull(1
UNIV_INTERN void trx_rollback_or_clean_recovered(ibool all)
UNIV_INTERN void log_groups_write_checkpoint_info(void)
#define FIL_PAGE_END_LSN_OLD_CHKSUM
UNIV_INTERN byte * mlog_parse_index(byte *ptr, const byte *end_ptr, ibool comp, dict_index_t **index)
UNIV_INTERN byte * btr_cur_parse_del_mark_set_clust_rec(byte *ptr, byte *end_ptr, page_t *page, page_zip_des_t *page_zip, dict_index_t *index)
UNIV_INTERN ibool fil_tablespace_deleted_or_being_deleted_in_mem(ulint id, ib_int64_t version)
UNIV_INLINE void mtr_start(mtr_t *mtr) __attribute__((nonnull))
UNIV_INLINE ulint log_block_calc_checksum(const byte *block)
#define MLOG_SINGLE_REC_FLAG
UNIV_INTERN byte * btr_parse_page_reorganize(byte *ptr, byte *end_ptr, dict_index_t *index, buf_block_t *block, mtr_t *mtr)
UNIV_INTERN byte * trx_undo_parse_page_init(byte *ptr, byte *end_ptr, page_t *page, mtr_t *mtr)
UNIV_INLINE ulint log_block_get_hdr_no(const byte *log_block)
UNIV_INLINE ulint mach_read_from_2(const byte *b) __attribute__((nonnull
UNIV_INTERN void log_checkpoint_get_nth_group_info(const byte *buf, ulint n, ulint *file_no, ulint *offset)
UNIV_INTERN void row_mysql_drop_temp_tables(void)
#define MLOG_COMP_LIST_END_DELETE
UNIV_INLINE int ut_memcmp(const void *str1, const void *str2, ulint n)
UNIV_INLINE ib_uint64_t mach_read_from_8(const byte *b) __attribute__((nonnull
#define MLOG_ZIP_WRITE_BLOB_PTR
UNIV_INTERN void recv_sys_var_init(void)
UNIV_INTERN byte * trx_undo_parse_page_header(ulint type, byte *ptr, byte *end_ptr, page_t *page, mtr_t *mtr)
rw_lock_t checkpoint_lock
ulint srv_buf_pool_instances
UNIV_INLINE ulint buf_pool_get_curr_size(void)
UNIV_INTERN ulint recv_recovery_from_checkpoint_start_func(ib_uint64_t min_flushed_lsn, ib_uint64_t max_flushed_lsn)
UNIV_INLINE ulint hash_get_n_cells(hash_table_t *table)
UNIV_INTERN ulint fil_load_single_table_tablespaces(void)
#define buf_page_get(SP, ZS, OF, LA, MTR)
UNIV_INTERN void UNIV_INTERN byte * page_zip_parse_write_node_ptr(byte *ptr, byte *end_ptr, page_t *page, page_zip_des_t *page_zip)
#define MLOG_LIST_END_COPY_CREATED