/* Check that REP refers to a revision that exists in FS. */
static svn_error_t *
rep_has_been_born(representation_t *rep,
svn_fs_t *fs,
apr_pool_t *pool)
{
fs_fs_data_t *ffd = fs->fsap_data;
svn_revnum_t youngest;
SVN_ERR_ASSERT(rep);
youngest = ffd->youngest_rev_cache;
if (youngest < rep->revision)
{
/* Stale cache. */
SVN_ERR(svn_fs_fs__youngest_rev(&youngest, fs, pool));
/* Fresh cache. */
if (youngest < rep->revision)
return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
_("Youngest revision is r%ld, but "
"rep-cache contains r%ld"),
youngest, rep->revision);
}
return SVN_NO_ERROR;
}
/* This implements the fs_library_vtable_t.open_for_recovery() API. */
static svn_error_t *
fs_open_for_recovery(svn_fs_t *fs,
const char *path,
svn_mutex__t *common_pool_lock,
apr_pool_t *pool,
apr_pool_t *common_pool)
{
svn_error_t * err;
svn_revnum_t youngest_rev;
apr_pool_t * subpool = svn_pool_create(pool);
/* Recovery for FSFS is currently limited to recreating the 'current'
file from the latest revision. */
/* The only thing we have to watch out for is that the 'current' file
might not exist or contain garbage. So we'll try to read it here
and provide or replace the existing file if we couldn't read it.
(We'll also need it to exist later anyway as a source for the new
file's permissions). */
/* Use a partly-filled fs pointer first to create 'current'. */
fs->path = apr_pstrdup(fs->pool, path);
SVN_ERR(initialize_fs_struct(fs));
/* Figure out the repo format and check that we can even handle it. */
SVN_ERR(svn_fs_fs__read_format_file(fs, subpool));
/* Now, read 'current' and try to patch it if necessary. */
err = svn_fs_fs__youngest_rev(&youngest_rev, fs, subpool);
if (err)
{
const char *file_path;
/* 'current' file is missing or contains garbage. Since we are trying
* to recover from whatever problem there is, being picky about the
* error code here won't do us much good. If there is a persistent
* problem that we can't fix, it will show up when we try rewrite the
* file a few lines further below and we will report the failure back
* to the caller.
*
* Start recovery with HEAD = 0. */
svn_error_clear(err);
file_path = svn_fs_fs__path_current(fs, subpool);
/* Best effort to ensure the file exists and is valid.
* This may fail for r/o filesystems etc. */
SVN_ERR(svn_io_remove_file2(file_path, TRUE, subpool));
SVN_ERR(svn_io_file_create_empty(file_path, subpool));
SVN_ERR(svn_fs_fs__write_current(fs, 0, 1, 1, subpool));
}
uninitialize_fs_struct(fs);
svn_pool_destroy(subpool);
/* Now open the filesystem properly by calling the vtable method directly. */
return fs_open(fs, path, common_pool_lock, pool, common_pool);
}
/* Perform a hotcopy, either normal or incremental.
*
* Normal hotcopy assumes that the destination exists as an empty
* directory. It behaves like an incremental hotcopy except that
* none of the copied files already exist in the destination.
*
* An incremental hotcopy copies only changed or new files to the destination,
* and removes files from the destination no longer present in the source.
* While the incremental hotcopy is running, readers should still be able
* to access the destintation repository without error and should not see
* revisions currently in progress of being copied. Readers are able to see
* new fully copied revisions even if the entire incremental hotcopy procedure
* has not yet completed.
*
* Writers are blocked out completely during the entire incremental hotcopy
* process to ensure consistency. This function assumes that the repository
* write-lock is held.
*/
static svn_error_t *
hotcopy_body(void *baton, apr_pool_t *pool)
{
struct hotcopy_body_baton *hbb = baton;
svn_fs_t *src_fs = hbb->src_fs;
fs_fs_data_t *src_ffd = src_fs->fsap_data;
svn_fs_t *dst_fs = hbb->dst_fs;
fs_fs_data_t *dst_ffd = dst_fs->fsap_data;
svn_boolean_t incremental = hbb->incremental;
svn_fs_hotcopy_notify_t notify_func = hbb->notify_func;
void* notify_baton = hbb->notify_baton;
svn_cancel_func_t cancel_func = hbb->cancel_func;
void* cancel_baton = hbb->cancel_baton;
svn_revnum_t src_youngest;
apr_uint64_t src_next_node_id;
apr_uint64_t src_next_copy_id;
svn_revnum_t dst_youngest;
const char *src_revprops_dir;
const char *dst_revprops_dir;
const char *src_revs_dir;
const char *dst_revs_dir;
const char *src_subdir;
const char *dst_subdir;
svn_node_kind_t kind;
/* Try to copy the config.
*
* ### We try copying the config file before doing anything else,
* ### because higher layers will abort the hotcopy if we throw
* ### an error from this function, and that renders the hotcopy
* ### unusable anyway. */
if (src_ffd->format >= SVN_FS_FS__MIN_CONFIG_FILE)
{
svn_error_t *err;
err = svn_io_dir_file_copy(src_fs->path, dst_fs->path, PATH_CONFIG,
pool);
if (err)
{
if (APR_STATUS_IS_ENOENT(err->apr_err))
{
/* 1.6.0 to 1.6.11 did not copy the configuration file during
* hotcopy. So if we're hotcopying a repository which has been
* created as a hotcopy itself, it's possible that fsfs.conf
* does not exist. Ask the user to re-create it.
*
* ### It would be nice to make this a non-fatal error,
* ### but this function does not get an svn_fs_t object
* ### so we have no way of just printing a warning via
* ### the fs->warning() callback. */
const char *src_abspath;
const char *dst_abspath;
const char *config_relpath;
svn_error_t *err2;
config_relpath = svn_dirent_join(src_fs->path, PATH_CONFIG, pool);
err2 = svn_dirent_get_absolute(&src_abspath, src_fs->path, pool);
if (err2)
return svn_error_trace(svn_error_compose_create(err, err2));
err2 = svn_dirent_get_absolute(&dst_abspath, dst_fs->path, pool);
if (err2)
return svn_error_trace(svn_error_compose_create(err, err2));
/* ### hack: strip off the 'db/' directory from paths so
* ### they make sense to the user */
src_abspath = svn_dirent_dirname(src_abspath, pool);
dst_abspath = svn_dirent_dirname(dst_abspath, pool);
return svn_error_quick_wrapf(err,
_("Failed to create hotcopy at '%s'. "
"The file '%s' is missing from the source "
"repository. Please create this file, for "
"instance by running 'svnadmin upgrade %s'"),
dst_abspath, config_relpath, src_abspath);
}
else
return svn_error_trace(err);
}
}
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
/* Find the youngest revision in the source and destination.
* We only support hotcopies from sources with an equal or greater amount
* of revisions than the destination.
* This also catches the case where users accidentally swap the
* source and destination arguments. */
SVN_ERR(svn_fs_fs__read_current(&src_youngest, &src_next_node_id,
&src_next_copy_id, src_fs, pool));
if (incremental)
{
SVN_ERR(svn_fs_fs__youngest_rev(&dst_youngest, dst_fs, pool));
if (src_youngest < dst_youngest)
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("The hotcopy destination already contains more revisions "
"(%lu) than the hotcopy source contains (%lu); are source "
"and destination swapped?"),
dst_youngest, src_youngest);
}
else
dst_youngest = 0;
src_revs_dir = svn_dirent_join(src_fs->path, PATH_REVS_DIR, pool);
dst_revs_dir = svn_dirent_join(dst_fs->path, PATH_REVS_DIR, pool);
src_revprops_dir = svn_dirent_join(src_fs->path, PATH_REVPROPS_DIR, pool);
dst_revprops_dir = svn_dirent_join(dst_fs->path, PATH_REVPROPS_DIR, pool);
/* Ensure that the required folders exist in the destination
* before actually copying the revisions and revprops. */
SVN_ERR(svn_io_make_dir_recursively(dst_revs_dir, pool));
SVN_ERR(svn_io_make_dir_recursively(dst_revprops_dir, pool));
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
/* Split the logic for new and old FS formats. The latter is much simpler
* due to the absense of sharding and packing. However, it requires special
* care when updating the 'current' file (which contains not just the
* revision number, but also the next-ID counters). */
if (src_ffd->format >= SVN_FS_FS__MIN_NO_GLOBAL_IDS_FORMAT)
{
SVN_ERR(hotcopy_revisions(src_fs, dst_fs, src_youngest, dst_youngest,
incremental, src_revs_dir, dst_revs_dir,
src_revprops_dir, dst_revprops_dir,
notify_func, notify_baton,
cancel_func, cancel_baton, pool));
SVN_ERR(svn_fs_fs__write_current(dst_fs, src_youngest, 0, 0, pool));
}
else
{
SVN_ERR(hotcopy_revisions_old(src_fs, dst_fs, src_youngest,
src_revs_dir, dst_revs_dir,
src_revprops_dir, dst_revprops_dir,
notify_func, notify_baton,
cancel_func, cancel_baton, pool));
SVN_ERR(svn_fs_fs__write_current(dst_fs, src_youngest, src_next_node_id,
src_next_copy_id, pool));
}
/* Replace the locks tree.
* This is racy in case readers are currently trying to list locks in
* the destination. However, we need to get rid of stale locks.
* This is the simplest way of doing this, so we accept this small race. */
dst_subdir = svn_dirent_join(dst_fs->path, PATH_LOCKS_DIR, pool);
SVN_ERR(svn_io_remove_dir2(dst_subdir, TRUE, cancel_func, cancel_baton,
pool));
src_subdir = svn_dirent_join(src_fs->path, PATH_LOCKS_DIR, pool);
SVN_ERR(svn_io_check_path(src_subdir, &kind, pool));
if (kind == svn_node_dir)
SVN_ERR(svn_io_copy_dir_recursively(src_subdir, dst_fs->path,
PATH_LOCKS_DIR, TRUE,
cancel_func, cancel_baton, pool));
/* Now copy the node-origins cache tree. */
src_subdir = svn_dirent_join(src_fs->path, PATH_NODE_ORIGINS_DIR, pool);
SVN_ERR(svn_io_check_path(src_subdir, &kind, pool));
if (kind == svn_node_dir)
SVN_ERR(hotcopy_io_copy_dir_recursively(NULL, src_subdir, dst_fs->path,
PATH_NODE_ORIGINS_DIR, TRUE,
cancel_func, cancel_baton, pool));
/*
* NB: Data copied below is only read by writers, not readers.
* Writers are still locked out at this point.
*/
if (dst_ffd->format >= SVN_FS_FS__MIN_REP_SHARING_FORMAT)
{
/* Copy the rep cache and then remove entries for revisions
* that did not make it into the destination. */
src_subdir = svn_dirent_join(src_fs->path, REP_CACHE_DB_NAME, pool);
dst_subdir = svn_dirent_join(dst_fs->path, REP_CACHE_DB_NAME, pool);
SVN_ERR(svn_io_check_path(src_subdir, &kind, pool));
if (kind == svn_node_file)
{
SVN_ERR(svn_sqlite__hotcopy(src_subdir, dst_subdir, pool));
/* The source might have r/o flags set on it - which would be
carried over to the copy. */
SVN_ERR(svn_io_set_file_read_write(dst_subdir, FALSE, pool));
SVN_ERR(svn_fs_fs__del_rep_reference(dst_fs, src_youngest, pool));
}
}
/* Copy the txn-current file. */
if (dst_ffd->format >= SVN_FS_FS__MIN_TXN_CURRENT_FORMAT)
SVN_ERR(svn_io_dir_file_copy(src_fs->path, dst_fs->path,
PATH_TXN_CURRENT, pool));
return SVN_NO_ERROR;
}