/************************************************************************
Does an asynchronous write of a buffer page. NOTE: in simulated aio and
also when the doublewrite buffer is used, we must call
buf_flush_buffered_writes after we have posted a batch of writes! */
static
void
buf_flush_write_block_low(
/*======================*/
buf_block_t* block) /* in: buffer block to write */
{
#ifdef UNIV_LOG_DEBUG
static ibool univ_log_debug_warned;
#endif /* UNIV_LOG_DEBUG */
ut_a(block->state == BUF_BLOCK_FILE_PAGE);
#ifdef UNIV_IBUF_DEBUG
ut_a(ibuf_count_get(block->space, block->offset) == 0);
#endif
ut_ad(!ut_dulint_is_zero(block->newest_modification));
#ifdef UNIV_LOG_DEBUG
if (!univ_log_debug_warned) {
univ_log_debug_warned = TRUE;
fputs("Warning: cannot force log to disk if"
" UNIV_LOG_DEBUG is defined!\n"
"Crash recovery will not work!\n",
stderr);
}
#else
/* Force the log to the disk before writing the modified block */
log_write_up_to(block->newest_modification, LOG_WAIT_ALL_GROUPS, TRUE);
#endif
buf_flush_init_for_writing(block->frame, block->newest_modification,
block->space, block->offset);
if (!srv_use_doublewrite_buf || !trx_doublewrite) {
fil_io(OS_FILE_WRITE | OS_AIO_SIMULATED_WAKE_LATER,
FALSE, block->space, block->offset, 0, UNIV_PAGE_SIZE,
(void*)block->frame, (void*)block);
} else {
buf_flush_post_to_doublewrite_buf(block);
}
}
/********************************************************************//**
Low-level function which reads a page asynchronously from a file to the
buffer buf_pool if it is not already there, in which case does nothing.
Sets the io_fix flag and sets an exclusive lock on the buffer frame. The
flag is cleared and the x-lock released by an i/o-handler thread.
@return 1 if a read request was queued, 0 if the page already resided
in buf_pool, or if the page is in the doublewrite buffer blocks in
which case it is never read into the pool, or if the tablespace does
not exist or is being dropped
@return 1 if read request is issued. 0 if it is not */
static
ulint
buf_read_page_low(
/*==============*/
ulint* err, /*!< out: DB_SUCCESS or DB_TABLESPACE_DELETED if we are
trying to read from a non-existent tablespace, or a
tablespace which is just now being dropped */
ibool sync, /*!< in: TRUE if synchronous aio is desired */
ulint mode, /*!< in: BUF_READ_IBUF_PAGES_ONLY, ...,
ORed to OS_AIO_SIMULATED_WAKE_LATER (see below
at read-ahead functions) */
ulint space, /*!< in: space id */
ulint zip_size,/*!< in: compressed page size, or 0 */
ibool unzip, /*!< in: TRUE=request uncompressed page */
ib_int64_t tablespace_version, /*!< in: if the space memory object has
this timestamp different from what we are giving here,
treat the tablespace as dropped; this is a timestamp we
use to stop dangling page reads from a tablespace
which we have DISCARDed + IMPORTed back */
ulint offset) /*!< in: page number */
{
buf_page_t* bpage;
ulint wake_later;
*err = DB_SUCCESS;
wake_later = mode & OS_AIO_SIMULATED_WAKE_LATER;
mode = mode & ~OS_AIO_SIMULATED_WAKE_LATER;
if (trx_doublewrite && space == TRX_SYS_SPACE
&& ( (offset >= trx_doublewrite->block1
&& offset < trx_doublewrite->block1
+ TRX_SYS_DOUBLEWRITE_BLOCK_SIZE)
|| (offset >= trx_doublewrite->block2
&& offset < trx_doublewrite->block2
+ TRX_SYS_DOUBLEWRITE_BLOCK_SIZE))) {
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Warning: trying to read"
" doublewrite buffer page %lu\n",
(ulong) offset);
return(0);
}
if (ibuf_bitmap_page(zip_size, offset)
|| trx_sys_hdr_page(space, offset)) {
/* Trx sys header is so low in the latching order that we play
safe and do not leave the i/o-completion to an asynchronous
i/o-thread. Ibuf bitmap pages must always be read with
syncronous i/o, to make sure they do not get involved in
thread deadlocks. */
sync = TRUE;
}
/* The following call will also check if the tablespace does not exist
or is being dropped; if we succeed in initing the page in the buffer
pool for read, then DISCARD cannot proceed until the read has
completed */
bpage = buf_page_init_for_read(err, mode, space, zip_size, unzip,
tablespace_version, offset);
if (bpage == NULL) {
return(0);
}
#ifdef UNIV_DEBUG
if (buf_debug_prints) {
fprintf(stderr,
"Posting read request for page %lu, sync %lu\n",
(ulong) offset,
(ulong) sync);
}
#endif
ut_ad(buf_page_in_file(bpage));
if (zip_size) {
*err = fil_io(OS_FILE_READ | wake_later,
sync, space, zip_size, offset, 0, zip_size,
bpage->zip.data, bpage);
} else {
ut_a(buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE);
*err = fil_io(OS_FILE_READ | wake_later,
sync, space, 0, offset, 0, UNIV_PAGE_SIZE,
((buf_block_t*) bpage)->frame, bpage);
}
ut_a(*err == DB_SUCCESS);
if (sync) {
/* The i/o is already completed when we arrive from
fil_read */
buf_page_io_complete(bpage);
}
return(1);
}
/************************************************************************
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;
}
