/************************************************************************
Flushes possible buffered writes from the doublewrite memory buffer to disk,
and also wakes up the aio thread if simulated aio is used. It is very
important to call this function after a batch of writes has been posted,
and also when we may have to wait for a page latch! Otherwise a deadlock
of threads can occur. */
static
void
buf_flush_buffered_writes(void)
/*===========================*/
{
buf_block_t* block;
byte* write_buf;
ulint len;
ulint len2;
ulint i;
if (!srv_use_doublewrite_buf || trx_doublewrite == NULL) {
os_aio_simulated_wake_handler_threads();
return;
}
mutex_enter(&(trx_doublewrite->mutex));
/* Write first to doublewrite buffer blocks. We use synchronous
aio and thus know that file write has been completed when the
control returns. */
if (trx_doublewrite->first_free == 0) {
mutex_exit(&(trx_doublewrite->mutex));
return;
}
for (i = 0; i < trx_doublewrite->first_free; i++) {
block = trx_doublewrite->buf_block_arr[i];
ut_a(block->state == BUF_BLOCK_FILE_PAGE);
if (mach_read_from_4(block->frame + FIL_PAGE_LSN + 4)
!= mach_read_from_4(block->frame + UNIV_PAGE_SIZE
- FIL_PAGE_END_LSN_OLD_CHKSUM + 4)) {
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: ERROR: The page to be written"
" seems corrupt!\n"
"InnoDB: The lsn fields do not match!"
" Noticed in the buffer pool\n"
"InnoDB: before posting to the"
" doublewrite buffer.\n");
}
if (block->check_index_page_at_flush
&& !page_simple_validate(block->frame)) {
buf_page_print(block->frame);
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Apparent corruption of an"
" index page n:o %lu in space %lu\n"
"InnoDB: to be written to data file."
" We intentionally crash server\n"
"InnoDB: to prevent corrupt data"
" from ending up in data\n"
"InnoDB: files.\n",
(ulong) block->offset, (ulong) block->space);
ut_error;
}
}
/* increment the doublewrite flushed pages counter */
srv_dblwr_pages_written+= trx_doublewrite->first_free;
srv_dblwr_writes++;
if (trx_doublewrite->first_free > TRX_SYS_DOUBLEWRITE_BLOCK_SIZE) {
len = TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * UNIV_PAGE_SIZE;
} else {
len = trx_doublewrite->first_free * UNIV_PAGE_SIZE;
}
fil_io(OS_FILE_WRITE,
TRUE, TRX_SYS_SPACE,
trx_doublewrite->block1, 0, len,
(void*)trx_doublewrite->write_buf, NULL);
write_buf = trx_doublewrite->write_buf;
for (len2 = 0; len2 + UNIV_PAGE_SIZE <= len; len2 += UNIV_PAGE_SIZE) {
if (mach_read_from_4(write_buf + len2 + FIL_PAGE_LSN + 4)
!= mach_read_from_4(write_buf + len2 + UNIV_PAGE_SIZE
- FIL_PAGE_END_LSN_OLD_CHKSUM + 4)) {
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: ERROR: The page to be written"
" seems corrupt!\n"
"InnoDB: The lsn fields do not match!"
" Noticed in the doublewrite block1.\n");
}
}
if (trx_doublewrite->first_free > TRX_SYS_DOUBLEWRITE_BLOCK_SIZE) {
len = (trx_doublewrite->first_free
- TRX_SYS_DOUBLEWRITE_BLOCK_SIZE) * UNIV_PAGE_SIZE;
fil_io(OS_FILE_WRITE,
TRUE, TRX_SYS_SPACE,
trx_doublewrite->block2, 0, len,
(void*)(trx_doublewrite->write_buf
+ TRX_SYS_DOUBLEWRITE_BLOCK_SIZE
* UNIV_PAGE_SIZE),
NULL);
write_buf = trx_doublewrite->write_buf
+ TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * UNIV_PAGE_SIZE;
for (len2 = 0; len2 + UNIV_PAGE_SIZE <= len;
len2 += UNIV_PAGE_SIZE) {
if (mach_read_from_4(write_buf + len2
+ FIL_PAGE_LSN + 4)
!= mach_read_from_4(write_buf + len2
+ UNIV_PAGE_SIZE
- FIL_PAGE_END_LSN_OLD_CHKSUM
+ 4)) {
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: ERROR: The page to be"
" written seems corrupt!\n"
"InnoDB: The lsn fields do not match!"
" Noticed in"
" the doublewrite block2.\n");
}
}
}
/* Now flush the doublewrite buffer data to disk */
fil_flush(TRX_SYS_SPACE);
/* We know that the writes have been flushed to disk now
and in recovery we will find them in the doublewrite buffer
blocks. Next do the writes to the intended positions. */
for (i = 0; i < trx_doublewrite->first_free; i++) {
block = trx_doublewrite->buf_block_arr[i];
if (mach_read_from_4(block->frame + FIL_PAGE_LSN + 4)
!= mach_read_from_4(block->frame + UNIV_PAGE_SIZE
- FIL_PAGE_END_LSN_OLD_CHKSUM + 4)) {
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: ERROR: The page to be written"
" seems corrupt!\n"
"InnoDB: The lsn fields do not match!"
" Noticed in the buffer pool\n"
"InnoDB: after posting and flushing"
" the doublewrite buffer.\n"
"InnoDB: Page buf fix count %lu,"
" io fix %lu, state %lu\n",
(ulong)block->buf_fix_count,
(ulong)block->io_fix,
(ulong)block->state);
}
ut_a(block->state == BUF_BLOCK_FILE_PAGE);
fil_io(OS_FILE_WRITE | OS_AIO_SIMULATED_WAKE_LATER,
FALSE, block->space, block->offset, 0, UNIV_PAGE_SIZE,
(void*)block->frame, (void*)block);
}
/* Wake possible simulated aio thread to actually post the
writes to the operating system */
os_aio_simulated_wake_handler_threads();
/* Wait that all async writes to tablespaces have been posted to
the OS */
os_aio_wait_until_no_pending_writes();
/* Now we flush the data to disk (for example, with fsync) */
fil_flush_file_spaces(FIL_TABLESPACE);
/* We can now reuse the doublewrite memory buffer: */
trx_doublewrite->first_free = 0;
mutex_exit(&(trx_doublewrite->mutex));
}
/********************************************************************//**
Flush pages from flash cache.
@return number of pages have been flushed to tablespace */
UNIV_INTERN
ulint
fc_flush_to_disk(
/*==================*/
ibool do_full_io) /*!< in: whether do full io capacity */
{
ulint distance;
byte* page;
ulint ret;
ulint space;
ulint offset;
ulint page_type;
ulint i, j;
ulint pos;
ulint zip_size;
ulint block_offset, byte_offset;
ulint fc_size = fc_get_size();
ulint fc_blk_size = fc_get_block_size_byte();
ulint start_offset;
ulint data_size;
fc_block_t *flush_block = NULL;
ulint c_flush = 0;
ut_ad(!mutex_own(&fc->mutex));
ut_a(fc->flush_buf->free_pos == 0);
/* step 1: get the number of blocks need to flush to tablespace */
flash_cache_mutex_enter();
distance = fc_get_distance();
start_offset = fc->flush_off;
if ( distance == 0 ) {
flash_cache_mutex_exit();
return 0;
} else if ( recv_recovery_on ) {
if ( distance < (( 1.0 * srv_flash_cache_write_cache_pct /100 ) * fc_size)) {
fc->n_flush_cur = 0;
} else if ( distance < ( ( 1.0*srv_flash_cache_do_full_io_pct /100 ) * fc_size)) {
fc->n_flush_cur = ut_min(PCT_IO_FC(10), distance);
} else {
fc->n_flush_cur = ut_min(PCT_IO_FC(100), distance);
}
} else if ( distance < (( 1.0 * srv_flash_cache_write_cache_pct /100 ) * fc_size)
&& !do_full_io ) {
flash_cache_mutex_exit();
return 0;
} else if ( distance < (( 1.0 * srv_flash_cache_do_full_io_pct/100 ) * fc_size)
&& !do_full_io ) {
fc->n_flush_cur = PCT_IO_FC(srv_fc_write_cache_flush_pct);
} else {
ut_ad((distance > ( 1.0 * srv_flash_cache_do_full_io_pct/100 ) * fc_size)
|| do_full_io );
fc->n_flush_cur = ut_min(PCT_IO_FC(srv_fc_full_flush_pct), distance);
}
flash_cache_mutex_exit();
/* step 2: start to flush blocks use async io, set block io_fix IO_FIX_FLUSH */
i = 0;
while (i < fc->n_flush_cur) {
ulint b_space;
ulint b_offset;
ulint raw_zip_size;
ulint size;
ulint fil_offset;
#ifdef UNIV_FLASH_CACHE_TRACE
ulint is_v4_blk;
#endif
byte* page_io;
flash_cache_mutex_enter();
pos = ( start_offset + i ) % fc_size;
flush_block = fc_get_block(pos);
if (flush_block == NULL) {
i++;
flash_cache_mutex_exit();
continue;
}
/* we should get the mutex, as doublewrite may hit this block and invalid the block */
flash_block_mutex_enter(flush_block->fil_offset);
flash_cache_mutex_exit();
data_size = fc_block_get_data_size(flush_block);
if (flush_block->state != BLOCK_READY_FOR_FLUSH) {
/* if readonly or merge write or already flushed*/
ut_a (flush_block->state == BLOCK_NOT_USED
|| flush_block->state == BLOCK_READ_CACHE
|| flush_block->state == BLOCK_FLUSHED);
i += data_size;
flash_block_mutex_exit(flush_block->fil_offset);
if (flush_block->state == BLOCK_NOT_USED) {
//fc_block_detach(FALSE, flush_block);
fc_block_free(flush_block);
}
continue;
}
zip_size = fil_space_get_zip_size(flush_block->space);
if (zip_size == ULINT_UNDEFINED) {
/* table has been droped, just set it BLOCK_FLUSHED */
#ifdef UNIV_FLASH_CACHE_TRACE
ut_print_timestamp(fc->f_debug);
fprintf(fc->f_debug, "space:%lu is droped, the page(%lu, %lu) need not to be flushed.\n",
(ulong)flush_block->space, (ulong)flush_block->space, (ulong)flush_block->offset);
#endif
flush_block->state = BLOCK_FLUSHED;
i += data_size;
c_flush += data_size;
flash_block_mutex_exit(flush_block->fil_offset);
continue;
}
#ifdef UNIV_FLASH_CACHE_TRACE
if (flush_block->state != BLOCK_READY_FOR_FLUSH) {
fc_block_print(flush_block);
ut_error;
}
#endif
flush_block->io_fix |= IO_FIX_FLUSH;
/*
* we should set block state BLOCK_FLUSHED, if not, doublewrite may hit this block
* and invalid this block and reduce the dirty count, but when finish flush ,we will
* reduce the dirty count too, so it may reduce twice.
*/
flush_block->state = BLOCK_FLUSHED;
/* save the block info, as the block may be invalided by doublewrite after release mutex */
b_space = flush_block->space;
b_offset = flush_block->offset;
raw_zip_size = flush_block->raw_zip_size;
size = flush_block->size;
fil_offset = flush_block->fil_offset;
#ifdef UNIV_FLASH_CACHE_TRACE
is_v4_blk = flush_block->is_v4_blk;
#endif
/* release the block now, so read can hit in this blocks and read the data */
flash_block_mutex_exit(flush_block->fil_offset);
/*
* Only flush thread will update read_buf and flush_off/round.
* there only single flush thread no need to lock read_buf
*/
page = fc->flush_buf->buf + fc->flush_buf->free_pos * fc_blk_size;
if (raw_zip_size > 0) {
ut_a((size * fc_blk_size) == UNIV_PAGE_SIZE);
page_io = fc->flush_zip_read_buf;
} else {
page_io = page;
}
fc_io_offset(fil_offset, &block_offset, &byte_offset);
ret = fil_io(OS_FILE_READ, TRUE, FLASH_CACHE_SPACE, 0,
block_offset, byte_offset, data_size * fc_blk_size,
page_io, NULL);
if (ret != DB_SUCCESS) {
ut_print_timestamp(stderr);
fprintf(stderr, " InnoDB: Flash cache [Error]: unable to read page from flash cache.\n"
"flash cache flush offset is:%lu.\n", (ulong)(start_offset + i));
ut_error;
}
if ((flush_block != NULL) && (flush_block->state == BLOCK_NOT_USED)) {
goto skip;
}
/* decompress the compress data */
if (raw_zip_size > 0) {
#ifdef UNIV_FLASH_CACHE_TRACE
ulint blk_zip_size_byte;
if (is_v4_blk) {
blk_zip_size_byte = raw_zip_size * fc_get_block_size_byte();
} else {
blk_zip_size_byte = fc_block_compress_align(raw_zip_size) * fc_get_block_size_byte();
ut_a((ulint)mach_read_from_4(page_io + FC_ZIP_PAGE_ZIP_RAW_SIZE) == raw_zip_size);
}
ut_a(page_io);
ut_a(page);
ut_a((ulint)mach_read_from_4(page_io + FC_ZIP_PAGE_HEADER) == FC_ZIP_PAGE_CHECKSUM);
ut_a((ulint)mach_read_from_4(page_io + blk_zip_size_byte - FC_ZIP_PAGE_TAILER)
== FC_ZIP_PAGE_CHECKSUM);
ut_a((ulint)mach_read_from_4(page_io + FC_ZIP_PAGE_SIZE) == blk_zip_size_byte);
ut_a((ulint)mach_read_from_4(page_io + FC_ZIP_PAGE_ORIG_SIZE) == UNIV_PAGE_SIZE);
ut_a((ulint)mach_read_from_4(page_io + FC_ZIP_PAGE_SPACE) == b_space);
ut_a((ulint)mach_read_from_4(page_io + FC_ZIP_PAGE_OFFSET) == b_offset);
/* only qlz can do this check */
if (srv_flash_cache_compress_algorithm == FC_BLOCK_COMPRESS_QUICKLZ) {
if (is_v4_blk) {
ut_a(raw_zip_size * fc_get_block_size_byte()
>= (ulint)fc_qlz_size_compressed((const char *)(page_io + FC_ZIP_PAGE_DATA)));
} else {
ut_a(raw_zip_size
== (ulint)fc_qlz_size_compressed((const char *)(page_io + FC_ZIP_PAGE_DATA)));
}
ut_a(UNIV_PAGE_SIZE == fc_qlz_size_decompressed((const char *)(page_io + FC_ZIP_PAGE_DATA)));
}
#endif
fc_block_do_decompress(DECOMPRESS_FLUSH, page_io, raw_zip_size, page);
}
space = mach_read_from_4(page + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID);
offset = mach_read_from_4(page + FIL_PAGE_OFFSET);
if ((space != b_space) || (offset != b_offset)) {
ut_print_timestamp(stderr);
fc_block_print(flush_block);
ut_error;
}
if (buf_page_is_corrupted(page, zip_size)) {
buf_page_print(page, zip_size, BUF_PAGE_PRINT_NO_CRASH);
ut_error;
}
page_type = fil_page_get_type(page);
if (page_type == FIL_PAGE_INDEX) {
page_type = 1;
}
srv_flash_cache_flush_detail[page_type]++;
ret = fil_io(OS_FILE_WRITE | OS_AIO_SIMULATED_WAKE_LATER, FALSE, space,
zip_size, offset, 0, zip_size ? zip_size : UNIV_PAGE_SIZE, page, NULL);
if (ret != DB_SUCCESS && ret != DB_TABLESPACE_DELETED) {
ut_print_timestamp(stderr);
fc_block_print(flush_block);
ut_error;
}
/* add UNIV_PAGE_SIZE / fc_blk_size for safe */
fc->flush_buf->free_pos += UNIV_PAGE_SIZE / fc_blk_size;
skip:
i += data_size;
c_flush += data_size;
if ((fc->flush_buf->free_pos + UNIV_PAGE_SIZE / fc_blk_size) >= fc->flush_buf->size) {
/* FIXME: is it safe to change n_flush, as step 3 will use n_flush */
fc->n_flush_cur = i;
break;
}
}
/* ok, now flush all async io to disk */
fc_flush_sync_dbfile();
/* step 3: all the flush blocks have sync to disk, update the state and io_fix */
j = 0;
while (j < fc->n_flush_cur) {
flash_cache_mutex_enter();
pos = (start_offset + j) % fc_size;
flush_block = fc_get_block(pos);
if (flush_block == NULL) {
j++;
flash_cache_mutex_exit();
continue;
}
/* block state and io_fix may be changed by doublewrite and lru move */
flash_block_mutex_enter(flush_block->fil_offset);
flash_cache_mutex_exit();
if (flush_block->io_fix & IO_FIX_FLUSH) {
/* the block is already in BLOCK_FLUSHED state */
flush_block->io_fix &= ~IO_FIX_FLUSH;
}
data_size = fc_block_get_data_size(flush_block);
flash_block_mutex_exit(flush_block->fil_offset);
j += data_size;
}
/*
* i and j may be different, as the last been flushed block may be invalid by doublewrite,
* so maybe i > j
*/
/* add the actual flushed blocks */
srv_flash_cache_flush = srv_flash_cache_flush + c_flush;
/* step 4: update fc status and flush_off, and wake up threads that are sleep for space */
if (i > 0) {
ut_a(i >= c_flush);
flash_cache_mutex_enter();
/*
* it is safe to inc flush off and sub dirty blocks at this time,
* as fc_validate is not work
*/
fc_inc_flush_off(i);
flash_cache_log_mutex_enter();
fc_log->current_stat->flush_offset = fc->flush_off;
fc_log->current_stat->flush_round = fc->flush_round;
flash_cache_log_mutex_exit();
ut_a(srv_flash_cache_dirty >= c_flush);
srv_flash_cache_dirty -= c_flush;
srv_fc_flush_should_commit_log_flush++;
os_event_set(fc->wait_space_event);
fc->n_flush_cur = 0;
flash_cache_mutex_exit();
}
fc->flush_buf->free_pos = 0;
return c_flush;
}
