/*
* __log_openfile --
* Open a log file with the given log file number and return the WT_FH.
*/
static int
__log_openfile(WT_SESSION_IMPL *session, int ok_create, WT_FH **fh, uint32_t id)
{
WT_DECL_ITEM(path);
WT_DECL_RET;
WT_RET(__wt_scr_alloc(session, 0, &path));
WT_ERR(__wt_log_filename(session, id, path));
WT_ERR(__wt_verbose(session, WT_VERB_LOG,
"opening log %s", (const char *)path->data));
WT_ERR(__wt_open(
session, path->data, ok_create, 0, WT_FILE_TYPE_LOG, fh));
err: __wt_scr_free(&path);
return (ret);
}
/*
* __optrack_open_file --
* Open the per-session operation-tracking file.
*/
static int
__optrack_open_file(WT_SESSION_IMPL *session)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_ITEM(buf);
WT_DECL_RET;
WT_OPTRACK_HEADER optrack_header = { WT_OPTRACK_VERSION, 0,
(uint32_t)WT_TSC_DEFAULT_RATIO * WT_THOUSAND };
conn = S2C(session);
if (!F_ISSET(conn, WT_CONN_OPTRACK))
WT_RET_MSG(session, WT_ERROR, "WT_CONN_OPTRACK not set");
WT_RET(__wt_scr_alloc(session, 0, &buf));
WT_ERR(__wt_filename_construct(session, conn->optrack_path,
"optrack", conn->optrack_pid, session->id, buf));
WT_ERR(__wt_open(session,
(const char *)buf->data, WT_FS_OPEN_FILE_TYPE_REGULAR,
WT_FS_OPEN_CREATE, &session->optrack_fh));
/* Indicate whether this is an internal session */
if (F_ISSET(session, WT_SESSION_INTERNAL))
optrack_header.optrack_session_internal = 1;
/*
* Record the clock ticks to nanoseconds ratio. Multiply it by one
* thousand, so we can use a fixed width integer.
*/
optrack_header.optrack_tsc_nsec_ratio =
(uint32_t)(__wt_process.tsc_nsec_ratio * WT_THOUSAND);
/* Write the header into the operation-tracking file. */
WT_ERR(session->optrack_fh->handle->fh_write(
session->optrack_fh->handle, (WT_SESSION *)session,
0, sizeof(WT_OPTRACK_HEADER), &optrack_header));
session->optrack_offset = sizeof(WT_OPTRACK_HEADER);
if (0) {
err: WT_TRET(__wt_close(session, &session->optrack_fh));
}
__wt_scr_free(session, &buf);
return (ret);
}
/*
* __wt_fopen --
* Open a stream handle.
*/
int
__wt_fopen(WT_SESSION_IMPL *session,
const char *name, uint32_t open_flags, uint32_t flags, WT_FSTREAM **fstrp)
{
WT_DECL_RET;
WT_FH *fh;
WT_FSTREAM *fstr;
*fstrp = NULL;
fstr = NULL;
WT_RET(__wt_open(
session, name, WT_OPEN_FILE_TYPE_REGULAR, open_flags, &fh));
WT_ERR(__wt_calloc_one(session, &fstr));
fstr->fh = fh;
fstr->name = fh->name;
fstr->flags = flags;
fstr->close = __fstream_close;
WT_ERR(__wt_filesize(session, fh, &fstr->size));
if (LF_ISSET(WT_STREAM_APPEND))
fstr->off = fstr->size;
if (LF_ISSET(WT_STREAM_APPEND | WT_STREAM_WRITE)) {
fstr->fstr_flush = __fstream_flush;
fstr->fstr_getline = __fstream_getline_notsup;
fstr->fstr_printf = __fstream_printf;
} else {
WT_ASSERT(session, LF_ISSET(WT_STREAM_READ));
fstr->fstr_flush = __fstream_flush_notsup;
fstr->fstr_getline = __fstream_getline;
fstr->fstr_printf = __fstream_printf_notsup;
}
*fstrp = fstr;
return (0);
err: WT_TRET(__wt_close(session, &fh));
__wt_free(session, fstr);
return (ret);
}
/*
* __wt_block_manager_truncate --
* Truncate a file.
*/
int
__wt_block_manager_truncate(
WT_SESSION_IMPL *session, const char *filename, uint32_t allocsize)
{
WT_DECL_RET;
WT_FH *fh;
/* Open the underlying file handle. */
WT_RET(__wt_open(session, filename, 0, 0, WT_FILE_TYPE_DATA, &fh));
/* Truncate the file. */
WT_ERR(__wt_ftruncate(session, fh, (off_t)0));
/* Write out the file's meta-data. */
ret = __wt_desc_init(session, fh, allocsize);
/* Close the file handle. */
err: WT_TRET(__wt_close(session, fh));
return (ret);
}
/*
* __wt_block_manager_create --
* Create a file.
*/
int
__wt_block_manager_create(
WT_SESSION_IMPL *session, const char *filename, uint32_t allocsize)
{
WT_DECL_RET;
WT_FH *fh;
/* Create the underlying file and open a handle. */
WT_RET(__wt_open(session, filename, 1, 1, WT_FILE_TYPE_DATA, &fh));
/* Write out the file's meta-data. */
ret = __wt_desc_init(session, fh, allocsize);
/* Close the file handle. */
WT_TRET(__wt_close(session, fh));
/* Undo any create on error. */
if (ret != 0)
WT_TRET(__wt_remove(session, filename));
return (ret);
}
/*
* __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);
}
/*
* wiredtiger_open --
* Main library entry point: open a new connection to a WiredTiger
* database.
*/
int
wiredtiger_open(const char *home, WT_EVENT_HANDLER *event_handler,
const char *config, WT_CONNECTION **wt_connp)
{
static WT_CONNECTION stdc = {
__conn_close,
__conn_reconfigure,
__conn_get_home,
__conn_is_new,
__conn_open_session,
__conn_load_extension,
__conn_add_data_source,
__conn_add_collator,
__conn_add_compressor,
__conn_add_extractor
};
static struct {
const char *name;
uint32_t flag;
} *ft, directio_types[] = {
{ "data", WT_DIRECTIO_DATA },
{ "log", WT_DIRECTIO_LOG },
{ NULL, 0 }
};
WT_CONFIG subconfig;
WT_CONFIG_ITEM cval, skey, sval;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_ITEM *cbuf, expath, exconfig;
WT_SESSION_IMPL *session;
const char *cfg[] =
{ __wt_confdfl_wiredtiger_open, config, NULL, NULL, NULL };
int exist;
*wt_connp = NULL;
session = NULL;
cbuf = NULL;
WT_CLEAR(expath);
WT_CLEAR(exconfig);
WT_RET(__wt_library_init());
WT_RET(__wt_calloc_def(NULL, 1, &conn));
conn->iface = stdc;
/*
* Immediately link the structure into the connection structure list:
* the only thing ever looked at on that list is the database name,
* and a NULL value is fine.
*/
__wt_spin_lock(NULL, &__wt_process.spinlock);
TAILQ_INSERT_TAIL(&__wt_process.connqh, conn, q);
__wt_spin_unlock(NULL, &__wt_process.spinlock);
session = conn->default_session = &conn->dummy_session;
session->iface.connection = &conn->iface;
session->name = "wiredtiger_open";
__wt_event_handler_set(session, event_handler);
/* Remaining basic initialization of the connection structure. */
WT_ERR(__wt_connection_init(conn));
/* Check the configuration strings. */
WT_ERR(__wt_config_check(
session, __wt_confchk_wiredtiger_open, config, 0));
/* Get the database home. */
WT_ERR(__conn_home(session, home, cfg));
/* Make sure no other thread of control already owns this database. */
WT_ERR(__conn_single(session, cfg));
/* Read the database-home configuration file. */
WT_ERR(__conn_config_file(session, cfg, &cbuf));
/* Read the environment variable configuration. */
WT_ERR(__conn_config_env(session, cfg));
WT_ERR(__wt_config_gets(session, cfg, "hazard_max", &cval));
conn->hazard_max = (uint32_t)cval.val;
WT_ERR(__wt_config_gets(session, cfg, "session_max", &cval));
conn->session_size = (uint32_t)cval.val + WT_NUM_INTERNAL_SESSIONS;
WT_ERR(__wt_config_gets(session, cfg, "lsm_merge", &cval));
if (cval.val)
F_SET(conn, WT_CONN_LSM_MERGE);
WT_ERR(__wt_config_gets(session, cfg, "sync", &cval));
if (cval.val)
F_SET(conn, WT_CONN_SYNC);
WT_ERR(__wt_config_gets(session, cfg, "transactional", &cval));
if (cval.val)
F_SET(conn, WT_CONN_TRANSACTIONAL);
/* Configure verbose flags. */
WT_ERR(__conn_verbose_config(session, cfg));
WT_ERR(__wt_conn_cache_pool_config(session, cfg));
WT_ERR(__wt_config_gets(session, cfg, "logging", &cval));
if (cval.val != 0)
WT_ERR(__wt_open(
session, WT_LOG_FILENAME, 1, 0, 0, &conn->log_fh));
/* Configure direct I/O and buffer alignment. */
WT_ERR(__wt_config_gets(session, cfg, "buffer_alignment", &cval));
if (cval.val == -1)
conn->buffer_alignment = WT_BUFFER_ALIGNMENT_DEFAULT;
else
conn->buffer_alignment = (size_t)cval.val;
#ifndef HAVE_POSIX_MEMALIGN
if (conn->buffer_alignment != 0)
WT_ERR_MSG(session, EINVAL,
"buffer_alignment requires posix_memalign");
#endif
/*
* Configuration: direct_io, mmap, statistics.
*/
WT_ERR(__wt_config_gets(session, cfg, "direct_io", &cval));
for (ft = directio_types; ft->name != NULL; ft++) {
ret = __wt_config_subgets(session, &cval, ft->name, &sval);
if (ret == 0) {
if (sval.val)
FLD_SET(conn->direct_io, ft->flag);
} else if (ret != WT_NOTFOUND)
goto err;
}
WT_ERR(__wt_config_gets(session, cfg, "mmap", &cval));
conn->mmap = cval.val == 0 ? 0 : 1;
WT_ERR(__wt_config_gets(session, cfg, "statistics", &cval));
conn->statistics = cval.val == 0 ? 0 : 1;
/* Load any extensions referenced in the config. */
WT_ERR(__wt_config_gets(session, cfg, "extensions", &cval));
WT_ERR(__wt_config_subinit(session, &subconfig, &cval));
while ((ret = __wt_config_next(&subconfig, &skey, &sval)) == 0) {
WT_ERR(__wt_buf_fmt(
session, &expath, "%.*s", (int)skey.len, skey.str));
if (sval.len > 0)
WT_ERR(__wt_buf_fmt(session, &exconfig,
"entry=%.*s\n", (int)sval.len, sval.str));
WT_ERR(conn->iface.load_extension(&conn->iface,
expath.data, (sval.len > 0) ? exconfig.data : NULL));
}
WT_ERR_NOTFOUND_OK(ret);
/*
* Open the connection; if that fails, the connection handle has been
* destroyed by the time the open function returns.
*/
if ((ret = __wt_connection_open(conn, cfg)) != 0) {
conn = NULL;
WT_ERR(ret);
}
/* Open the default session. */
WT_ERR(__wt_open_session(conn, 1, NULL, NULL, &conn->default_session));
session = conn->default_session;
/*
* Check on the turtle and metadata files, creating them if necessary
* (which avoids application threads racing to create the metadata file
* later).
*/
WT_ERR(__wt_meta_turtle_init(session, &exist));
if (!exist) {
/*
* We're single-threaded, but acquire the schema lock
* regardless: the lower level code checks that it is
* appropriately synchronized.
*/
WT_WITH_SCHEMA_LOCK(session,
ret = __wt_schema_create(session, WT_METADATA_URI, NULL));
WT_ERR(ret);
}
WT_ERR(__wt_metadata_open(session));
/* If there's a hot-backup file, load it. */
WT_ERR(__wt_metadata_load_backup(session));
/*
* XXX LSM initialization.
* This is structured so that it could be moved to an extension.
*/
WT_ERR(__wt_lsm_init(&conn->iface, NULL));
STATIC_ASSERT(offsetof(WT_CONNECTION_IMPL, iface) == 0);
*wt_connp = &conn->iface;
/*
* Destroying the connection on error will destroy our session handle,
* cleanup using the session handle first, then discard the connection.
*/
err: if (cbuf != NULL)
__wt_buf_free(session, cbuf);
__wt_buf_free(session, &expath);
__wt_buf_free(session, &exconfig);
if (ret != 0 && conn != NULL)
WT_TRET(__wt_connection_destroy(conn));
/* Let the server threads proceed. */
if (ret == 0)
conn->connection_initialized = 1;
return (ret);
}
/*
* __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);
}
/*
* __conn_config_file --
* Read in any WiredTiger_config file in the home directory.
*/
static int
__conn_config_file(WT_SESSION_IMPL *session, const char **cfg, WT_ITEM **cbufp)
{
WT_DECL_ITEM(cbuf);
WT_DECL_RET;
WT_FH *fh;
off_t size;
uint32_t len;
int exist, quoted;
uint8_t *p, *t;
*cbufp = NULL; /* Returned buffer */
fh = NULL;
/* Check for an optional configuration file. */
#define WT_CONFIGFILE "WiredTiger.config"
WT_RET(__wt_exist(session, WT_CONFIGFILE, &exist));
if (!exist)
return (0);
/* Open the configuration file. */
WT_RET(__wt_open(session, WT_CONFIGFILE, 0, 0, 0, &fh));
WT_ERR(__wt_filesize(session, fh, &size));
if (size == 0)
goto err;
/*
* Sanity test: a 100KB configuration file would be insane. (There's
* no practical reason to limit the file size, but I can either limit
* the file size to something rational, or I can add code to test if
* the off_t size is larger than a uint32_t, which is more complicated
* and a waste of time.)
*/
if (size > 100 * 1024)
WT_ERR_MSG(session, EFBIG, WT_CONFIGFILE);
len = (uint32_t)size;
/*
* Copy the configuration file into memory, with a little slop, I'm not
* interested in debugging off-by-ones.
*
* The beginning of a file is the same as if we run into an unquoted
* newline character, simplify the parsing loop by pretending that's
* what we're doing.
*/
WT_ERR(__wt_scr_alloc(session, len + 10, &cbuf));
WT_ERR(
__wt_read(session, fh, (off_t)0, len, ((uint8_t *)cbuf->mem) + 1));
((uint8_t *)cbuf->mem)[0] = '\n';
cbuf->size = len + 1;
/*
* Collapse the file's lines into a single string: newline characters
* are replaced with commas unless the newline is quoted or backslash
* escaped. Comment lines (an unescaped newline where the next non-
* white-space character is a hash), are discarded.
*/
for (quoted = 0, p = t = cbuf->mem; len > 0;) {
/*
* Backslash pairs pass through untouched, unless immediately
* preceding a newline, in which case both the backslash and
* the newline are discarded. Backslash characters escape
* quoted characters, too, that is, a backslash followed by a
* quote doesn't start or end a quoted string.
*/
if (*p == '\\' && len > 1) {
if (p[1] != '\n') {
*t++ = p[0];
*t++ = p[1];
}
p += 2;
len -= 2;
continue;
}
/*
* If we're in a quoted string, or starting a quoted string,
* take all characters, including white-space and newlines.
*/
if (quoted || *p == '"') {
if (*p == '"')
quoted = !quoted;
*t++ = *p++;
--len;
continue;
}
/* Everything else gets taken, except for newline characters. */
if (*p != '\n') {
*t++ = *p++;
--len;
continue;
}
/*
* Replace any newline characters with commas (and strings of
* commas are safe).
*
* After any newline, skip to a non-white-space character; if
* the next character is a hash mark, skip to the next newline.
*/
for (;;) {
for (*t++ = ','; --len > 0 && isspace(*++p);)
;
if (len == 0)
break;
if (*p != '#')
break;
while (--len > 0 && *++p != '\n')
;
if (len == 0)
break;
}
}
*t = '\0';
#if 0
fprintf(stderr, "file config: {%s}\n", (const char *)cbuf->data);
#endif
/* Check the configuration string. */
WT_ERR(__wt_config_check(
session, __wt_confchk_wiredtiger_open, cbuf->data, 0));
/*
* The configuration file falls between the default configuration and
* the wiredtiger_open() configuration, overriding the defaults but not
* overriding the wiredtiger_open() configuration.
*/
while (cfg[1] != NULL)
++cfg;
cfg[1] = cfg[0];
cfg[0] = cbuf->data;
*cbufp = cbuf;
if (0) {
err: if (cbuf != NULL)
__wt_buf_free(session, cbuf);
}
if (fh != NULL)
WT_TRET(__wt_close(session, fh));
return (ret);
}
/*
* __wt_conn_optrack_setup --
* Set up operation logging.
*/
int
__wt_conn_optrack_setup(WT_SESSION_IMPL *session,
const char *cfg[], bool reconfig)
{
WT_CONFIG_ITEM cval;
WT_CONNECTION_IMPL *conn;
WT_DECL_ITEM(buf);
WT_DECL_RET;
conn = S2C(session);
/* Once an operation tracking path has been set it can't be changed. */
if (!reconfig) {
WT_RET(__wt_config_gets(session,
cfg, "operation_tracking.path", &cval));
WT_RET(__wt_strndup(session,
cval.str, cval.len, &conn->optrack_path));
}
WT_RET(__wt_config_gets(session,
cfg, "operation_tracking.enabled", &cval));
if (cval.val == 0) {
if (F_ISSET(conn, WT_CONN_OPTRACK)) {
WT_RET(__wt_conn_optrack_teardown(session, reconfig));
F_CLR(conn, WT_CONN_OPTRACK);
}
return (0);
}
if (F_ISSET(conn, WT_CONN_READONLY))
/* Operation tracking isn't supported in read-only mode */
WT_RET_MSG(session, EINVAL,
"Operation tracking is incompatible with read only "
"configuration.");
if (F_ISSET(conn, WT_CONN_OPTRACK))
/* Already enabled, nothing else to do */
return (0);
/*
* Operation tracking files will include the ID of the creating process
* in their name, so we can distinguish between log files created by
* different WiredTiger processes in the same directory. We cache the
* process id for future use.
*/
conn->optrack_pid = __wt_process_id();
/*
* Open the file in the same directory that will hold a map of
* translations between function names and function IDs. If the file
* exists, remove it.
*/
WT_RET(__wt_scr_alloc(session, 0, &buf));
WT_ERR(__wt_filename_construct(session, conn->optrack_path,
"optrack-map", conn->optrack_pid, UINT32_MAX, buf));
WT_ERR(__wt_open(session,
(const char *)buf->data, WT_FS_OPEN_FILE_TYPE_REGULAR,
WT_FS_OPEN_CREATE, &conn->optrack_map_fh));
WT_ERR(__wt_spin_init(session,
&conn->optrack_map_spinlock, "optrack map spinlock"));
WT_ERR(__wt_malloc(session, WT_OPTRACK_BUFSIZE,
&conn->dummy_session.optrack_buf));
/* Set operation tracking on */
F_SET(conn, WT_CONN_OPTRACK);
err: __wt_scr_free(session, &buf);
return (ret);
}
/*
* __wt_block_open --
* Open a block handle.
*/
int
__wt_block_open(WT_SESSION_IMPL *session,
const char *filename, const char *cfg[],
int forced_salvage, int readonly, uint32_t allocsize, WT_BLOCK **blockp)
{
WT_BLOCK *block;
WT_CONFIG_ITEM cval;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_TRET(__wt_verbose(session, WT_VERB_BLOCK, "open: %s", filename));
conn = S2C(session);
*blockp = NULL;
__wt_spin_lock(session, &conn->block_lock);
TAILQ_FOREACH(block, &conn->blockqh, q)
if (strcmp(filename, block->name) == 0) {
++block->ref;
*blockp = block;
__wt_spin_unlock(session, &conn->block_lock);
return (0);
}
/* Basic structure allocation, initialization. */
WT_ERR(__wt_calloc_def(session, 1, &block));
block->ref = 1;
TAILQ_INSERT_HEAD(&conn->blockqh, block, q);
WT_ERR(__wt_strdup(session, filename, &block->name));
block->allocsize = allocsize;
WT_ERR(__wt_config_gets(session, cfg, "block_allocation", &cval));
block->allocfirst =
WT_STRING_MATCH("first", cval.str, cval.len) ? 1 : 0;
/* Configuration: optional OS buffer cache maximum size. */
WT_ERR(__wt_config_gets(session, cfg, "os_cache_max", &cval));
block->os_cache_max = (size_t)cval.val;
#ifdef HAVE_POSIX_FADVISE
if (conn->direct_io && block->os_cache_max)
WT_ERR_MSG(session, EINVAL,
"os_cache_max not supported in combination with direct_io");
#else
if (block->os_cache_max)
WT_ERR_MSG(session, EINVAL,
"os_cache_max not supported if posix_fadvise not "
"available");
#endif
/* Configuration: optional immediate write scheduling flag. */
WT_ERR(__wt_config_gets(session, cfg, "os_cache_dirty_max", &cval));
block->os_cache_dirty_max = (size_t)cval.val;
#ifdef HAVE_SYNC_FILE_RANGE
if (conn->direct_io && block->os_cache_dirty_max)
WT_ERR_MSG(session, EINVAL,
"os_cache_dirty_max not supported in combination with "
"direct_io");
#else
if (block->os_cache_dirty_max) {
/*
* Ignore any setting if it is not supported.
*/
block->os_cache_dirty_max = 0;
WT_ERR(__wt_verbose(session, WT_VERB_BLOCK,
"os_cache_dirty_max ignored when sync_file_range not "
"available"));
}
#endif
/* Open the underlying file handle. */
WT_ERR(__wt_open(session, filename, 0, 0,
readonly ? WT_FILE_TYPE_CHECKPOINT : WT_FILE_TYPE_DATA,
&block->fh));
/* Initialize the live checkpoint's lock. */
WT_ERR(__wt_spin_init(session, &block->live_lock, "block manager"));
/*
* Read the description information from the first block.
*
* Salvage is a special case: if we're forcing the salvage, we don't
* look at anything, including the description information.
*/
if (!forced_salvage)
WT_ERR(__desc_read(session, block));
*blockp = block;
__wt_spin_unlock(session, &conn->block_lock);
return (0);
err: WT_TRET(__block_destroy(session, block));
__wt_spin_unlock(session, &conn->block_lock);
return (ret);
}
* Remove the target file if it exists, then create a temporary file,
* copy the original into it and rename it into place. I don't think
* its necessary to remove the file, or create a copy and do a rename,
* it's likely safe to overwrite the backup file directly. I'm doing
* the remove and rename to insulate us from errors in other programs
* that might not detect a corrupted backup file; it's cheap insurance
* in a path where undetected failure is very bad.
*/
WT_ERR(__wt_scr_alloc(session, 0, &tmp));
WT_ERR(__wt_buf_fmt(session, tmp, "%s.copy", to));
WT_ERR(__wt_remove_if_exists(session, to, false));
WT_ERR(__wt_remove_if_exists(session, tmp->data, false));
/* Open the from and temporary file handles. */
WT_ERR(__wt_open(session, from, WT_FS_OPEN_FILE_TYPE_REGULAR, 0, &ffh));
WT_ERR(__wt_open(session, tmp->data, WT_FS_OPEN_FILE_TYPE_REGULAR,
WT_FS_OPEN_CREATE | WT_FS_OPEN_EXCLUSIVE, &tfh));
/*
* Allocate a copy buffer. Don't use a scratch buffer, this thing is
* big, and we don't want it hanging around.
*/
#define WT_BACKUP_COPY_SIZE (128 * 1024)
WT_ERR(__wt_malloc(session, WT_BACKUP_COPY_SIZE, &buf));
/* Get the file's size, then copy the bytes. */
WT_ERR(__wt_filesize(session, ffh, &size));
for (offset = 0; size > 0; size -= n, offset += n) {
n = WT_MIN(size, WT_BACKUP_COPY_SIZE);
WT_ERR(__wt_read(session, ffh, offset, (size_t)n, buf));
