/*计算写入block需要的buffer的长度,进行size对齐*/
int __wt_block_write_size(WT_SESSION_IMPL *session, WT_BLOCK *block, size_t *sizep)
{
WT_UNUSED(session);
*sizep = (size_t)WT_ALIGN(*sizep + WT_BLOCK_HEADER_BYTE_SIZE, block->allocsize);
return (*sizep > UINT32_MAX - 1024 ? EINVAL : 0);
}
int
__wt_logrec_alloc(WT_SESSION_IMPL *session, size_t size, WT_ITEM **logrecp)
{
WT_ITEM *logrec;
WT_RET(__wt_scr_alloc(session, WT_ALIGN(size + 1, LOG_ALIGN), &logrec));
WT_CLEAR(*(WT_LOG_RECORD *)logrec->data);
logrec->size = offsetof(WT_LOG_RECORD, record);
*logrecp = logrec;
return (0);
}
/*
* __wt_block_write_size --
* Return the buffer size required to write a block.
*/
int
__wt_block_write_size(WT_SESSION_IMPL *session, WT_BLOCK *block, size_t *sizep)
{
WT_UNUSED(session);
/*
* We write the page size, in bytes, into the block's header as a 4B
* unsigned value, and it's possible for the engine to accept an item
* we can't write. For example, a huge key/value where the allocation
* size has been set to something large will overflow 4B when it tries
* to align the write. We could make this work (for example, writing
* the page size in units of allocation size or something else), but
* it's not worth the effort, writing 4GB objects into a btree makes
* no sense. Limit the writes to (4GB - 1KB), it gives us potential
* mode bits, and I'm not interested in debugging corner cases anyway.
*/
*sizep = (size_t)
WT_ALIGN(*sizep + WT_BLOCK_HEADER_BYTE_SIZE, block->allocsize);
return (*sizep > UINT32_MAX - 1024 ? EINVAL : 0);
}
/*
* __wt_block_write_off --
* Write a buffer into a block, returning the block's addr/size and
* checksum.
*/
int
__wt_block_write_off(WT_SESSION_IMPL *session, WT_BLOCK *block,
WT_ITEM *buf, off_t *offsetp, uint32_t *sizep, uint32_t *cksump,
int data_cksum, int locked)
{
WT_BLOCK_HEADER *blk;
WT_DECL_RET;
WT_FH *fh;
off_t offset;
uint32_t align_size;
blk = WT_BLOCK_HEADER_REF(buf->mem);
fh = block->fh;
/* Buffers should be aligned for writing. */
if (!F_ISSET(buf, WT_ITEM_ALIGNED)) {
WT_ASSERT(session, F_ISSET(buf, WT_ITEM_ALIGNED));
WT_RET_MSG(session, EINVAL,
"direct I/O check: write buffer incorrectly allocated");
}
/*
* Align the size to an allocation unit.
*
* The buffer must be big enough for us to zero to the next allocsize
* boundary, this is one of the reasons the btree layer must find out
* from the block-manager layer the maximum size of the eventual write.
*/
align_size = (uint32_t)WT_ALIGN(buf->size, block->allocsize);
if (align_size > buf->memsize) {
WT_ASSERT(session, align_size <= buf->memsize);
WT_RET_MSG(session, EINVAL,
"buffer size check: write buffer incorrectly allocated");
}
/* Zero out any unused bytes at the end of the buffer. */
memset((uint8_t *)buf->mem + buf->size, 0, align_size - buf->size);
/*
* Set the disk size so we don't have to incrementally read blocks
* during salvage.
*/
blk->disk_size = align_size;
/*
* Update the block's checksum: if our caller specifies, checksum the
* complete data, otherwise checksum the leading WT_BLOCK_COMPRESS_SKIP
* bytes. The assumption is applications with good compression support
* turn off checksums and assume corrupted blocks won't decompress
* correctly. However, if compression failed to shrink the block, the
* block wasn't compressed, in which case our caller will tell us to
* checksum the data to detect corruption. If compression succeeded,
* we still need to checksum the first WT_BLOCK_COMPRESS_SKIP bytes
* because they're not compressed, both to give salvage a quick test
* of whether a block is useful and to give us a test so we don't lose
* the first WT_BLOCK_COMPRESS_SKIP bytes without noticing.
*/
blk->flags = 0;
if (data_cksum)
F_SET(blk, WT_BLOCK_DATA_CKSUM);
blk->cksum = 0;
blk->cksum = __wt_cksum(
buf->mem, data_cksum ? align_size : WT_BLOCK_COMPRESS_SKIP);
if (!locked)
__wt_spin_lock(session, &block->live_lock);
ret = __wt_block_alloc(session, block, &offset, (off_t)align_size);
if (!locked)
__wt_spin_unlock(session, &block->live_lock);
WT_RET(ret);
#if defined(HAVE_POSIX_FALLOCATE) || defined(HAVE_FTRUNCATE)
/*
* Extend the file in chunks. We aren't holding a lock and we'd prefer
* to limit the number of threads extending the file at the same time,
* so choose the one thread that's crossing the extended boundary. We
* don't extend newly created files, and it's theoretically possible we
* might wait so long our extension of the file is passed by another
* thread writing single blocks, that's why there's a check in case the
* extended file size becomes too small: if the file size catches up,
* every thread will try to extend it.
*/
if (fh->extend_len != 0 &&
(fh->extend_size <= fh->size ||
(offset + fh->extend_len <= fh->extend_size &&
offset + fh->extend_len + align_size >= fh->extend_size))) {
fh->extend_size = offset + fh->extend_len * 2;
#if defined(HAVE_POSIX_FALLOCATE)
if ((ret =
posix_fallocate(fh->fd, offset, fh->extend_len * 2)) != 0)
WT_RET_MSG(
session, ret, "%s: posix_fallocate", fh->name);
#elif defined(HAVE_FTRUNCATE)
if ((ret = ftruncate(fh->fd, fh->extend_size)) != 0)
WT_RET_MSG(session, ret, "%s: ftruncate", fh->name);
#endif
}
#endif
if ((ret =
__wt_write(session, fh, offset, align_size, buf->mem)) != 0) {
if (!locked)
__wt_spin_lock(session, &block->live_lock);
WT_TRET(
__wt_block_off_free(session, block, offset, align_size));
if (!locked)
__wt_spin_unlock(session, &block->live_lock);
WT_RET(ret);
}
#ifdef HAVE_SYNC_FILE_RANGE
/*
* Optionally schedule writes for dirty pages in the system buffer
* cache.
*/
if (block->os_cache_dirty_max != 0 &&
(block->os_cache_dirty += align_size) > block->os_cache_dirty_max) {
block->os_cache_dirty = 0;
if ((ret = sync_file_range(fh->fd,
(off64_t)0, (off64_t)0, SYNC_FILE_RANGE_WRITE)) != 0)
WT_RET_MSG(
session, ret, "%s: sync_file_range", block->name);
}
#endif
#ifdef HAVE_POSIX_FADVISE
/* Optionally discard blocks from the system buffer cache. */
if (block->os_cache_max != 0 &&
(block->os_cache += align_size) > block->os_cache_max) {
block->os_cache = 0;
if ((ret = posix_fadvise(fh->fd,
(off_t)0, (off_t)0, POSIX_FADV_DONTNEED)) != 0)
WT_RET_MSG(
session, ret, "%s: posix_fadvise", block->name);
}
#endif
WT_CSTAT_INCR(session, block_write);
WT_CSTAT_INCRV(session, block_byte_write, align_size);
WT_VERBOSE_RET(session, write,
"off %" PRIuMAX ", size %" PRIu32 ", cksum %" PRIu32,
(uintmax_t)offset, align_size, blk->cksum);
*offsetp = offset;
*sizep = align_size;
*cksump = blk->cksum;
return (ret);
}
/*
* __wt_block_write_off --
* Write a buffer into a block, returning the block's offset, size and
* checksum.
*/
int
__wt_block_write_off(WT_SESSION_IMPL *session, WT_BLOCK *block,
WT_ITEM *buf, wt_off_t *offsetp, uint32_t *sizep, uint32_t *cksump,
int data_cksum, int caller_locked)
{
WT_BLOCK_HEADER *blk;
WT_DECL_RET;
WT_FH *fh;
size_t align_size;
wt_off_t offset;
int local_locked;
blk = WT_BLOCK_HEADER_REF(buf->mem);
fh = block->fh;
local_locked = 0;
/* Buffers should be aligned for writing. */
if (!F_ISSET(buf, WT_ITEM_ALIGNED)) {
WT_ASSERT(session, F_ISSET(buf, WT_ITEM_ALIGNED));
WT_RET_MSG(session, EINVAL,
"direct I/O check: write buffer incorrectly allocated");
}
/*
* Align the size to an allocation unit.
*
* The buffer must be big enough for us to zero to the next allocsize
* boundary, this is one of the reasons the btree layer must find out
* from the block-manager layer the maximum size of the eventual write.
*/
align_size = WT_ALIGN(buf->size, block->allocsize);
if (align_size > buf->memsize) {
WT_ASSERT(session, align_size <= buf->memsize);
WT_RET_MSG(session, EINVAL,
"buffer size check: write buffer incorrectly allocated");
}
if (align_size > UINT32_MAX) {
WT_ASSERT(session, align_size <= UINT32_MAX);
WT_RET_MSG(session, EINVAL,
"buffer size check: write buffer too large to write");
}
/* Zero out any unused bytes at the end of the buffer. */
memset((uint8_t *)buf->mem + buf->size, 0, align_size - buf->size);
/*
* Set the disk size so we don't have to incrementally read blocks
* during salvage.
*/
blk->disk_size = WT_STORE_SIZE(align_size);
/*
* Update the block's checksum: if our caller specifies, checksum the
* complete data, otherwise checksum the leading WT_BLOCK_COMPRESS_SKIP
* bytes. The assumption is applications with good compression support
* turn off checksums and assume corrupted blocks won't decompress
* correctly. However, if compression failed to shrink the block, the
* block wasn't compressed, in which case our caller will tell us to
* checksum the data to detect corruption. If compression succeeded,
* we still need to checksum the first WT_BLOCK_COMPRESS_SKIP bytes
* because they're not compressed, both to give salvage a quick test
* of whether a block is useful and to give us a test so we don't lose
* the first WT_BLOCK_COMPRESS_SKIP bytes without noticing.
*/
blk->flags = 0;
if (data_cksum)
F_SET(blk, WT_BLOCK_DATA_CKSUM);
blk->cksum = 0;
blk->cksum = __wt_cksum(
buf->mem, data_cksum ? align_size : WT_BLOCK_COMPRESS_SKIP);
if (!caller_locked) {
WT_RET(__wt_block_ext_prealloc(session, 5));
__wt_spin_lock(session, &block->live_lock);
local_locked = 1;
}
ret = __wt_block_alloc(session, block, &offset, (wt_off_t)align_size);
/*
* Extend the file in chunks. We want to limit the number of threads
* extending the file at the same time, so choose the one thread that's
* crossing the extended boundary. We don't extend newly created files,
* and it's theoretically possible we might wait so long our extension
* of the file is passed by another thread writing single blocks, that's
* why there's a check in case the extended file size becomes too small:
* if the file size catches up, every thread tries to extend it.
*
* File extension may require locking: some variants of the system call
* used to extend the file initialize the extended space. If a writing
* thread races with the extending thread, the extending thread might
* overwrite already written data, and that would be very, very bad.
*
* Some variants of the system call to extend the file fail at run-time
* based on the filesystem type, fall back to ftruncate in that case,
* and remember that ftruncate requires locking.
*/
if (ret == 0 &&
fh->extend_len != 0 &&
(fh->extend_size <= fh->size ||
(offset + fh->extend_len <= fh->extend_size &&
offset +
fh->extend_len + (wt_off_t)align_size >= fh->extend_size))) {
fh->extend_size = offset + fh->extend_len * 2;
if (fh->fallocate_available != WT_FALLOCATE_NOT_AVAILABLE) {
/*
* Release any locally acquired lock if it's not needed
* to extend the file, extending the file might require
* updating file metadata, which can be slow. (It may be
* a bad idea to configure for file extension on systems
* that require locking over the extend call.)
*/
if (!fh->fallocate_requires_locking && local_locked) {
__wt_spin_unlock(session, &block->live_lock);
local_locked = 0;
}
/* Extend the file. */
if ((ret = __wt_fallocate(session,
fh, offset, fh->extend_len * 2)) == ENOTSUP) {
ret = 0;
goto extend_truncate;
}
} else {
extend_truncate: /*
* We may have a caller lock or a locally acquired lock,
* but we need a lock to call ftruncate.
*/
if (!caller_locked && local_locked == 0) {
__wt_spin_lock(session, &block->live_lock);
local_locked = 1;
}
/*
* The truncate might fail if there's a file mapping
* (if there's an open checkpoint on the file), that's
* OK.
*/
if ((ret = __wt_ftruncate(
session, fh, offset + fh->extend_len * 2)) == EBUSY)
ret = 0;
}
}
/* Release any locally acquired lock. */
if (local_locked) {
__wt_spin_unlock(session, &block->live_lock);
local_locked = 0;
}
WT_RET(ret);
/* Write the block. */
if ((ret =
__wt_write(session, fh, offset, align_size, buf->mem)) != 0) {
if (!caller_locked)
__wt_spin_lock(session, &block->live_lock);
WT_TRET(__wt_block_off_free(
session, block, offset, (wt_off_t)align_size));
if (!caller_locked)
__wt_spin_unlock(session, &block->live_lock);
WT_RET(ret);
}
#ifdef HAVE_SYNC_FILE_RANGE
/*
* Optionally schedule writes for dirty pages in the system buffer
* cache, but only if the current session can wait.
*/
if (block->os_cache_dirty_max != 0 &&
(block->os_cache_dirty += align_size) > block->os_cache_dirty_max &&
__wt_session_can_wait(session)) {
block->os_cache_dirty = 0;
WT_RET(__wt_fsync_async(session, fh));
}
#endif
#ifdef HAVE_POSIX_FADVISE
/* Optionally discard blocks from the system buffer cache. */
if (block->os_cache_max != 0 &&
(block->os_cache += align_size) > block->os_cache_max) {
block->os_cache = 0;
if ((ret = posix_fadvise(fh->fd,
(wt_off_t)0, (wt_off_t)0, POSIX_FADV_DONTNEED)) != 0)
WT_RET_MSG(
session, ret, "%s: posix_fadvise", block->name);
}
#endif
WT_STAT_FAST_CONN_INCR(session, block_write);
WT_STAT_FAST_CONN_INCRV(session, block_byte_write, align_size);
WT_RET(__wt_verbose(session, WT_VERB_WRITE,
"off %" PRIuMAX ", size %" PRIuMAX ", cksum %" PRIu32,
(uintmax_t)offset, (uintmax_t)align_size, blk->cksum));
*offsetp = offset;
*sizep = WT_STORE_SIZE(align_size);
*cksump = blk->cksum;
return (ret);
}
/*
* __wt_block_write_off --
* Write a buffer into a block, returning the block's offset, size and
* checksum.
*/
int
__wt_block_write_off(WT_SESSION_IMPL *session, WT_BLOCK *block,
WT_ITEM *buf, wt_off_t *offsetp, uint32_t *sizep, uint32_t *cksump,
bool data_cksum, bool caller_locked)
{
WT_BLOCK_HEADER *blk;
WT_DECL_RET;
WT_FH *fh;
size_t align_size;
wt_off_t offset;
uint32_t cksum;
bool local_locked;
fh = block->fh;
/*
* Clear the block header to ensure all of it is initialized, even the
* unused fields.
*/
blk = WT_BLOCK_HEADER_REF(buf->mem);
memset(blk, 0, sizeof(*blk));
/*
* Swap the page-header as needed; this doesn't belong here, but it's
* the best place to catch all callers.
*/
__wt_page_header_byteswap(buf->mem);
/* Buffers should be aligned for writing. */
if (!F_ISSET(buf, WT_ITEM_ALIGNED)) {
WT_ASSERT(session, F_ISSET(buf, WT_ITEM_ALIGNED));
WT_RET_MSG(session, EINVAL,
"direct I/O check: write buffer incorrectly allocated");
}
/*
* Align the size to an allocation unit.
*
* The buffer must be big enough for us to zero to the next allocsize
* boundary, this is one of the reasons the btree layer must find out
* from the block-manager layer the maximum size of the eventual write.
*/
align_size = WT_ALIGN(buf->size, block->allocsize);
if (align_size > buf->memsize) {
WT_ASSERT(session, align_size <= buf->memsize);
WT_RET_MSG(session, EINVAL,
"buffer size check: write buffer incorrectly allocated");
}
if (align_size > UINT32_MAX) {
WT_ASSERT(session, align_size <= UINT32_MAX);
WT_RET_MSG(session, EINVAL,
"buffer size check: write buffer too large to write");
}
/* Zero out any unused bytes at the end of the buffer. */
memset((uint8_t *)buf->mem + buf->size, 0, align_size - buf->size);
/*
* Set the disk size so we don't have to incrementally read blocks
* during salvage.
*/
blk->disk_size = WT_STORE_SIZE(align_size);
/*
* Update the block's checksum: if our caller specifies, checksum the
* complete data, otherwise checksum the leading WT_BLOCK_COMPRESS_SKIP
* bytes. The assumption is applications with good compression support
* turn off checksums and assume corrupted blocks won't decompress
* correctly. However, if compression failed to shrink the block, the
* block wasn't compressed, in which case our caller will tell us to
* checksum the data to detect corruption. If compression succeeded,
* we still need to checksum the first WT_BLOCK_COMPRESS_SKIP bytes
* because they're not compressed, both to give salvage a quick test
* of whether a block is useful and to give us a test so we don't lose
* the first WT_BLOCK_COMPRESS_SKIP bytes without noticing.
*
* Checksum a little-endian version of the header, and write everything
* in little-endian format. The checksum is (potentially) returned in a
* big-endian format, swap it into place in a separate step.
*/
blk->flags = 0;
if (data_cksum)
F_SET(blk, WT_BLOCK_DATA_CKSUM);
blk->cksum = 0;
__wt_block_header_byteswap(blk);
blk->cksum = cksum = __wt_cksum(
buf->mem, data_cksum ? align_size : WT_BLOCK_COMPRESS_SKIP);
#ifdef WORDS_BIGENDIAN
blk->cksum = __wt_bswap32(blk->cksum);
#endif
/* Pre-allocate some number of extension structures. */
WT_RET(__wt_block_ext_prealloc(session, 5));
/*
* Acquire a lock, if we don't already hold one.
* Allocate space for the write, and optionally extend the file (note
* the block-extend function may release the lock).
* Release any locally acquired lock.
*/
local_locked = false;
if (!caller_locked) {
__wt_spin_lock(session, &block->live_lock);
local_locked = true;
}
ret = __wt_block_alloc(session, block, &offset, (wt_off_t)align_size);
if (ret == 0)
ret = __wt_block_extend(
session, block, fh, offset, align_size, &local_locked);
if (local_locked)
__wt_spin_unlock(session, &block->live_lock);
WT_RET(ret);
/* Write the block. */
if ((ret =
__wt_write(session, fh, offset, align_size, buf->mem)) != 0) {
if (!caller_locked)
__wt_spin_lock(session, &block->live_lock);
WT_TRET(__wt_block_off_free(
session, block, offset, (wt_off_t)align_size));
if (!caller_locked)
__wt_spin_unlock(session, &block->live_lock);
WT_RET(ret);
}
#ifdef HAVE_SYNC_FILE_RANGE
/*
* Optionally schedule writes for dirty pages in the system buffer
* cache, but only if the current session can wait.
*/
if (block->os_cache_dirty_max != 0 &&
(block->os_cache_dirty += align_size) > block->os_cache_dirty_max &&
__wt_session_can_wait(session)) {
block->os_cache_dirty = 0;
WT_RET(__wt_fsync_async(session, fh));
}
#endif
#ifdef HAVE_POSIX_FADVISE
/* Optionally discard blocks from the system buffer cache. */
if (block->os_cache_max != 0 &&
(block->os_cache += align_size) > block->os_cache_max) {
block->os_cache = 0;
if ((ret = posix_fadvise(fh->fd,
(wt_off_t)0, (wt_off_t)0, POSIX_FADV_DONTNEED)) != 0)
WT_RET_MSG(
session, ret, "%s: posix_fadvise", block->name);
}
#endif
WT_STAT_FAST_CONN_INCR(session, block_write);
WT_STAT_FAST_CONN_INCRV(session, block_byte_write, align_size);
WT_RET(__wt_verbose(session, WT_VERB_WRITE,
"off %" PRIuMAX ", size %" PRIuMAX ", cksum %" PRIu32,
(uintmax_t)offset, (uintmax_t)align_size, cksum));
*offsetp = offset;
*sizep = WT_STORE_SIZE(align_size);
*cksump = cksum;
return (0);
}
/*
* __wt_realloc_aligned --
* ANSI realloc function that aligns to buffer boundaries, configured with
* the "buffer_alignment" key to wiredtiger_open.
*/
int
__wt_realloc_aligned(WT_SESSION_IMPL *session,
size_t *bytes_allocated_ret, size_t bytes_to_allocate, void *retp)
{
#if defined(HAVE_POSIX_MEMALIGN)
WT_DECL_RET;
/*
* !!!
* This function MUST handle a NULL WT_SESSION_IMPL handle.
*/
if (session != NULL && S2C(session)->buffer_alignment > 0) {
void *p, *newp;
size_t bytes_allocated;
/*
* Sometimes we're allocating memory and we don't care about the
* final length -- bytes_allocated_ret may be NULL.
*/
p = *(void **)retp;
bytes_allocated =
(bytes_allocated_ret == NULL) ? 0 : *bytes_allocated_ret;
WT_ASSERT(session,
(p == NULL && bytes_allocated == 0) ||
(p != NULL &&
(bytes_allocated_ret == NULL || bytes_allocated != 0)));
WT_ASSERT(session, bytes_to_allocate != 0);
WT_ASSERT(session, bytes_allocated < bytes_to_allocate);
/*
* We are going to allocate an aligned buffer. When we do this
* repeatedly, the allocator is expected to start on a boundary
* each time, account for that additional space by never asking
* for less than a full alignment size. The primary use case
* for aligned buffers is Linux direct I/O, which requires that
* the size be a multiple of the alignment anyway.
*/
bytes_to_allocate =
WT_ALIGN(bytes_to_allocate, S2C(session)->buffer_alignment);
WT_STAT_FAST_CONN_INCR(session, memory_allocation);
if ((ret = posix_memalign(&newp,
S2C(session)->buffer_alignment,
bytes_to_allocate)) != 0)
WT_RET_MSG(session, ret, "memory allocation");
if (p != NULL)
memcpy(newp, p, bytes_allocated);
__wt_free(session, p);
p = newp;
/* Clear the allocated memory (see above). */
memset((uint8_t *)p + bytes_allocated, 0,
bytes_to_allocate - bytes_allocated);
/* Update caller's bytes allocated value. */
if (bytes_allocated_ret != NULL)
*bytes_allocated_ret = bytes_to_allocate;
*(void **)retp = p;
return (0);
}
#endif
/*
* If there is no posix_memalign function, or no alignment configured,
* fall back to realloc.
*
* Windows note: Visual C CRT memalign does not match Posix behavior
* and would also double each allocation so it is bad for memory use
*/
return (__wt_realloc(
session, bytes_allocated_ret, bytes_to_allocate, retp));
}
/*将buffer的数据写入到block对应的文件中，并计算checksum和size*/
int __wt_block_write_off(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_ITEM *buf, wt_off_t *offsetp,
uint32_t *sizep, uint32_t *cksump, int data_cksum, int caller_locked)
{
WT_BLOCK_HEADER *blk;
WT_DECL_RET;
WT_FH *fh;
size_t align_size;
wt_off_t offset;
int local_locked;
blk = WT_BLOCK_HEADER_REF(buf->mem);
fh = block->fh;
local_locked = 0;
/*buf不是对齐模式，不能进行写,因为这个是和磁盘相关的写入，必须是对齐的*/
if(!F_ISSET(buf, WT_ITEM_ALIGNED)){
WT_ASSERT(session, F_ISSET(buf, WT_ITEM_ALIGNED));
WT_RET_MSG(session, EINVAL, "direct I/O check: write buffer incorrectly allocated");
}
/*计算buf->size按block对齐,对齐后有可能会比现有的buf->memsize大，如果大的话，不能进行写，有可能会缓冲区溢出*/
align_size = WT_ALIGN(buf->size, block->allocsize);
if (align_size > buf->memsize) {
WT_ASSERT(session, align_size <= buf->memsize);
WT_RET_MSG(session, EINVAL, "buffer size check: write buffer incorrectly allocated");
}
/*超过4G*/
if (align_size > UINT32_MAX) {
WT_ASSERT(session, align_size <= UINT32_MAX);
WT_RET_MSG(session, EINVAL, "buffer size check: write buffer too large to write");
}
/*将对其后pading的buffer位置进行清0*/
memset((uint8_t*)buf->mem + buf->size, 0, align_size - buf->size);
/*设置block header,计算存储的数据长度*/
blk->disk_size = WT_STORE_SIZE(align_size);
blk->flags = 0;
if(data_cksum)
F_SET(blk, WT_BLOCK_DATA_CKSUM);
/*计算buf的cksum*/
blk->cksum = __wt_cksum(buf->mem, data_cksum ? align_size : WT_BLOCK_COMPRESS_SKIP);
if (!caller_locked) {
WT_RET(__wt_block_ext_prealloc(session, 5));
__wt_spin_lock(session, &block->live_lock);
local_locked = 1;
}
ret = __wt_block_alloc(session, block, &offset, (wt_off_t)align_size);
/*判断文件是否需要进行扩大,如果不扩大就有可能存不下写入的block数据*/
if(ret == 0 && fh->extend_len != 0 && (fh->extend_size <= fh->size ||
(offset + fh->extend_len <= fh->extend_size && offset + fh->extend_len + (wt_off_t)align_size >= fh->extend_size))){
/*调整extend_size为原来的offset + extend_len的两倍*/
fh->extend_size = offset + fh->extend_len * 2;
if (fh->fallocate_available != WT_FALLOCATE_NOT_AVAILABLE) {
/*释放block->live_lock的自旋锁，因为重设文件大小会时间比较长，需要先释放自旋锁，防止CPU空转*/
if (!fh->fallocate_requires_locking && local_locked) {
__wt_spin_unlock(session, &block->live_lock);
local_locked = 0;
}
/*扩大文件的占用空间*/
if ((ret = __wt_fallocate(session,fh, offset, fh->extend_len * 2)) == ENOTSUP) {
ret = 0;
goto extend_truncate;
}
}
else{
extend_truncate:
if (!caller_locked && local_locked == 0) {
__wt_spin_lock(session, &block->live_lock);
local_locked = 1;
}
/*直接调整文件大小,这个比__wt_fallocate更慢*/
if ((ret = __wt_ftruncate(session, fh, offset + fh->extend_len * 2)) == EBUSY)
ret = 0;
}
}
if(local_locked){
__wt_spin_unlock(session, &block->live_lock);
local_locked = 0;
}
WT_RET(ret);
/*进行block的数据写入*/
ret =__wt_write(session, fh, offset, align_size, buf->mem);
if (ret != 0) {
if (!caller_locked)
__wt_spin_lock(session, &block->live_lock);
/*没写成功，将ext对应的数据返回给avail list*/
WT_TRET(__wt_block_off_free(session, block, offset, (wt_off_t)align_size));
if (!caller_locked)
__wt_spin_unlock(session, &block->live_lock);
WT_RET(ret);
}
#ifdef HAVE_SYNC_FILE_RANGE
/*需要进行fsync操作,脏页太多,进行一次异步刷盘*/
if (block->os_cache_dirty_max != 0 && (block->os_cache_dirty += align_size) > block->os_cache_dirty_max && __wt_session_can_wait(session)) {
block->os_cache_dirty = 0;
WT_RET(__wt_fsync_async(session, fh));
}
#endif
#ifdef HAVE_POSIX_FADVISE
/*清理fh->fd文件对应的system page cache中的数据,这个过程可能会有IO操作,相当于同步的sync调用*/
if (block->os_cache_max != 0 && (block->os_cache += align_size) > block->os_cache_max) {
block->os_cache = 0;
if ((ret = posix_fadvise(fh->fd, (wt_off_t)0, (wt_off_t)0, POSIX_FADV_DONTNEED)) != 0)
WT_RET_MSG( session, ret, "%s: posix_fadvise", block->name);
}
#endif
WT_STAT_FAST_CONN_INCR(session, block_write);
WT_STAT_FAST_CONN_INCRV(session, block_byte_write, align_size);
WT_RET(__wt_verbose(session, WT_VERB_WRITE, "off %" PRIuMAX ", size %" PRIuMAX ", cksum %" PRIu32,
(uintmax_t)offset, (uintmax_t)align_size, blk->cksum));
*offsetp = offset;
*sizep = WT_STORE_SIZE(align_size);
*cksump = blk->cksum;
return ret;
}
