You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@subversion.apache.org by iv...@apache.org on 2015/09/11 17:51:34 UTC
svn commit: r1702504 [5/19] - in /subversion/branches/reuse-ra-session: ./
build/ build/ac-macros/ build/generator/ build/generator/templates/
contrib/hook-scripts/ notes/ subversion/bindings/ctypes-python/csvn/ext/
subversion/bindings/javahl/native/ s...
Modified: subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/index.c
URL: http://svn.apache.org/viewvc/subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/index.c?rev=1702504&r1=1702503&r2=1702504&view=diff
==============================================================================
--- subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/index.c (original)
+++ subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/index.c Fri Sep 11 15:51:30 2015
@@ -3207,18 +3207,11 @@ svn_fs_fs__l2p_index_from_p2l_entries(co
apr_pool_t *iterpool = svn_pool_create(scratch_pool);
int i;
svn_revnum_t last_revision = SVN_INVALID_REVNUM;
- svn_revnum_t revision = SVN_INVALID_REVNUM;
/* L2P index must be written in revision order.
* Sort ENTRIES accordingly. */
svn_sort__array(entries, compare_p2l_entry_revision);
- /* Find the first revision in the index
- * (must exist since no truly empty revs are allowed). */
- for (i = 0; i < entries->nelts && !SVN_IS_VALID_REVNUM(revision); ++i)
- revision = APR_ARRAY_IDX(entries, i, const svn_fs_fs__p2l_entry_t *)
- ->item.revision;
-
/* Create the temporary proto-rev file. */
SVN_ERR(svn_io_open_unique_file3(NULL, protoname, NULL,
svn_io_file_del_on_pool_cleanup,
Modified: subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/load-index.c
URL: http://svn.apache.org/viewvc/subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/load-index.c?rev=1702504&r1=1702503&r2=1702504&view=diff
==============================================================================
--- subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/load-index.c (original)
+++ subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/load-index.c Fri Sep 11 15:51:30 2015
@@ -23,53 +23,152 @@
#include "svn_pools.h"
#include "private/svn_fs_fs_private.h"
+#include "private/svn_sorts_private.h"
#include "index.h"
#include "util.h"
#include "transaction.h"
+/* From the ENTRIES array of svn_fs_fs__p2l_entry_t*, sorted by offset,
+ * return the first offset behind the last item. */
+static apr_off_t
+get_max_covered(apr_array_header_t *entries)
+{
+ const svn_fs_fs__p2l_entry_t *entry;
+ if (entries->nelts == 0)
+ return -1;
+
+ entry = APR_ARRAY_IDX(entries, entries->nelts - 1,
+ const svn_fs_fs__p2l_entry_t *);
+ return entry->offset + entry->size;
+}
+
+/* Make sure that the svn_fs_fs__p2l_entry_t* in ENTRIES are consecutive
+ * and non-overlapping. Use SCRATCH_POOL for temporaries. */
+static svn_error_t *
+check_all_covered(apr_array_header_t *entries,
+ apr_pool_t *scratch_pool)
+{
+ int i;
+ apr_off_t expected = 0;
+ for (i = 0; i < entries->nelts; ++i)
+ {
+ const svn_fs_fs__p2l_entry_t *entry
+ = APR_ARRAY_IDX(entries, i, const svn_fs_fs__p2l_entry_t *);
+
+ if (entry->offset < expected)
+ return svn_error_createf(SVN_ERR_INVALID_INPUT, NULL,
+ "Overlapping index data for offset %s",
+ apr_psprintf(scratch_pool,
+ "%" APR_UINT64_T_HEX_FMT,
+ (apr_uint64_t)expected));
+
+ if (entry->offset > expected)
+ return svn_error_createf(SVN_ERR_INVALID_INPUT, NULL,
+ "Missing index data for offset %s",
+ apr_psprintf(scratch_pool,
+ "%" APR_UINT64_T_HEX_FMT,
+ (apr_uint64_t)expected));
+
+ expected = entry->offset + entry->size;
+ }
+
+ return SVN_NO_ERROR;
+}
+
+/* A svn_sort__array compatible comparator function, sorting the
+ * svn_fs_fs__p2l_entry_t** given in LHS, RHS by offset. */
+static int
+compare_p2l_entry_revision(const void *lhs,
+ const void *rhs)
+{
+ const svn_fs_fs__p2l_entry_t *lhs_entry
+ =*(const svn_fs_fs__p2l_entry_t **)lhs;
+ const svn_fs_fs__p2l_entry_t *rhs_entry
+ =*(const svn_fs_fs__p2l_entry_t **)rhs;
+
+ if (lhs_entry->offset < rhs_entry->offset)
+ return -1;
+
+ return lhs_entry->offset == rhs_entry->offset ? 0 : 1;
+}
+
svn_error_t *
svn_fs_fs__load_index(svn_fs_t *fs,
svn_revnum_t revision,
apr_array_header_t *entries,
apr_pool_t *scratch_pool)
{
- apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+ apr_pool_t *subpool = svn_pool_create(scratch_pool);
/* Check the FS format number. */
if (! svn_fs_fs__use_log_addressing(fs))
return svn_error_create(SVN_ERR_FS_UNSUPPORTED_FORMAT, NULL, NULL);
+ /* P2L index must be written in offset order.
+ * Sort ENTRIES accordingly. */
+ svn_sort__array(entries, compare_p2l_entry_revision);
+
/* Treat an empty array as a no-op instead error. */
if (entries->nelts != 0)
{
const char *l2p_proto_index;
const char *p2l_proto_index;
svn_fs_fs__revision_file_t *rev_file;
+ svn_error_t *err;
+ apr_off_t max_covered = get_max_covered(entries);
+
+ /* Ensure that the index data is complete. */
+ SVN_ERR(check_all_covered(entries, scratch_pool));
/* Open rev / pack file & trim indexes + footer off it. */
SVN_ERR(svn_fs_fs__open_pack_or_rev_file_writable(&rev_file, fs,
- revision, iterpool,
- iterpool));
- SVN_ERR(svn_fs_fs__auto_read_footer(rev_file));
- SVN_ERR(svn_io_file_trunc(rev_file->file, rev_file->l2p_offset,
- iterpool));
+ revision, subpool,
+ subpool));
+
+ /* Remove the existing index info. */
+ err = svn_fs_fs__auto_read_footer(rev_file);
+ if (err)
+ {
+ /* Even the index footer cannot be read, even less be trusted.
+ * Take the range of valid data from the new index data. */
+ svn_error_clear(err);
+ SVN_ERR(svn_io_file_trunc(rev_file->file, max_covered,
+ subpool));
+ }
+ else
+ {
+ /* We assume that the new index data covers all contents.
+ * Error out if it doesn't. The user can always truncate
+ * the file themselves. */
+ if (max_covered != rev_file->l2p_offset)
+ return svn_error_createf(SVN_ERR_INVALID_INPUT, NULL,
+ "New index data ends at %s, old index ended at %s",
+ apr_psprintf(scratch_pool, "%" APR_UINT64_T_HEX_FMT,
+ (apr_uint64_t)max_covered),
+ apr_psprintf(scratch_pool, "%" APR_UINT64_T_HEX_FMT,
+ (apr_uint64_t) rev_file->l2p_offset));
+
+ SVN_ERR(svn_io_file_trunc(rev_file->file, rev_file->l2p_offset,
+ subpool));
+ }
/* Create proto index files for the new index data
* (will be cleaned up automatically with iterpool). */
SVN_ERR(svn_fs_fs__p2l_index_from_p2l_entries(&p2l_proto_index, fs,
rev_file, entries,
- iterpool, iterpool));
+ subpool, subpool));
SVN_ERR(svn_fs_fs__l2p_index_from_p2l_entries(&l2p_proto_index, fs,
- entries, iterpool,
- iterpool));
+ entries, subpool,
+ subpool));
/* Combine rev data with new index data. */
SVN_ERR(svn_fs_fs__add_index_data(fs, rev_file->file, l2p_proto_index,
- p2l_proto_index, revision, iterpool));
+ p2l_proto_index,
+ rev_file->start_revision, subpool));
}
- svn_pool_destroy(iterpool);
+ svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
Modified: subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/lock.c
URL: http://svn.apache.org/viewvc/subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/lock.c?rev=1702504&r1=1702503&r2=1702504&view=diff
==============================================================================
--- subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/lock.c (original)
+++ subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/lock.c Fri Sep 11 15:51:30 2015
@@ -230,7 +230,7 @@ write_digest_file(apr_hash_t *children,
}
SVN_ERR(svn_stream_close(stream));
- SVN_ERR(svn_io_file_rename(tmp_path, digest_path, pool));
+ SVN_ERR(svn_io_file_rename2(tmp_path, digest_path, FALSE, pool));
SVN_ERR(svn_io_copy_perms(perms_reference, digest_path, pool));
return SVN_NO_ERROR;
}
Modified: subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/pack.c
URL: http://svn.apache.org/viewvc/subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/pack.c?rev=1702504&r1=1702503&r2=1702504&view=diff
==============================================================================
--- subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/pack.c (original)
+++ subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/pack.c Fri Sep 11 15:51:30 2015
@@ -1931,6 +1931,34 @@ pack_shard(struct pack_baton *baton,
return SVN_NO_ERROR;
}
+/* Read the youngest rev and the first non-packed rev info for FS from disk.
+ Set *FULLY_PACKED when there is no completed unpacked shard.
+ Use SCRATCH_POOL for temporary allocations.
+ */
+static svn_error_t *
+get_pack_status(svn_boolean_t *fully_packed,
+ svn_fs_t *fs,
+ apr_pool_t *scratch_pool)
+{
+ fs_fs_data_t *ffd = fs->fsap_data;
+ apr_int64_t completed_shards;
+ svn_revnum_t youngest;
+
+ SVN_ERR(svn_fs_fs__read_min_unpacked_rev(&ffd->min_unpacked_rev, fs,
+ scratch_pool));
+
+ SVN_ERR(svn_fs_fs__youngest_rev(&youngest, fs, scratch_pool));
+ completed_shards = (youngest + 1) / ffd->max_files_per_dir;
+
+ /* See if we've already completed all possible shards thus far. */
+ if (ffd->min_unpacked_rev == (completed_shards * ffd->max_files_per_dir))
+ *fully_packed = TRUE;
+ else
+ *fully_packed = FALSE;
+
+ return SVN_NO_ERROR;
+}
+
/* The work-horse for svn_fs_fs__pack, called with the FS write lock.
This implements the svn_fs_fs__with_write_lock() 'body' callback
type. BATON is a 'struct pack_baton *'.
@@ -1952,30 +1980,23 @@ pack_body(void *baton,
struct pack_baton *pb = baton;
fs_fs_data_t *ffd = pb->fs->fsap_data;
apr_int64_t completed_shards;
- svn_revnum_t youngest;
apr_pool_t *iterpool;
+ svn_boolean_t fully_packed;
- /* If the repository isn't a new enough format, we don't support packing.
- Return a friendly error to that effect. */
- if (ffd->format < SVN_FS_FS__MIN_PACKED_FORMAT)
- return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
- _("FSFS format (%d) too old to pack; please upgrade the filesystem."),
- ffd->format);
-
- /* If we aren't using sharding, we can't do any packing, so quit. */
- if (!ffd->max_files_per_dir)
- return SVN_NO_ERROR;
-
- SVN_ERR(svn_fs_fs__read_min_unpacked_rev(&ffd->min_unpacked_rev, pb->fs,
- pool));
-
- SVN_ERR(svn_fs_fs__youngest_rev(&youngest, pb->fs, pool));
- completed_shards = (youngest + 1) / ffd->max_files_per_dir;
+ /* Since another process might have already packed the repo,
+ we need to re-read the pack status. */
+ SVN_ERR(get_pack_status(&fully_packed, pb->fs, pool));
+ if (fully_packed)
+ {
+ if (pb->notify_func)
+ (*pb->notify_func)(pb->notify_baton,
+ ffd->min_unpacked_rev / ffd->max_files_per_dir,
+ svn_fs_pack_notify_noop, pool);
- /* See if we've already completed all possible shards thus far. */
- if (ffd->min_unpacked_rev == (completed_shards * ffd->max_files_per_dir))
- return SVN_NO_ERROR;
+ return SVN_NO_ERROR;
+ }
+ completed_shards = (ffd->youngest_rev_cache + 1) / ffd->max_files_per_dir;
pb->revs_dir = svn_dirent_join(pb->fs->path, PATH_REVS_DIR, pool);
if (ffd->format >= SVN_FS_FS__MIN_PACKED_REVPROP_FORMAT)
pb->revsprops_dir = svn_dirent_join(pb->fs->path, PATH_REVPROPS_DIR,
@@ -2009,7 +2030,37 @@ svn_fs_fs__pack(svn_fs_t *fs,
struct pack_baton pb = { 0 };
fs_fs_data_t *ffd = fs->fsap_data;
svn_error_t *err;
+ svn_boolean_t fully_packed;
+
+ /* If the repository isn't a new enough format, we don't support packing.
+ Return a friendly error to that effect. */
+ if (ffd->format < SVN_FS_FS__MIN_PACKED_FORMAT)
+ return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
+ _("FSFS format (%d) too old to pack; please upgrade the filesystem."),
+ ffd->format);
+
+ /* If we aren't using sharding, we can't do any packing, so quit. */
+ if (!ffd->max_files_per_dir)
+ {
+ if (notify_func)
+ (*notify_func)(notify_baton, -1, svn_fs_pack_notify_noop, pool);
+
+ return SVN_NO_ERROR;
+ }
+
+ /* Is there we even anything to do?. */
+ SVN_ERR(get_pack_status(&fully_packed, fs, pool));
+ if (fully_packed)
+ {
+ if (notify_func)
+ (*notify_func)(notify_baton,
+ ffd->min_unpacked_rev / ffd->max_files_per_dir,
+ svn_fs_pack_notify_noop, pool);
+
+ return SVN_NO_ERROR;
+ }
+ /* Lock the repo and start the pack process. */
pb.fs = fs;
pb.notify_func = notify_func;
pb.notify_baton = notify_baton;
Modified: subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/temp_serializer.c
URL: http://svn.apache.org/viewvc/subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/temp_serializer.c?rev=1702504&r1=1702503&r2=1702504&view=diff
==============================================================================
--- subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/temp_serializer.c (original)
+++ subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/temp_serializer.c Fri Sep 11 15:51:30 2015
@@ -103,9 +103,7 @@ serialize_svn_string(svn_temp_serializer
if (string == NULL)
return;
- svn_temp_serializer__push(context,
- (const void * const *)s,
- sizeof(*string));
+ svn_temp_serializer__push(context, (const void * const *)s, sizeof(**s));
/* the "string" content may actually be arbitrary binary data.
* Thus, we cannot use svn_temp_serializer__add_string. */
@@ -143,7 +141,7 @@ serialize_representation(svn_temp_serial
/* serialize the representation struct itself */
svn_temp_serializer__add_leaf(context,
(const void * const *)representation,
- sizeof(*rep));
+ sizeof(**representation));
}
/* auxiliary structure representing the content of a directory array */
@@ -191,7 +189,7 @@ serialize_dir_entry(svn_temp_serializer_
svn_temp_serializer__push(context,
(const void * const *)entry_p,
- sizeof(svn_fs_dirent_t));
+ sizeof(**entry_p));
svn_fs_fs__id_serialize(context, &entry->id);
svn_temp_serializer__add_string(context, &entry->name);
@@ -216,8 +214,9 @@ serialize_dir(svn_fs_fs__dir_data_t *dir
/* calculate sizes */
int count = entries->nelts;
apr_size_t over_provision = 2 + count / 4;
- apr_size_t entries_len = (count + over_provision) * sizeof(svn_fs_dirent_t*);
- apr_size_t lengths_len = (count + over_provision) * sizeof(apr_uint32_t);
+ apr_size_t total_count = count + over_provision;
+ apr_size_t entries_len = total_count * sizeof(*dir_data.entries);
+ apr_size_t lengths_len = total_count * sizeof(*dir_data.lengths);
/* copy the hash entries to an auxiliary struct of known layout */
dir_data.count = count;
@@ -416,7 +415,7 @@ serialize_txdelta_ops(svn_temp_serialize
/* the ops form a contiguous chunk of memory with no further references */
svn_temp_serializer__add_leaf(context,
(const void * const *)ops,
- count * sizeof(svn_txdelta_op_t));
+ count * sizeof(**ops));
}
/* Utility function to serialize W in the given serialization CONTEXT.
@@ -428,9 +427,7 @@ serialize_txdeltawindow(svn_temp_seriali
svn_txdelta_window_t *window = *w;
/* serialize the window struct itself */
- svn_temp_serializer__push(context,
- (const void * const *)w,
- sizeof(svn_txdelta_window_t));
+ svn_temp_serializer__push(context, (const void * const *)w, sizeof(**w));
/* serialize its sub-structures */
serialize_txdelta_ops(context, &window->ops, window->num_ops);
@@ -1088,7 +1085,7 @@ svn_fs_fs__serialize_rep_header(void **d
svn_fs_fs__rep_header_t *copy = apr_palloc(pool, sizeof(*copy));
*copy = *(svn_fs_fs__rep_header_t *)in;
- *data_len = sizeof(svn_fs_fs__rep_header_t);
+ *data_len = sizeof(*copy);
*data = copy;
return SVN_NO_ERROR;
Modified: subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/transaction.c
URL: http://svn.apache.org/viewvc/subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/transaction.c?rev=1702504&r1=1702503&r2=1702504&view=diff
==============================================================================
--- subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/transaction.c (original)
+++ subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/transaction.c Fri Sep 11 15:51:30 2015
@@ -89,15 +89,6 @@ path_txn_props(svn_fs_t *fs,
}
static APR_INLINE const char *
-path_txn_props_final(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
-{
- return svn_dirent_join(svn_fs_fs__path_txn_dir(fs, txn_id, pool),
- PATH_TXN_PROPS_FINAL, pool);
-}
-
-static APR_INLINE const char *
path_txn_next_ids(svn_fs_t *fs,
const svn_fs_fs__id_part_t *txn_id,
apr_pool_t *pool)
@@ -1160,24 +1151,24 @@ static svn_error_t *
set_txn_proplist(svn_fs_t *fs,
const svn_fs_fs__id_part_t *txn_id,
apr_hash_t *props,
- svn_boolean_t final,
apr_pool_t *pool)
{
- svn_stringbuf_t *buf;
- svn_stream_t *stream;
+ svn_stream_t *tmp_stream;
+ const char *tmp_path;
+ const char *final_path = path_txn_props(fs, txn_id, pool);
+
+ /* Write the new contents into a temporary file. */
+ SVN_ERR(svn_stream_open_unique(&tmp_stream, &tmp_path,
+ svn_dirent_dirname(final_path, pool),
+ svn_io_file_del_none,
+ pool, pool));
+
+ /* Replace the old file with the new one. */
+ SVN_ERR(svn_hash_write2(props, tmp_stream, SVN_HASH_TERMINATOR, pool));
+ SVN_ERR(svn_stream_close(tmp_stream));
- /* Write out the new file contents to BUF. */
- buf = svn_stringbuf_create_ensure(1024, pool);
- stream = svn_stream_from_stringbuf(buf, pool);
- SVN_ERR(svn_hash_write2(props, stream, SVN_HASH_TERMINATOR, pool));
- SVN_ERR(svn_stream_close(stream));
+ SVN_ERR(svn_io_file_rename2(tmp_path, final_path, FALSE, pool));
- /* Open the transaction properties file and write new contents to it. */
- SVN_ERR(svn_io_write_atomic((final
- ? path_txn_props_final(fs, txn_id, pool)
- : path_txn_props(fs, txn_id, pool)),
- buf->data, buf->len,
- NULL /* copy_perms_path */, pool));
return SVN_NO_ERROR;
}
@@ -1232,7 +1223,7 @@ svn_fs_fs__change_txn_props(svn_fs_txn_t
/* Create a new version of the file and write out the new props. */
/* Open the transaction properties file. */
- SVN_ERR(set_txn_proplist(txn->fs, &ftd->txn_id, txn_prop, FALSE, pool));
+ SVN_ERR(set_txn_proplist(txn->fs, &ftd->txn_id, txn_prop, pool));
return SVN_NO_ERROR;
}
@@ -3337,41 +3328,31 @@ verify_locks(svn_fs_t *fs,
return SVN_NO_ERROR;
}
-/* Return in *PATH the path to a file containing the properties that
- make up the final revision properties file. This involves setting
- svn:date and removing any temporary properties associated with the
- commit flags. */
+/* Writes final revision properties to file PATH applying permissions
+ from file PERMS_REFERENCE. This involves setting svn:date and
+ removing any temporary properties associated with the commit flags. */
static svn_error_t *
-write_final_revprop(const char **path,
+write_final_revprop(const char *path,
+ const char *perms_reference,
svn_fs_txn_t *txn,
- const svn_fs_fs__id_part_t *txn_id,
apr_pool_t *pool)
{
apr_hash_t *txnprops;
- svn_boolean_t final_mods = FALSE;
svn_string_t date;
svn_string_t *client_date;
+ apr_file_t *revprop_file;
+ svn_stream_t *stream;
SVN_ERR(svn_fs_fs__txn_proplist(&txnprops, txn, pool));
/* Remove any temporary txn props representing 'flags'. */
- if (svn_hash_gets(txnprops, SVN_FS__PROP_TXN_CHECK_OOD))
- {
- svn_hash_sets(txnprops, SVN_FS__PROP_TXN_CHECK_OOD, NULL);
- final_mods = TRUE;
- }
-
- if (svn_hash_gets(txnprops, SVN_FS__PROP_TXN_CHECK_LOCKS))
- {
- svn_hash_sets(txnprops, SVN_FS__PROP_TXN_CHECK_LOCKS, NULL);
- final_mods = TRUE;
- }
+ svn_hash_sets(txnprops, SVN_FS__PROP_TXN_CHECK_OOD, NULL);
+ svn_hash_sets(txnprops, SVN_FS__PROP_TXN_CHECK_LOCKS, NULL);
client_date = svn_hash_gets(txnprops, SVN_FS__PROP_TXN_CLIENT_DATE);
if (client_date)
{
svn_hash_sets(txnprops, SVN_FS__PROP_TXN_CLIENT_DATE, NULL);
- final_mods = TRUE;
}
/* Update commit time to ensure that svn:date revprops remain ordered if
@@ -3381,18 +3362,22 @@ write_final_revprop(const char **path,
date.data = svn_time_to_cstring(apr_time_now(), pool);
date.len = strlen(date.data);
svn_hash_sets(txnprops, SVN_PROP_REVISION_DATE, &date);
- final_mods = TRUE;
}
- if (final_mods)
- {
- SVN_ERR(set_txn_proplist(txn->fs, txn_id, txnprops, TRUE, pool));
- *path = path_txn_props_final(txn->fs, txn_id, pool);
- }
- else
- {
- *path = path_txn_props(txn->fs, txn_id, pool);
- }
+ /* Create new revprops file. Tell OS to truncate existing file,
+ since file may already exists from failed transaction. */
+ SVN_ERR(svn_io_file_open(&revprop_file, path,
+ APR_WRITE | APR_CREATE | APR_TRUNCATE
+ | APR_BUFFERED, APR_OS_DEFAULT, pool));
+
+ stream = svn_stream_from_aprfile2(revprop_file, TRUE, pool);
+ SVN_ERR(svn_hash_write2(txnprops, stream, SVN_HASH_TERMINATOR, pool));
+ SVN_ERR(svn_stream_close(stream));
+
+ SVN_ERR(svn_io_file_flush_to_disk(revprop_file, pool));
+ SVN_ERR(svn_io_file_close(revprop_file, pool));
+
+ SVN_ERR(svn_io_copy_perms(perms_reference, path, pool));
return SVN_NO_ERROR;
}
@@ -3457,7 +3442,7 @@ commit_body(void *baton, apr_pool_t *poo
struct commit_baton *cb = baton;
fs_fs_data_t *ffd = cb->fs->fsap_data;
const char *old_rev_filename, *rev_filename, *proto_filename;
- const char *revprop_filename, *final_revprop;
+ const char *revprop_filename;
const svn_fs_id_t *root_id, *new_root_id;
apr_uint64_t start_node_id;
apr_uint64_t start_copy_id;
@@ -3610,12 +3595,11 @@ commit_body(void *baton, apr_pool_t *poo
remove the transaction directory later. */
SVN_ERR(unlock_proto_rev(cb->fs, txn_id, proto_file_lockcookie, pool));
- /* Move the revprops file into place. */
+ /* Write final revprops file. */
SVN_ERR_ASSERT(! svn_fs_fs__is_packed_revprop(cb->fs, new_rev));
- SVN_ERR(write_final_revprop(&revprop_filename, cb->txn, txn_id, pool));
- final_revprop = svn_fs_fs__path_revprops(cb->fs, new_rev, pool);
- SVN_ERR(svn_fs_fs__move_into_place(revprop_filename, final_revprop,
- old_rev_filename, pool));
+ revprop_filename = svn_fs_fs__path_revprops(cb->fs, new_rev, pool);
+ SVN_ERR(write_final_revprop(revprop_filename, old_rev_filename,
+ cb->txn, pool));
/* Update the 'current' file. */
SVN_ERR(verify_as_revision_before_current_plus_plus(cb->fs, new_rev, pool));
@@ -3919,6 +3903,5 @@ svn_fs_fs__begin_txn(svn_fs_txn_t **txn_
svn_string_create("0", pool));
ftd = (*txn_p)->fsap_data;
- return svn_error_trace(set_txn_proplist(fs, &ftd->txn_id, props, FALSE,
- pool));
+ return svn_error_trace(set_txn_proplist(fs, &ftd->txn_id, props, pool));
}
Modified: subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/util.c
URL: http://svn.apache.org/viewvc/subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/util.c?rev=1702504&r1=1702503&r2=1702504&view=diff
==============================================================================
--- subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/util.c (original)
+++ subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/util.c Fri Sep 11 15:51:30 2015
@@ -639,58 +639,44 @@ svn_fs_fs__move_into_place(const char *o
svn_error_t *err;
apr_file_t *file;
-#if defined(WIN32) || defined(__OS2__)
-
- /* APR will *not* error out on Win32 if this requires a copy instead of
- of a move. */
- SVN_ERR(svn_io_file_rename(old_filename, new_filename, pool));
-
- /* Flush the target of the copy to disk. */
- SVN_ERR(svn_io_file_open(&file, new_filename, APR_WRITE,
- APR_OS_DEFAULT, pool));
- SVN_ERR(svn_io_file_flush_to_disk(file, pool));
- SVN_ERR(svn_io_file_close(file, pool));
-
/* Copying permissions is a no-op on WIN32. */
-#else
-
SVN_ERR(svn_io_copy_perms(perms_reference, old_filename, pool));
/* Move the file into place. */
- err = svn_io_file_rename(old_filename, new_filename, pool);
+ err = svn_io_file_rename2(old_filename, new_filename, TRUE, pool);
if (err && APR_STATUS_IS_EXDEV(err->apr_err))
{
/* Can't rename across devices; fall back to copying. */
svn_error_clear(err);
- err = SVN_NO_ERROR;
SVN_ERR(svn_io_copy_file(old_filename, new_filename, TRUE, pool));
- /* Flush the target of the copy to disk. */
- SVN_ERR(svn_io_file_open(&file, new_filename, APR_READ,
+ /* Flush the target of the copy to disk.
+ ### The code below is duplicates svn_io_file_rename2(), because
+ currently we don't have the svn_io_copy_file2() function with
+ a flush_to_disk argument. */
+ SVN_ERR(svn_io_file_open(&file, new_filename, APR_WRITE,
APR_OS_DEFAULT, pool));
SVN_ERR(svn_io_file_flush_to_disk(file, pool));
SVN_ERR(svn_io_file_close(file, pool));
- }
- if (err)
- return svn_error_trace(err);
-#if SVN_ON_POSIX
- {
- /* On POSIX, the file name is stored in the file's directory entry.
- Hence, we need to fsync() that directory as well.
- On other operating systems, we'd only be asking for trouble
- by trying to open and fsync a directory. */
- const char *dirname;
-
- dirname = svn_dirent_dirname(new_filename, pool);
- SVN_ERR(svn_io_file_open(&file, dirname, APR_READ, APR_OS_DEFAULT,
- pool));
- SVN_ERR(svn_io_file_flush_to_disk(file, pool));
- SVN_ERR(svn_io_file_close(file, pool));
- }
+#ifdef SVN_ON_POSIX
+ {
+ /* On POSIX, the file name is stored in the file's directory entry.
+ Hence, we need to fsync() that directory as well.
+ On other operating systems, we'd only be asking for trouble
+ by trying to open and fsync a directory. */
+ const char *dirname;
+
+ dirname = svn_dirent_dirname(new_filename, pool);
+ SVN_ERR(svn_io_file_open(&file, dirname, APR_READ, APR_OS_DEFAULT,
+ pool));
+ SVN_ERR(svn_io_file_flush_to_disk(file, pool));
+ SVN_ERR(svn_io_file_close(file, pool));
+ }
#endif
-
-#endif /* defined(WIN32) || defined(__OS2__) */
+ }
+ else if (err)
+ return svn_error_trace(err);
return SVN_NO_ERROR;
}
Modified: subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/verify.c
URL: http://svn.apache.org/viewvc/subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/verify.c?rev=1702504&r1=1702503&r2=1702504&view=diff
==============================================================================
--- subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/verify.c (original)
+++ subversion/branches/reuse-ra-session/subversion/libsvn_fs_fs/verify.c Fri Sep 11 15:51:30 2015
@@ -816,8 +816,15 @@ verify_f7_metadata_consistency(svn_fs_t
/* concurrent packing is one of the reasons why verification may fail.
Make sure, we operate on up-to-date information. */
if (err)
- SVN_ERR(svn_fs_fs__read_min_unpacked_rev(&ffd->min_unpacked_rev,
- fs, pool));
+ {
+ svn_error_t *err2
+ = svn_fs_fs__read_min_unpacked_rev(&ffd->min_unpacked_rev,
+ fs, pool);
+
+ /* Be careful to not leak ERR. */
+ if (err2)
+ return svn_error_trace(svn_error_compose_create(err, err2));
+ }
/* retry the whole shard if it got packed in the meantime */
if (err && count != pack_size(fs, revision))
Propchange: subversion/branches/reuse-ra-session/subversion/libsvn_fs_x/
------------------------------------------------------------------------------
--- svn:mergeinfo (original)
+++ svn:mergeinfo Fri Sep 11 15:51:30 2015
@@ -1,3 +1,4 @@
+/subversion/branches/1.10-cache-improvements/subversion/libsvn_fs_x:1669168-1694487
/subversion/branches/1.5.x-r30215/subversion/libsvn_fs_x:870312
/subversion/branches/1.7.x-fs-verify/subversion/libsvn_fs_x:1146708,1161180
/subversion/branches/10Gb/subversion/libsvn_fs_x:1388102,1388163-1388190,1388195,1388202,1388205,1388211,1388276,1388362,1388375,1388394,1388636,1388639-1388640,1388643-1388644,1388654,1388720,1388789,1388795,1388801,1388805,1388807,1388810,1388816,1389044,1389276,1389289,1389662,1389867,1390017,1390209,1390216,1390407,1390409,1390414,1390419,1390955
@@ -17,10 +18,11 @@
/subversion/branches/fs-rep-sharing/subversion/libsvn_fs_x:869036-873803
/subversion/branches/fsfs-format7/subversion/libsvn_fs_x:1426304,1430673,1433848,1438408,1438982,1441129,1442051,1442068,1442504,1442910,1443171,1443803,1444690,1444693,1444695,1445040,1445080,1446103,1451129,1453590,1454307,1460579,1461851,1461865,1462837,1462904,1463120,1467362,1467382,1469487,1471208,1477166,1478055,1481447,1489817,1489949,1490673-1490674,1491784,1493042,1498029,1498103,1498155,1500054
/subversion/branches/fsfs-improvements/subversion/libsvn_fs_fs:1499981-1593795
-/subversion/branches/fsfs-improvements/subversion/libsvn_fs_x:1499981-1517476
+/subversion/branches/fsfs-improvements/subversion/libsvn_fs_x:1499981-1517476,1532583,1536949,1545955,1546837
/subversion/branches/fsfs-lock-many/subversion/libsvn_fs_x:1571740-1577217
/subversion/branches/fsfs-pack/subversion/libsvn_fs_x:873717-874575
/subversion/branches/fsx/subversion/libsvn_fs_x:1507845-1508040
+/subversion/branches/fsx-1.10/subversion/libsvn_fs_x:1658219-1694500
/subversion/branches/fsx-id/subversion/libsvn_fs_x:1645603-1649011
/subversion/branches/gnome-keyring/subversion/libsvn_fs_x:870558-871410
/subversion/branches/gpg-agent-password-store/subversion/libsvn_fs_x:1005036-1150766
@@ -72,6 +74,7 @@
/subversion/branches/subtree-mergeinfo/subversion/libsvn_fs_x:876734-878766
/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x:1603509-1655900
/subversion/branches/svn-mergeinfo-enhancements/subversion/libsvn_fs_x:870119-870195,870197-870288
+/subversion/branches/svn-mergeinfo-normalizer/subversion/libsvn_fs_x:1642232-1695991
/subversion/branches/svn-patch-improvements/subversion/libsvn_fs_x:918519-934609
/subversion/branches/svn_mutex/subversion/libsvn_fs_x:1141683-1182099
/subversion/branches/svnpatch-diff/subversion/libsvn_fs_x:865738-876477
@@ -90,4 +93,4 @@
/subversion/branches/verify-keep-going/subversion/libsvn_fs_x:1439280-1492639,1546002-1546110
/subversion/branches/wc-collate-path/subversion/libsvn_fs_x:1402685-1480384
/subversion/trunk/subversion/libsvn_fs_fs:1415133-1596500,1596567,1597414,1597989,1598273,1599140,1600872,1601633,1603485-1603487,1603499,1603605,1604128,1604188,1604413-1604414,1604416-1604417,1604421,1604442,1604700,1604717,1604720,1604726,1604755,1604794,1604802,1604824,1604836,1604844,1604902-1604903,1604911,1604925,1604933,1604947,1605059-1605060,1605064-1605065,1605068,1605071-1605073,1605075,1605123,1605188-1605189,1605191,1605197,1605444,1605633,1606132,1606142,1606144,1606514,1606526,1606528,1606551,1606554,1606564,1606598-1606599,1606656,1606658,1606662,1606744,1606840,1607085,1607572,1612407,1612810,1613339,1613872,1614611,1615348,1615351-1615352,1615356,1616338-1616339,1616613,1617586,1617688,1618138,1618151,1618153,1618226,1618641,1618653,1618662,1619068,1619358,1619413,1619769,1619774,1620602,1620909,1620912,1620928,1620930,1621275,1621635,1622931,1622937,1622942,1622946,1622959-1622960,1622963,1622987,1623007,1623368,1623373,1623377,1623379,1623381,1623398,1623402,162
4011,1624265,1624512,1626246,1626871,1626873,1626886,1627497-1627498,1627502,1627947-1627949,1627966,1628083,1628093,1628158-1628159,1628161,1628392-1628393,1628415,1628427,1628676,1628738,1628762,1628764,1629854-1629855,1629857,1629865,1629873,1629875,1629879,1630067,1630070,1631049-1631051,1631075,1631115,1631171,1631180,1631185-1631186,1631196-1631197,1631239-1631240,1631548,1631550,1631563,1631567,1631588,1631598,1632646,1632776,1632849,1632851-1632853,1632856-1632857,1632868,1632908,1632926,1633232,1633617-1633618,1634872,1634875,1634879-1634880,1634920,1636478,1636483,1636629,1636644,1637184,1637186,1637330,1637358,1637363,1637393,1639319,1639322,1639335,1639348,1639352,1639355,1639358,1639414,1639419,1639426,1639430,1639436,1639440,1639549,1640061-1640062,1640197,1640915,1640966,1641013,1643139,1643233,1645567,1646021,1646712,1646716,1647537,1647540-1647541,1647820,1647905,1648230,1648238,1648241-1648243,1648253,1648272,1648532,1648537-1648539,1648542,1648591,1648612,1653608,
1658482
-/subversion/trunk/subversion/libsvn_fs_x:1414756-1686172
+/subversion/trunk/subversion/libsvn_fs_x:1414756-1702502
Modified: subversion/branches/reuse-ra-session/subversion/libsvn_fs_x/cached_data.c
URL: http://svn.apache.org/viewvc/subversion/branches/reuse-ra-session/subversion/libsvn_fs_x/cached_data.c?rev=1702504&r1=1702503&r2=1702504&view=diff
==============================================================================
--- subversion/branches/reuse-ra-session/subversion/libsvn_fs_x/cached_data.c (original)
+++ subversion/branches/reuse-ra-session/subversion/libsvn_fs_x/cached_data.c Fri Sep 11 15:51:30 2015
@@ -173,21 +173,6 @@ dgb__log_access(svn_fs_t *fs,
return SVN_NO_ERROR;
}
-/* Convenience wrapper around svn_io_file_aligned_seek, taking filesystem
- FS instead of a block size. */
-static svn_error_t *
-aligned_seek(svn_fs_t *fs,
- apr_file_t *file,
- apr_off_t *buffer_start,
- apr_off_t offset,
- apr_pool_t *scratch_pool)
-{
- svn_fs_x__data_t *ffd = fs->fsap_data;
- return svn_error_trace(svn_io_file_aligned_seek(file, ffd->block_size,
- buffer_start, offset,
- scratch_pool));
-}
-
/* Open the revision file for the item given by ID in filesystem FS and
store the newly opened file in FILE. Seek to the item's location before
returning.
@@ -207,11 +192,10 @@ open_and_seek_revision(svn_fs_x__revisio
SVN_ERR(svn_fs_x__ensure_revision_exists(rev, fs, scratch_pool));
- SVN_ERR(svn_fs_x__open_pack_or_rev_file(&rev_file, fs, rev, result_pool,
- scratch_pool));
+ SVN_ERR(svn_fs_x__rev_file_init(&rev_file, fs, rev, result_pool));
SVN_ERR(svn_fs_x__item_offset(&offset, &sub_item, fs, rev_file, id,
scratch_pool));
- SVN_ERR(aligned_seek(fs, rev_file->file, NULL, offset, scratch_pool));
+ SVN_ERR(svn_fs_x__rev_file_seek(rev_file, NULL, offset));
*file = rev_file;
@@ -233,12 +217,12 @@ open_and_seek_transaction(svn_fs_x__revi
apr_uint32_t sub_item = 0;
apr_int64_t txn_id = svn_fs_x__get_txn_id(rep->id.change_set);
- SVN_ERR(svn_fs_x__open_proto_rev_file(file, fs, txn_id, result_pool,
- scratch_pool));
+ SVN_ERR(svn_fs_x__rev_file_open_proto_rev(file, fs, txn_id, result_pool,
+ scratch_pool));
SVN_ERR(svn_fs_x__item_offset(&offset, &sub_item, fs, *file, &rep->id,
scratch_pool));
- SVN_ERR(aligned_seek(fs, (*file)->file, NULL, offset, scratch_pool));
+ SVN_ERR(svn_fs_x__rev_file_seek(*file, NULL, offset));
return SVN_NO_ERROR;
}
@@ -294,6 +278,7 @@ get_node_revision_body(svn_fs_x__noderev
if (svn_fs_x__is_txn(id->change_set))
{
apr_file_t *file;
+ svn_stream_t *stream;
/* This is a transaction node-rev. Its storage logic is very
different from that of rev / pack files. */
@@ -314,10 +299,9 @@ get_node_revision_body(svn_fs_x__noderev
return svn_error_trace(err);
}
- SVN_ERR(svn_fs_x__read_noderev(noderev_p,
- svn_stream_from_aprfile2(file,
- FALSE,
- scratch_pool),
+ /* Be sure to close the file ASAP. */
+ stream = svn_stream_from_aprfile2(file, FALSE, scratch_pool);
+ SVN_ERR(svn_fs_x__read_noderev(noderev_p, stream,
result_pool, scratch_pool));
}
else
@@ -328,8 +312,8 @@ get_node_revision_body(svn_fs_x__noderev
svn_revnum_t revision = svn_fs_x__get_revnum(id->change_set);
svn_fs_x__pair_cache_key_t key;
- SVN_ERR(svn_fs_x__open_pack_or_rev_file(&revision_file, fs, revision,
- scratch_pool, scratch_pool));
+ SVN_ERR(svn_fs_x__rev_file_init(&revision_file, fs, revision,
+ scratch_pool));
/* First, try a noderevs container cache lookup. */
if ( svn_fs_x__is_packed_rev(fs, revision)
@@ -355,16 +339,13 @@ get_node_revision_body(svn_fs_x__noderev
/* Not found or not applicable. Try a noderev cache lookup.
* If that succeeds, we are done here. */
- if (ffd->node_revision_cache)
- {
- SVN_ERR(svn_cache__get((void **) noderev_p,
- &is_cached,
- ffd->node_revision_cache,
- &key,
- result_pool));
- if (is_cached)
- return SVN_NO_ERROR;
- }
+ SVN_ERR(svn_cache__get((void **) noderev_p,
+ &is_cached,
+ ffd->node_revision_cache,
+ &key,
+ result_pool));
+ if (is_cached)
+ return SVN_NO_ERROR;
/* block-read will parse the whole block and will also return
the one noderev that we need right now. */
@@ -423,8 +404,8 @@ svn_fs_x__get_mergeinfo_count(apr_int64_
svn_revnum_t revision = svn_fs_x__get_revnum(id->change_set);
svn_fs_x__revision_file_t *rev_file;
- SVN_ERR(svn_fs_x__open_pack_or_rev_file(&rev_file, fs, revision,
- scratch_pool, scratch_pool));
+ SVN_ERR(svn_fs_x__rev_file_init(&rev_file, fs, revision,
+ scratch_pool));
if ( svn_fs_x__is_packed_rev(fs, revision)
&& ffd->noderevs_container_cache)
@@ -505,39 +486,13 @@ typedef struct rep_state_t
int chunk_index; /* number of the window to read */
} rep_state_t;
-/* Simple wrapper around svn_fs_x__get_file_offset to simplify callers. */
-static svn_error_t *
-get_file_offset(apr_off_t *offset,
- rep_state_t *rs,
- apr_pool_t *scratch_pool)
-{
- return svn_error_trace(svn_fs_x__get_file_offset(offset,
- rs->sfile->rfile->file,
- scratch_pool));
-}
-
-/* Simple wrapper around svn_io_file_aligned_seek to simplify callers. */
-static svn_error_t *
-rs_aligned_seek(rep_state_t *rs,
- apr_off_t *buffer_start,
- apr_off_t offset,
- apr_pool_t *scratch_pool)
-{
- svn_fs_x__data_t *ffd = rs->sfile->fs->fsap_data;
- return svn_error_trace(svn_io_file_aligned_seek(rs->sfile->rfile->file,
- ffd->block_size,
- buffer_start, offset,
- scratch_pool));
-}
-
/* Open FILE->FILE and FILE->STREAM if they haven't been opened, yet. */
static svn_error_t*
auto_open_shared_file(shared_file_t *file)
{
if (file->rfile == NULL)
- SVN_ERR(svn_fs_x__open_pack_or_rev_file(&file->rfile, file->fs,
- file->revision, file->pool,
- file->pool));
+ SVN_ERR(svn_fs_x__rev_file_init(&file->rfile, file->fs,
+ file->revision, file->pool));
return SVN_NO_ERROR;
}
@@ -571,9 +526,8 @@ auto_read_diff_version(rep_state_t *rs,
if (rs->ver == -1)
{
char buf[4];
- SVN_ERR(rs_aligned_seek(rs, NULL, rs->start, scratch_pool));
- SVN_ERR(svn_io_file_read_full2(rs->sfile->rfile->file, buf,
- sizeof(buf), NULL, NULL, scratch_pool));
+ SVN_ERR(svn_fs_x__rev_file_seek(rs->sfile->rfile, NULL, rs->start));
+ SVN_ERR(svn_fs_x__rev_file_read(rs->sfile->rfile, buf, sizeof(buf)));
/* ### Layering violation */
if (! ((buf[0] == 'S') && (buf[1] == 'V') && (buf[2] == 'N')))
@@ -655,7 +609,7 @@ create_rep_state_body(rep_state_t **rep_
: NULL;
/* cache lookup, i.e. skip reading the rep header if possible */
- if (ffd->rep_header_cache && SVN_IS_VALID_REVNUM(revision))
+ if (SVN_IS_VALID_REVNUM(revision))
SVN_ERR(svn_cache__get((void **) &rh, &is_cached,
ffd->rep_header_cache, &key, result_pool));
@@ -680,6 +634,8 @@ create_rep_state_body(rep_state_t **rep_
/* read rep header, if necessary */
if (!is_cached)
{
+ svn_stream_t *stream;
+
/* we will need the on-disk location for non-txn reps */
apr_off_t offset;
svn_boolean_t in_container = TRUE;
@@ -731,21 +687,21 @@ create_rep_state_body(rep_state_t **rep_
return SVN_NO_ERROR;
}
- SVN_ERR(rs_aligned_seek(rs, NULL, offset, scratch_pool));
+ SVN_ERR(svn_fs_x__rev_file_seek(rs->sfile->rfile, NULL, offset));
}
- SVN_ERR(svn_fs_x__read_rep_header(&rh, rs->sfile->rfile->stream,
+ SVN_ERR(svn_fs_x__rev_file_stream(&stream, rs->sfile->rfile));
+ SVN_ERR(svn_fs_x__read_rep_header(&rh, stream,
result_pool, scratch_pool));
- SVN_ERR(get_file_offset(&rs->start, rs, result_pool));
+ SVN_ERR(svn_fs_x__rev_file_offset(&rs->start, rs->sfile->rfile));
/* populate the cache if appropriate */
if (SVN_IS_VALID_REVNUM(revision))
{
SVN_ERR(block_read(NULL, fs, &rs->rep_id, rs->sfile->rfile,
result_pool, scratch_pool));
- if (ffd->rep_header_cache)
- SVN_ERR(svn_cache__set(ffd->rep_header_cache, &key, rh,
- scratch_pool));
+ SVN_ERR(svn_cache__set(ffd->rep_header_cache, &key, rh,
+ scratch_pool));
}
}
@@ -820,8 +776,7 @@ svn_fs_x__check_rep(svn_fs_x__representa
svn_revnum_t revision = svn_fs_x__get_revnum(rep->id.change_set);
svn_fs_x__revision_file_t *rev_file;
- SVN_ERR(svn_fs_x__open_pack_or_rev_file(&rev_file, fs, revision,
- scratch_pool, scratch_pool));
+ SVN_ERR(svn_fs_x__rev_file_init(&rev_file, fs, revision, scratch_pool));
/* Does REP->ID refer to an actual item? Which one is it? */
SVN_ERR(svn_fs_x__item_offset(&offset, &sub_item, fs, rev_file, &rep->id,
@@ -1075,22 +1030,14 @@ get_cached_window_sizes(window_sizes_t *
svn_boolean_t *is_cached,
apr_pool_t *pool)
{
- if (! rs->window_cache)
- {
- /* txdelta window has not been enabled */
- *is_cached = FALSE;
- }
- else
- {
- svn_fs_x__window_cache_key_t key = { 0 };
- SVN_ERR(svn_cache__get_partial((void **)sizes,
- is_cached,
- rs->window_cache,
- get_window_key(&key, rs),
- get_cached_window_sizes_func,
- NULL,
- pool));
- }
+ svn_fs_x__window_cache_key_t key = { 0 };
+ SVN_ERR(svn_cache__get_partial((void **)sizes,
+ is_cached,
+ rs->window_cache,
+ get_window_key(&key, rs),
+ get_cached_window_sizes_func,
+ NULL,
+ pool));
return SVN_NO_ERROR;
}
@@ -1103,33 +1050,25 @@ get_cached_window(svn_txdelta_window_t *
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
- if (! rs->window_cache)
- {
- /* txdelta window has not been enabled */
- *is_cached = FALSE;
- }
- else
- {
- /* ask the cache for the desired txdelta window */
- svn_fs_x__txdelta_cached_window_t *cached_window;
- svn_fs_x__window_cache_key_t key = { 0 };
- get_window_key(&key, rs);
- key.chunk_index = chunk_index;
- SVN_ERR(svn_cache__get((void **) &cached_window,
- is_cached,
- rs->window_cache,
- &key,
- result_pool));
-
- if (*is_cached)
- {
- /* found it. Pass it back to the caller. */
- *window_p = cached_window->window;
-
- /* manipulate the RS as if we just read the data */
- rs->current = cached_window->end_offset;
- rs->chunk_index = chunk_index;
- }
+ /* ask the cache for the desired txdelta window */
+ svn_fs_x__txdelta_cached_window_t *cached_window;
+ svn_fs_x__window_cache_key_t key = { 0 };
+ get_window_key(&key, rs);
+ key.chunk_index = chunk_index;
+ SVN_ERR(svn_cache__get((void **) &cached_window,
+ is_cached,
+ rs->window_cache,
+ &key,
+ result_pool));
+
+ if (*is_cached)
+ {
+ /* found it. Pass it back to the caller. */
+ *window_p = cached_window->window;
+
+ /* manipulate the RS as if we just read the data */
+ rs->current = cached_window->end_offset;
+ rs->chunk_index = chunk_index;
}
return SVN_NO_ERROR;
@@ -1145,23 +1084,20 @@ set_cached_window(svn_txdelta_window_t *
apr_off_t start_offset,
apr_pool_t *scratch_pool)
{
- if (rs->window_cache)
- {
- /* store the window and the first offset _past_ it */
- svn_fs_x__txdelta_cached_window_t cached_window;
- svn_fs_x__window_cache_key_t key = {0};
-
- cached_window.window = window;
- cached_window.start_offset = start_offset - rs->start;
- cached_window.end_offset = rs->current;
-
- /* but key it with the start offset because that is the known state
- * when we will look it up */
- SVN_ERR(svn_cache__set(rs->window_cache,
- get_window_key(&key, rs),
- &cached_window,
- scratch_pool));
- }
+ /* store the window and the first offset _past_ it */
+ svn_fs_x__txdelta_cached_window_t cached_window;
+ svn_fs_x__window_cache_key_t key = {0};
+
+ cached_window.window = window;
+ cached_window.start_offset = start_offset - rs->start;
+ cached_window.end_offset = rs->current;
+
+ /* but key it with the start offset because that is the known state
+ * when we will look it up */
+ SVN_ERR(svn_cache__set(rs->window_cache,
+ get_window_key(&key, rs),
+ &cached_window,
+ scratch_pool));
return SVN_NO_ERROR;
}
@@ -1178,23 +1114,13 @@ get_cached_combined_window(svn_stringbuf
svn_boolean_t *is_cached,
apr_pool_t *pool)
{
- if (! rs->combined_cache)
- {
- /* txdelta window has not been enabled */
- *is_cached = FALSE;
- }
- else
- {
- /* ask the cache for the desired txdelta window */
- svn_fs_x__window_cache_key_t key = { 0 };
- return svn_cache__get((void **)window_p,
- is_cached,
- rs->combined_cache,
- get_window_key(&key, rs),
- pool);
- }
-
- return SVN_NO_ERROR;
+ /* ask the cache for the desired txdelta window */
+ svn_fs_x__window_cache_key_t key = { 0 };
+ return svn_cache__get((void **)window_p,
+ is_cached,
+ rs->combined_cache,
+ get_window_key(&key, rs),
+ pool);
}
/* Store the WINDOW read for the rep state RS in the current FSX session's
@@ -1205,18 +1131,13 @@ set_cached_combined_window(svn_stringbuf
rep_state_t *rs,
apr_pool_t *scratch_pool)
{
- if (rs->combined_cache)
- {
- /* but key it with the start offset because that is the known state
- * when we will look it up */
- svn_fs_x__window_cache_key_t key = { 0 };
- return svn_cache__set(rs->combined_cache,
- get_window_key(&key, rs),
- window,
- scratch_pool);
- }
-
- return SVN_NO_ERROR;
+ /* but key it with the start offset because that is the known state
+ * when we will look it up */
+ svn_fs_x__window_cache_key_t key = { 0 };
+ return svn_cache__set(rs->combined_cache,
+ get_window_key(&key, rs),
+ window,
+ scratch_pool);
}
/* Build an array of rep_state structures in *LIST giving the delta
@@ -1364,6 +1285,8 @@ read_delta_window(svn_txdelta_window_t *
apr_off_t start_offset;
apr_off_t end_offset;
apr_pool_t *iterpool;
+ svn_stream_t *stream;
+ svn_fs_x__revision_file_t *file;
SVN_ERR_ASSERT(rs->chunk_index <= this_chunk);
@@ -1378,6 +1301,7 @@ read_delta_window(svn_txdelta_window_t *
/* someone has to actually read the data from file. Open it */
SVN_ERR(auto_open_shared_file(rs->sfile));
+ file = rs->sfile->rfile;
/* invoke the 'block-read' feature for non-txn data.
However, don't do that if we are in the middle of some representation,
@@ -1386,8 +1310,8 @@ read_delta_window(svn_txdelta_window_t *
&& svn_fs_x__is_revision(rs->rep_id.change_set)
&& rs->window_cache)
{
- SVN_ERR(block_read(NULL, rs->sfile->fs, &rs->rep_id,
- rs->sfile->rfile, result_pool, scratch_pool));
+ SVN_ERR(block_read(NULL, rs->sfile->fs, &rs->rep_id, file,
+ result_pool, scratch_pool));
/* reading the whole block probably also provided us with the
desired txdelta window */
@@ -1405,18 +1329,19 @@ read_delta_window(svn_txdelta_window_t *
/* RS->FILE may be shared between RS instances -> make sure we point
* to the right data. */
start_offset = rs->start + rs->current;
- SVN_ERR(rs_aligned_seek(rs, NULL, start_offset, scratch_pool));
+ SVN_ERR(svn_fs_x__rev_file_seek(file, NULL, start_offset));
/* Skip windows to reach the current chunk if we aren't there yet. */
iterpool = svn_pool_create(scratch_pool);
while (rs->chunk_index < this_chunk)
{
- apr_file_t *file = rs->sfile->rfile->file;
+ apr_file_t *apr_file;
svn_pool_clear(iterpool);
- SVN_ERR(svn_txdelta_skip_svndiff_window(file, rs->ver, iterpool));
+ SVN_ERR(svn_fs_x__rev_file_get(&apr_file, file));
+ SVN_ERR(svn_txdelta_skip_svndiff_window(apr_file, rs->ver, iterpool));
rs->chunk_index++;
- SVN_ERR(svn_fs_x__get_file_offset(&start_offset, file, iterpool));
+ SVN_ERR(svn_fs_x__get_file_offset(&start_offset, apr_file, iterpool));
rs->current = start_offset - rs->start;
if (rs->current >= rs->size)
@@ -1428,9 +1353,10 @@ read_delta_window(svn_txdelta_window_t *
svn_pool_destroy(iterpool);
/* Actually read the next window. */
- SVN_ERR(svn_txdelta_read_svndiff_window(nwin, rs->sfile->rfile->stream,
- rs->ver, result_pool));
- SVN_ERR(get_file_offset(&end_offset, rs, scratch_pool));
+ SVN_ERR(svn_fs_x__rev_file_stream(&stream, file));
+ SVN_ERR(svn_txdelta_read_svndiff_window(nwin, stream, rs->ver,
+ result_pool));
+ SVN_ERR(svn_fs_x__rev_file_offset(&end_offset, file));
rs->current = end_offset - rs->start;
if (rs->current > rs->size)
return svn_error_create(SVN_ERR_FS_CORRUPT, NULL,
@@ -1458,24 +1384,21 @@ read_container_window(svn_stringbuf_t **
svn_fs_x__data_t *ffd = fs->fsap_data;
svn_fs_x__pair_cache_key_t key;
svn_revnum_t revision = svn_fs_x__get_revnum(rs->rep_id.change_set);
+ svn_boolean_t is_cached = FALSE;
+ svn_fs_x__reps_baton_t baton;
SVN_ERR(auto_set_start_offset(rs, scratch_pool));
key.revision = svn_fs_x__packed_base_rev(fs, revision);
key.second = rs->start;
/* already in cache? */
- if (ffd->reps_container_cache)
- {
- svn_boolean_t is_cached = FALSE;
- svn_fs_x__reps_baton_t baton;
- baton.fs = fs;
- baton.idx = rs->sub_item;
-
- SVN_ERR(svn_cache__get_partial((void**)&extractor, &is_cached,
- ffd->reps_container_cache, &key,
- svn_fs_x__reps_get_func, &baton,
- result_pool));
- }
+ baton.fs = fs;
+ baton.idx = rs->sub_item;
+
+ SVN_ERR(svn_cache__get_partial((void**)&extractor, &is_cached,
+ ffd->reps_container_cache, &key,
+ svn_fs_x__reps_get_func, &baton,
+ result_pool));
/* read from disk, if necessary */
if (extractor == NULL)
@@ -1690,23 +1613,23 @@ cache_windows(svn_filesize_t *fulltext_l
else
{
svn_txdelta_window_t *window;
+ svn_fs_x__revision_file_t *file = rs->sfile->rfile;
+ svn_stream_t *stream;
apr_off_t start_offset = rs->start + rs->current;
apr_off_t end_offset;
apr_off_t block_start;
/* navigate to & read the current window */
- SVN_ERR(rs_aligned_seek(rs, &block_start, start_offset, iterpool));
- SVN_ERR(svn_txdelta_read_svndiff_window(&window,
- rs->sfile->rfile->stream,
- rs->ver, iterpool));
+ SVN_ERR(svn_fs_x__rev_file_stream(&stream, file));
+ SVN_ERR(svn_fs_x__rev_file_seek(file, &block_start, start_offset));
+ SVN_ERR(svn_txdelta_read_svndiff_window(&window, stream, rs->ver,
+ iterpool));
/* aggregate expanded window size */
*fulltext_len += window->tview_len;
/* determine on-disk window size */
- SVN_ERR(svn_fs_x__get_file_offset(&end_offset,
- rs->sfile->rfile->file,
- iterpool));
+ SVN_ERR(svn_fs_x__rev_file_offset(&end_offset, rs->sfile->rfile));
rs->current = end_offset - rs->start;
if (rs->current > rs->size)
return svn_error_create(SVN_ERR_FS_CORRUPT, NULL,
@@ -1735,25 +1658,22 @@ cache_windows(svn_filesize_t *fulltext_l
static svn_error_t *
read_rep_header(svn_fs_x__rep_header_t **rep_header,
svn_fs_t *fs,
- svn_stream_t *stream,
+ svn_fs_x__revision_file_t *file,
svn_fs_x__representation_cache_key_t *key,
apr_pool_t *pool)
{
svn_fs_x__data_t *ffd = fs->fsap_data;
+ svn_stream_t *stream;
svn_boolean_t is_cached = FALSE;
- if (ffd->rep_header_cache)
- {
- SVN_ERR(svn_cache__get((void**)rep_header, &is_cached,
- ffd->rep_header_cache, key, pool));
- if (is_cached)
- return SVN_NO_ERROR;
- }
+ SVN_ERR(svn_cache__get((void**)rep_header, &is_cached,
+ ffd->rep_header_cache, key, pool));
+ if (is_cached)
+ return SVN_NO_ERROR;
+ SVN_ERR(svn_fs_x__rev_file_stream(&stream, file));
SVN_ERR(svn_fs_x__read_rep_header(rep_header, stream, pool, pool));
-
- if (ffd->rep_header_cache)
- SVN_ERR(svn_cache__set(ffd->rep_header_cache, key, *rep_header, pool));
+ SVN_ERR(svn_cache__set(ffd->rep_header_cache, key, *rep_header, pool));
return SVN_NO_ERROR;
}
@@ -1779,8 +1699,7 @@ svn_fs_x__get_representation_length(svn_
key.revision = svn_fs_x__get_revnum(entry->items[0].change_set);
key.is_packed = svn_fs_x__is_packed_rev(fs, key.revision);
key.item_index = entry->items[0].number;
- SVN_ERR(read_rep_header(&rep_header, fs, rev_file->stream, &key,
- scratch_pool));
+ SVN_ERR(read_rep_header(&rep_header, fs, rev_file, &key, scratch_pool));
/* prepare representation reader state (rs) structure */
SVN_ERR(init_rep_state(&rs, rep_header, fs, rev_file, entry,
@@ -2186,7 +2105,7 @@ svn_fs_x__get_contents(svn_stream_t **co
/* Make the stream attempt fulltext cache lookups if the fulltext
* is cacheable. If it is not, then also don't try to buffer and
* cache it. */
- if (ffd->fulltext_cache && cache_fulltext
+ if ( cache_fulltext
&& SVN_IS_VALID_REVNUM(revision)
&& fulltext_size_is_cachable(ffd, len))
{
@@ -2257,8 +2176,7 @@ svn_fs_x__try_process_file_contents(svn_
fulltext_cache_key.revision = svn_fs_x__get_revnum(rep->id.change_set);
fulltext_cache_key.second = rep->id.number;
- if (ffd->fulltext_cache
- && SVN_IS_VALID_REVNUM(fulltext_cache_key.revision)
+ if ( SVN_IS_VALID_REVNUM(fulltext_cache_key.revision)
&& fulltext_size_is_cachable(ffd, rep->expanded_size))
{
cache_access_wrapper_baton_t wrapper_baton;
@@ -2344,12 +2262,11 @@ svn_fs_x__get_file_delta_stream(svn_txde
svn_stream_t *source_stream, *target_stream;
rep_state_t *rep_state;
svn_fs_x__rep_header_t *rep_header;
- svn_fs_x__data_t *ffd = fs->fsap_data;
/* Try a shortcut: if the target is stored as a delta against the source,
then just use that delta. However, prefer using the fulltext cache
whenever that is available. */
- if (target->data_rep && (source || !ffd->fulltext_cache))
+ if (target->data_rep && source)
{
/* Read target's base rep if any. */
SVN_ERR(create_rep_state(&rep_state, &rep_header, NULL,
@@ -2654,23 +2571,19 @@ svn_fs_x__rep_contents_dir(apr_array_hea
/* find the cache we may use */
svn_cache__t *cache = locate_dir_cache(fs, &key, noderev);
- if (cache)
- {
- svn_boolean_t found;
+ svn_boolean_t found;
- SVN_ERR(svn_cache__get((void **)entries_p, &found, cache, &key,
- result_pool));
- if (found)
- return SVN_NO_ERROR;
- }
+ SVN_ERR(svn_cache__get((void **)entries_p, &found, cache, &key,
+ result_pool));
+ if (found)
+ return SVN_NO_ERROR;
/* Read in the directory contents. */
SVN_ERR(get_dir_contents(entries_p, fs, noderev, result_pool,
scratch_pool));
/* Update the cache, if we are to use one. */
- if (cache)
- SVN_ERR(svn_cache__set(cache, &key, *entries_p, scratch_pool));
+ SVN_ERR(svn_cache__set(cache, &key, *entries_p, scratch_pool));
return SVN_NO_ERROR;
}
@@ -2699,25 +2612,22 @@ svn_fs_x__rep_contents_dir_entry(svn_fs_
/* find the cache we may use */
svn_fs_x__id_t key;
svn_cache__t *cache = locate_dir_cache(fs, &key, noderev);
- if (cache)
- {
- svn_fs_x__ede_baton_t baton;
- baton.hint = *hint;
- baton.name = name;
-
- /* Cache lookup. */
- SVN_ERR(svn_cache__get_partial((void **)dirent,
- &found,
- cache,
- &key,
- svn_fs_x__extract_dir_entry,
- &baton,
- result_pool));
-
- /* Remember the new clue only if we found something at that spot. */
- if (found)
- *hint = baton.hint;
- }
+ svn_fs_x__ede_baton_t baton;
+ baton.hint = *hint;
+ baton.name = name;
+
+ /* Cache lookup. */
+ SVN_ERR(svn_cache__get_partial((void **)dirent,
+ &found,
+ cache,
+ &key,
+ svn_fs_x__extract_dir_entry,
+ &baton,
+ result_pool));
+
+ /* Remember the new clue only if we found something at that spot. */
+ if (found)
+ *hint = baton.hint;
/* fetch data from disk if we did not find it in the cache */
if (! found)
@@ -2778,7 +2688,7 @@ svn_fs_x__get_proplist(apr_hash_t **prop
key.revision = svn_fs_x__get_revnum(rep->id.change_set);
key.second = rep->id.number;
- if (ffd->properties_cache && SVN_IS_VALID_REVNUM(key.revision))
+ if (SVN_IS_VALID_REVNUM(key.revision))
{
svn_boolean_t is_cached;
SVN_ERR(svn_cache__get((void **) proplist_p, &is_cached,
@@ -2794,7 +2704,7 @@ svn_fs_x__get_proplist(apr_hash_t **prop
result_pool));
SVN_ERR(svn_stream_close(stream));
- if (ffd->properties_cache && SVN_IS_VALID_REVNUM(rep->id.change_set))
+ if (SVN_IS_VALID_REVNUM(rep->id.change_set))
SVN_ERR(svn_cache__set(ffd->properties_cache, &key, proplist,
scratch_pool));
}
@@ -2829,12 +2739,11 @@ svn_fs_x__get_changes(apr_array_header_t
/* Provide revision file. */
SVN_ERR(svn_fs_x__ensure_revision_exists(rev, fs, scratch_pool));
- SVN_ERR(svn_fs_x__open_pack_or_rev_file(&revision_file, fs, rev,
- scratch_pool, scratch_pool));
+ SVN_ERR(svn_fs_x__rev_file_init(&revision_file, fs, rev, scratch_pool));
/* try cache lookup first */
- if (ffd->changes_container_cache && svn_fs_x__is_packed_rev(fs, rev))
+ if (svn_fs_x__is_packed_rev(fs, rev))
{
apr_off_t offset;
apr_uint32_t sub_item;
@@ -2850,15 +2759,11 @@ svn_fs_x__get_changes(apr_array_header_t
svn_fs_x__changes_get_list_func,
&sub_item, result_pool));
}
- else if (ffd->changes_cache)
+ else
{
SVN_ERR(svn_cache__get((void **) changes, &found, ffd->changes_cache,
&rev, result_pool));
}
- else
- {
- found = FALSE;
- }
if (!found)
{
@@ -2890,20 +2795,16 @@ block_read_contents(svn_fs_t *fs,
apr_off_t max_offset,
apr_pool_t *scratch_pool)
{
- svn_fs_x__data_t *ffd = fs->fsap_data;
svn_fs_x__representation_cache_key_t header_key = { 0 };
rep_state_t rs = { 0 };
svn_filesize_t fulltext_len;
svn_fs_x__rep_header_t *rep_header;
- if (!ffd->txdelta_window_cache || !ffd->combined_window_cache)
- return SVN_NO_ERROR;
-
header_key.revision = (apr_int32_t)key->revision;
header_key.is_packed = svn_fs_x__is_packed_rev(fs, header_key.revision);
header_key.item_index = key->second;
- SVN_ERR(read_rep_header(&rep_header, fs, rev_file->stream, &header_key,
+ SVN_ERR(read_rep_header(&rep_header, fs, rev_file, &header_key,
scratch_pool));
SVN_ERR(init_rep_state(&rs, rep_header, fs, rev_file, entry, scratch_pool));
SVN_ERR(cache_windows(&fulltext_len, fs, &rs, max_offset, scratch_pool));
@@ -2930,8 +2831,7 @@ read_item(svn_stream_t **stream,
svn_stringbuf_t *text = svn_stringbuf_create_ensure(entry->size, pool);
text->len = entry->size;
text->data[text->len] = 0;
- SVN_ERR(svn_io_file_read_full2(rev_file->file, text->data, text->len,
- NULL, NULL, pool));
+ SVN_ERR(svn_fs_x__rev_file_read(rev_file, text->data, text->len));
/* Return (construct, calculate) stream and checksum. */
*stream = svn_stream_from_stringbuf(text, pool);
@@ -2976,14 +2876,13 @@ block_read_changes(apr_array_header_t **
svn_fs_x__data_t *ffd = fs->fsap_data;
svn_stream_t *stream;
svn_revnum_t revision = svn_fs_x__get_revnum(entry->items[0].change_set);
- if (!must_read && !ffd->changes_cache)
- return SVN_NO_ERROR;
+ apr_size_t estimated_size;
/* we don't support containers, yet */
SVN_ERR_ASSERT(entry->item_count == 1);
/* already in cache? */
- if (!must_read && ffd->changes_cache)
+ if (!must_read)
{
svn_boolean_t is_cached = FALSE;
SVN_ERR(svn_cache__has_key(&is_cached, ffd->changes_cache, &revision,
@@ -2995,24 +2894,20 @@ block_read_changes(apr_array_header_t **
SVN_ERR(read_item(&stream, fs, rev_file, entry, scratch_pool));
/* read changes from revision file */
-
SVN_ERR(svn_fs_x__read_changes(changes, stream, result_pool, scratch_pool));
/* cache for future reference */
- if (ffd->changes_cache)
- {
- /* Guesstimate for the size of the in-cache representation. */
- apr_size_t estimated_size = (apr_size_t)250 * (*changes)->nelts;
+ /* Guesstimate for the size of the in-cache representation. */
+ estimated_size = (apr_size_t)250 * (*changes)->nelts;
- /* Don't even serialize data that probably won't fit into the
- * cache. This often implies that either CHANGES is very
- * large, memory is scarce or both. Having a huge temporary
- * copy would not be a good thing in either case. */
- if (svn_cache__is_cachable(ffd->changes_cache, estimated_size))
- SVN_ERR(svn_cache__set(ffd->changes_cache, &revision, *changes,
- scratch_pool));
- }
+ /* Don't even serialize data that probably won't fit into the
+ * cache. This often implies that either CHANGES is very
+ * large, memory is scarce or both. Having a huge temporary
+ * copy would not be a good thing in either case. */
+ if (svn_cache__is_cachable(ffd->changes_cache, estimated_size))
+ SVN_ERR(svn_cache__set(ffd->changes_cache, &revision, *changes,
+ scratch_pool));
return SVN_NO_ERROR;
}
@@ -3037,7 +2932,7 @@ block_read_changes_container(apr_array_h
key.second = entry->offset;
/* already in cache? */
- if (!must_read && ffd->changes_container_cache)
+ if (!must_read)
{
svn_boolean_t is_cached = FALSE;
SVN_ERR(svn_cache__has_key(&is_cached, ffd->changes_container_cache,
@@ -3058,10 +2953,8 @@ block_read_changes_container(apr_array_h
if (must_read)
SVN_ERR(svn_fs_x__changes_get_list(changes, container, sub_item,
result_pool));
-
- if (ffd->changes_container_cache)
- SVN_ERR(svn_cache__set(ffd->changes_container_cache, &key, container,
- scratch_pool));
+ SVN_ERR(svn_cache__set(ffd->changes_container_cache, &key, container,
+ scratch_pool));
return SVN_NO_ERROR;
}
@@ -3078,14 +2971,12 @@ block_read_noderev(svn_fs_x__noderev_t *
{
svn_fs_x__data_t *ffd = fs->fsap_data;
svn_stream_t *stream;
- if (!must_read && !ffd->node_revision_cache)
- return SVN_NO_ERROR;
/* we don't support containers, yet */
SVN_ERR_ASSERT(entry->item_count == 1);
/* already in cache? */
- if (!must_read && ffd->node_revision_cache)
+ if (!must_read)
{
svn_boolean_t is_cached = FALSE;
SVN_ERR(svn_cache__has_key(&is_cached, ffd->node_revision_cache, key,
@@ -3100,9 +2991,8 @@ block_read_noderev(svn_fs_x__noderev_t *
SVN_ERR(svn_fs_x__read_noderev(noderev_p, stream, result_pool,
scratch_pool));
- if (ffd->node_revision_cache)
- SVN_ERR(svn_cache__set(ffd->node_revision_cache, key, *noderev_p,
- scratch_pool));
+ SVN_ERR(svn_cache__set(ffd->node_revision_cache, key, *noderev_p,
+ scratch_pool));
return SVN_NO_ERROR;
}
@@ -3127,7 +3017,7 @@ block_read_noderevs_container(svn_fs_x__
key.second = entry->offset;
/* already in cache? */
- if (!must_read && ffd->noderevs_container_cache)
+ if (!must_read)
{
svn_boolean_t is_cached = FALSE;
SVN_ERR(svn_cache__has_key(&is_cached, ffd->noderevs_container_cache,
@@ -3147,9 +3037,8 @@ block_read_noderevs_container(svn_fs_x__
SVN_ERR(svn_fs_x__noderevs_get(noderev_p, container, sub_item,
result_pool));
- if (ffd->noderevs_container_cache)
- SVN_ERR(svn_cache__set(ffd->noderevs_container_cache, &key, container,
- scratch_pool));
+ SVN_ERR(svn_cache__set(ffd->noderevs_container_cache, &key, container,
+ scratch_pool));
return SVN_NO_ERROR;
}
@@ -3174,7 +3063,7 @@ block_read_reps_container(svn_fs_x__rep_
key.second = entry->offset;
/* already in cache? */
- if (!must_read && ffd->reps_container_cache)
+ if (!must_read)
{
svn_boolean_t is_cached = FALSE;
SVN_ERR(svn_cache__has_key(&is_cached, ffd->reps_container_cache,
@@ -3195,9 +3084,8 @@ block_read_reps_container(svn_fs_x__rep_
SVN_ERR(svn_fs_x__reps_get(extractor, fs, container, sub_item,
result_pool));
- if (ffd->noderevs_container_cache)
- SVN_ERR(svn_cache__set(ffd->reps_container_cache, &key, container,
- scratch_pool));
+ SVN_ERR(svn_cache__set(ffd->reps_container_cache, &key, container,
+ scratch_pool));
return SVN_NO_ERROR;
}
@@ -3232,8 +3120,7 @@ block_read(void **result,
do
{
/* fetch list of items in the block surrounding OFFSET */
- SVN_ERR(aligned_seek(fs, revision_file->file, &block_start, offset,
- iterpool));
+ SVN_ERR(svn_fs_x__rev_file_seek(revision_file, &block_start, offset));
SVN_ERR(svn_fs_x__p2l_index_lookup(&entries, fs, revision_file,
revision, block_start,
ffd->block_size, scratch_pool,
@@ -3272,8 +3159,8 @@ block_read(void **result,
key.revision = svn_fs_x__get_revnum(entry->items[0].change_set);
key.second = entry->items[0].number;
- SVN_ERR(svn_io_file_seek(revision_file->file, SEEK_SET,
- &entry->offset, iterpool));
+ SVN_ERR(svn_fs_x__rev_file_seek(revision_file, NULL,
+ entry->offset));
switch (entry->type)
{
case SVN_FS_X__ITEM_TYPE_FILE_REP:
@@ -3289,11 +3176,10 @@ block_read(void **result,
break;
case SVN_FS_X__ITEM_TYPE_NODEREV:
- if (ffd->node_revision_cache || is_result)
- SVN_ERR(block_read_noderev((svn_fs_x__noderev_t **)&item,
- fs, revision_file,
- entry, &key, is_result,
- pool, iterpool));
+ SVN_ERR(block_read_noderev((svn_fs_x__noderev_t **)&item,
+ fs, revision_file,
+ entry, &key, is_result,
+ pool, iterpool));
break;
case SVN_FS_X__ITEM_TYPE_CHANGES:
Modified: subversion/branches/reuse-ra-session/subversion/libsvn_fs_x/cached_data.h
URL: http://svn.apache.org/viewvc/subversion/branches/reuse-ra-session/subversion/libsvn_fs_x/cached_data.h?rev=1702504&r1=1702503&r2=1702504&view=diff
==============================================================================
--- subversion/branches/reuse-ra-session/subversion/libsvn_fs_x/cached_data.h (original)
+++ subversion/branches/reuse-ra-session/subversion/libsvn_fs_x/cached_data.h Fri Sep 11 15:51:30 2015
@@ -20,8 +20,8 @@
* ====================================================================
*/
-#ifndef SVN_LIBSVN_FS__CACHED_DATA_H
-#define SVN_LIBSVN_FS__CACHED_DATA_H
+#ifndef SVN_LIBSVN_FS_X_CACHED_DATA_H
+#define SVN_LIBSVN_FS_X_CACHED_DATA_H
#include "svn_pools.h"
#include "svn_fs.h"