/*
* __wt_log_slot_init --
* Initialize the slot array.
*/
int
__wt_log_slot_init(WT_SESSION_IMPL *session, bool alloc)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_LOG *log;
WT_LOGSLOT *slot;
int32_t i;
conn = S2C(session);
log = conn->log;
for (i = 0; i < WT_SLOT_POOL; i++)
log->slot_pool[i].slot_state = WT_LOG_SLOT_FREE;
/*
* Allocate memory for buffers now that the arrays are setup. Separate
* this from the loop above to make error handling simpler.
*/
/*
* !!! If the buffer size is too close to the log file size, we will
* switch log files very aggressively. Scale back the buffer for
* small log file sizes.
*/
if (alloc) {
log->slot_buf_size = (uint32_t)WT_MIN(
(size_t)conn->log_file_max / 10, WT_LOG_SLOT_BUF_SIZE);
for (i = 0; i < WT_SLOT_POOL; i++) {
WT_ERR(__wt_buf_init(session,
&log->slot_pool[i].slot_buf, log->slot_buf_size));
F_SET(&log->slot_pool[i], WT_SLOT_INIT_FLAGS);
}
WT_STAT_CONN_SET(session,
log_buffer_size, log->slot_buf_size * WT_SLOT_POOL);
}
/*
* Set up the available slot from the pool the first time.
*/
slot = &log->slot_pool[0];
/*
* We cannot initialize the release LSN in the activate function
* because that function can be called after a log file switch.
* The release LSN is usually the same as the slot_start_lsn except
* around a log file switch.
*/
slot->slot_release_lsn = log->alloc_lsn;
__wt_log_slot_activate(session, slot);
log->active_slot = slot;
log->pool_index = 0;
if (0) {
err: while (--i >= 0)
__wt_buf_free(session, &log->slot_pool[i].slot_buf);
}
return (ret);
}
/*
* __log_prealloc_once --
* Perform one iteration of log pre-allocation.
*/
static int
__log_prealloc_once(WT_SESSION_IMPL *session)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_LOG *log;
u_int i, reccount;
char **recfiles;
conn = S2C(session);
log = conn->log;
reccount = 0;
recfiles = NULL;
/*
* Allocate up to the maximum number, accounting for any existing
* files that may not have been used yet.
*/
WT_ERR(__wt_fs_directory_list(
session, conn->log_path, WT_LOG_PREPNAME, &recfiles, &reccount));
/*
* Adjust the number of files to pre-allocate if we find that
* the critical path had to allocate them since we last ran.
*/
if (log->prep_missed > 0) {
conn->log_prealloc += log->prep_missed;
__wt_verbose(session, WT_VERB_LOG,
"Missed %" PRIu32 ". Now pre-allocating up to %" PRIu32,
log->prep_missed, conn->log_prealloc);
}
WT_STAT_CONN_SET(session, log_prealloc_max, conn->log_prealloc);
/*
* Allocate up to the maximum number that we just computed and detected.
*/
for (i = reccount; i < (u_int)conn->log_prealloc; i++) {
WT_ERR(__wt_log_allocfile(
session, ++log->prep_fileid, WT_LOG_PREPNAME));
WT_STAT_CONN_INCR(session, log_prealloc_files);
}
/*
* Reset the missed count now. If we missed during pre-allocating
* the log files, it means the allocation is not keeping up, not that
* we didn't allocate enough. So we don't just want to keep adding
* in more.
*/
log->prep_missed = 0;
if (0)
err: __wt_err(session, ret, "log pre-alloc server error");
WT_TRET(__wt_fs_directory_list_free(session, &recfiles, reccount));
return (ret);
}
/*
* __logmgr_config --
* Parse and setup the logging server options.
*/
static int
__logmgr_config(
WT_SESSION_IMPL *session, const char **cfg, bool *runp, bool reconfig)
{
WT_CONFIG_ITEM cval;
WT_CONNECTION_IMPL *conn;
bool enabled;
/*
* A note on reconfiguration: the standard "is this configuration string
* allowed" checks should fail if reconfiguration has invalid strings,
* for example, "log=(enabled)", or "statistics_log=(path=XXX)", because
* the connection reconfiguration method doesn't allow those strings.
* Additionally, the base configuration values during reconfiguration
* are the currently configured values (so we don't revert to default
* values when repeatedly reconfiguring), and configuration processing
* of a currently set value should not change the currently set value.
*
* In this code path, log server reconfiguration does not stop/restart
* the log server, so there's no point in re-evaluating configuration
* strings that cannot be reconfigured, risking bugs in configuration
* setup, and depending on evaluation of currently set values to always
* result in the currently set value. Skip tests for any configuration
* strings which don't make sense during reconfiguration, but don't
* worry about error reporting because it should never happen.
*/
conn = S2C(session);
WT_RET(__wt_config_gets(session, cfg, "log.enabled", &cval));
enabled = cval.val != 0;
/*
* If we're reconfiguring, enabled must match the already
* existing setting.
*
* If it is off and the user it turning it on, or it is on
* and the user is turning it off, return an error.
*
* See above: should never happen.
*/
if (reconfig &&
((enabled && !FLD_ISSET(conn->log_flags, WT_CONN_LOG_ENABLED)) ||
(!enabled && FLD_ISSET(conn->log_flags, WT_CONN_LOG_ENABLED))))
WT_RET_MSG(session, EINVAL,
"log manager reconfigure: enabled mismatch with existing "
"setting");
/* Logging is incompatible with in-memory */
if (enabled) {
WT_RET(__wt_config_gets(session, cfg, "in_memory", &cval));
if (cval.val != 0)
WT_RET_MSG(session, EINVAL,
"In-memory configuration incompatible with "
"log=(enabled=true)");
}
*runp = enabled;
/*
* Setup a log path and compression even if logging is disabled in case
* we are going to print a log. Only do this on creation. Once a
* compressor or log path are set they cannot be changed.
*
* See above: should never happen.
*/
if (!reconfig) {
conn->log_compressor = NULL;
WT_RET(__wt_config_gets_none(
session, cfg, "log.compressor", &cval));
WT_RET(__wt_compressor_config(
session, &cval, &conn->log_compressor));
WT_RET(__wt_config_gets(session, cfg, "log.path", &cval));
WT_RET(__wt_strndup(
session, cval.str, cval.len, &conn->log_path));
}
/* We are done if logging isn't enabled. */
if (!*runp)
return (0);
WT_RET(__wt_config_gets(session, cfg, "log.archive", &cval));
if (cval.val != 0)
FLD_SET(conn->log_flags, WT_CONN_LOG_ARCHIVE);
/*
* The file size cannot be reconfigured. The amount of memory allocated
* to the log slots may be based on the log file size at creation and we
* don't want to re-allocate that memory while running.
*
* See above: should never happen.
*/
if (!reconfig) {
WT_RET(__wt_config_gets(session, cfg, "log.file_max", &cval));
conn->log_file_max = (wt_off_t)cval.val;
WT_STAT_CONN_SET(session, log_max_filesize, conn->log_file_max);
}
/*
* If pre-allocation is configured, set the initial number to a few.
* We'll adapt as load dictates.
*/
WT_RET(__wt_config_gets(session, cfg, "log.prealloc", &cval));
if (cval.val != 0)
conn->log_prealloc = 1;
/*
* Note it's meaningless to reconfigure this value during runtime, it
* only matters on create before recovery runs.
*
* See above: should never happen.
*/
if (!reconfig) {
WT_RET(__wt_config_gets_def(
session, cfg, "log.recover", 0, &cval));
if (WT_STRING_MATCH("error", cval.str, cval.len))
FLD_SET(conn->log_flags, WT_CONN_LOG_RECOVER_ERR);
}
WT_RET(__wt_config_gets(session, cfg, "log.zero_fill", &cval));
if (cval.val != 0) {
if (F_ISSET(conn, WT_CONN_READONLY))
WT_RET_MSG(session, EINVAL,
"Read-only configuration incompatible with "
"zero-filling log files");
FLD_SET(conn->log_flags, WT_CONN_LOG_ZERO_FILL);
}
WT_RET(__logmgr_sync_cfg(session, cfg));
if (conn->log_cond != NULL)
__wt_cond_signal(session, conn->log_cond);
return (0);
}
