/*
* __recovery_cursor --
* Get a cursor for a recovery operation.
*/
static int
__recovery_cursor(WT_SESSION_IMPL *session, WT_RECOVERY *r,
WT_LSN *lsnp, u_int id, int duplicate, WT_CURSOR **cp)
{
WT_CURSOR *c;
const char *cfg[] = { WT_CONFIG_BASE(session, session_open_cursor),
"overwrite", NULL };
int metadata_op;
c = NULL;
/* Track the largest file ID we have seen. */
if (id > r->max_fileid)
r->max_fileid = id;
/*
* Metadata operations have an id of 0. Match operations based
* on the id and the current pass of recovery for metadata.
*
* Only apply operations in the correct metadata phase, and if the LSN
* is more recent than the last checkpoint. If there is no entry for a
* file, assume it was dropped or missing after a hot backup.
*/
metadata_op = (id == WT_METAFILE_ID);
if (r->metadata_only != metadata_op)
;
else if (id >= r->nfiles || r->files[id].uri == NULL) {
/* If a file is missing, output a verbose message once. */
if (!r->missing)
WT_RET(__wt_verbose(session, WT_VERB_RECOVERY,
"No file found with ID %u (max %u)",
id, r->nfiles));
r->missing = 1;
} else if (LOG_CMP(lsnp, &r->files[id].ckpt_lsn) >= 0) {
/*
* We're going to apply the operation. Get the cursor, opening
* one if none is cached.
*/
if ((c = r->files[id].c) == NULL) {
WT_RET(__wt_open_cursor(
session, r->files[id].uri, NULL, cfg, &c));
r->files[id].c = c;
}
}
if (duplicate && c != NULL)
WT_RET(__wt_open_cursor(
session, r->files[id].uri, NULL, cfg, &c));
*cp = c;
return (0);
}
/*
* __curlog_compare --
* WT_CURSOR.compare method for the log cursor type.
*/
static int
__curlog_compare(WT_CURSOR *a, WT_CURSOR *b, int *cmpp)
{
WT_CURSOR_LOG *acl, *bcl;
WT_DECL_RET;
WT_SESSION_IMPL *session;
CURSOR_API_CALL(a, session, compare, NULL);
acl = (WT_CURSOR_LOG *)a;
bcl = (WT_CURSOR_LOG *)b;
WT_ASSERT(session, cmpp != NULL);
*cmpp = LOG_CMP(acl->cur_lsn, bcl->cur_lsn);
/*
* If both are on the same LSN, compare step counter.
*/
if (*cmpp == 0)
*cmpp = (acl->step_count != bcl->step_count ?
(acl->step_count < bcl->step_count ? -1 : 1) : 0);
err: API_END_RET(session, ret);
}
/*
* __wt_log_write --
* Write a record into the log.
*/
int
__wt_log_write(WT_SESSION_IMPL *session, WT_ITEM *record, WT_LSN *lsnp,
uint32_t flags)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_LOG *log;
WT_LOG_RECORD *logrec;
WT_LSN lsn;
WT_MYSLOT myslot;
uint32_t rdup_len;
int locked;
conn = S2C(session);
log = conn->log;
locked = 0;
INIT_LSN(&lsn);
myslot.slot = NULL;
/*
* Assume the WT_ITEM the user passed is a WT_LOG_RECORD, which has
* a header at the beginning for us to fill in.
*
* If using direct_io, the caller should pass us an aligned record.
* But we need to make sure it is big enough and zero-filled so
* that we can write the full amount. Do this whether or not
* direct_io is in use because it makes the reading code cleaner.
*/
WT_STAT_FAST_CONN_INCRV(session, log_bytes_user, record->size);
rdup_len = __wt_rduppo2((uint32_t)record->size, log->allocsize);
WT_ERR(__wt_buf_grow(session, record, rdup_len));
WT_ASSERT(session, record->data == record->mem);
/*
* If the caller's record only partially fills the necessary
* space, we need to zero-fill the remainder.
*/
if (record->size != rdup_len) {
memset((uint8_t *)record->mem + record->size, 0,
rdup_len - record->size);
record->size = rdup_len;
}
logrec = (WT_LOG_RECORD *)record->mem;
logrec->len = (uint32_t)record->size;
logrec->checksum = 0;
logrec->checksum = __wt_cksum(logrec, record->size);
WT_STAT_FAST_CONN_INCR(session, log_writes);
if (!F_ISSET(log, WT_LOG_FORCE_CONSOLIDATE)) {
ret = __log_direct_write(session, record, lsnp, flags);
if (ret == 0)
return (0);
if (ret != EAGAIN)
WT_ERR(ret);
/*
* An EAGAIN return means we failed to get the try lock -
* fall through to the consolidation code in that case.
*/
}
/*
* As soon as we see contention for the log slot, disable direct
* log writes. We get better performance by forcing writes through
* the consolidation code. This is because individual writes flood
* the I/O system faster than they contend on the log slot lock.
*/
F_SET(log, WT_LOG_FORCE_CONSOLIDATE);
if ((ret = __wt_log_slot_join(
session, rdup_len, flags, &myslot)) == ENOMEM) {
/*
* If we couldn't find a consolidated slot for this record
* write the record directly.
*/
while ((ret = __log_direct_write(
session, record, lsnp, flags)) == EAGAIN)
;
WT_ERR(ret);
/*
* Increase the buffer size of any slots we can get access
* to, so future consolidations are likely to succeed.
*/
WT_ERR(__wt_log_slot_grow_buffers(session, 4 * rdup_len));
return (0);
}
WT_ERR(ret);
if (myslot.offset == 0) {
__wt_spin_lock(session, &log->log_slot_lock);
locked = 1;
WT_ERR(__wt_log_slot_close(session, myslot.slot));
WT_ERR(__log_acquire(
session, myslot.slot->slot_group_size, myslot.slot));
__wt_spin_unlock(session, &log->log_slot_lock);
locked = 0;
WT_ERR(__wt_log_slot_notify(session, myslot.slot));
} else
WT_ERR(__wt_log_slot_wait(session, myslot.slot));
WT_ERR(__log_fill(session, &myslot, 0, record, &lsn));
if (__wt_log_slot_release(myslot.slot, rdup_len) == WT_LOG_SLOT_DONE) {
WT_ERR(__log_release(session, myslot.slot));
WT_ERR(__wt_log_slot_free(myslot.slot));
} else if (LF_ISSET(WT_LOG_FSYNC)) {
/* Wait for our writes to reach disk */
while (LOG_CMP(&log->sync_lsn, &lsn) <= 0 &&
myslot.slot->slot_error == 0)
(void)__wt_cond_wait(
session, log->log_sync_cond, 10000);
}
err:
if (locked)
__wt_spin_unlock(session, &log->log_slot_lock);
if (ret == 0 && lsnp != NULL)
*lsnp = lsn;
/*
* If we're synchronous and some thread had an error, we don't know
* if our write made it out to the file or not. The error could be
* before or after us. So, if anyone got an error, we report it.
* If we're not synchronous, only report if our own operation got
* an error.
*/
if (LF_ISSET(WT_LOG_DSYNC | WT_LOG_FSYNC) && ret == 0 &&
myslot.slot != NULL)
ret = myslot.slot->slot_error;
return (ret);
}
/*
* __wt_log_scan --
* Scan the logs, calling a function on each record found.
*/
int
__wt_log_scan(WT_SESSION_IMPL *session, WT_LSN *lsnp, uint32_t flags,
int (*func)(WT_SESSION_IMPL *session,
WT_ITEM *record, WT_LSN *lsnp, void *cookie), void *cookie)
{
WT_CONNECTION_IMPL *conn;
WT_ITEM buf;
WT_DECL_RET;
WT_FH *log_fh;
WT_LOG *log;
WT_LOG_RECORD *logrec;
WT_LSN end_lsn, rd_lsn, start_lsn;
off_t log_size;
uint32_t allocsize, cksum, firstlog, lastlog, lognum, rdup_len, reclen;
u_int i, logcount;
int eol;
char **logfiles;
conn = S2C(session);
log = conn->log;
log_fh = NULL;
logcount = 0;
logfiles = NULL;
eol = 0;
WT_CLEAR(buf);
/*
* If the caller did not give us a callback function there is nothing
* to do.
*/
if (func == NULL)
return (0);
if (LF_ISSET(WT_LOGSCAN_RECOVER))
WT_RET(__wt_verbose(session, WT_VERB_LOG,
"__wt_log_scan truncating to %u/%" PRIuMAX,
log->trunc_lsn.file, (uintmax_t)log->trunc_lsn.offset));
if (log != NULL) {
allocsize = log->allocsize;
if (lsnp == NULL) {
if (LF_ISSET(WT_LOGSCAN_FIRST))
start_lsn = log->first_lsn;
else if (LF_ISSET(WT_LOGSCAN_FROM_CKP))
start_lsn = log->ckpt_lsn;
else
return (WT_ERROR); /* Illegal usage */
} else {
if (LF_ISSET(WT_LOGSCAN_FIRST|WT_LOGSCAN_FROM_CKP))
WT_RET_MSG(session, WT_ERROR,
"choose either a start LSN or a start flag");
/* Offsets must be on allocation boundaries. */
if (lsnp->offset % allocsize != 0 ||
lsnp->file > log->fileid)
return (WT_NOTFOUND);
/*
* Log cursors may not know the starting LSN. If an
* LSN pointer is passed in, but it is the INIT_LSN,
* start from the first_lsn.
*/
start_lsn = *lsnp;
if (IS_INIT_LSN(&start_lsn))
start_lsn = log->first_lsn;
}
end_lsn = log->alloc_lsn;
} else {
/*
* If logging is not configured, we can still print out the log
* if log files exist. We just need to set the LSNs from what
* is in the files versus what is in the live connection.
*/
/*
* Set allocsize to the minimum alignment it could be. Larger
* records and larger allocation boundaries should always be
* a multiple of this.
*/
allocsize = LOG_ALIGN;
lastlog = 0;
firstlog = UINT32_MAX;
WT_RET(__wt_log_get_files(session, &logfiles, &logcount));
if (logcount == 0)
/*
* Return it is not supported if none don't exist.
*/
return (ENOTSUP);
for (i = 0; i < logcount; i++) {
WT_ERR(__wt_log_extract_lognum(session, logfiles[i],
&lognum));
lastlog = WT_MAX(lastlog, lognum);
firstlog = WT_MIN(firstlog, lognum);
}
start_lsn.file = firstlog;
end_lsn.file = lastlog;
start_lsn.offset = end_lsn.offset = 0;
__wt_log_files_free(session, logfiles, logcount);
logfiles = NULL;
}
WT_ERR(__log_openfile(session, 0, &log_fh, start_lsn.file));
WT_ERR(__log_filesize(session, log_fh, &log_size));
rd_lsn = start_lsn;
WT_ERR(__wt_buf_initsize(session, &buf, LOG_ALIGN));
for (;;) {
if (rd_lsn.offset + allocsize > log_size) {
advance:
/*
* If we read the last record, go to the next file.
*/
WT_ERR(__wt_close(session, log_fh));
log_fh = NULL;
eol = 1;
/*
* Truncate this log file before we move to the next.
*/
if (LF_ISSET(WT_LOGSCAN_RECOVER))
WT_ERR(__log_truncate(session, &rd_lsn, 1));
rd_lsn.file++;
rd_lsn.offset = 0;
/*
* Avoid an error message when we reach end of log
* by checking here.
*/
if (rd_lsn.file > end_lsn.file)
break;
WT_ERR(__log_openfile(
session, 0, &log_fh, rd_lsn.file));
WT_ERR(__log_filesize(session, log_fh, &log_size));
continue;
}
/*
* Read the minimum allocation size a record could be.
*/
WT_ASSERT(session, buf.memsize >= allocsize);
WT_ERR(__wt_read(session,
log_fh, rd_lsn.offset, (size_t)allocsize, buf.mem));
/*
* First 8 bytes is the real record length. See if we
* need to read more than the allocation size. We expect
* that we rarely will have to read more. Most log records
* will be fairly small.
*/
reclen = *(uint32_t *)buf.mem;
/*
* Log files are pre-allocated. We never expect a zero length
* unless we've reached the end of the log. The log can be
* written out of order, so when recovery finds the end of
* the log, truncate the file and remove any later log files
* that may exist.
*/
if (reclen == 0) {
/* This LSN is the end. */
break;
}
rdup_len = __wt_rduppo2(reclen, allocsize);
if (reclen > allocsize) {
/*
* The log file end could be the middle of this
* log record.
*/
if (rd_lsn.offset + rdup_len > log_size)
goto advance;
/*
* We need to round up and read in the full padded
* record, especially for direct I/O.
*/
WT_ERR(__wt_buf_grow(session, &buf, rdup_len));
WT_ERR(__wt_read(session,
log_fh, rd_lsn.offset, (size_t)rdup_len, buf.mem));
WT_STAT_FAST_CONN_INCR(session, log_scan_rereads);
}
/*
* We read in the record, verify checksum.
*/
buf.size = reclen;
logrec = (WT_LOG_RECORD *)buf.mem;
cksum = logrec->checksum;
logrec->checksum = 0;
logrec->checksum = __wt_cksum(logrec, logrec->len);
if (logrec->checksum != cksum) {
/*
* A checksum mismatch means we have reached the end of
* the useful part of the log. This should be found on
* the first pass through recovery. In the second pass
* where we truncate the log, this is where it should
* end.
*/
if (log != NULL)
log->trunc_lsn = rd_lsn;
break;
}
/*
* We have a valid log record. If it is not the log file
* header, invoke the callback.
*/
WT_STAT_FAST_CONN_INCR(session, log_scan_records);
if (rd_lsn.offset != 0) {
WT_ERR((*func)(session, &buf, &rd_lsn, cookie));
if (LF_ISSET(WT_LOGSCAN_ONE))
break;
}
rd_lsn.offset += (off_t)rdup_len;
}
/* Truncate if we're in recovery. */
if (LF_ISSET(WT_LOGSCAN_RECOVER) &&
LOG_CMP(&rd_lsn, &log->trunc_lsn) < 0)
WT_ERR(__log_truncate(session, &rd_lsn, 0));
err: WT_STAT_FAST_CONN_INCR(session, log_scans);
if (logfiles != NULL)
__wt_log_files_free(session, logfiles, logcount);
__wt_buf_free(session, &buf);
/*
* If the caller wants one record and it is at the end of log,
* return WT_NOTFOUND.
*/
if (LF_ISSET(WT_LOGSCAN_ONE) && eol && ret == 0)
ret = WT_NOTFOUND;
if (ret == ENOENT)
ret = 0;
if (log_fh != NULL)
WT_TRET(__wt_close(session, log_fh));
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_txn_recover --
* Run recovery.
*/
int
__wt_txn_recover(WT_CONNECTION_IMPL *conn)
{
WT_CURSOR *metac;
WT_DECL_RET;
WT_RECOVERY r;
WT_SESSION_IMPL *session;
struct WT_RECOVERY_FILE *metafile;
char *config;
int was_backup;
WT_CLEAR(r);
INIT_LSN(&r.ckpt_lsn);
was_backup = F_ISSET(conn, WT_CONN_WAS_BACKUP) ? 1 : 0;
/* We need a real session for recovery. */
WT_RET(__wt_open_session(conn, NULL, NULL, &session));
F_SET(session, WT_SESSION_NO_LOGGING);
r.session = session;
WT_ERR(__wt_metadata_search(session, WT_METAFILE_URI, &config));
WT_ERR(__recovery_setup_file(&r, WT_METAFILE_URI, config));
WT_ERR(__wt_metadata_cursor(session, NULL, &metac));
metafile = &r.files[WT_METAFILE_ID];
metafile->c = metac;
/*
* First, do a pass through the log to recover the metadata, and
* establish the last checkpoint LSN. Skip this when opening a hot
* backup: we already have the correct metadata in that case.
*/
if (!was_backup) {
r.metadata_only = 1;
if (IS_INIT_LSN(&metafile->ckpt_lsn))
WT_ERR(__wt_log_scan(session,
NULL, WT_LOGSCAN_FIRST, __txn_log_recover, &r));
else
WT_ERR(__wt_log_scan(session,
&metafile->ckpt_lsn, 0, __txn_log_recover, &r));
WT_ASSERT(session,
LOG_CMP(&r.ckpt_lsn, &conn->log->first_lsn) >= 0);
}
/* Scan the metadata to find the live files and their IDs. */
WT_ERR(__recovery_file_scan(&r));
/*
* We no longer need the metadata cursor: close it to avoid pinning any
* resources that could block eviction during recovery.
*/
r.files[0].c = NULL;
WT_ERR(metac->close(metac));
/*
* Now, recover all the files apart from the metadata.
* Pass WT_LOGSCAN_RECOVER so that old logs get truncated.
*/
r.metadata_only = 0;
WT_ERR(__wt_verbose(session, WT_VERB_RECOVERY,
"Main recovery loop: starting at %u/%" PRIuMAX,
r.ckpt_lsn.file, (uintmax_t)r.ckpt_lsn.offset));
if (IS_INIT_LSN(&r.ckpt_lsn))
WT_ERR(__wt_log_scan(session, NULL,
WT_LOGSCAN_FIRST | WT_LOGSCAN_RECOVER,
__txn_log_recover, &r));
else
WT_ERR(__wt_log_scan(session, &r.ckpt_lsn,
WT_LOGSCAN_RECOVER,
__txn_log_recover, &r));
conn->next_file_id = r.max_fileid;
/*
* If recovery ran successfully forcibly log a checkpoint so the next
* open is fast and keep the metadata up to date with the checkpoint
* LSN and archiving.
*/
WT_ERR(session->iface.checkpoint(&session->iface, "force=1"));
err: WT_TRET(__recovery_free(&r));
__wt_free(session, config);
WT_TRET(session->iface.close(&session->iface, NULL));
return (ret);
}