/*
* __backup_start --
* Start a backup.
*/
static int
__backup_start(
WT_SESSION_IMPL *session, WT_CURSOR_BACKUP *cb, const char *cfg[])
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
int exist, log_only, target_list;
conn = S2C(session);
cb->next = 0;
cb->list = NULL;
/*
* Single thread hot backups: we're holding the schema lock, so we
* know we'll serialize with other attempts to start a hot backup.
*/
if (conn->hot_backup)
WT_RET_MSG(
session, EINVAL, "there is already a backup cursor open");
/*
* The hot backup copy is done outside of WiredTiger, which means file
* blocks can't be freed and re-allocated until the backup completes.
* The checkpoint code checks the backup flag, and if a backup cursor
* is open checkpoints aren't discarded. We release the lock as soon
* as we've set the flag, we don't want to block checkpoints, we just
* want to make sure no checkpoints are deleted. The checkpoint code
* holds the lock until it's finished the checkpoint, otherwise we
* could start a hot backup that would race with an already-started
* checkpoint.
*/
__wt_spin_lock(session, &conn->hot_backup_lock);
conn->hot_backup = 1;
__wt_spin_unlock(session, &conn->hot_backup_lock);
/* Create the hot backup file. */
WT_ERR(__backup_file_create(session, cb, 0));
/* Add log files if logging is enabled. */
/*
* If a list of targets was specified, work our way through them.
* Else, generate a list of all database objects.
*
* Include log files if doing a full backup, and copy them before
* copying data files to avoid rolling the metadata forward across
* a checkpoint that completes during the backup.
*/
target_list = 0;
WT_ERR(__backup_uri(session, cb, cfg, &target_list, &log_only));
if (!target_list) {
WT_ERR(__backup_log_append(session, cb, 1));
WT_ERR(__backup_all(session, cb));
}
/* Add the hot backup and standard WiredTiger files to the list. */
if (log_only) {
/*
* Close any hot backup file.
* We're about to open the incremental backup file.
*/
if (cb->bfp != NULL) {
WT_TRET(fclose(cb->bfp) == 0 ? 0 : __wt_errno());
cb->bfp = NULL;
}
WT_ERR(__backup_file_create(session, cb, log_only));
WT_ERR(__backup_list_append(
session, cb, WT_INCREMENTAL_BACKUP));
} else {
WT_ERR(__backup_list_append(
session, cb, WT_METADATA_BACKUP));
WT_ERR(__wt_exist(session, WT_BASECONFIG, &exist));
if (exist)
WT_ERR(__backup_list_append(
session, cb, WT_BASECONFIG));
WT_ERR(__wt_exist(session, WT_USERCONFIG, &exist));
if (exist)
WT_ERR(__backup_list_append(
session, cb, WT_USERCONFIG));
WT_ERR(__backup_list_append(session, cb, WT_WIREDTIGER));
}
err: /* Close the hot backup file. */
if (cb->bfp != NULL) {
WT_TRET(fclose(cb->bfp) == 0 ? 0 : __wt_errno());
cb->bfp = NULL;
}
if (ret != 0) {
WT_TRET(__backup_cleanup_handles(session, cb));
WT_TRET(__backup_stop(session));
}
return (ret);
}
/*
* __backup_start --
* Start a backup.
*/
static int
__backup_start(
WT_SESSION_IMPL *session, WT_CURSOR_BACKUP *cb, const char *cfg[])
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_FSTREAM *srcfs;
const char *dest;
bool exist, log_only, target_list;
conn = S2C(session);
srcfs = NULL;
dest = NULL;
cb->next = 0;
cb->list = NULL;
cb->list_next = 0;
WT_RET(__wt_inmem_unsupported_op(session, "backup cursor"));
/*
* Single thread hot backups: we're holding the schema lock, so we
* know we'll serialize with other attempts to start a hot backup.
*/
if (conn->hot_backup)
WT_RET_MSG(
session, EINVAL, "there is already a backup cursor open");
/*
* The hot backup copy is done outside of WiredTiger, which means file
* blocks can't be freed and re-allocated until the backup completes.
* The checkpoint code checks the backup flag, and if a backup cursor
* is open checkpoints aren't discarded. We release the lock as soon
* as we've set the flag, we don't want to block checkpoints, we just
* want to make sure no checkpoints are deleted. The checkpoint code
* holds the lock until it's finished the checkpoint, otherwise we
* could start a hot backup that would race with an already-started
* checkpoint.
*
* We are holding the checkpoint and schema locks so schema operations
* will not see the backup file list until it is complete and valid.
*/
__wt_writelock(session, &conn->hot_backup_lock);
conn->hot_backup = true;
conn->hot_backup_list = NULL;
__wt_writeunlock(session, &conn->hot_backup_lock);
/* We're the lock holder, we own cleanup. */
F_SET(cb, WT_CURBACKUP_LOCKER);
/*
* Create a temporary backup file. This must be opened before
* generating the list of targets in backup_uri. This file will
* later be renamed to the correct name depending on whether or not
* we're doing an incremental backup. We need a temp file so that if
* we fail or crash while filling it, the existence of a partial file
* doesn't confuse restarting in the source database.
*/
WT_ERR(__wt_fopen(session, WT_BACKUP_TMP,
WT_FS_OPEN_CREATE, WT_STREAM_WRITE, &cb->bfs));
/*
* If a list of targets was specified, work our way through them.
* Else, generate a list of all database objects.
*
* Include log files if doing a full backup, and copy them before
* copying data files to avoid rolling the metadata forward across
* a checkpoint that completes during the backup.
*/
target_list = false;
WT_ERR(__backup_uri(session, cfg, &target_list, &log_only));
if (!target_list) {
WT_ERR(__backup_log_append(session, cb, true));
WT_ERR(__backup_all(session));
}
/* Add the hot backup and standard WiredTiger files to the list. */
if (log_only) {
/*
* We also open an incremental backup source file so that we
* can detect a crash with an incremental backup existing in
* the source directory versus an improper destination.
*/
dest = WT_INCREMENTAL_BACKUP;
WT_ERR(__wt_fopen(session, WT_INCREMENTAL_SRC,
WT_FS_OPEN_CREATE, WT_STREAM_WRITE, &srcfs));
WT_ERR(__backup_list_append(
session, cb, WT_INCREMENTAL_BACKUP));
} else {
dest = WT_METADATA_BACKUP;
WT_ERR(__backup_list_append(session, cb, WT_METADATA_BACKUP));
WT_ERR(__wt_fs_exist(session, WT_BASECONFIG, &exist));
if (exist)
WT_ERR(__backup_list_append(
session, cb, WT_BASECONFIG));
WT_ERR(__wt_fs_exist(session, WT_USERCONFIG, &exist));
if (exist)
WT_ERR(__backup_list_append(
session, cb, WT_USERCONFIG));
WT_ERR(__backup_list_append(session, cb, WT_WIREDTIGER));
}
err: /* Close the hot backup file. */
WT_TRET(__wt_fclose(session, &cb->bfs));
if (srcfs != NULL)
WT_TRET(__wt_fclose(session, &srcfs));
if (ret == 0) {
WT_ASSERT(session, dest != NULL);
WT_TRET(__wt_fs_rename(session, WT_BACKUP_TMP, dest, false));
__wt_writelock(session, &conn->hot_backup_lock);
conn->hot_backup_list = cb->list;
__wt_writeunlock(session, &conn->hot_backup_lock);
}
return (ret);
}
