You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@subversion.apache.org by st...@apache.org on 2013/06/30 19:01:17 UTC
svn commit: r1498157 [4/11] - in
/subversion/branches/fsfs-format7/subversion: libsvn_fs_x/ tests/libsvn_fs_x/
Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/fs_x.h
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/fs_x.h?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/fs_x.h (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/fs_x.h Sun Jun 30 17:01:16 2013
@@ -30,101 +30,101 @@
### Some parts of *FS must have been initialized beforehand; some parts
(including FS->path) are initialized by this function. */
-svn_error_t *svn_fs_fs__open(svn_fs_t *fs,
- const char *path,
- apr_pool_t *pool);
+svn_error_t *svn_fs_x__open(svn_fs_t *fs,
+ const char *path,
+ apr_pool_t *pool);
/* Upgrade the fsfs filesystem FS. Indicate progress via the optional
* NOTIFY_FUNC callback using NOTIFY_BATON. The optional CANCEL_FUNC
* will periodically be called with CANCEL_BATON to allow for preemption.
* Use POOL for temporary allocations. */
-svn_error_t *svn_fs_fs__upgrade(svn_fs_t *fs,
- svn_fs_upgrade_notify_t notify_func,
- void *notify_baton,
- svn_cancel_func_t cancel_func,
- void *cancel_baton,
- apr_pool_t *pool);
+svn_error_t *svn_fs_x__upgrade(svn_fs_t *fs,
+ svn_fs_upgrade_notify_t notify_func,
+ void *notify_baton,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool);
/* Set *YOUNGEST to the youngest revision in filesystem FS. Do any
temporary allocation in POOL. */
-svn_error_t *svn_fs_fs__youngest_rev(svn_revnum_t *youngest,
- svn_fs_t *fs,
- apr_pool_t *pool);
+svn_error_t *svn_fs_x__youngest_rev(svn_revnum_t *youngest,
+ svn_fs_t *fs,
+ apr_pool_t *pool);
/* For revision REV in fileysystem FS, open the revision (or packed rev)
file and seek to the start of the revision. Return it in *FILE, and
use POOL for allocations. */
svn_error_t *
-svn_fs_fs__open_pack_or_rev_file(apr_file_t **file,
- svn_fs_t *fs,
- svn_revnum_t rev,
- apr_pool_t *pool);
+svn_fs_x__open_pack_or_rev_file(apr_file_t **file,
+ svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool);
/* Return SVN_ERR_FS_NO_SUCH_REVISION if the given revision REV is newer
than the current youngest revision in FS or is simply not a valid
revision number, else return success. */
svn_error_t *
-svn_fs_fs__ensure_revision_exists(svn_revnum_t rev,
- svn_fs_t *fs,
- apr_pool_t *pool);
+svn_fs_x__ensure_revision_exists(svn_revnum_t rev,
+ svn_fs_t *fs,
+ apr_pool_t *pool);
/* Return an error iff REV does not exist in FS. */
svn_error_t *
-svn_fs_fs__revision_exists(svn_revnum_t rev,
- svn_fs_t *fs,
- apr_pool_t *pool);
+svn_fs_x__revision_exists(svn_revnum_t rev,
+ svn_fs_t *fs,
+ apr_pool_t *pool);
/* Set *PROPLIST to be an apr_hash_t containing the property list of
revision REV as seen in filesystem FS. Use POOL for temporary
allocations. */
-svn_error_t *svn_fs_fs__revision_proplist(apr_hash_t **proplist,
- svn_fs_t *fs,
- svn_revnum_t rev,
- apr_pool_t *pool);
+svn_error_t *svn_fs_x__revision_proplist(apr_hash_t **proplist,
+ svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool);
/* Set *LENGTH to the be fulltext length of the node revision
specified by NODEREV. Use POOL for temporary allocations. */
-svn_error_t *svn_fs_fs__file_length(svn_filesize_t *length,
- node_revision_t *noderev,
- apr_pool_t *pool);
+svn_error_t *svn_fs_x__file_length(svn_filesize_t *length,
+ node_revision_t *noderev,
+ apr_pool_t *pool);
/* Return TRUE if the representation keys in A and B both point to the
same representation, else return FALSE. */
-svn_boolean_t svn_fs_fs__noderev_same_rep_key(representation_t *a,
- representation_t *b);
+svn_boolean_t svn_fs_x__noderev_same_rep_key(representation_t *a,
+ representation_t *b);
/* Return a copy of the representation REP allocated from POOL. */
-representation_t *svn_fs_fs__rep_copy(representation_t *rep,
- apr_pool_t *pool);
+representation_t *svn_fs_x__rep_copy(representation_t *rep,
+ apr_pool_t *pool);
/* Return the recorded checksum of type KIND for the text representation
of NODREV into CHECKSUM, allocating from POOL. If no stored checksum is
available, put all NULL into CHECKSUM. */
-svn_error_t *svn_fs_fs__file_checksum(svn_checksum_t **checksum,
- node_revision_t *noderev,
- svn_checksum_kind_t kind,
- apr_pool_t *pool);
+svn_error_t *svn_fs_x__file_checksum(svn_checksum_t **checksum,
+ node_revision_t *noderev,
+ svn_checksum_kind_t kind,
+ apr_pool_t *pool);
/* Return whether or not the given FS supports mergeinfo metadata. */
-svn_boolean_t svn_fs_fs__fs_supports_mergeinfo(svn_fs_t *fs);
+svn_boolean_t svn_fs_x__fs_supports_mergeinfo(svn_fs_t *fs);
/* Create a fs_fs fileysystem referenced by FS at path PATH. Get any
temporary allocations from POOL.
### Some parts of *FS must have been initialized beforehand; some parts
(including FS->path) are initialized by this function. */
-svn_error_t *svn_fs_fs__create(svn_fs_t *fs,
- const char *path,
- apr_pool_t *pool);
+svn_error_t *svn_fs_x__create(svn_fs_t *fs,
+ const char *path,
+ apr_pool_t *pool);
/* Set the uuid of repository FS to UUID, if UUID is not NULL;
otherwise, set the uuid of FS to a newly generated UUID. Perform
temporary allocations in POOL. */
-svn_error_t *svn_fs_fs__set_uuid(svn_fs_t *fs,
- const char *uuid,
- apr_pool_t *pool);
+svn_error_t *svn_fs_x__set_uuid(svn_fs_t *fs,
+ const char *uuid,
+ apr_pool_t *pool);
/* Set *PATH to the path of REV in FS, whether in a pack file or not.
Allocate *PATH in POOL.
@@ -135,14 +135,14 @@ svn_error_t *svn_fs_fs__set_uuid(svn_fs_
call. If a file exists at that path, then it is correct; if not, then
the caller should call update_min_unpacked_rev() and re-try once. */
const char *
-svn_fs_fs__path_rev_absolute(svn_fs_t *fs,
- svn_revnum_t rev,
- apr_pool_t *pool);
+svn_fs_x__path_rev_absolute(svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool);
/* Return the path to the 'current' file in FS.
Perform allocation in POOL. */
const char *
-svn_fs_fs__path_current(svn_fs_t *fs, apr_pool_t *pool);
+svn_fs_x__path_current(svn_fs_t *fs, apr_pool_t *pool);
/* Read the format number and maximum number of files per directory
from PATH and return them in *PFORMAT and *MAX_FILES_PER_DIR
@@ -153,34 +153,34 @@ svn_fs_fs__path_current(svn_fs_t *fs, ap
Use POOL for temporary allocation. */
svn_error_t *
-svn_fs_fs__write_format(svn_fs_t *fs,
- svn_boolean_t overwrite,
- apr_pool_t *pool);
+svn_fs_x__write_format(svn_fs_t *fs,
+ svn_boolean_t overwrite,
+ apr_pool_t *pool);
/* Find the value of the property named PROPNAME in transaction TXN.
Return the contents in *VALUE_P. The contents will be allocated
from POOL. */
-svn_error_t *svn_fs_fs__revision_prop(svn_string_t **value_p, svn_fs_t *fs,
- svn_revnum_t rev,
- const char *propname,
- apr_pool_t *pool);
+svn_error_t *svn_fs_x__revision_prop(svn_string_t **value_p, svn_fs_t *fs,
+ svn_revnum_t rev,
+ const char *propname,
+ apr_pool_t *pool);
/* Change, add, or delete a property on a revision REV in filesystem
FS. NAME gives the name of the property, and value, if non-NULL,
gives the new contents of the property. If value is NULL, then the
property will be deleted. If OLD_VALUE_P is not NULL, do nothing unless the
preexisting value is *OLD_VALUE_P. Do any temporary allocation in POOL. */
-svn_error_t *svn_fs_fs__change_rev_prop(svn_fs_t *fs, svn_revnum_t rev,
- const char *name,
- const svn_string_t *const *old_value_p,
- const svn_string_t *value,
- apr_pool_t *pool);
+svn_error_t *svn_fs_x__change_rev_prop(svn_fs_t *fs, svn_revnum_t rev,
+ const char *name,
+ const svn_string_t *const *old_value_p,
+ const svn_string_t *value,
+ apr_pool_t *pool);
/* If directory PATH does not exist, create it and give it the same
permissions as FS_PATH.*/
-svn_error_t *svn_fs_fs__ensure_dir_exists(const char *path,
- const char *fs_path,
- apr_pool_t *pool);
+svn_error_t *svn_fs_x__ensure_dir_exists(const char *path,
+ const char *fs_path,
+ apr_pool_t *pool);
/* Update the node origin index for FS, recording the mapping from
NODE_ID to NODE_REV_ID. Use POOL for any temporary allocations.
@@ -190,10 +190,10 @@ svn_error_t *svn_fs_fs__ensure_dir_exist
returns an error for other error conditions.
*/
svn_error_t *
-svn_fs_fs__set_node_origin(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *node_id,
- const svn_fs_id_t *node_rev_id,
- apr_pool_t *pool);
+svn_fs_x__set_node_origin(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *node_id,
+ const svn_fs_id_t *node_rev_id,
+ apr_pool_t *pool);
/* Set *ORIGIN_ID to the node revision ID from which the history of
all nodes in FS whose "Node ID" is NODE_ID springs, as determined
@@ -203,10 +203,10 @@ svn_fs_fs__set_node_origin(svn_fs_t *fs,
If there is no entry for NODE_ID in the cache, return NULL
in *ORIGIN_ID. */
svn_error_t *
-svn_fs_fs__get_node_origin(const svn_fs_id_t **origin_id,
- svn_fs_t *fs,
- const svn_fs_fs__id_part_t *node_id,
- apr_pool_t *pool);
+svn_fs_x__get_node_origin(const svn_fs_id_t **origin_id,
+ svn_fs_t *fs,
+ const svn_fs_x__id_part_t *node_id,
+ apr_pool_t *pool);
/* Initialize all session-local caches in FS according to the global
@@ -215,7 +215,7 @@ svn_fs_fs__get_node_origin(const svn_fs_
Please note that it is permissible for this function to set some
or all of these caches to NULL, regardless of any setting. */
svn_error_t *
-svn_fs_fs__initialize_caches(svn_fs_t *fs, apr_pool_t *pool);
+svn_fs_x__initialize_caches(svn_fs_t *fs, apr_pool_t *pool);
/* Initialize all transaction-local caches in FS according to the global
cache settings and make TXN_ID part of their key space. Use POOL for
@@ -224,13 +224,13 @@ svn_fs_fs__initialize_caches(svn_fs_t *f
Please note that it is permissible for this function to set some or all
of these caches to NULL, regardless of any setting. */
svn_error_t *
-svn_fs_fs__initialize_txn_caches(svn_fs_t *fs,
- const char *txn_id,
- apr_pool_t *pool);
+svn_fs_x__initialize_txn_caches(svn_fs_t *fs,
+ const char *txn_id,
+ apr_pool_t *pool);
/* Resets the svn_cache__t structures local to the current transaction in FS.
Calling it more than once per txn or from outside any txn is allowed. */
void
-svn_fs_fs__reset_txn_caches(svn_fs_t *fs);
+svn_fs_x__reset_txn_caches(svn_fs_t *fs);
#endif
Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/hotcopy.c
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/hotcopy.c?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/hotcopy.c (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/hotcopy.c Sun Jun 30 17:01:16 2013
@@ -281,7 +281,7 @@ hotcopy_copy_packed_shard(svn_revnum_t *
const char *src_subdir_packed_shard;
svn_revnum_t revprop_rev;
apr_pool_t *iterpool;
- fs_fs_data_t *src_ffd = src_fs->fsap_data;
+ fs_x_data_t *src_ffd = src_fs->fsap_data;
/* Copy the packed shard. */
src_subdir = svn_dirent_join(src_fs->path, PATH_REVS_DIR, scratch_pool);
@@ -341,9 +341,9 @@ hotcopy_copy_packed_shard(svn_revnum_t *
if (*dst_min_unpacked_rev < rev + max_files_per_dir)
{
*dst_min_unpacked_rev = rev + max_files_per_dir;
- SVN_ERR(write_revnum_file(dst_fs,
- *dst_min_unpacked_rev,
- scratch_pool));
+ SVN_ERR(svn_fs_x__write_revnum_file(dst_fs,
+ *dst_min_unpacked_rev,
+ scratch_pool));
}
return SVN_NO_ERROR;
@@ -360,20 +360,20 @@ hotcopy_update_current(svn_revnum_t *dst
{
apr_uint64_t next_node_id = 0;
apr_uint64_t next_copy_id = 0;
- fs_fs_data_t *dst_ffd = dst_fs->fsap_data;
+ fs_x_data_t *dst_ffd = dst_fs->fsap_data;
if (*dst_youngest >= new_youngest)
return SVN_NO_ERROR;
/* If necessary, get new current next_node and next_copy IDs. */
if (dst_ffd->format < SVN_FS_FS__MIN_NO_GLOBAL_IDS_FORMAT)
- SVN_ERR(svn_fs_fs__find_max_ids(dst_fs, new_youngest,
- &next_node_id, &next_copy_id,
- scratch_pool));
+ SVN_ERR(svn_fs_x__find_max_ids(dst_fs, new_youngest,
+ &next_node_id, &next_copy_id,
+ scratch_pool));
/* Update 'current'. */
- SVN_ERR(write_current(dst_fs, new_youngest, next_node_id, next_copy_id,
- scratch_pool));
+ SVN_ERR(svn_fs_x__write_current(dst_fs, new_youngest, next_node_id,
+ next_copy_id, scratch_pool));
*dst_youngest = new_youngest;
@@ -439,8 +439,8 @@ hotcopy_incremental_check_preconditions(
svn_fs_t *dst_fs,
apr_pool_t *pool)
{
- fs_fs_data_t *src_ffd = src_fs->fsap_data;
- fs_fs_data_t *dst_ffd = dst_fs->fsap_data;
+ fs_x_data_t *src_ffd = src_fs->fsap_data;
+ fs_x_data_t *dst_ffd = dst_fs->fsap_data;
/* We only support incremental hotcopy between the same format. */
if (src_ffd->format != dst_ffd->format)
@@ -501,9 +501,9 @@ hotcopy_body(void *baton, apr_pool_t *po
{
struct hotcopy_body_baton *hbb = baton;
svn_fs_t *src_fs = hbb->src_fs;
- fs_fs_data_t *src_ffd = src_fs->fsap_data;
+ fs_x_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;
+ fs_x_data_t *dst_ffd = dst_fs->fsap_data;
int max_files_per_dir = src_ffd->max_files_per_dir;
svn_boolean_t incremental = hbb->incremental;
svn_cancel_func_t cancel_func = hbb->cancel_func;
@@ -586,10 +586,10 @@ hotcopy_body(void *baton, apr_pool_t *po
* of revisions than the destination.
* This also catches the case where users accidentally swap the
* source and destination arguments. */
- SVN_ERR(svn_fs_fs__youngest_rev(&src_youngest, src_fs, pool));
+ SVN_ERR(svn_fs_x__youngest_rev(&src_youngest, src_fs, pool));
if (incremental)
{
- SVN_ERR(svn_fs_fs__youngest_rev(&dst_youngest, dst_fs, pool));
+ SVN_ERR(svn_fs_x__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 "
@@ -606,8 +606,10 @@ hotcopy_body(void *baton, apr_pool_t *po
/* Copy the min unpacked rev, and read its value. */
if (src_ffd->format >= SVN_FS_FS__MIN_PACKED_FORMAT)
{
- SVN_ERR(read_min_unpacked_rev(&src_min_unpacked_rev, src_fs, pool));
- SVN_ERR(read_min_unpacked_rev(&dst_min_unpacked_rev, dst_fs, pool));
+ SVN_ERR(svn_fs_x__read_min_unpacked_rev(&src_min_unpacked_rev, src_fs,
+ pool));
+ SVN_ERR(svn_fs_x__read_min_unpacked_rev(&dst_min_unpacked_rev, dst_fs,
+ pool));
/* We only support packs coming from the hotcopy source.
* The destination should not be packed independently from
@@ -671,7 +673,7 @@ hotcopy_body(void *baton, apr_pool_t *po
/* Now that all revisions have moved into the pack, the original
* rev dir can be removed. */
- err = svn_io_remove_dir2(path_rev_shard(dst_fs, rev, iterpool),
+ err = svn_io_remove_dir2(svn_fs_x__path_rev_shard(dst_fs, rev, iterpool),
TRUE, cancel_func, cancel_baton, iterpool);
if (err)
{
@@ -722,10 +724,10 @@ hotcopy_body(void *baton, apr_pool_t *po
*
* If the youngest revision ended up being packed, don't try
* to be smart and work around this. Just abort the hotcopy. */
- SVN_ERR(update_min_unpacked_rev(src_fs, pool));
- if (is_packed_rev(src_fs, rev))
+ SVN_ERR(svn_fs_x__update_min_unpacked_rev(src_fs, pool));
+ if (svn_fs_x__is_packed_rev(src_fs, rev))
{
- if (is_packed_rev(src_fs, src_youngest))
+ if (svn_fs_x__is_packed_rev(src_fs, src_youngest))
return svn_error_createf(
SVN_ERR_FS_NO_SUCH_REVISION, NULL,
_("The assumed HEAD revision (%lu) of the "
@@ -810,7 +812,7 @@ hotcopy_body(void *baton, apr_pool_t *po
if (kind == svn_node_file)
{
SVN_ERR(svn_sqlite__hotcopy(src_subdir, dst_subdir, pool));
- SVN_ERR(svn_fs_fs__del_rep_reference(dst_fs, dst_youngest, pool));
+ SVN_ERR(svn_fs_x__del_rep_reference(dst_fs, dst_youngest, pool));
}
}
@@ -823,7 +825,7 @@ hotcopy_body(void *baton, apr_pool_t *po
* reset it to zero (since this is on a different path, it will not
* overlap with data already in cache). Also, clean up stale files
* used for the named atomics implementation. */
- SVN_ERR(svn_io_check_path(path_revprop_generation(src_fs, pool),
+ SVN_ERR(svn_io_check_path(svn_fs_x__path_revprop_generation(src_fs, pool),
&kind, pool));
if (kind == svn_node_file)
SVN_ERR(write_revprop_generation_file(dst_fs, 0, pool));
@@ -832,7 +834,7 @@ hotcopy_body(void *baton, apr_pool_t *po
/* Hotcopied FS is complete. Stamp it with a format file. */
dst_ffd->max_files_per_dir = max_files_per_dir;
- SVN_ERR(svn_fs_fs__write_format(dst_fs, TRUE, pool));
+ SVN_ERR(svn_fs_x__write_format(dst_fs, TRUE, pool));
return SVN_NO_ERROR;
}
@@ -842,8 +844,8 @@ hotcopy_body(void *baton, apr_pool_t *po
static void
hotcopy_setup_shared_fs_data(svn_fs_t *src_fs, svn_fs_t *dst_fs)
{
- fs_fs_data_t *src_ffd = src_fs->fsap_data;
- fs_fs_data_t *dst_ffd = dst_fs->fsap_data;
+ fs_x_data_t *src_ffd = src_fs->fsap_data;
+ fs_x_data_t *dst_ffd = dst_fs->fsap_data;
/* The common pool and mutexes are shared between src and dst filesystems.
* During hotcopy we only grab the mutexes for the destination, so there
@@ -861,8 +863,8 @@ hotcopy_create_empty_dest(svn_fs_t *src_
const char *dst_path,
apr_pool_t *pool)
{
- fs_fs_data_t *src_ffd = src_fs->fsap_data;
- fs_fs_data_t *dst_ffd = dst_fs->fsap_data;
+ fs_x_data_t *src_ffd = src_fs->fsap_data;
+ fs_x_data_t *dst_ffd = dst_fs->fsap_data;
dst_fs->path = apr_pstrdup(pool, dst_path);
@@ -872,7 +874,8 @@ hotcopy_create_empty_dest(svn_fs_t *src_
/* Create the revision data directories. */
if (dst_ffd->max_files_per_dir)
- SVN_ERR(svn_io_make_dir_recursively(path_rev_shard(dst_fs, 0, pool),
+ SVN_ERR(svn_io_make_dir_recursively(svn_fs_x__path_rev_shard(dst_fs, 0,
+ pool),
pool));
else
SVN_ERR(svn_io_make_dir_recursively(svn_dirent_join(dst_path,
@@ -881,7 +884,8 @@ hotcopy_create_empty_dest(svn_fs_t *src_
/* Create the revprops directory. */
if (src_ffd->max_files_per_dir)
- SVN_ERR(svn_io_make_dir_recursively(path_revprops_shard(dst_fs, 0, pool),
+ SVN_ERR(svn_io_make_dir_recursively(svn_fs_x__path_revprops_shard(dst_fs,
+ 0, pool),
pool));
else
SVN_ERR(svn_io_make_dir_recursively(svn_dirent_join(dst_path,
@@ -902,54 +906,55 @@ hotcopy_create_empty_dest(svn_fs_t *src_
pool));
/* Create the 'current' file. */
- SVN_ERR(svn_io_file_create(svn_fs_fs__path_current(dst_fs, pool),
+ SVN_ERR(svn_io_file_create(svn_fs_x__path_current(dst_fs, pool),
(dst_ffd->format >=
SVN_FS_FS__MIN_NO_GLOBAL_IDS_FORMAT
? "0\n" : "0 1 1\n"),
pool));
/* Create lock file and UUID. */
- SVN_ERR(svn_io_file_create_empty(path_lock(dst_fs, pool), pool));
- SVN_ERR(svn_fs_fs__set_uuid(dst_fs, src_fs->uuid, pool));
+ SVN_ERR(svn_io_file_create_empty(svn_fs_x__path_lock(dst_fs, pool), pool));
+ SVN_ERR(svn_fs_x__set_uuid(dst_fs, src_fs->uuid, pool));
/* Create the min unpacked rev file. */
if (dst_ffd->format >= SVN_FS_FS__MIN_PACKED_FORMAT)
- SVN_ERR(svn_io_file_create(path_min_unpacked_rev(dst_fs, pool),
- "0\n", pool));
+ SVN_ERR(svn_io_file_create(svn_fs_x__path_min_unpacked_rev(dst_fs, pool),
+ "0\n", pool));
/* Create the txn-current file if the repository supports
the transaction sequence file. */
if (dst_ffd->format >= SVN_FS_FS__MIN_TXN_CURRENT_FORMAT)
{
- SVN_ERR(svn_io_file_create(path_txn_current(dst_fs, pool),
- "0\n", pool));
- SVN_ERR(svn_io_file_create_empty(path_txn_current_lock(dst_fs, pool),
+ SVN_ERR(svn_io_file_create(svn_fs_x__path_txn_current(dst_fs, pool),
+ "0\n", pool));
+ SVN_ERR(svn_io_file_create_empty(svn_fs_x__path_txn_current_lock(dst_fs,
+ pool),
pool));
}
dst_ffd->youngest_rev_cache = 0;
hotcopy_setup_shared_fs_data(src_fs, dst_fs);
- SVN_ERR(svn_fs_fs__initialize_caches(dst_fs, pool));
+ SVN_ERR(svn_fs_x__initialize_caches(dst_fs, pool));
return SVN_NO_ERROR;
}
svn_error_t *
-svn_fs_fs__hotcopy(svn_fs_t *src_fs,
- svn_fs_t *dst_fs,
- const char *src_path,
- const char *dst_path,
- svn_boolean_t incremental,
- svn_cancel_func_t cancel_func,
- void *cancel_baton,
- apr_pool_t *pool)
+svn_fs_x__hotcopy(svn_fs_t *src_fs,
+ svn_fs_t *dst_fs,
+ const char *src_path,
+ const char *dst_path,
+ svn_boolean_t incremental,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool)
{
struct hotcopy_body_baton hbb;
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
- SVN_ERR(svn_fs_fs__open(src_fs, src_path, pool));
+ SVN_ERR(svn_fs_x__open(src_fs, src_path, pool));
if (incremental)
{
@@ -969,11 +974,11 @@ svn_fs_fs__hotcopy(svn_fs_t *src_fs,
else
{
/* Check the existing repository. */
- SVN_ERR(svn_fs_fs__open(dst_fs, dst_path, pool));
+ SVN_ERR(svn_fs_x__open(dst_fs, dst_path, pool));
SVN_ERR(hotcopy_incremental_check_preconditions(src_fs, dst_fs,
pool));
hotcopy_setup_shared_fs_data(src_fs, dst_fs);
- SVN_ERR(svn_fs_fs__initialize_caches(dst_fs, pool));
+ SVN_ERR(svn_fs_x__initialize_caches(dst_fs, pool));
}
}
else
@@ -991,7 +996,7 @@ svn_fs_fs__hotcopy(svn_fs_t *src_fs,
hbb.incremental = incremental;
hbb.cancel_func = cancel_func;
hbb.cancel_baton = cancel_baton;
- SVN_ERR(svn_fs_fs__with_write_lock(dst_fs, hotcopy_body, &hbb, pool));
+ SVN_ERR(svn_fs_x__with_write_lock(dst_fs, hotcopy_body, &hbb, pool));
return SVN_NO_ERROR;
}
Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/hotcopy.h
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/hotcopy.h?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/hotcopy.h (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/hotcopy.h Sun Jun 30 17:01:16 2013
@@ -28,13 +28,13 @@
/* Copy the fsfs filesystem SRC_FS at SRC_PATH into a new copy DST_FS at
* DST_PATH. If INCREMENTAL is TRUE, do not re-copy data which already
* exists in DST_FS. Use POOL for temporary allocations. */
-svn_error_t * svn_fs_fs__hotcopy(svn_fs_t *src_fs,
- svn_fs_t *dst_fs,
- const char *src_path,
- const char *dst_path,
- svn_boolean_t incremental,
- svn_cancel_func_t cancel_func,
- void *cancel_baton,
- apr_pool_t *pool);
+svn_error_t * svn_fs_x__hotcopy(svn_fs_t *src_fs,
+ svn_fs_t *dst_fs,
+ const char *src_path,
+ const char *dst_path,
+ svn_boolean_t incremental,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool);
#endif
Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/id.c
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/id.c?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/id.c (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/id.c Sun Jun 30 17:01:16 2013
@@ -31,24 +31,24 @@
#include "private/svn_string_private.h"
-typedef struct fs_fs__id_t
+typedef struct fs_x__id_t
{
/* API visible part */
svn_fs_id_t generic_id;
/* private members */
- svn_fs_fs__id_part_t node_id;
- svn_fs_fs__id_part_t copy_id;
- svn_fs_fs__id_part_t txn_id;
- svn_fs_fs__id_part_t rev_item;
-} fs_fs__id_t;
+ svn_fs_x__id_part_t node_id;
+ svn_fs_x__id_part_t copy_id;
+ svn_fs_x__id_part_t txn_id;
+ svn_fs_x__id_part_t rev_item;
+} fs_x__id_t;
/* Parse the NUL-terminated ID part at DATA and write the result into *PART.
* Return TRUE if no errors were detected. */
static svn_boolean_t
-part_parse(svn_fs_fs__id_part_t *part,
+part_parse(svn_fs_x__id_part_t *part,
const char *data)
{
/* special case: ID inside some transaction */
@@ -84,7 +84,7 @@ part_parse(svn_fs_fs__id_part_t *part,
* Return FALSE if there was some problem.
*/
static svn_boolean_t
-txn_id_parse(svn_fs_fs__id_part_t *txn_id,
+txn_id_parse(svn_fs_x__id_part_t *txn_id,
const char *data)
{
txn_id->revision = SVN_STR_TO_REV(data);
@@ -101,7 +101,7 @@ txn_id_parse(svn_fs_fs__id_part_t *txn_i
*/
static char *
unparse_id_part(char *p,
- const svn_fs_fs__id_part_t *part)
+ const svn_fs_x__id_part_t *part)
{
if (SVN_IS_VALID_REVNUM(part->revision))
{
@@ -130,34 +130,34 @@ unparse_id_part(char *p,
/* Operations on ID parts */
svn_boolean_t
-svn_fs_fs__id_part_is_root(const svn_fs_fs__id_part_t* part)
+svn_fs_x__id_part_is_root(const svn_fs_x__id_part_t* part)
{
return part->revision == 0 && part->number == 0;
}
svn_boolean_t
-svn_fs_fs__id_part_eq(const svn_fs_fs__id_part_t *lhs,
- const svn_fs_fs__id_part_t *rhs)
+svn_fs_x__id_part_eq(const svn_fs_x__id_part_t *lhs,
+ const svn_fs_x__id_part_t *rhs)
{
return lhs->revision == rhs->revision && lhs->number == rhs->number;
}
svn_boolean_t
-svn_fs_fs__id_txn_used(const svn_fs_fs__id_part_t *txn_id)
+svn_fs_x__id_txn_used(const svn_fs_x__id_part_t *txn_id)
{
return SVN_IS_VALID_REVNUM(txn_id->revision) || (txn_id->number != 0);
}
void
-svn_fs_fs__id_txn_reset(svn_fs_fs__id_part_t *txn_id)
+svn_fs_x__id_txn_reset(svn_fs_x__id_part_t *txn_id)
{
txn_id->revision = SVN_INVALID_REVNUM;
txn_id->number = 0;
}
svn_error_t *
-svn_fs_fs__id_txn_parse(svn_fs_fs__id_part_t *txn_id,
- const char *data)
+svn_fs_x__id_txn_parse(svn_fs_x__id_part_t *txn_id,
+ const char *data)
{
if (! txn_id_parse(txn_id, data))
return svn_error_createf(SVN_ERR_FS_MALFORMED_TXN_ID, NULL,
@@ -167,8 +167,8 @@ svn_fs_fs__id_txn_parse(svn_fs_fs__id_pa
}
const char *
-svn_fs_fs__id_txn_unparse(const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__id_txn_unparse(const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
char string[2 * SVN_INT64_BUFFER_SIZE + 1];
char *p = string;
@@ -184,77 +184,77 @@ svn_fs_fs__id_txn_unparse(const svn_fs_f
/* Accessing ID Pieces. */
-const svn_fs_fs__id_part_t *
-svn_fs_fs__id_node_id(const svn_fs_id_t *fs_id)
+const svn_fs_x__id_part_t *
+svn_fs_x__id_node_id(const svn_fs_id_t *fs_id)
{
- fs_fs__id_t *id = (fs_fs__id_t *)fs_id;
+ fs_x__id_t *id = (fs_x__id_t *)fs_id;
return &id->node_id;
}
-const svn_fs_fs__id_part_t *
-svn_fs_fs__id_copy_id(const svn_fs_id_t *fs_id)
+const svn_fs_x__id_part_t *
+svn_fs_x__id_copy_id(const svn_fs_id_t *fs_id)
{
- fs_fs__id_t *id = (fs_fs__id_t *)fs_id;
+ fs_x__id_t *id = (fs_x__id_t *)fs_id;
return &id->copy_id;
}
-const svn_fs_fs__id_part_t *
-svn_fs_fs__id_txn_id(const svn_fs_id_t *fs_id)
+const svn_fs_x__id_part_t *
+svn_fs_x__id_txn_id(const svn_fs_id_t *fs_id)
{
- fs_fs__id_t *id = (fs_fs__id_t *)fs_id;
+ fs_x__id_t *id = (fs_x__id_t *)fs_id;
return &id->txn_id;
}
-const svn_fs_fs__id_part_t *
-svn_fs_fs__id_rev_item(const svn_fs_id_t *fs_id)
+const svn_fs_x__id_part_t *
+svn_fs_x__id_rev_item(const svn_fs_id_t *fs_id)
{
- fs_fs__id_t *id = (fs_fs__id_t *)fs_id;
+ fs_x__id_t *id = (fs_x__id_t *)fs_id;
return &id->rev_item;
}
svn_revnum_t
-svn_fs_fs__id_rev(const svn_fs_id_t *fs_id)
+svn_fs_x__id_rev(const svn_fs_id_t *fs_id)
{
- fs_fs__id_t *id = (fs_fs__id_t *)fs_id;
+ fs_x__id_t *id = (fs_x__id_t *)fs_id;
return id->rev_item.revision;
}
apr_uint64_t
-svn_fs_fs__id_item(const svn_fs_id_t *fs_id)
+svn_fs_x__id_item(const svn_fs_id_t *fs_id)
{
- fs_fs__id_t *id = (fs_fs__id_t *)fs_id;
+ fs_x__id_t *id = (fs_x__id_t *)fs_id;
return id->rev_item.number;
}
svn_boolean_t
-svn_fs_fs__id_is_txn(const svn_fs_id_t *fs_id)
+svn_fs_x__id_is_txn(const svn_fs_id_t *fs_id)
{
- fs_fs__id_t *id = (fs_fs__id_t *)fs_id;
+ fs_x__id_t *id = (fs_x__id_t *)fs_id;
- return svn_fs_fs__id_txn_used(&id->txn_id);
+ return svn_fs_x__id_txn_used(&id->txn_id);
}
svn_string_t *
-svn_fs_fs__id_unparse(const svn_fs_id_t *fs_id,
- apr_pool_t *pool)
+svn_fs_x__id_unparse(const svn_fs_id_t *fs_id,
+ apr_pool_t *pool)
{
char string[6 * SVN_INT64_BUFFER_SIZE + 10];
- fs_fs__id_t *id = (fs_fs__id_t *)fs_id;
+ fs_x__id_t *id = (fs_x__id_t *)fs_id;
char *p = unparse_id_part(string, &id->node_id);
p = unparse_id_part(p, &id->copy_id);
- if (svn_fs_fs__id_txn_used(&id->txn_id))
+ if (svn_fs_x__id_txn_used(&id->txn_id))
{
*(p++) = 't';
p += svn__i64toa(p, id->txn_id.revision);
@@ -276,11 +276,11 @@ svn_fs_fs__id_unparse(const svn_fs_id_t
/*** Comparing node IDs ***/
svn_boolean_t
-svn_fs_fs__id_eq(const svn_fs_id_t *a,
- const svn_fs_id_t *b)
+svn_fs_x__id_eq(const svn_fs_id_t *a,
+ const svn_fs_id_t *b)
{
- fs_fs__id_t *id_a = (fs_fs__id_t *)a;
- fs_fs__id_t *id_b = (fs_fs__id_t *)b;
+ fs_x__id_t *id_a = (fs_x__id_t *)a;
+ fs_x__id_t *id_b = (fs_x__id_t *)b;
if (a == b)
return TRUE;
@@ -291,11 +291,11 @@ svn_fs_fs__id_eq(const svn_fs_id_t *a,
svn_boolean_t
-svn_fs_fs__id_check_related(const svn_fs_id_t *a,
- const svn_fs_id_t *b)
+svn_fs_x__id_check_related(const svn_fs_id_t *a,
+ const svn_fs_id_t *b)
{
- fs_fs__id_t *id_a = (fs_fs__id_t *)a;
- fs_fs__id_t *id_b = (fs_fs__id_t *)b;
+ fs_x__id_t *id_a = (fs_x__id_t *)a;
+ fs_x__id_t *id_b = (fs_x__id_t *)b;
if (a == b)
return TRUE;
@@ -304,27 +304,27 @@ svn_fs_fs__id_check_related(const svn_fs
IDs, then it is impossible for them to be related. */
if (id_a->node_id.revision == SVN_INVALID_REVNUM)
{
- if ( !svn_fs_fs__id_part_eq(&id_a->txn_id, &id_b->txn_id)
- || !svn_fs_fs__id_txn_used(&id_a->txn_id))
+ if ( !svn_fs_x__id_part_eq(&id_a->txn_id, &id_b->txn_id)
+ || !svn_fs_x__id_txn_used(&id_a->txn_id))
return FALSE;
}
- return svn_fs_fs__id_part_eq(&id_a->node_id, &id_b->node_id);
+ return svn_fs_x__id_part_eq(&id_a->node_id, &id_b->node_id);
}
int
-svn_fs_fs__id_compare(const svn_fs_id_t *a,
- const svn_fs_id_t *b)
+svn_fs_x__id_compare(const svn_fs_id_t *a,
+ const svn_fs_id_t *b)
{
- if (svn_fs_fs__id_eq(a, b))
+ if (svn_fs_x__id_eq(a, b))
return 0;
- return (svn_fs_fs__id_check_related(a, b) ? 1 : -1);
+ return (svn_fs_x__id_check_related(a, b) ? 1 : -1);
}
int
-svn_fs_fs__id_part_compare(const svn_fs_fs__id_part_t *a,
- const svn_fs_fs__id_part_t *b)
+svn_fs_x__id_part_compare(const svn_fs_x__id_part_t *a,
+ const svn_fs_x__id_part_t *b)
{
if (a->revision < b->revision)
return -1;
@@ -339,18 +339,18 @@ svn_fs_fs__id_part_compare(const svn_fs_
/* Creating ID's. */
static id_vtable_t id_vtable = {
- svn_fs_fs__id_unparse,
- svn_fs_fs__id_compare
+ svn_fs_x__id_unparse,
+ svn_fs_x__id_compare
};
svn_fs_id_t *
-svn_fs_fs__id_txn_create_root(const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__id_txn_create_root(const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
- fs_fs__id_t *id = apr_pcalloc(pool, sizeof(*id));
+ fs_x__id_t *id = apr_pcalloc(pool, sizeof(*id));
/* node ID and copy ID are "0" */
-
+
id->txn_id = *txn_id;
id->rev_item.revision = SVN_INVALID_REVNUM;
@@ -360,10 +360,10 @@ svn_fs_fs__id_txn_create_root(const svn_
return (svn_fs_id_t *)id;
}
-svn_fs_id_t *svn_fs_fs__id_create_root(const svn_revnum_t revision,
- apr_pool_t *pool)
+svn_fs_id_t *svn_fs_x__id_create_root(const svn_revnum_t revision,
+ apr_pool_t *pool)
{
- fs_fs__id_t *id = apr_pcalloc(pool, sizeof(*id));
+ fs_x__id_t *id = apr_pcalloc(pool, sizeof(*id));
id->txn_id.revision = SVN_INVALID_REVNUM;
id->rev_item.revision = revision;
@@ -376,12 +376,12 @@ svn_fs_id_t *svn_fs_fs__id_create_root(c
}
svn_fs_id_t *
-svn_fs_fs__id_txn_create(const svn_fs_fs__id_part_t *node_id,
- const svn_fs_fs__id_part_t *copy_id,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__id_txn_create(const svn_fs_x__id_part_t *node_id,
+ const svn_fs_x__id_part_t *copy_id,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
- fs_fs__id_t *id = apr_pcalloc(pool, sizeof(*id));
+ fs_x__id_t *id = apr_pcalloc(pool, sizeof(*id));
id->node_id = *node_id;
id->copy_id = *copy_id;
@@ -396,12 +396,12 @@ svn_fs_fs__id_txn_create(const svn_fs_fs
svn_fs_id_t *
-svn_fs_fs__id_rev_create(const svn_fs_fs__id_part_t *node_id,
- const svn_fs_fs__id_part_t *copy_id,
- const svn_fs_fs__id_part_t *rev_item,
- apr_pool_t *pool)
+svn_fs_x__id_rev_create(const svn_fs_x__id_part_t *node_id,
+ const svn_fs_x__id_part_t *copy_id,
+ const svn_fs_x__id_part_t *rev_item,
+ apr_pool_t *pool)
{
- fs_fs__id_t *id = apr_pcalloc(pool, sizeof(*id));
+ fs_x__id_t *id = apr_pcalloc(pool, sizeof(*id));
id->node_id = *node_id;
id->copy_id = *copy_id;
@@ -416,10 +416,10 @@ svn_fs_fs__id_rev_create(const svn_fs_fs
svn_fs_id_t *
-svn_fs_fs__id_copy(const svn_fs_id_t *source, apr_pool_t *pool)
+svn_fs_x__id_copy(const svn_fs_id_t *source, apr_pool_t *pool)
{
- fs_fs__id_t *id = (fs_fs__id_t *)source;
- fs_fs__id_t *new_id = apr_palloc(pool, sizeof(*new_id));
+ fs_x__id_t *id = (fs_x__id_t *)source;
+ fs_x__id_t *new_id = apr_palloc(pool, sizeof(*new_id));
*new_id = *id;
new_id->generic_id.fsap_data = new_id;
@@ -429,11 +429,11 @@ svn_fs_fs__id_copy(const svn_fs_id_t *so
svn_fs_id_t *
-svn_fs_fs__id_parse(const char *data,
- apr_size_t len,
- apr_pool_t *pool)
+svn_fs_x__id_parse(const char *data,
+ apr_size_t len,
+ apr_pool_t *pool)
{
- fs_fs__id_t *id;
+ fs_x__id_t *id;
char *data_copy, *str;
/* Dup the ID data into POOL. Our returned ID will have references
@@ -513,10 +513,10 @@ svn_fs_fs__id_parse(const char *data,
/* Serialize an ID within the serialization CONTEXT.
*/
void
-svn_fs_fs__id_serialize(svn_temp_serializer__context_t *context,
- const svn_fs_id_t * const *in)
+svn_fs_x__id_serialize(svn_temp_serializer__context_t *context,
+ const svn_fs_id_t * const *in)
{
- const fs_fs__id_t *id = (const fs_fs__id_t *)*in;
+ const fs_x__id_t *id = (const fs_x__id_t *)*in;
/* nothing to do for NULL ids */
if (id == NULL)
@@ -525,22 +525,22 @@ svn_fs_fs__id_serialize(svn_temp_seriali
/* serialize the id data struct itself */
svn_temp_serializer__add_leaf(context,
(const void * const *)in,
- sizeof(fs_fs__id_t));
+ sizeof(fs_x__id_t));
}
/* Deserialize an ID inside the BUFFER.
*/
void
-svn_fs_fs__id_deserialize(void *buffer, svn_fs_id_t **in_out)
+svn_fs_x__id_deserialize(void *buffer, svn_fs_id_t **in_out)
{
- fs_fs__id_t *id;
+ fs_x__id_t *id;
/* The id maybe all what is in the whole buffer.
* Don't try to fixup the pointer in that case*/
if (*in_out != buffer)
svn_temp_deserializer__resolve(buffer, (void**)in_out);
- id = (fs_fs__id_t *)*in_out;
+ id = (fs_x__id_t *)*in_out;
/* no id, no sub-structure fixup necessary */
if (id == NULL)
Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/id.h
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/id.h?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/id.h (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/id.h Sun Jun 30 17:01:16 2013
@@ -33,7 +33,7 @@ extern "C" {
* of a creation REVISION number and some revision-local counter value
* (NUMBER). Old-style ID parts use global counter values.
*/
-typedef struct svn_fs_fs__id_part_t
+typedef struct svn_fs_x__id_part_t
{
/* SVN_INVALID_REVNUM for txns -> not a txn, COUNTER must be 0.
SVN_INVALID_REVNUM for others -> not assigned to a revision, yet.
@@ -42,111 +42,111 @@ typedef struct svn_fs_fs__id_part_t
/* some numerical value. */
apr_uint64_t number;
-} svn_fs_fs__id_part_t;
+} svn_fs_x__id_part_t;
/*** Operations on ID parts. ***/
/* Return TRUE, if both elements of the PART is 0, i.e. this is the default
* value if e.g. no copies were made of this node. */
-svn_boolean_t svn_fs_fs__id_part_is_root(const svn_fs_fs__id_part_t *part);
+svn_boolean_t svn_fs_x__id_part_is_root(const svn_fs_x__id_part_t *part);
/* Return TRUE, if all element values of *LHS and *RHS match. */
-svn_boolean_t svn_fs_fs__id_part_eq(const svn_fs_fs__id_part_t *lhs,
- const svn_fs_fs__id_part_t *rhs);
+svn_boolean_t svn_fs_x__id_part_eq(const svn_fs_x__id_part_t *lhs,
+ const svn_fs_x__id_part_t *rhs);
/* Return TRUE, if TXN_ID is used, i.e. doesn't contain just the defaults. */
-svn_boolean_t svn_fs_fs__id_txn_used(const svn_fs_fs__id_part_t *txn_id);
+svn_boolean_t svn_fs_x__id_txn_used(const svn_fs_x__id_part_t *txn_id);
/* Reset TXN_ID to the defaults. */
-void svn_fs_fs__id_txn_reset(svn_fs_fs__id_part_t *txn_id);
+void svn_fs_x__id_txn_reset(svn_fs_x__id_part_t *txn_id);
/* Parse the transaction id in DATA and store the result in *TXN_ID */
-svn_error_t *svn_fs_fs__id_txn_parse(svn_fs_fs__id_part_t *txn_id,
- const char *data);
+svn_error_t *svn_fs_x__id_txn_parse(svn_fs_x__id_part_t *txn_id,
+ const char *data);
/* Convert the transaction id in *TXN_ID into a textual representation
* allocated in POOL. */
-const char *svn_fs_fs__id_txn_unparse(const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool);
+const char *svn_fs_x__id_txn_unparse(const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool);
/*** ID accessor functions. ***/
/* Get the "node id" portion of ID. */
-const svn_fs_fs__id_part_t *svn_fs_fs__id_node_id(const svn_fs_id_t *id);
+const svn_fs_x__id_part_t *svn_fs_x__id_node_id(const svn_fs_id_t *id);
/* Get the "copy id" portion of ID. */
-const svn_fs_fs__id_part_t *svn_fs_fs__id_copy_id(const svn_fs_id_t *id);
+const svn_fs_x__id_part_t *svn_fs_x__id_copy_id(const svn_fs_id_t *id);
/* Get the "txn id" portion of ID, or NULL if it is a permanent ID. */
-const svn_fs_fs__id_part_t *svn_fs_fs__id_txn_id(const svn_fs_id_t *id);
+const svn_fs_x__id_part_t *svn_fs_x__id_txn_id(const svn_fs_id_t *id);
/* Get the "rev,item" portion of ID. */
-const svn_fs_fs__id_part_t *svn_fs_fs__id_rev_item(const svn_fs_id_t *id);
+const svn_fs_x__id_part_t *svn_fs_x__id_rev_item(const svn_fs_id_t *id);
/* Get the "rev" portion of ID, or SVN_INVALID_REVNUM if it is a
transaction ID. */
-svn_revnum_t svn_fs_fs__id_rev(const svn_fs_id_t *id);
+svn_revnum_t svn_fs_x__id_rev(const svn_fs_id_t *id);
/* Access the "item" portion of the ID, or 0 if it is a transaction
ID. */
-apr_uint64_t svn_fs_fs__id_item(const svn_fs_id_t *id);
+apr_uint64_t svn_fs_x__id_item(const svn_fs_id_t *id);
/* Return TRUE, if this is a transaction ID. */
-svn_boolean_t svn_fs_fs__id_is_txn(const svn_fs_id_t *id);
+svn_boolean_t svn_fs_x__id_is_txn(const svn_fs_id_t *id);
/* Convert ID into string form, allocated in POOL. */
-svn_string_t *svn_fs_fs__id_unparse(const svn_fs_id_t *id,
- apr_pool_t *pool);
+svn_string_t *svn_fs_x__id_unparse(const svn_fs_id_t *id,
+ apr_pool_t *pool);
/* Return true if A and B are equal. */
-svn_boolean_t svn_fs_fs__id_eq(const svn_fs_id_t *a,
- const svn_fs_id_t *b);
+svn_boolean_t svn_fs_x__id_eq(const svn_fs_id_t *a,
+ const svn_fs_id_t *b);
/* Return true if A and B are related. */
-svn_boolean_t svn_fs_fs__id_check_related(const svn_fs_id_t *a,
- const svn_fs_id_t *b);
+svn_boolean_t svn_fs_x__id_check_related(const svn_fs_id_t *a,
+ const svn_fs_id_t *b);
/* Return 0 if A and B are equal, 1 if they are related, -1 otherwise. */
-int svn_fs_fs__id_compare(const svn_fs_id_t *a,
- const svn_fs_id_t *b);
+int svn_fs_x__id_compare(const svn_fs_id_t *a,
+ const svn_fs_id_t *b);
/* Return 0 if A and B are equal, 1 if A is "greater than" B, -1 otherwise. */
-int svn_fs_fs__id_part_compare(const svn_fs_fs__id_part_t *a,
- const svn_fs_fs__id_part_t *b);
+int svn_fs_x__id_part_compare(const svn_fs_x__id_part_t *a,
+ const svn_fs_x__id_part_t *b);
/* Create the txn root ID for transaction TXN_ID. Allocate it in POOL. */
-svn_fs_id_t *svn_fs_fs__id_txn_create_root(const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool);
+svn_fs_id_t *svn_fs_x__id_txn_create_root(const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool);
/* Create the root ID for REVISION. Allocate it in POOL. */
-svn_fs_id_t *svn_fs_fs__id_create_root(const svn_revnum_t revision,
- apr_pool_t *pool);
+svn_fs_id_t *svn_fs_x__id_create_root(const svn_revnum_t revision,
+ apr_pool_t *pool);
/* Create an ID within a transaction based on NODE_ID, COPY_ID, and
TXN_ID, allocated in POOL. */
-svn_fs_id_t *svn_fs_fs__id_txn_create(const svn_fs_fs__id_part_t *node_id,
- const svn_fs_fs__id_part_t *copy_id,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool);
+svn_fs_id_t *svn_fs_x__id_txn_create(const svn_fs_x__id_part_t *node_id,
+ const svn_fs_x__id_part_t *copy_id,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool);
/* Create a permanent ID based on NODE_ID, COPY_ID and REV_ITEM,
allocated in POOL. */
-svn_fs_id_t *svn_fs_fs__id_rev_create(const svn_fs_fs__id_part_t *node_id,
- const svn_fs_fs__id_part_t *copy_id,
- const svn_fs_fs__id_part_t *rev_item,
- apr_pool_t *pool);
+svn_fs_id_t *svn_fs_x__id_rev_create(const svn_fs_x__id_part_t *node_id,
+ const svn_fs_x__id_part_t *copy_id,
+ const svn_fs_x__id_part_t *rev_item,
+ apr_pool_t *pool);
/* Return a copy of ID, allocated from POOL. */
-svn_fs_id_t *svn_fs_fs__id_copy(const svn_fs_id_t *id,
- apr_pool_t *pool);
+svn_fs_id_t *svn_fs_x__id_copy(const svn_fs_id_t *id,
+ apr_pool_t *pool);
/* Return an ID resulting from parsing the string DATA (with length
LEN), or NULL if DATA is an invalid ID string. */
-svn_fs_id_t *svn_fs_fs__id_parse(const char *data,
- apr_size_t len,
- apr_pool_t *pool);
+svn_fs_id_t *svn_fs_x__id_parse(const char *data,
+ apr_size_t len,
+ apr_pool_t *pool);
/* (de-)serialization support*/
@@ -157,14 +157,14 @@ struct svn_temp_serializer__context_t;
* Serialize an @a id within the serialization @a context.
*/
void
-svn_fs_fs__id_serialize(struct svn_temp_serializer__context_t *context,
+svn_fs_x__id_serialize(struct svn_temp_serializer__context_t *context,
const svn_fs_id_t * const *id);
/**
* Deserialize an @a id within the @a buffer.
*/
void
-svn_fs_fs__id_deserialize(void *buffer,
+svn_fs_x__id_deserialize(void *buffer,
svn_fs_id_t **id);
#ifdef __cplusplus
Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/index.c
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/index.c?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/index.c (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/index.c Sun Jun 30 17:01:16 2013
@@ -406,9 +406,9 @@ packed_stream_offset(packed_number_strea
* log-to-phys index
*/
svn_error_t *
-svn_fs_fs__l2p_proto_index_open(apr_file_t **proto_index,
- const char *file_name,
- apr_pool_t *pool)
+svn_fs_x__l2p_proto_index_open(apr_file_t **proto_index,
+ const char *file_name,
+ apr_pool_t *pool)
{
SVN_ERR(svn_io_file_open(proto_index, file_name, APR_READ | APR_WRITE
| APR_CREATE | APR_APPEND | APR_BUFFERED,
@@ -434,8 +434,8 @@ write_entry_to_proto_index(apr_file_t *p
}
svn_error_t *
-svn_fs_fs__l2p_proto_index_add_revision(apr_file_t *proto_index,
- apr_pool_t *pool)
+svn_fs_x__l2p_proto_index_add_revision(apr_file_t *proto_index,
+ apr_pool_t *pool)
{
l2p_proto_entry_t entry;
entry.offset = 0;
@@ -446,11 +446,11 @@ svn_fs_fs__l2p_proto_index_add_revision(
}
svn_error_t *
-svn_fs_fs__l2p_proto_index_add_entry(apr_file_t *proto_index,
- apr_off_t offset,
- apr_uint32_t sub_item,
- apr_uint64_t item_index,
- apr_pool_t *pool)
+svn_fs_x__l2p_proto_index_add_entry(apr_file_t *proto_index,
+ apr_off_t offset,
+ apr_uint32_t sub_item,
+ apr_uint64_t item_index,
+ apr_pool_t *pool)
{
l2p_proto_entry_t entry;
@@ -654,13 +654,13 @@ encode_l2p_page(apr_array_header_t *entr
}
svn_error_t *
-svn_fs_fs__l2p_index_create(svn_fs_t *fs,
- const char *file_name,
- const char *proto_file_name,
- svn_revnum_t revision,
- apr_pool_t *pool)
+svn_fs_x__l2p_index_create(svn_fs_t *fs,
+ const char *file_name,
+ const char *proto_file_name,
+ svn_revnum_t revision,
+ apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
apr_file_t *proto_index = NULL;
int i;
int end;
@@ -816,8 +816,8 @@ svn_fs_fs__l2p_index_create(svn_fs_t *fs
static svn_revnum_t
base_revision(svn_fs_t *fs, svn_revnum_t revision)
{
- fs_fs_data_t *ffd = fs->fsap_data;
- return is_packed_rev(fs, revision)
+ fs_x_data_t *ffd = fs->fsap_data;
+ return svn_fs_x__is_packed_rev(fs, revision)
? revision - (revision % ffd->max_files_per_dir)
: revision;
}
@@ -976,7 +976,7 @@ get_l2p_header_body(l2p_header_t **heade
svn_revnum_t revision,
apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
apr_uint64_t value;
int i;
apr_size_t page, page_count;
@@ -988,10 +988,11 @@ get_l2p_header_body(l2p_header_t **heade
pair_cache_key_t key;
key.revision = base_revision(fs, revision);
- key.second = is_packed_rev(fs, revision);
+ key.second = svn_fs_x__is_packed_rev(fs, revision);
if (*stream == NULL)
- SVN_ERR(packed_stream_open(stream, path_l2p_index(fs, revision, pool),
+ SVN_ERR(packed_stream_open(stream,
+ svn_fs_x__path_l2p_index(fs, revision, pool),
ffd->block_size, pool));
else
packed_stream_seek(*stream, 0);
@@ -1059,7 +1060,7 @@ get_l2p_page_info(l2p_page_info_baton_t
svn_fs_t *fs,
apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
l2p_header_t *result;
svn_boolean_t is_cached = FALSE;
void *dummy = NULL;
@@ -1067,7 +1068,7 @@ get_l2p_page_info(l2p_page_info_baton_t
/* try to find the info in the cache */
pair_cache_key_t key;
key.revision = base_revision(fs, baton->revision);
- key.second = is_packed_rev(fs, baton->revision);
+ key.second = svn_fs_x__is_packed_rev(fs, baton->revision);
SVN_ERR(svn_cache__get_partial((void**)&dummy, &is_cached,
ffd->l2p_header_cache, &key,
l2p_header_access_func, baton,
@@ -1094,13 +1095,13 @@ get_l2p_header(l2p_header_t **header,
svn_revnum_t revision,
apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
svn_boolean_t is_cached = FALSE;
/* first, try cache lookop */
pair_cache_key_t key;
key.revision = base_revision(fs, revision);
- key.second = is_packed_rev(fs, revision);
+ key.second = svn_fs_x__is_packed_rev(fs, revision);
SVN_ERR(svn_cache__get((void**)header, &is_cached, ffd->l2p_header_cache,
&key, pool));
if (is_cached)
@@ -1125,7 +1126,7 @@ get_l2p_page(l2p_page_t **page,
l2p_page_table_entry_t *table_entry,
apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
apr_uint64_t value, last_value = 0;
apr_uint32_t i;
l2p_page_t *result = apr_pcalloc(pool, sizeof(*result));
@@ -1135,7 +1136,8 @@ get_l2p_page(l2p_page_t **page,
/* open index file and select page */
if (*stream == NULL)
SVN_ERR(packed_stream_open(stream,
- path_l2p_index(fs, start_revision, pool),
+ svn_fs_x__path_l2p_index(fs, start_revision,
+ pool),
ffd->block_size,
pool));
@@ -1319,13 +1321,13 @@ get_l2p_page_table(apr_array_header_t *p
svn_revnum_t revision,
apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
svn_boolean_t is_cached = FALSE;
l2p_page_table_baton_t baton;
pair_cache_key_t key;
key.revision = base_revision(fs, revision);
- key.second = is_packed_rev(fs, revision);
+ key.second = svn_fs_x__is_packed_rev(fs, revision);
apr_array_clear(pages);
baton.revision = revision;
@@ -1356,10 +1358,10 @@ prefetch_l2p_pages(svn_boolean_t *end,
apr_off_t max_offset,
apr_pool_t *scratch_pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
int i;
apr_pool_t *iterpool;
- svn_fs_fs__page_cache_key_t key = { 0 };
+ svn_fs_x__page_cache_key_t key = { 0 };
/* get the page table for REVISION from cache */
*end = FALSE;
@@ -1376,7 +1378,7 @@ prefetch_l2p_pages(svn_boolean_t *end,
iterpool = svn_pool_create(scratch_pool);
assert(revision <= APR_UINT32_MAX);
key.revision = (apr_uint32_t)revision;
- key.is_packed = is_packed_rev(fs, revision);
+ key.is_packed = svn_fs_x__is_packed_rev(fs, revision);
for (i = 0; i < pages->nelts && !*end; ++i)
{
@@ -1429,12 +1431,12 @@ l2p_index_lookup(apr_off_t *offset,
apr_uint64_t item_index,
apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
l2p_page_info_baton_t info_baton;
l2p_page_baton_t page_baton;
l2p_page_t *page = NULL;
packed_number_stream_t *stream = NULL;
- svn_fs_fs__page_cache_key_t key = { 0 };
+ svn_fs_x__page_cache_key_t key = { 0 };
svn_boolean_t is_cached = FALSE;
void *dummy = NULL;
@@ -1451,7 +1453,7 @@ l2p_index_lookup(apr_off_t *offset,
assert(revision <= APR_UINT32_MAX);
key.revision = (apr_uint32_t)revision;
- key.is_packed = is_packed_rev(fs, revision);
+ key.is_packed = svn_fs_x__is_packed_rev(fs, revision);
key.page = info_baton.page_no;
SVN_ERR(svn_cache__get_partial(&dummy, &is_cached,
@@ -1532,14 +1534,14 @@ static svn_error_t *
l2p_proto_index_lookup(apr_off_t *offset,
apr_uint32_t *sub_item,
svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
+ const svn_fs_x__id_part_t *txn_id,
apr_uint64_t item_index,
apr_pool_t *pool)
{
svn_boolean_t eof = FALSE;
apr_file_t *file = NULL;
SVN_ERR(svn_io_file_open(&file,
- path_l2p_proto_index(fs, txn_id, pool),
+ svn_fs_x__path_l2p_proto_index(fs, txn_id, pool),
APR_READ | APR_BUFFERED, APR_OS_DEFAULT, pool));
/* process all entries until we fail due to EOF */
@@ -1569,11 +1571,11 @@ l2p_proto_index_lookup(apr_off_t *offset
}
svn_error_t *
-svn_fs_fs__l2p_get_max_ids(apr_array_header_t **max_ids,
- svn_fs_t *fs,
- svn_revnum_t start_rev,
- apr_size_t count,
- apr_pool_t *pool)
+svn_fs_x__l2p_get_max_ids(apr_array_header_t **max_ids,
+ svn_fs_t *fs,
+ svn_revnum_t start_rev,
+ apr_size_t count,
+ apr_pool_t *pool)
{
l2p_header_t *header = NULL;
svn_revnum_t revision;
@@ -1626,11 +1628,11 @@ svn_fs_fs__l2p_get_max_ids(apr_array_hea
/*
* phys-to-log index
*/
-svn_fs_fs__p2l_entry_t *
-svn_fs_fs__p2l_entry_dup(svn_fs_fs__p2l_entry_t *entry,
- apr_pool_t *pool)
+svn_fs_x__p2l_entry_t *
+svn_fs_x__p2l_entry_dup(svn_fs_x__p2l_entry_t *entry,
+ apr_pool_t *pool)
{
- svn_fs_fs__p2l_entry_t *new_entry = apr_palloc(pool, sizeof(*new_entry));
+ svn_fs_x__p2l_entry_t *new_entry = apr_palloc(pool, sizeof(*new_entry));
*new_entry = *entry;
if (new_entry->item_count)
@@ -1642,9 +1644,9 @@ svn_fs_fs__p2l_entry_dup(svn_fs_fs__p2l_
}
svn_error_t *
-svn_fs_fs__p2l_proto_index_open(apr_file_t **proto_index,
- const char *file_name,
- apr_pool_t *pool)
+svn_fs_x__p2l_proto_index_open(apr_file_t **proto_index,
+ const char *file_name,
+ apr_pool_t *pool)
{
SVN_ERR(svn_io_file_open(proto_index, file_name, APR_READ | APR_WRITE
| APR_CREATE | APR_APPEND | APR_BUFFERED,
@@ -1655,9 +1657,9 @@ svn_fs_fs__p2l_proto_index_open(apr_file
svn_error_t *
-svn_fs_fs__p2l_proto_index_add_entry(apr_file_t *proto_index,
- svn_fs_fs__p2l_entry_t *entry,
- apr_pool_t *pool)
+svn_fs_x__p2l_proto_index_add_entry(apr_file_t *proto_index,
+ svn_fs_x__p2l_entry_t *entry,
+ apr_pool_t *pool)
{
apr_size_t written = sizeof(*entry);
@@ -1677,13 +1679,13 @@ svn_fs_fs__p2l_proto_index_add_entry(apr
}
svn_error_t *
-svn_fs_fs__p2l_index_create(svn_fs_t *fs,
- const char *file_name,
- const char *proto_file_name,
- svn_revnum_t revision,
- apr_pool_t *pool)
+svn_fs_x__p2l_index_create(svn_fs_t *fs,
+ const char *file_name,
+ const char *proto_file_name,
+ svn_revnum_t revision,
+ apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
apr_uint64_t page_size = ffd->p2l_page_size;
apr_file_t *proto_index = NULL;
int i;
@@ -1718,7 +1720,7 @@ svn_fs_fs__p2l_index_create(svn_fs_t *fs
/* process all entries until we fail due to EOF */
while (!eof)
{
- svn_fs_fs__p2l_entry_t entry;
+ svn_fs_x__p2l_entry_t entry;
apr_size_t read = 0;
apr_size_t to_read;
apr_uint64_t entry_end;
@@ -1958,7 +1960,7 @@ get_p2l_header(p2l_header_t **header,
apr_pool_t *stream_pool,
apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
apr_uint64_t value;
apr_size_t i;
apr_off_t offset;
@@ -1968,7 +1970,7 @@ get_p2l_header(p2l_header_t **header,
/* look for the header data in our cache */
pair_cache_key_t key;
key.revision = base_revision(fs, revision);
- key.second = is_packed_rev(fs, revision);
+ key.second = svn_fs_x__is_packed_rev(fs, revision);
SVN_ERR(svn_cache__get((void**)header, &is_cached, ffd->p2l_header_cache,
&key, pool));
@@ -1979,7 +1981,8 @@ get_p2l_header(p2l_header_t **header,
* Open index file or position read pointer to the begin of the file */
if (*stream == NULL)
SVN_ERR(packed_stream_open(stream,
- path_p2l_index(fs, key.revision, pool),
+ svn_fs_x__path_p2l_index(fs, key.revision,
+ pool),
ffd->block_size, stream_pool));
else
packed_stream_seek(*stream, 0);
@@ -2034,7 +2037,7 @@ get_p2l_page_info(p2l_page_info_baton_t
apr_pool_t *stream_pool,
apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
p2l_header_t *header;
svn_boolean_t is_cached = FALSE;
void *dummy = NULL;
@@ -2042,7 +2045,7 @@ get_p2l_page_info(p2l_page_info_baton_t
/* look for the header data in our cache */
pair_cache_key_t key;
key.revision = base_revision(fs, baton->revision);
- key.second = is_packed_rev(fs, baton->revision);
+ key.second = svn_fs_x__is_packed_rev(fs, baton->revision);
SVN_ERR(svn_cache__get_partial(&dummy, &is_cached, ffd->p2l_header_cache,
&key, p2l_page_info_func, baton, pool));
@@ -2073,7 +2076,7 @@ read_entry(packed_number_stream_t *strea
apr_uint64_t number = 0;
apr_uint32_t sub_item;
- svn_fs_fs__p2l_entry_t entry;
+ svn_fs_x__p2l_entry_t entry;
entry.offset = *item_offset;
SVN_ERR(packed_stream_get(&value, stream));
@@ -2106,7 +2109,7 @@ read_entry(packed_number_stream_t *strea
}
}
- APR_ARRAY_PUSH(result, svn_fs_fs__p2l_entry_t) = entry;
+ APR_ARRAY_PUSH(result, svn_fs_x__p2l_entry_t) = entry;
*item_offset += entry.size;
return SVN_NO_ERROR;
@@ -2132,18 +2135,18 @@ get_p2l_page(apr_array_header_t **entrie
apr_pool_t *stream_pool,
apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
apr_uint64_t value;
apr_array_header_t *result
- = apr_array_make(pool, 16, sizeof(svn_fs_fs__p2l_entry_t));
+ = apr_array_make(pool, 16, sizeof(svn_fs_x__p2l_entry_t));
apr_off_t item_offset;
apr_off_t offset;
/* open index and navigate to page start */
if (*stream == NULL)
SVN_ERR(packed_stream_open(stream,
- path_p2l_index(fs, start_revision, pool),
- ffd->block_size, stream_pool));
+ svn_fs_x__path_p2l_index(fs, start_revision, pool),
+ ffd->block_size, stream_pool));
packed_stream_seek(*stream, start_offset);
/* read rev file offset of the first page entry (all page entries will
@@ -2196,10 +2199,10 @@ prefetch_p2l_page(svn_boolean_t *end,
apr_pool_t *stream_pool,
apr_pool_t *scratch_pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
svn_boolean_t already_cached;
apr_array_header_t *page;
- svn_fs_fs__page_cache_key_t key = { 0 };
+ svn_fs_x__page_cache_key_t key = { 0 };
/* fetch the page info */
*end = FALSE;
@@ -2215,7 +2218,7 @@ prefetch_p2l_page(svn_boolean_t *end,
/* do we have that page in our caches already? */
assert(baton->first_revision <= APR_UINT32_MAX);
key.revision = (apr_uint32_t)baton->first_revision;
- key.is_packed = is_packed_rev(fs, baton->first_revision);
+ key.is_packed = svn_fs_x__is_packed_rev(fs, baton->first_revision);
key.page = baton->page_no;
SVN_ERR(svn_cache__has_key(&already_cached, ffd->p2l_page_cache,
&key, scratch_pool));
@@ -2256,7 +2259,7 @@ prefetch_p2l_page(svn_boolean_t *end,
*/
static svn_error_t *
get_p2l_keys(p2l_page_info_baton_t *page_info_p,
- svn_fs_fs__page_cache_key_t *key_p,
+ svn_fs_x__page_cache_key_t *key_p,
packed_number_stream_t **stream,
svn_fs_t *fs,
svn_revnum_t revision,
@@ -2287,10 +2290,10 @@ get_p2l_keys(p2l_page_info_baton_t *page
/* construct cache key */
if (key_p)
{
- svn_fs_fs__page_cache_key_t key = { 0 };
+ svn_fs_x__page_cache_key_t key = { 0 };
assert(page_info.first_revision <= APR_UINT32_MAX);
key.revision = (apr_uint32_t)page_info.first_revision;
- key.is_packed = is_packed_rev(fs, revision);
+ key.is_packed = svn_fs_x__is_packed_rev(fs, revision);
key.page = page_info.page_no;
*key_p = key;
@@ -2299,7 +2302,7 @@ get_p2l_keys(p2l_page_info_baton_t *page
return SVN_NO_ERROR;
}
-/* Body of svn_fs_fs__p2l_index_lookup. Use / autoconstruct *STREAM as
+/* Body of svn_fs_x__p2l_index_lookup. Use / autoconstruct *STREAM as
* your input based on REVISION.
*/
static svn_error_t *
@@ -2310,8 +2313,8 @@ p2l_index_lookup(apr_array_header_t **en
apr_off_t offset,
apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
- svn_fs_fs__page_cache_key_t key;
+ fs_x_data_t *ffd = fs->fsap_data;
+ svn_fs_x__page_cache_key_t key;
svn_boolean_t is_cached = FALSE;
p2l_page_info_baton_t page_info;
@@ -2383,11 +2386,11 @@ p2l_index_lookup(apr_array_header_t **en
}
svn_error_t *
-svn_fs_fs__p2l_index_lookup(apr_array_header_t **entries,
- svn_fs_t *fs,
- svn_revnum_t revision,
- apr_off_t offset,
- apr_pool_t *pool)
+svn_fs_x__p2l_index_lookup(apr_array_header_t **entries,
+ svn_fs_t *fs,
+ svn_revnum_t revision,
+ apr_off_t offset,
+ apr_pool_t *pool)
{
packed_number_stream_t *stream = NULL;
@@ -2400,23 +2403,23 @@ svn_fs_fs__p2l_index_lookup(apr_array_he
return SVN_NO_ERROR;
}
-/* compare_fn_t comparing a svn_fs_fs__p2l_entry_t at LHS with an offset
+/* compare_fn_t comparing a svn_fs_x__p2l_entry_t at LHS with an offset
* RHS.
*/
static int
compare_p2l_entry_offsets(const void *lhs, const void *rhs)
{
- const svn_fs_fs__p2l_entry_t *entry = (const svn_fs_fs__p2l_entry_t *)lhs;
+ const svn_fs_x__p2l_entry_t *entry = (const svn_fs_x__p2l_entry_t *)lhs;
apr_off_t offset = *(const apr_off_t *)rhs;
return entry->offset < offset ? -1 : (entry->offset == offset ? 0 : 1);
}
/* Cached data extraction utility. DATA is a P2L index page, e.g. an APR
- * array of svn_fs_fs__p2l_entry_t elements. Return the entry for the item
+ * array of svn_fs_x__p2l_entry_t elements. Return the entry for the item
* starting at OFFSET or NULL if that's not an the start offset of any item.
*/
-static svn_fs_fs__p2l_entry_t *
+static svn_fs_x__p2l_entry_t *
get_p2l_entry_from_cached_page(const void *data,
apr_off_t offset,
apr_pool_t *pool)
@@ -2436,14 +2439,14 @@ get_p2l_entry_from_cached_page(const voi
/* return it, if it is a perfect match */
if (idx < entries->nelts)
{
- svn_fs_fs__p2l_entry_t *entry
- = &APR_ARRAY_IDX(entries, idx, svn_fs_fs__p2l_entry_t);
+ svn_fs_x__p2l_entry_t *entry
+ = &APR_ARRAY_IDX(entries, idx, svn_fs_x__p2l_entry_t);
if (entry->offset == offset)
{
- svn_fs_fs__p2l_entry_t *result
+ svn_fs_x__p2l_entry_t *result
= apr_pmemdup(pool, entry, sizeof(*result));
result->items
- = (svn_fs_fs__id_part_t *)svn_temp_deserializer__ptr(entries->elts,
+ = (svn_fs_x__id_part_t *)svn_temp_deserializer__ptr(entries->elts,
(const void *const *)&entry->items);
return result;
}
@@ -2463,26 +2466,26 @@ p2l_entry_lookup_func(void **out,
void *baton,
apr_pool_t *result_pool)
{
- svn_fs_fs__p2l_entry_t *entry
+ svn_fs_x__p2l_entry_t *entry
= get_p2l_entry_from_cached_page(data, *(apr_off_t *)baton, result_pool);
*out = entry && entry->offset == *(apr_off_t *)baton
- ? svn_fs_fs__p2l_entry_dup(entry, result_pool)
+ ? svn_fs_x__p2l_entry_dup(entry, result_pool)
: NULL;
return SVN_NO_ERROR;
}
static svn_error_t *
-p2l_entry_lookup(svn_fs_fs__p2l_entry_t **entry_p,
+p2l_entry_lookup(svn_fs_x__p2l_entry_t **entry_p,
packed_number_stream_t **stream,
svn_fs_t *fs,
svn_revnum_t revision,
apr_off_t offset,
apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
- svn_fs_fs__page_cache_key_t key = { 0 };
+ fs_x_data_t *ffd = fs->fsap_data;
+ svn_fs_x__page_cache_key_t key = { 0 };
svn_boolean_t is_cached = FALSE;
p2l_page_info_baton_t page_info;
@@ -2509,8 +2512,8 @@ p2l_entry_lookup(svn_fs_fs__p2l_entry_t
/* return it, if it is a perfect match */
if (idx < entries->nelts)
{
- svn_fs_fs__p2l_entry_t *entry
- = &APR_ARRAY_IDX(entries, idx, svn_fs_fs__p2l_entry_t);
+ svn_fs_x__p2l_entry_t *entry
+ = &APR_ARRAY_IDX(entries, idx, svn_fs_x__p2l_entry_t);
if (entry->offset == offset)
*entry_p = entry;
}
@@ -2520,11 +2523,11 @@ p2l_entry_lookup(svn_fs_fs__p2l_entry_t
}
svn_error_t *
-svn_fs_fs__p2l_entry_lookup(svn_fs_fs__p2l_entry_t **entry_p,
- svn_fs_t *fs,
- svn_revnum_t revision,
- apr_off_t offset,
- apr_pool_t *pool)
+svn_fs_x__p2l_entry_lookup(svn_fs_x__p2l_entry_t **entry_p,
+ svn_fs_t *fs,
+ svn_revnum_t revision,
+ apr_off_t offset,
+ apr_pool_t *pool)
{
packed_number_stream_t *stream = NULL;
@@ -2550,7 +2553,7 @@ typedef struct p2l_item_lookup_baton_t
} p2l_item_lookup_baton_t;
/* Implements svn_cache__partial_getter_func_t for P2L index pages, copying
- * the svn_fs_fs__id_part_t for the item described 2l_item_lookup_baton_t
+ * the svn_fs_x__id_part_t for the item described 2l_item_lookup_baton_t
* *BATON. *OUT will be NULL if there is no matching index entry or the
* sub-item is out of range.
*/
@@ -2562,7 +2565,7 @@ p2l_item_lookup_func(void **out,
apr_pool_t *result_pool)
{
p2l_item_lookup_baton_t *lookup_baton = baton;
- svn_fs_fs__p2l_entry_t *entry
+ svn_fs_x__p2l_entry_t *entry
= get_p2l_entry_from_cached_page(data, lookup_baton->offset, result_pool);
*out = entry
@@ -2577,16 +2580,16 @@ p2l_item_lookup_func(void **out,
}
svn_error_t *
-svn_fs_fs__p2l_item_lookup(svn_fs_fs__id_part_t **item,
- svn_fs_t *fs,
- svn_revnum_t revision,
- apr_off_t offset,
- apr_uint32_t sub_item,
- apr_pool_t *pool)
+svn_fs_x__p2l_item_lookup(svn_fs_x__id_part_t **item,
+ svn_fs_t *fs,
+ svn_revnum_t revision,
+ apr_off_t offset,
+ apr_uint32_t sub_item,
+ apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
packed_number_stream_t *stream = NULL;
- svn_fs_fs__page_cache_key_t key = { 0 };
+ svn_fs_x__page_cache_key_t key = { 0 };
svn_boolean_t is_cached = FALSE;
p2l_page_info_baton_t page_info;
p2l_item_lookup_baton_t baton;
@@ -2605,7 +2608,7 @@ svn_fs_fs__p2l_item_lookup(svn_fs_fs__id
{
/* do a standard index lookup. This is will automatically prefetch
* data to speed up future lookups. */
- svn_fs_fs__p2l_entry_t *entry;
+ svn_fs_x__p2l_entry_t *entry;
SVN_ERR(p2l_entry_lookup(&entry, &stream, fs, revision, offset, pool));
/* return result */
@@ -2637,12 +2640,12 @@ p2l_get_max_offset_func(void **out,
}
svn_error_t *
-svn_fs_fs__p2l_get_max_offset(apr_off_t *offset,
- svn_fs_t *fs,
- svn_revnum_t revision,
- apr_pool_t *pool)
+svn_fs_x__p2l_get_max_offset(apr_off_t *offset,
+ svn_fs_t *fs,
+ svn_revnum_t revision,
+ apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
packed_number_stream_t *stream = NULL;
p2l_header_t *header;
svn_boolean_t is_cached = FALSE;
@@ -2651,7 +2654,7 @@ svn_fs_fs__p2l_get_max_offset(apr_off_t
/* look for the header data in our cache */
pair_cache_key_t key;
key.revision = base_revision(fs, revision);
- key.second = is_packed_rev(fs, revision);
+ key.second = svn_fs_x__is_packed_rev(fs, revision);
SVN_ERR(svn_cache__get_partial((void **)&offset_p, &is_cached,
ffd->p2l_header_cache, &key,
@@ -2672,15 +2675,15 @@ svn_fs_fs__p2l_get_max_offset(apr_off_t
}
svn_error_t *
-svn_fs_fs__item_offset(apr_off_t *offset,
- apr_uint32_t *sub_item,
- svn_fs_t *fs,
- svn_revnum_t revision,
- const svn_fs_fs__id_part_t *txn_id,
- apr_uint64_t item_index,
- apr_pool_t *pool)
+svn_fs_x__item_offset(apr_off_t *offset,
+ apr_uint32_t *sub_item,
+ svn_fs_t *fs,
+ svn_revnum_t revision,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_uint64_t item_index,
+ apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
if (ffd->format < SVN_FS_FS__MIN_LOG_ADDRESSING_FORMAT)
{
/* older fsfs formats don't have containers */
@@ -2688,12 +2691,12 @@ svn_fs_fs__item_offset(apr_off_t *offset
/* older fsfs formats use the manifest file to re-map the offsets */
*offset = (apr_off_t)item_index;
- if (!txn_id && is_packed_rev(fs, revision))
+ if (!txn_id && svn_fs_x__is_packed_rev(fs, revision))
{
apr_off_t rev_offset;
- SVN_ERR(svn_fs_fs__get_packed_offset(&rev_offset, fs, revision,
- pool));
+ SVN_ERR(svn_fs_x__get_packed_offset(&rev_offset, fs, revision,
+ pool));
*offset += rev_offset;
}
}
@@ -2713,10 +2716,10 @@ svn_fs_fs__item_offset(apr_off_t *offset
*/
svn_error_t *
-svn_fs_fs__serialize_l2p_header(void **data,
- apr_size_t *data_len,
- void *in,
- apr_pool_t *pool)
+svn_fs_x__serialize_l2p_header(void **data,
+ apr_size_t *data_len,
+ void *in,
+ apr_pool_t *pool)
{
l2p_header_t *header = in;
svn_temp_serializer__context_t *context;
@@ -2753,10 +2756,10 @@ svn_fs_fs__serialize_l2p_header(void **d
}
svn_error_t *
-svn_fs_fs__deserialize_l2p_header(void **out,
- void *data,
- apr_size_t data_len,
- apr_pool_t *pool)
+svn_fs_x__deserialize_l2p_header(void **out,
+ void *data,
+ apr_size_t data_len,
+ apr_pool_t *pool)
{
l2p_header_t *header = (l2p_header_t *)data;
@@ -2771,10 +2774,10 @@ svn_fs_fs__deserialize_l2p_header(void *
}
svn_error_t *
-svn_fs_fs__serialize_l2p_page(void **data,
- apr_size_t *data_len,
- void *in,
- apr_pool_t *pool)
+svn_fs_x__serialize_l2p_page(void **data,
+ apr_size_t *data_len,
+ void *in,
+ apr_pool_t *pool)
{
l2p_page_t *page = in;
svn_temp_serializer__context_t *context;
@@ -2807,10 +2810,10 @@ svn_fs_fs__serialize_l2p_page(void **dat
}
svn_error_t *
-svn_fs_fs__deserialize_l2p_page(void **out,
- void *data,
- apr_size_t data_len,
- apr_pool_t *pool)
+svn_fs_x__deserialize_l2p_page(void **out,
+ void *data,
+ apr_size_t data_len,
+ apr_pool_t *pool)
{
l2p_page_t *page = data;
@@ -2825,10 +2828,10 @@ svn_fs_fs__deserialize_l2p_page(void **o
}
svn_error_t *
-svn_fs_fs__serialize_p2l_header(void **data,
- apr_size_t *data_len,
- void *in,
- apr_pool_t *pool)
+svn_fs_x__serialize_p2l_header(void **data,
+ apr_size_t *data_len,
+ void *in,
+ apr_pool_t *pool)
{
p2l_header_t *header = in;
svn_temp_serializer__context_t *context;
@@ -2856,10 +2859,10 @@ svn_fs_fs__serialize_p2l_header(void **d
}
svn_error_t *
-svn_fs_fs__deserialize_p2l_header(void **out,
- void *data,
- apr_size_t data_len,
- apr_pool_t *pool)
+svn_fs_x__deserialize_p2l_header(void **out,
+ void *data,
+ apr_size_t data_len,
+ apr_pool_t *pool)
{
p2l_header_t *header = data;
@@ -2873,16 +2876,16 @@ svn_fs_fs__deserialize_p2l_header(void *
}
svn_error_t *
-svn_fs_fs__serialize_p2l_page(void **data,
- apr_size_t *data_len,
- void *in,
- apr_pool_t *pool)
+svn_fs_x__serialize_p2l_page(void **data,
+ apr_size_t *data_len,
+ void *in,
+ apr_pool_t *pool)
{
apr_array_header_t *page = in;
svn_temp_serializer__context_t *context;
svn_stringbuf_t *serialized;
apr_size_t table_size = page->elt_size * page->nelts;
- svn_fs_fs__p2l_entry_t *entries = (svn_fs_fs__p2l_entry_t *)page->elts;
+ svn_fs_x__p2l_entry_t *entries = (svn_fs_x__p2l_entry_t *)page->elts;
int i;
/* serialize array header and all its elements */
@@ -2914,20 +2917,20 @@ svn_fs_fs__serialize_p2l_page(void **dat
}
svn_error_t *
-svn_fs_fs__deserialize_p2l_page(void **out,
- void *data,
- apr_size_t data_len,
- apr_pool_t *pool)
+svn_fs_x__deserialize_p2l_page(void **out,
+ void *data,
+ apr_size_t data_len,
+ apr_pool_t *pool)
{
apr_array_header_t *page = (apr_array_header_t *)data;
- svn_fs_fs__p2l_entry_t *entries;
+ svn_fs_x__p2l_entry_t *entries;
int i;
/* resolve the only pointer in the struct */
svn_temp_deserializer__resolve(page, (void**)&page->elts);
/* resolve sub-struct pointers*/
- entries = (svn_fs_fs__p2l_entry_t *)page->elts;
+ entries = (svn_fs_x__p2l_entry_t *)page->elts;
for (i = 0; i < page->nelts; ++i)
svn_temp_deserializer__resolve(entries, (void**)&entries[i].items);