/*
* __log_wrlsn_server --
* The log wrlsn server thread.
*/
static WT_THREAD_RET
__log_wrlsn_server(void *arg)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_SESSION_IMPL *session;
session = arg;
conn = S2C(session);
while (F_ISSET(conn, WT_CONN_LOG_SERVER_RUN)) {
/*
* Write out any log record buffers.
*/
WT_ERR(__wt_log_wrlsn(session));
WT_ERR(__wt_cond_wait(session, conn->log_wrlsn_cond, 10000));
}
/*
* On close we need to do this one more time because there could
* be straggling log writes that need to be written.
*/
WT_ERR(__wt_log_force_write(session, 1));
WT_ERR(__wt_log_wrlsn(session));
if (0) {
err: __wt_err(session, ret, "log wrlsn server error");
}
return (WT_THREAD_RET_VALUE);
}
/*
* __log_wrlsn_server --
* The log wrlsn server thread.
*/
static WT_THREAD_RET
__log_wrlsn_server(void *arg)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_LOG *log;
WT_LSN prev;
WT_SESSION_IMPL *session;
int yield;
bool did_work;
session = arg;
conn = S2C(session);
log = conn->log;
yield = 0;
WT_INIT_LSN(&prev);
did_work = false;
while (F_ISSET(conn, WT_CONN_LOG_SERVER_RUN)) {
/*
* Write out any log record buffers if anything was done
* since last time. Only call the function to walk the
* slots if the system is not idle. On an idle system
* the alloc_lsn will not advance and the written lsn will
* match the alloc_lsn.
*/
if (__wt_log_cmp(&prev, &log->alloc_lsn) != 0 ||
__wt_log_cmp(&log->write_lsn, &log->alloc_lsn) != 0)
WT_ERR(__wt_log_wrlsn(session, &yield));
else
WT_STAT_FAST_CONN_INCR(session, log_write_lsn_skip);
prev = log->alloc_lsn;
if (yield == 0)
did_work = true;
else
did_work = false;
/*
* If __wt_log_wrlsn did work we want to yield instead of sleep.
*/
if (yield++ < WT_THOUSAND)
__wt_yield();
else
/*
* Send in false because if we did any work we would
* not be on this path.
*/
WT_ERR(__wt_cond_auto_wait(
session, conn->log_wrlsn_cond, did_work));
}
/*
* On close we need to do this one more time because there could
* be straggling log writes that need to be written.
*/
WT_ERR(__wt_log_force_write(session, 1, NULL));
WT_ERR(__wt_log_wrlsn(session, NULL));
if (0) {
err: __wt_err(session, ret, "log wrlsn server error");
}
return (WT_THREAD_RET_VALUE);
}
/*
* __log_server --
* The log server thread.
*/
static WT_THREAD_RET
__log_server(void *arg)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_LOG *log;
WT_SESSION_IMPL *session;
int freq_per_sec, signalled;
session = arg;
conn = S2C(session);
log = conn->log;
signalled = 0;
/*
* Set this to the number of times per second we want to force out the
* log slot buffer.
*/
#define WT_FORCE_PER_SECOND 20
freq_per_sec = WT_FORCE_PER_SECOND;
/*
* The log server thread does a variety of work. It forces out any
* buffered log writes. It pre-allocates log files and it performs
* log archiving. The reason the wrlsn thread does not force out
* the buffered writes is because we want to process and move the
* write_lsn forward as quickly as possible. The same reason applies
* to why the log file server thread does not force out the writes.
* That thread does fsync calls which can take a long time and we
* don't want log records sitting in the buffer over the time it
* takes to sync out an earlier file.
*/
while (F_ISSET(conn, WT_CONN_LOG_SERVER_RUN)) {
/*
* Slots depend on future activity. Force out buffered
* writes in case we are idle. This cannot be part of the
* wrlsn thread because of interaction advancing the write_lsn
* and a buffer may need to wait for the write_lsn to advance
* in the case of a synchronous buffer. We end up with a hang.
*/
WT_ERR_BUSY_OK(__wt_log_force_write(session, 0));
/*
* We don't want to archive or pre-allocate files as often as
* we want to force out log buffers. Only do it once per second
* or if the condition was signalled.
*/
if (--freq_per_sec <= 0 || signalled != 0) {
freq_per_sec = WT_FORCE_PER_SECOND;
/*
* Perform log pre-allocation.
*/
if (conn->log_prealloc > 0)
WT_ERR(__log_prealloc_once(session));
/*
* Perform the archive.
*/
if (FLD_ISSET(conn->log_flags, WT_CONN_LOG_ARCHIVE)) {
if (__wt_try_writelock(
session, log->log_archive_lock) == 0) {
ret = __log_archive_once(session, 0);
WT_TRET(__wt_writeunlock(
session, log->log_archive_lock));
WT_ERR(ret);
} else
WT_ERR(
__wt_verbose(session, WT_VERB_LOG,
"log_archive: Blocked due to open "
"log cursor holding archive lock"));
}
}
/* Wait until the next event. */
WT_ERR(__wt_cond_wait_signal(session, conn->log_cond,
WT_MILLION / WT_FORCE_PER_SECOND, &signalled));
}
if (0) {
err: __wt_err(session, ret, "log server error");
}
return (WT_THREAD_RET_VALUE);
}
/*
* __log_server --
* The log server thread.
*/
static WT_THREAD_RET
__log_server(void *arg)
{
struct timespec start, now;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_LOG *log;
WT_SESSION_IMPL *session;
uint64_t timediff;
bool did_work, locked, signalled;
session = arg;
conn = S2C(session);
log = conn->log;
locked = signalled = false;
/*
* Set this to the number of milliseconds we want to run archive and
* pre-allocation. Start it so that we run on the first time through.
*/
timediff = WT_THOUSAND;
/*
* The log server thread does a variety of work. It forces out any
* buffered log writes. It pre-allocates log files and it performs
* log archiving. The reason the wrlsn thread does not force out
* the buffered writes is because we want to process and move the
* write_lsn forward as quickly as possible. The same reason applies
* to why the log file server thread does not force out the writes.
* That thread does fsync calls which can take a long time and we
* don't want log records sitting in the buffer over the time it
* takes to sync out an earlier file.
*/
did_work = true;
while (F_ISSET(conn, WT_CONN_LOG_SERVER_RUN)) {
/*
* Slots depend on future activity. Force out buffered
* writes in case we are idle. This cannot be part of the
* wrlsn thread because of interaction advancing the write_lsn
* and a buffer may need to wait for the write_lsn to advance
* in the case of a synchronous buffer. We end up with a hang.
*/
WT_ERR_BUSY_OK(__wt_log_force_write(session, 0, &did_work));
/*
* We don't want to archive or pre-allocate files as often as
* we want to force out log buffers. Only do it once per second
* or if the condition was signalled.
*/
if (timediff >= WT_THOUSAND || signalled) {
/*
* Perform log pre-allocation.
*/
if (conn->log_prealloc > 0) {
/*
* Log file pre-allocation is disabled when a
* hot backup cursor is open because we have
* agreed not to rename or remove any files in
* the database directory.
*/
WT_ERR(__wt_readlock(
session, conn->hot_backup_lock));
locked = true;
if (!conn->hot_backup)
WT_ERR(__log_prealloc_once(session));
WT_ERR(__wt_readunlock(
session, conn->hot_backup_lock));
locked = false;
}
/*
* Perform the archive.
*/
if (FLD_ISSET(conn->log_flags, WT_CONN_LOG_ARCHIVE)) {
if (__wt_try_writelock(
session, log->log_archive_lock) == 0) {
ret = __log_archive_once(session, 0);
WT_TRET(__wt_writeunlock(
session, log->log_archive_lock));
WT_ERR(ret);
} else
WT_ERR(
__wt_verbose(session, WT_VERB_LOG,
"log_archive: Blocked due to open "
"log cursor holding archive lock"));
}
}
/* Wait until the next event. */
WT_ERR(__wt_epoch(session, &start));
WT_ERR(__wt_cond_auto_wait_signal(session, conn->log_cond,
did_work, &signalled));
WT_ERR(__wt_epoch(session, &now));
timediff = WT_TIMEDIFF_MS(now, start);
}
if (0) {
err: __wt_err(session, ret, "log server error");
if (locked)
WT_TRET(__wt_readunlock(
session, conn->hot_backup_lock));
}
return (WT_THREAD_RET_VALUE);
}
/*
* __wt_curlog_open --
* Initialize a log cursor.
*/
int
__wt_curlog_open(WT_SESSION_IMPL *session,
const char *uri, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CONNECTION_IMPL *conn;
WT_CURSOR_STATIC_INIT(iface,
__wt_cursor_get_key, /* get-key */
__wt_cursor_get_value, /* get-value */
__wt_cursor_set_key, /* set-key */
__wt_cursor_set_value, /* set-value */
__curlog_compare, /* compare */
__wt_cursor_equals, /* equals */
__curlog_next, /* next */
__wt_cursor_notsup, /* prev */
__curlog_reset, /* reset */
__curlog_search, /* search */
__wt_cursor_search_near_notsup, /* search-near */
__wt_cursor_notsup, /* insert */
__wt_cursor_notsup, /* update */
__wt_cursor_notsup, /* remove */
__wt_cursor_reconfigure_notsup, /* reconfigure */
__curlog_close); /* close */
WT_CURSOR *cursor;
WT_CURSOR_LOG *cl;
WT_DECL_RET;
WT_LOG *log;
WT_STATIC_ASSERT(offsetof(WT_CURSOR_LOG, iface) == 0);
conn = S2C(session);
if (!FLD_ISSET(conn->log_flags, WT_CONN_LOG_ENABLED))
WT_RET_MSG(session, EINVAL,
"Cannot open a log cursor without logging enabled");
log = conn->log;
cl = NULL;
WT_RET(__wt_calloc_one(session, &cl));
cursor = &cl->iface;
*cursor = iface;
cursor->session = &session->iface;
WT_ERR(__wt_calloc_one(session, &cl->cur_lsn));
WT_ERR(__wt_calloc_one(session, &cl->next_lsn));
WT_ERR(__wt_scr_alloc(session, 0, &cl->logrec));
WT_ERR(__wt_scr_alloc(session, 0, &cl->opkey));
WT_ERR(__wt_scr_alloc(session, 0, &cl->opvalue));
cursor->key_format = WT_LOGC_KEY_FORMAT;
cursor->value_format = WT_LOGC_VALUE_FORMAT;
WT_INIT_LSN(cl->cur_lsn);
WT_INIT_LSN(cl->next_lsn);
WT_ERR(__wt_cursor_init(cursor, uri, NULL, cfg, cursorp));
/*
* The user may be trying to read a log record they just wrote.
* Log records may be buffered, so force out any now.
*/
WT_ERR(__wt_log_force_write(session, 1));
/* Log cursors block archiving. */
WT_ERR(__wt_readlock(session, log->log_archive_lock));
if (0) {
err: if (F_ISSET(cursor, WT_CURSTD_OPEN))
WT_TRET(cursor->close(cursor));
else {
__wt_free(session, cl->cur_lsn);
__wt_free(session, cl->next_lsn);
__wt_scr_free(session, &cl->logrec);
__wt_scr_free(session, &cl->opkey);
__wt_scr_free(session, &cl->opvalue);
/*
* NOTE: We cannot get on the error path with the
* readlock held. No need to unlock it unless that
* changes above.
*/
__wt_free(session, cl);
}
*cursorp = NULL;
}
return (ret);
}
/*
* __wt_curlog_open --
* Initialize a log cursor.
*/
int
__wt_curlog_open(WT_SESSION_IMPL *session,
const char *uri, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CONNECTION_IMPL *conn;
WT_CURSOR_STATIC_INIT(iface,
__wt_cursor_get_key, /* get-key */
__wt_cursor_get_value, /* get-value */
__wt_cursor_set_key, /* set-key */
__wt_cursor_set_value, /* set-value */
__curlog_compare, /* compare */
__wt_cursor_equals, /* equals */
__curlog_next, /* next */
__wt_cursor_notsup, /* prev */
__curlog_reset, /* reset */
__curlog_search, /* search */
__wt_cursor_search_near_notsup, /* search-near */
__wt_cursor_notsup, /* insert */
__wt_cursor_modify_notsup, /* modify */
__wt_cursor_notsup, /* update */
__wt_cursor_notsup, /* remove */
__wt_cursor_notsup, /* reserve */
__wt_cursor_reconfigure_notsup, /* reconfigure */
__wt_cursor_notsup, /* cache */
__wt_cursor_reopen_notsup, /* reopen */
__curlog_close); /* close */
WT_CURSOR *cursor;
WT_CURSOR_LOG *cl;
WT_DECL_RET;
WT_LOG *log;
WT_STATIC_ASSERT(offsetof(WT_CURSOR_LOG, iface) == 0);
conn = S2C(session);
log = conn->log;
WT_RET(__wt_calloc_one(session, &cl));
cursor = (WT_CURSOR *)cl;
*cursor = iface;
cursor->session = (WT_SESSION *)session;
cursor->key_format = WT_LOGC_KEY_FORMAT;
cursor->value_format = WT_LOGC_VALUE_FORMAT;
WT_ERR(__wt_calloc_one(session, &cl->cur_lsn));
WT_ERR(__wt_calloc_one(session, &cl->next_lsn));
WT_ERR(__wt_scr_alloc(session, 0, &cl->logrec));
WT_ERR(__wt_scr_alloc(session, 0, &cl->opkey));
WT_ERR(__wt_scr_alloc(session, 0, &cl->opvalue));
WT_INIT_LSN(cl->cur_lsn);
WT_INIT_LSN(cl->next_lsn);
WT_ERR(__wt_cursor_init(cursor, uri, NULL, cfg, cursorp));
if (log != NULL) {
/*
* The user may be trying to read a log record they just wrote.
* Log records may be buffered, so force out any now.
*/
WT_ERR(__wt_log_force_write(session, 1, NULL));
/* Log cursors block archiving. */
__wt_readlock(session, &log->log_archive_lock);
F_SET(cl, WT_CURLOG_ARCHIVE_LOCK);
(void)__wt_atomic_add32(&conn->log_cursors, 1);
}
if (0) {
err: WT_TRET(__curlog_close(cursor));
*cursorp = NULL;
}
return (ret);
}
