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"
