/*
* __wt_log_slot_destroy --
* Clean up the slot array on shutdown.
*/
int
__wt_log_slot_destroy(WT_SESSION_IMPL *session)
{
WT_CONNECTION_IMPL *conn;
WT_LOG *log;
WT_LOGSLOT *slot;
int64_t rel;
int i;
conn = S2C(session);
log = conn->log;
/*
* Write out any remaining buffers. Free the buffer.
*/
for (i = 0; i < WT_SLOT_POOL; i++) {
slot = &log->slot_pool[i];
if (!FLD_LOG_SLOT_ISSET(
(uint64_t)slot->slot_state, WT_LOG_SLOT_RESERVED)) {
rel = WT_LOG_SLOT_RELEASED_BUFFERED(slot->slot_state);
if (rel != 0)
WT_RET(__wt_write(session, slot->slot_fh,
slot->slot_start_offset, (size_t)rel,
slot->slot_buf.mem));
}
__wt_buf_free(session, &log->slot_pool[i].slot_buf);
}
return (0);
}
/*
* __log_fill --
* Copy a thread's log records into the assigned slot.
*/
static int
__log_fill(WT_SESSION_IMPL *session,
WT_MYSLOT *myslot, int direct, WT_ITEM *record, WT_LSN *lsnp)
{
WT_DECL_RET;
WT_LOG_RECORD *logrec;
logrec = (WT_LOG_RECORD *)record->mem;
/*
* Call __wt_write. For now the offset is the real byte offset.
* If the offset becomes a unit of LOG_ALIGN this is where we would
* multiply by LOG_ALIGN to get the real file byte offset for write().
*/
if (direct)
WT_ERR(__wt_write(session, myslot->slot->slot_fh,
myslot->offset + myslot->slot->slot_start_offset,
(size_t)logrec->len, (void *)logrec));
else
memcpy((char *)myslot->slot->slot_buf.mem + myslot->offset,
logrec, logrec->len);
WT_STAT_FAST_CONN_INCRV(session, log_bytes_written, logrec->len);
if (lsnp != NULL) {
*lsnp = myslot->slot->slot_start_lsn;
lsnp->offset += (off_t)myslot->offset;
}
err:
if (ret != 0 && myslot->slot->slot_error == 0)
myslot->slot->slot_error = ret;
return (ret);
}
/*
* __wt_desc_init --
* Write a file's initial descriptor structure.
*/
int
__wt_desc_init(WT_SESSION_IMPL *session, WT_FH *fh, uint32_t allocsize)
{
WT_BLOCK_DESC *desc;
WT_DECL_ITEM(buf);
WT_DECL_RET;
/* Use a scratch buffer to get correct alignment for direct I/O. */
WT_RET(__wt_scr_alloc(session, allocsize, &buf));
memset(buf->mem, 0, allocsize);
desc = buf->mem;
desc->magic = WT_BLOCK_MAGIC;
desc->majorv = WT_BLOCK_MAJOR_VERSION;
desc->minorv = WT_BLOCK_MINOR_VERSION;
/* Update the checksum. */
desc->cksum = 0;
desc->cksum = __wt_cksum(desc, allocsize);
ret = __wt_write(session, fh, (off_t)0, (size_t)allocsize, desc);
__wt_scr_free(&buf);
return (ret);
}
/*
* __fstream_flush --
* Flush the data from a stream.
*/
static int
__fstream_flush(WT_SESSION_IMPL *session, WT_FSTREAM *fstr)
{
if (fstr->buf.size > 0) {
WT_RET(__wt_write(session,
fstr->fh, fstr->off, fstr->buf.size, fstr->buf.data));
fstr->off += (wt_off_t)fstr->buf.size;
fstr->buf.size = 0;
}
return (0);
}
/*
* __wt_turtle_update --
* Update the turtle file.
*/
int
__wt_turtle_update(
WT_SESSION_IMPL *session, const char *key, const char *value)
{
WT_FH *fh;
WT_DECL_ITEM(buf);
WT_DECL_RET;
int vmajor, vminor, vpatch;
const char *version;
fh = NULL;
/*
* Create the turtle setup file: we currently re-write it from scratch
* every time.
*/
WT_RET(__wt_open(
session, WT_METADATA_TURTLE_SET, 1, 1, WT_FILE_TYPE_TURTLE, &fh));
version = wiredtiger_version(&vmajor, &vminor, &vpatch);
WT_ERR(__wt_scr_alloc(session, 2 * 1024, &buf));
WT_ERR(__wt_buf_fmt(session, buf,
"%s\n%s\n%s\n" "major=%d,minor=%d,patch=%d\n%s\n%s\n",
WT_METADATA_VERSION_STR, version,
WT_METADATA_VERSION, vmajor, vminor, vpatch,
key, value));
WT_ERR(__wt_write(session, fh, 0, buf->size, buf->data));
/* Flush the handle and rename the file into place. */
ret = __wt_sync_and_rename_fh(
session, &fh, WT_METADATA_TURTLE_SET, WT_METADATA_TURTLE);
/* Close any file handle left open, remove any temporary file. */
err: WT_TRET(__wt_close(session, &fh));
WT_TRET(__wt_remove_if_exists(session, WT_METADATA_TURTLE_SET));
__wt_scr_free(session, &buf);
return (ret);
}
/*
* __wt_optrack_record_funcid --
* Allocate and record optrack function ID.
*/
void
__wt_optrack_record_funcid(
WT_SESSION_IMPL *session, const char *func, uint16_t *func_idp)
{
static uint16_t optrack_uid = 0; /* Unique for the process lifetime. */
WT_CONNECTION_IMPL *conn;
WT_DECL_ITEM(tmp);
WT_DECL_RET;
wt_off_t fsize;
bool locked;
conn = S2C(session);
locked = false;
WT_ERR(__wt_scr_alloc(session, strlen(func) + 32, &tmp));
__wt_spin_lock(session, &conn->optrack_map_spinlock);
locked = true;
if (*func_idp == 0) {
*func_idp = ++optrack_uid;
WT_ERR(__wt_buf_fmt(
session, tmp, "%" PRIu16 " %s\n", *func_idp, func));
WT_ERR(__wt_filesize(session, conn->optrack_map_fh, &fsize));
WT_ERR(__wt_write(session,
conn->optrack_map_fh, fsize, tmp->size, tmp->data));
}
if (0) {
err: WT_PANIC_MSG(session, ret,
"operation tracking initialization failure");
}
if (locked)
__wt_spin_unlock(session, &conn->optrack_map_spinlock);
__wt_scr_free(session, &tmp);
}
/*
* __conn_single --
* Confirm that no other thread of control is using this database.
*/
static int
__conn_single(WT_SESSION_IMPL *session, const char **cfg)
{
WT_CONFIG_ITEM cval;
WT_CONNECTION_IMPL *conn, *t;
WT_DECL_RET;
off_t size;
uint32_t len;
int created;
char buf[256];
conn = S2C(session);
/*
* Optionally create the wiredtiger flag file if it doesn't already
* exist. We don't actually care if we create it or not, the "am I the
* only locker" tests are all that matter.
*/
WT_RET(__wt_config_gets(session, cfg, "create", &cval));
WT_RET(__wt_open(session,
WT_SINGLETHREAD, cval.val == 0 ? 0 : 1, 0, 0, &conn->lock_fh));
/*
* Lock a byte of the file: if we don't get the lock, some other process
* is holding it, we're done. Note the file may be zero-length length,
* and that's OK, the underlying call supports acquisition of locks past
* the end-of-file.
*/
if (__wt_bytelock(conn->lock_fh, (off_t)0, 1) != 0)
WT_ERR_MSG(session, EBUSY, "%s",
"WiredTiger database is already being managed by another "
"process");
/* Check to see if another thread of control has this database open. */
__wt_spin_lock(session, &__wt_process.spinlock);
TAILQ_FOREACH(t, &__wt_process.connqh, q)
if (t->home != NULL &&
t != conn && strcmp(t->home, conn->home) == 0) {
ret = EBUSY;
break;
}
__wt_spin_unlock(session, &__wt_process.spinlock);
if (ret != 0)
WT_ERR_MSG(session, EBUSY, "%s",
"WiredTiger database is already being managed by another "
"thread in this process");
/*
* If the size of the file is 0, we created it (or we're racing with
* the thread that created it, it doesn't matter), write some bytes
* into the file. Strictly speaking, this isn't even necessary, but
* zero-length files always make me nervous.
*/
WT_ERR(__wt_filesize(session, conn->lock_fh, &size));
if (size == 0) {
len = (uint32_t)snprintf(buf, sizeof(buf), "%s\n%s\n",
WT_SINGLETHREAD, wiredtiger_version(NULL, NULL, NULL));
WT_ERR(__wt_write(
session, conn->lock_fh, (off_t)0, (uint32_t)len, buf));
created = 1;
} else
created = 0;
/*
* If we found a zero-length WiredTiger lock file, and eventually ended
* as the database owner, return that we created the database. (There
* is a theoretical chance that another process created the WiredTiger
* lock file but we won the race to add the WT_CONNECTION_IMPL structure
* to the process' list. It doesn't much matter, only one thread will
* be told it created the database.)
*/
conn->is_new = created;
return (0);
err: if (conn->lock_fh != NULL) {
WT_TRET(__wt_close(session, conn->lock_fh));
conn->lock_fh = NULL;
}
return (ret);
}
/*
* __log_release --
* Release a log slot.
*/
static int
__log_release(WT_SESSION_IMPL *session, WT_LOGSLOT *slot)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_FH *close_fh;
WT_LOG *log;
WT_LSN sync_lsn;
size_t write_size;
WT_DECL_SPINLOCK_ID(id); /* Must appear last */
conn = S2C(session);
log = conn->log;
/*
* If we're going to have to close our log file, make a local copy
* of the file handle structure.
*/
close_fh = NULL;
if (F_ISSET(slot, SLOT_CLOSEFH)) {
close_fh = log->log_close_fh;
log->log_close_fh = NULL;
F_CLR(slot, SLOT_CLOSEFH);
}
/* Write the buffered records */
if (F_ISSET(slot, SLOT_BUFFERED)) {
write_size = (size_t)
(slot->slot_end_lsn.offset - slot->slot_start_offset);
WT_ERR(__wt_write(session, slot->slot_fh,
slot->slot_start_offset, write_size, slot->slot_buf.mem));
}
/*
* Wait for earlier groups to finish, otherwise there could be holes
* in the log file.
*/
while (LOG_CMP(&log->write_lsn, &slot->slot_release_lsn) != 0)
__wt_yield();
log->write_lsn = slot->slot_end_lsn;
/*
* Try to consolidate calls to fsync to wait less. Acquire a spin lock
* so that threads finishing writing to the log will wait while the
* current fsync completes and advance log->write_lsn.
*/
while (F_ISSET(slot, SLOT_SYNC) &&
LOG_CMP(&log->sync_lsn, &slot->slot_end_lsn) < 0) {
if (__wt_spin_trylock(session, &log->log_sync_lock, &id) != 0) {
(void)__wt_cond_wait(
session, log->log_sync_cond, 10000);
continue;
}
/*
* Record the current end of log after we grabbed the lock.
* That is how far our fsync call with guarantee.
*/
sync_lsn = log->write_lsn;
if (LOG_CMP(&log->sync_lsn, &slot->slot_end_lsn) < 0) {
WT_STAT_FAST_CONN_INCR(session, log_sync);
ret = __wt_fsync(session, log->log_fh);
if (ret == 0) {
F_CLR(slot, SLOT_SYNC);
log->sync_lsn = sync_lsn;
ret = __wt_cond_signal(
session, log->log_sync_cond);
}
}
__wt_spin_unlock(session, &log->log_sync_lock);
WT_ERR(ret);
}
if (F_ISSET(slot, SLOT_BUF_GROW)) {
WT_STAT_FAST_CONN_INCR(session, log_buffer_grow);
F_CLR(slot, SLOT_BUF_GROW);
WT_STAT_FAST_CONN_INCRV(session,
log_buffer_size, slot->slot_buf.memsize);
WT_ERR(__wt_buf_grow(session,
&slot->slot_buf, slot->slot_buf.memsize * 2));
}
/*
* If we have a file to close, close it now.
*/
if (close_fh)
WT_ERR(__wt_close(session, close_fh));
err: if (ret != 0 && slot->slot_error == 0)
slot->slot_error = ret;
return (ret);
}
/*
* __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);
}
/*将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;
}