diff options
Diffstat (limited to 'subversion/libsvn_fs_fs')
| -rw-r--r-- | subversion/libsvn_fs_fs/caching.c | 20 | ||||
| -rw-r--r-- | subversion/libsvn_fs_fs/fs_fs.c | 137 | ||||
| -rw-r--r-- | subversion/libsvn_fs_fs/rep-cache-db.h | 2 | ||||
| -rw-r--r-- | subversion/libsvn_fs_fs/tree.c | 205 |
4 files changed, 130 insertions, 234 deletions
diff --git a/subversion/libsvn_fs_fs/caching.c b/subversion/libsvn_fs_fs/caching.c index 4af48b85807ce..42898cb6ec6bc 100644 --- a/subversion/libsvn_fs_fs/caching.c +++ b/subversion/libsvn_fs_fs/caching.c @@ -89,7 +89,7 @@ read_config(svn_memcache_t **memcache_p, fs_fs_data_t *ffd = fs->fsap_data; SVN_ERR(svn_cache__make_memcache_from_config(memcache_p, ffd->config, - fs->pool)); + fs->pool)); /* No cache namespace by default. I.e. all FS instances share the * cached data. If you specify different namespaces, the data will @@ -129,23 +129,9 @@ read_config(svn_memcache_t **memcache_p, SVN_FS_CONFIG_FSFS_CACHE_FULLTEXTS, TRUE); - /* don't cache revprops by default. - * Revprop caching significantly speeds up operations like - * svn ls -v. However, it requires synchronization that may - * not be available or efficient in the current server setup. - * - * If the caller chose option "2", enable revprop caching if - * the required API support is there to make it efficient. + /* For now, always disable revprop caching. */ - if (strcmp(svn_hash__get_cstring(fs->config, - SVN_FS_CONFIG_FSFS_CACHE_REVPROPS, - ""), "2")) - *cache_revprops - = svn_hash__get_bool(fs->config, - SVN_FS_CONFIG_FSFS_CACHE_REVPROPS, - FALSE); - else - *cache_revprops = svn_named_atomic__is_efficient(); + *cache_revprops = FALSE; return svn_config_get_bool(ffd->config, fail_stop, CONFIG_SECTION_CACHES, CONFIG_OPTION_FAIL_STOP, diff --git a/subversion/libsvn_fs_fs/fs_fs.c b/subversion/libsvn_fs_fs/fs_fs.c index 89816a8bcb6f3..82acb3c96111c 100644 --- a/subversion/libsvn_fs_fs/fs_fs.c +++ b/subversion/libsvn_fs_fs/fs_fs.c @@ -3988,17 +3988,23 @@ write_non_packed_revprop(const char **final_path, apr_hash_t *proplist, apr_pool_t *pool) { + apr_file_t *file; svn_stream_t *stream; *final_path = path_revprops(fs, rev, pool); /* ### do we have a directory sitting around already? we really shouldn't ### have to get the dirname here. */ - SVN_ERR(svn_stream_open_unique(&stream, tmp_path, - svn_dirent_dirname(*final_path, pool), - svn_io_file_del_none, pool, pool)); + SVN_ERR(svn_io_open_unique_file3(&file, tmp_path, + svn_dirent_dirname(*final_path, pool), + svn_io_file_del_none, pool, pool)); + stream = svn_stream_from_aprfile2(file, TRUE, pool); SVN_ERR(svn_hash_write2(proplist, stream, SVN_HASH_TERMINATOR, pool)); SVN_ERR(svn_stream_close(stream)); + /* Flush temporary file to disk and close it. */ + SVN_ERR(svn_io_file_flush_to_disk(file, pool)); + SVN_ERR(svn_io_file_close(file, pool)); + return SVN_NO_ERROR; } @@ -4085,7 +4091,7 @@ serialize_revprops_header(svn_stream_t *stream, return SVN_NO_ERROR; } -/* Writes the a pack file to FILE_STREAM. It copies the serialized data +/* Writes the a pack file to FILE. It copies the serialized data * from REVPROPS for the indexes [START,END) except for index CHANGED_INDEX. * * The data for the latter is taken from NEW_SERIALIZED. Note, that @@ -4103,7 +4109,7 @@ repack_revprops(svn_fs_t *fs, int changed_index, svn_stringbuf_t *new_serialized, apr_off_t new_total_size, - svn_stream_t *file_stream, + apr_file_t *file, apr_pool_t *pool) { fs_fs_data_t *ffd = fs->fsap_data; @@ -4151,9 +4157,11 @@ repack_revprops(svn_fs_t *fs, ? SVN_DELTA_COMPRESSION_LEVEL_DEFAULT : SVN_DELTA_COMPRESSION_LEVEL_NONE)); - /* finally, write the content to the target stream and close it */ - SVN_ERR(svn_stream_write(file_stream, compressed->data, &compressed->len)); - SVN_ERR(svn_stream_close(file_stream)); + /* finally, write the content to the target file, flush and close it */ + SVN_ERR(svn_io_file_write_full(file, compressed->data, compressed->len, + NULL, pool)); + SVN_ERR(svn_io_file_flush_to_disk(file, pool)); + SVN_ERR(svn_io_file_close(file, pool)); return SVN_NO_ERROR; } @@ -4161,23 +4169,22 @@ repack_revprops(svn_fs_t *fs, /* Allocate a new pack file name for revisions * [REVPROPS->START_REVISION + START, REVPROPS->START_REVISION + END - 1] * of REVPROPS->MANIFEST. Add the name of old file to FILES_TO_DELETE, - * auto-create that array if necessary. Return an open file stream to - * the new file in *STREAM allocated in POOL. + * auto-create that array if necessary. Return an open file *FILE that is + * allocated in POOL. */ static svn_error_t * -repack_stream_open(svn_stream_t **stream, - svn_fs_t *fs, - packed_revprops_t *revprops, - int start, - int end, - apr_array_header_t **files_to_delete, - apr_pool_t *pool) +repack_file_open(apr_file_t **file, + svn_fs_t *fs, + packed_revprops_t *revprops, + int start, + int end, + apr_array_header_t **files_to_delete, + apr_pool_t *pool) { apr_int64_t tag; const char *tag_string; svn_string_t *new_filename; int i; - apr_file_t *file; int manifest_offset = (int)(revprops->start_revision - revprops->manifest_start); @@ -4209,12 +4216,11 @@ repack_stream_open(svn_stream_t **stream, APR_ARRAY_IDX(revprops->manifest, i + manifest_offset, const char*) = new_filename->data; - /* create a file stream for the new file */ - SVN_ERR(svn_io_file_open(&file, svn_dirent_join(revprops->folder, - new_filename->data, - pool), + /* open the file */ + SVN_ERR(svn_io_file_open(file, svn_dirent_join(revprops->folder, + new_filename->data, + pool), APR_WRITE | APR_CREATE, APR_OS_DEFAULT, pool)); - *stream = svn_stream_from_aprfile2(file, FALSE, pool); return SVN_NO_ERROR; } @@ -4238,6 +4244,7 @@ write_packed_revprop(const char **final_path, packed_revprops_t *revprops; apr_int64_t generation = 0; svn_stream_t *stream; + apr_file_t *file; svn_stringbuf_t *serialized; apr_off_t new_total_size; int changed_index; @@ -4273,11 +4280,11 @@ write_packed_revprop(const char **final_path, *final_path = svn_dirent_join(revprops->folder, revprops->filename, pool); - SVN_ERR(svn_stream_open_unique(&stream, tmp_path, revprops->folder, - svn_io_file_del_none, pool, pool)); + SVN_ERR(svn_io_open_unique_file3(&file, tmp_path, revprops->folder, + svn_io_file_del_none, pool, pool)); SVN_ERR(repack_revprops(fs, revprops, 0, revprops->sizes->nelts, changed_index, serialized, new_total_size, - stream, pool)); + file, pool)); } else { @@ -4323,50 +4330,53 @@ write_packed_revprop(const char **final_path, /* write the new, split files */ if (left_count) { - SVN_ERR(repack_stream_open(&stream, fs, revprops, 0, - left_count, files_to_delete, pool)); + SVN_ERR(repack_file_open(&file, fs, revprops, 0, + left_count, files_to_delete, pool)); SVN_ERR(repack_revprops(fs, revprops, 0, left_count, changed_index, serialized, new_total_size, - stream, pool)); + file, pool)); } if (left_count + right_count < revprops->sizes->nelts) { - SVN_ERR(repack_stream_open(&stream, fs, revprops, changed_index, - changed_index + 1, files_to_delete, - pool)); + SVN_ERR(repack_file_open(&file, fs, revprops, changed_index, + changed_index + 1, files_to_delete, + pool)); SVN_ERR(repack_revprops(fs, revprops, changed_index, changed_index + 1, changed_index, serialized, new_total_size, - stream, pool)); + file, pool)); } if (right_count) { - SVN_ERR(repack_stream_open(&stream, fs, revprops, - revprops->sizes->nelts - right_count, - revprops->sizes->nelts, - files_to_delete, pool)); + SVN_ERR(repack_file_open(&file, fs, revprops, + revprops->sizes->nelts - right_count, + revprops->sizes->nelts, + files_to_delete, pool)); SVN_ERR(repack_revprops(fs, revprops, revprops->sizes->nelts - right_count, revprops->sizes->nelts, changed_index, - serialized, new_total_size, stream, + serialized, new_total_size, file, pool)); } /* write the new manifest */ *final_path = svn_dirent_join(revprops->folder, PATH_MANIFEST, pool); - SVN_ERR(svn_stream_open_unique(&stream, tmp_path, revprops->folder, - svn_io_file_del_none, pool, pool)); + SVN_ERR(svn_io_open_unique_file3(&file, tmp_path, revprops->folder, + svn_io_file_del_none, pool, pool)); for (i = 0; i < revprops->manifest->nelts; ++i) { const char *filename = APR_ARRAY_IDX(revprops->manifest, i, const char*); - SVN_ERR(svn_stream_printf(stream, pool, "%s\n", filename)); + SVN_ERR(svn_io_file_write_full(file, filename, strlen(filename), + NULL, pool)); + SVN_ERR(svn_io_file_putc('\n', file, pool)); } - SVN_ERR(svn_stream_close(stream)); + SVN_ERR(svn_io_file_flush_to_disk(file, pool)); + SVN_ERR(svn_io_file_close(file, pool)); } return SVN_NO_ERROR; @@ -5062,9 +5072,11 @@ get_combined_window(svn_stringbuf_t **result, /* Maybe, we've got a PLAIN start representation. If we do, read as much data from it as the needed for the txdelta window's source view. - Note that BUF / SOURCE may only be NULL in the first iteration. */ + Note that BUF / SOURCE may only be NULL in the first iteration. + Also note that we may have short-cut reading the delta chain -- + in which case SRC_OPS is 0 and it might not be a PLAIN rep. */ source = buf; - if (source == NULL && rb->src_state != NULL) + if (source == NULL && rb->src_state != NULL && window->src_ops) SVN_ERR(read_plain_window(&source, rb->src_state, window->sview_len, pool)); @@ -6966,8 +6978,13 @@ svn_fs_fs__set_entry(svn_fs_t *fs, rep = apr_pcalloc(pool, sizeof(*rep)); rep->revision = SVN_INVALID_REVNUM; rep->txn_id = txn_id; - SVN_ERR(get_new_txn_node_id(&unique_suffix, fs, txn_id, pool)); - rep->uniquifier = apr_psprintf(pool, "%s/%s", txn_id, unique_suffix); + + if (ffd->format >= SVN_FS_FS__MIN_REP_SHARING_FORMAT) + { + SVN_ERR(get_new_txn_node_id(&unique_suffix, fs, txn_id, pool)); + rep->uniquifier = apr_psprintf(pool, "%s/%s", txn_id, unique_suffix); + } + parent_noderev->data_rep = rep; SVN_ERR(svn_fs_fs__put_node_revision(fs, parent_noderev->id, parent_noderev, FALSE, pool)); @@ -7551,6 +7568,7 @@ rep_write_contents_close(void *baton) representation_t *rep; representation_t *old_rep; apr_off_t offset; + fs_fs_data_t *ffd = b->fs->fsap_data; rep = apr_pcalloc(b->parent_pool, sizeof(*rep)); rep->offset = b->rep_offset; @@ -7567,9 +7585,13 @@ rep_write_contents_close(void *baton) /* Fill in the rest of the representation field. */ rep->expanded_size = b->rep_size; rep->txn_id = svn_fs_fs__id_txn_id(b->noderev->id); - SVN_ERR(get_new_txn_node_id(&unique_suffix, b->fs, rep->txn_id, b->pool)); - rep->uniquifier = apr_psprintf(b->parent_pool, "%s/%s", rep->txn_id, - unique_suffix); + + if (ffd->format >= SVN_FS_FS__MIN_REP_SHARING_FORMAT) + { + SVN_ERR(get_new_txn_node_id(&unique_suffix, b->fs, rep->txn_id, b->pool)); + rep->uniquifier = apr_psprintf(b->parent_pool, "%s/%s", rep->txn_id, + unique_suffix); + } rep->revision = SVN_INVALID_REVNUM; /* Finalize the checksum. */ @@ -7842,7 +7864,7 @@ write_hash_rep(representation_t *rep, /* update the representation */ rep->size = whb->size; - rep->expanded_size = 0; + rep->expanded_size = whb->size; } return SVN_NO_ERROR; @@ -9070,7 +9092,9 @@ recover_find_max_ids(svn_fs_t *fs, svn_revnum_t rev, stored in the representation. */ baton.file = rev_file; baton.pool = pool; - baton.remaining = data_rep->expanded_size; + baton.remaining = data_rep->expanded_size + ? data_rep->expanded_size + : data_rep->size; stream = svn_stream_create(&baton, pool); svn_stream_set_read(stream, read_handler_recover); @@ -10912,6 +10936,9 @@ hotcopy_update_current(svn_revnum_t *dst_youngest, { apr_off_t root_offset; apr_file_t *rev_file; + char max_node_id[MAX_KEY_SIZE] = "0"; + char max_copy_id[MAX_KEY_SIZE] = "0"; + apr_size_t len; if (dst_ffd->format >= SVN_FS_FS__MIN_PACKED_FORMAT) SVN_ERR(update_min_unpacked_rev(dst_fs, scratch_pool)); @@ -10921,9 +10948,15 @@ hotcopy_update_current(svn_revnum_t *dst_youngest, SVN_ERR(get_root_changes_offset(&root_offset, NULL, rev_file, dst_fs, new_youngest, scratch_pool)); SVN_ERR(recover_find_max_ids(dst_fs, new_youngest, rev_file, - root_offset, next_node_id, next_copy_id, + root_offset, max_node_id, max_copy_id, scratch_pool)); SVN_ERR(svn_io_file_close(rev_file, scratch_pool)); + + /* We store the _next_ ids. */ + len = strlen(max_node_id); + svn_fs_fs__next_key(max_node_id, &len, next_node_id); + len = strlen(max_copy_id); + svn_fs_fs__next_key(max_copy_id, &len, next_copy_id); } /* Update 'current'. */ diff --git a/subversion/libsvn_fs_fs/rep-cache-db.h b/subversion/libsvn_fs_fs/rep-cache-db.h index 0c9b821fec4b9..c3a23072bf49c 100644 --- a/subversion/libsvn_fs_fs/rep-cache-db.h +++ b/subversion/libsvn_fs_fs/rep-cache-db.h @@ -1,4 +1,4 @@ -/* This file is automatically generated from rep-cache-db.sql and .dist_sandbox/subversion-1.8.10/subversion/libsvn_fs_fs/token-map.h. +/* This file is automatically generated from rep-cache-db.sql and .dist_sandbox/subversion-1.8.14/subversion/libsvn_fs_fs/token-map.h. * Do not edit this file -- edit the source and rerun gen-make.py */ #define STMT_CREATE_SCHEMA 0 diff --git a/subversion/libsvn_fs_fs/tree.c b/subversion/libsvn_fs_fs/tree.c index 64c8395295a81..acd1eb411889a 100644 --- a/subversion/libsvn_fs_fs/tree.c +++ b/subversion/libsvn_fs_fs/tree.c @@ -127,7 +127,6 @@ typedef struct fs_txn_root_data_t static svn_error_t * get_dag(dag_node_t **dag_node_p, svn_fs_root_t *root, const char *path, - svn_boolean_t needs_lock_cache, apr_pool_t *pool); static svn_fs_root_t *make_revision_root(svn_fs_t *fs, svn_revnum_t rev, @@ -178,34 +177,10 @@ typedef struct cache_entry_t */ enum { BUCKET_COUNT = 256 }; -/* Each pool that has received a DAG node, will hold at least on lock on - our cache to ensure that the node remains valid despite being allocated - in the cache's pool. This is the structure to represent the lock. - */ -typedef struct cache_lock_t -{ - /* pool holding the lock */ - apr_pool_t *pool; - - /* cache being locked */ - fs_fs_dag_cache_t *cache; - - /* next lock. NULL at EOL */ - struct cache_lock_t *next; - - /* previous lock. NULL at list head. Only then this==cache->first_lock */ - struct cache_lock_t *prev; -} cache_lock_t; - /* The actual cache structure. All nodes will be allocated in POOL. When the number of INSERTIONS (i.e. objects created form that pool) exceeds a certain threshold, the pool will be cleared and the cache with it. - - To ensure that nodes returned from this structure remain valid, the - cache will get locked for the lifetime of the _receiving_ pools (i.e. - those in which we would allocate the node if there was no cache.). - The cache will only be cleared FIRST_LOCK is 0. */ struct fs_fs_dag_cache_t { @@ -221,106 +196,23 @@ struct fs_fs_dag_cache_t /* Property lookups etc. have a very high locality (75% re-hit). Thus, remember the last hit location for optimistic lookup. */ apr_size_t last_hit; - - /* List of receiving pools that are still alive. */ - cache_lock_t *first_lock; }; -/* Cleanup function to be called when a receiving pool gets cleared. - Unlocks the cache once. - */ -static apr_status_t -unlock_cache(void *baton_void) -{ - cache_lock_t *lock = baton_void; - - /* remove lock from chain. Update the head */ - if (lock->next) - lock->next->prev = lock->prev; - if (lock->prev) - lock->prev->next = lock->next; - else - lock->cache->first_lock = lock->next; - - return APR_SUCCESS; -} - -/* Cleanup function to be called when the cache itself gets destroyed. - In that case, we must unregister all unlock requests. - */ -static apr_status_t -unregister_locks(void *baton_void) -{ - fs_fs_dag_cache_t *cache = baton_void; - cache_lock_t *lock; - - for (lock = cache->first_lock; lock; lock = lock->next) - apr_pool_cleanup_kill(lock->pool, - lock, - unlock_cache); - - return APR_SUCCESS; -} - fs_fs_dag_cache_t* svn_fs_fs__create_dag_cache(apr_pool_t *pool) { fs_fs_dag_cache_t *result = apr_pcalloc(pool, sizeof(*result)); result->pool = svn_pool_create(pool); - apr_pool_cleanup_register(pool, - result, - unregister_locks, - apr_pool_cleanup_null); - return result; } -/* Prevent the entries in CACHE from being destroyed, for as long as the - POOL lives. - */ -static void -lock_cache(fs_fs_dag_cache_t* cache, apr_pool_t *pool) -{ - /* we only need to lock / unlock once per pool. Since we will often ask - for multiple nodes with the same pool, we can reduce the overhead. - However, if e.g. pools are being used in an alternating pattern, - we may lock the cache more than once for the same pool (and register - just as many cleanup actions). - */ - cache_lock_t *lock = cache->first_lock; - - /* try to find an existing lock for POOL. - But limit the time spent on chasing pointers. */ - int limiter = 8; - while (lock && --limiter) - if (lock->pool == pool) - return; - - /* create a new lock and put it at the beginning of the lock chain */ - lock = apr_palloc(pool, sizeof(*lock)); - lock->cache = cache; - lock->pool = pool; - lock->next = cache->first_lock; - lock->prev = NULL; - - if (cache->first_lock) - cache->first_lock->prev = lock; - cache->first_lock = lock; - - /* instruct POOL to remove the look upon cleanup */ - apr_pool_cleanup_register(pool, - lock, - unlock_cache, - apr_pool_cleanup_null); -} - /* Clears the CACHE at regular intervals (destroying all cached nodes) */ static void auto_clear_dag_cache(fs_fs_dag_cache_t* cache) { - if (cache->first_lock == NULL && cache->insertions > BUCKET_COUNT) + if (cache->insertions > BUCKET_COUNT) { svn_pool_clear(cache->pool); @@ -433,18 +325,12 @@ locate_cache(svn_cache__t **cache, } } -/* Return NODE for PATH from ROOT's node cache, or NULL if the node - isn't cached; read it from the FS. *NODE remains valid until either - POOL or the FS gets cleared or destroyed (whichever comes first). - - Since locking can be expensive and POOL may be long-living, for - nodes that will not need to survive the next call to this function, - set NEEDS_LOCK_CACHE to FALSE. */ +/* Return NODE_P for PATH from ROOT's node cache, or NULL if the node + isn't cached; read it from the FS. *NODE_P is allocated in POOL. */ static svn_error_t * dag_node_cache_get(dag_node_t **node_p, svn_fs_root_t *root, const char *path, - svn_boolean_t needs_lock_cache, apr_pool_t *pool) { svn_boolean_t found; @@ -466,25 +352,23 @@ dag_node_cache_get(dag_node_t **node_p, if (bucket->node == NULL) { locate_cache(&cache, &key, root, path, pool); - SVN_ERR(svn_cache__get((void **)&node, &found, cache, key, - ffd->dag_node_cache->pool)); + SVN_ERR(svn_cache__get((void **)&node, &found, cache, key, pool)); if (found && node) { /* Patch up the FS, since this might have come from an old FS * object. */ svn_fs_fs__dag_set_fs(node, root->fs); - bucket->node = node; + + /* Retain the DAG node in L1 cache. */ + bucket->node = svn_fs_fs__dag_dup(node, + ffd->dag_node_cache->pool); } } else { - node = bucket->node; + /* Copy the node from L1 cache into the passed-in POOL. */ + node = svn_fs_fs__dag_dup(bucket->node, pool); } - - /* if we found a node, make sure it remains valid at least as long - as it would when allocated in POOL. */ - if (node && needs_lock_cache) - lock_cache(ffd->dag_node_cache, pool); } else { @@ -822,7 +706,7 @@ get_copy_inheritance(copy_id_inherit_t *inherit_p, SVN_ERR(svn_fs_fs__dag_get_copyroot(©root_rev, ©root_path, child->node)); SVN_ERR(svn_fs_fs__revision_root(©root_root, fs, copyroot_rev, pool)); - SVN_ERR(get_dag(©root_node, copyroot_root, copyroot_path, FALSE, pool)); + SVN_ERR(get_dag(©root_node, copyroot_root, copyroot_path, pool)); copyroot_id = svn_fs_fs__dag_get_id(copyroot_node); if (svn_fs_fs__id_compare(copyroot_id, child_id) == -1) @@ -938,7 +822,7 @@ open_path(parent_path_t **parent_path_p, { directory = svn_dirent_dirname(path, pool); if (directory[1] != 0) /* root nodes are covered anyway */ - SVN_ERR(dag_node_cache_get(&here, root, directory, TRUE, pool)); + SVN_ERR(dag_node_cache_get(&here, root, directory, pool)); } /* did the shortcut work? */ @@ -998,8 +882,8 @@ open_path(parent_path_t **parent_path_p, element if we already know the lookup to fail for the complete path. */ if (next || !(flags & open_path_uncached)) - SVN_ERR(dag_node_cache_get(&cached_node, root, path_so_far, - TRUE, pool)); + SVN_ERR(dag_node_cache_get(&cached_node, root, path_so_far, pool)); + if (cached_node) child = cached_node; else @@ -1136,8 +1020,7 @@ make_path_mutable(svn_fs_root_t *root, parent_path->node)); SVN_ERR(svn_fs_fs__revision_root(©root_root, root->fs, copyroot_rev, pool)); - SVN_ERR(get_dag(©root_node, copyroot_root, copyroot_path, - FALSE, pool)); + SVN_ERR(get_dag(©root_node, copyroot_root, copyroot_path, pool)); child_id = svn_fs_fs__dag_get_id(parent_path->node); copyroot_id = svn_fs_fs__dag_get_id(copyroot_node); @@ -1174,16 +1057,11 @@ make_path_mutable(svn_fs_root_t *root, /* Open the node identified by PATH in ROOT. Set DAG_NODE_P to the node we find, allocated in POOL. Return the error - SVN_ERR_FS_NOT_FOUND if this node doesn't exist. - - Since locking can be expensive and POOL may be long-living, for - nodes that will not need to survive the next call to this function, - set NEEDS_LOCK_CACHE to FALSE. */ + SVN_ERR_FS_NOT_FOUND if this node doesn't exist. */ static svn_error_t * get_dag(dag_node_t **dag_node_p, svn_fs_root_t *root, const char *path, - svn_boolean_t needs_lock_cache, apr_pool_t *pool) { parent_path_t *parent_path; @@ -1192,7 +1070,7 @@ get_dag(dag_node_t **dag_node_p, /* First we look for the DAG in our cache (if the path may be canonical). */ if (*path == '/') - SVN_ERR(dag_node_cache_get(&node, root, path, needs_lock_cache, pool)); + SVN_ERR(dag_node_cache_get(&node, root, path, pool)); if (! node) { @@ -1202,8 +1080,7 @@ get_dag(dag_node_t **dag_node_p, path = svn_fs__canonicalize_abspath(path, pool); /* Try again with the corrected path. */ - SVN_ERR(dag_node_cache_get(&node, root, path, needs_lock_cache, - pool)); + SVN_ERR(dag_node_cache_get(&node, root, path, pool)); } if (! node) @@ -1281,7 +1158,7 @@ svn_fs_fs__node_id(const svn_fs_id_t **id_p, { dag_node_t *node; - SVN_ERR(get_dag(&node, root, path, FALSE, pool)); + SVN_ERR(get_dag(&node, root, path, pool)); *id_p = svn_fs_fs__id_copy(svn_fs_fs__dag_get_id(node), pool); } return SVN_NO_ERROR; @@ -1296,7 +1173,7 @@ svn_fs_fs__node_created_rev(svn_revnum_t *revision, { dag_node_t *node; - SVN_ERR(get_dag(&node, root, path, FALSE, pool)); + SVN_ERR(get_dag(&node, root, path, pool)); return svn_fs_fs__dag_get_revision(revision, node, pool); } @@ -1311,7 +1188,7 @@ fs_node_created_path(const char **created_path, { dag_node_t *node; - SVN_ERR(get_dag(&node, root, path, TRUE, pool)); + SVN_ERR(get_dag(&node, root, path, pool)); *created_path = svn_fs_fs__dag_get_created_path(node); return SVN_NO_ERROR; @@ -1375,7 +1252,7 @@ fs_node_prop(svn_string_t **value_p, dag_node_t *node; apr_hash_t *proplist; - SVN_ERR(get_dag(&node, root, path, FALSE, pool)); + SVN_ERR(get_dag(&node, root, path, pool)); SVN_ERR(svn_fs_fs__dag_get_proplist(&proplist, node, pool)); *value_p = NULL; if (proplist) @@ -1398,7 +1275,7 @@ fs_node_proplist(apr_hash_t **table_p, apr_hash_t *table; dag_node_t *node; - SVN_ERR(get_dag(&node, root, path, FALSE, pool)); + SVN_ERR(get_dag(&node, root, path, pool)); SVN_ERR(svn_fs_fs__dag_get_proplist(&table, node, pool)); *table_p = table ? table : apr_hash_make(pool); @@ -1515,8 +1392,8 @@ fs_props_changed(svn_boolean_t *changed_p, (SVN_ERR_FS_GENERAL, NULL, _("Cannot compare property value between two different filesystems")); - SVN_ERR(get_dag(&node1, root1, path1, TRUE, pool)); - SVN_ERR(get_dag(&node2, root2, path2, TRUE, pool)); + SVN_ERR(get_dag(&node1, root1, path1, pool)); + SVN_ERR(get_dag(&node2, root2, path2, pool)); return svn_fs_fs__dag_things_different(changed_p, NULL, node1, node2); } @@ -1529,7 +1406,7 @@ fs_props_changed(svn_boolean_t *changed_p, static svn_error_t * get_root(dag_node_t **node, svn_fs_root_t *root, apr_pool_t *pool) { - return get_dag(node, root, "/", TRUE, pool); + return get_dag(node, root, "/", pool); } @@ -2193,7 +2070,7 @@ fs_dir_entries(apr_hash_t **table_p, dag_node_t *node; /* Get the entries for this path in the caller's pool. */ - SVN_ERR(get_dag(&node, root, path, FALSE, pool)); + SVN_ERR(get_dag(&node, root, path, pool)); return svn_fs_fs__dag_dir_entries(table_p, node, pool); } @@ -2365,7 +2242,7 @@ copy_helper(svn_fs_root_t *from_root, _("Copy from mutable tree not currently supported")); /* Get the NODE for FROM_PATH in FROM_ROOT.*/ - SVN_ERR(get_dag(&from_node, from_root, from_path, TRUE, pool)); + SVN_ERR(get_dag(&from_node, from_root, from_path, pool)); /* Build up the parent path from TO_PATH in TO_ROOT. If the last component does not exist, it's not that big a deal. We'll just @@ -2442,7 +2319,7 @@ copy_helper(svn_fs_root_t *from_root, pool)); /* Make a record of this modification in the changes table. */ - SVN_ERR(get_dag(&new_node, to_root, to_path, TRUE, pool)); + SVN_ERR(get_dag(&new_node, to_root, to_path, pool)); SVN_ERR(add_change(to_root->fs, txn_id, to_path, svn_fs_fs__dag_get_id(new_node), kind, FALSE, FALSE, svn_fs_fs__dag_node_kind(from_node), @@ -2553,7 +2430,7 @@ fs_copied_from(svn_revnum_t *rev_p, { /* There is no cached entry, look it up the old-fashioned way. */ - SVN_ERR(get_dag(&node, root, path, TRUE, pool)); + SVN_ERR(get_dag(&node, root, path, pool)); SVN_ERR(svn_fs_fs__dag_get_copyfrom_rev(©from_rev, node)); SVN_ERR(svn_fs_fs__dag_get_copyfrom_path(©from_path, node)); } @@ -2628,7 +2505,7 @@ fs_file_length(svn_filesize_t *length_p, dag_node_t *file; /* First create a dag_node_t from the root/path pair. */ - SVN_ERR(get_dag(&file, root, path, FALSE, pool)); + SVN_ERR(get_dag(&file, root, path, pool)); /* Now fetch its length */ return svn_fs_fs__dag_file_length(length_p, file, pool); @@ -2647,7 +2524,7 @@ fs_file_checksum(svn_checksum_t **checksum, { dag_node_t *file; - SVN_ERR(get_dag(&file, root, path, FALSE, pool)); + SVN_ERR(get_dag(&file, root, path, pool)); return svn_fs_fs__dag_file_checksum(checksum, file, kind, pool); } @@ -2666,7 +2543,7 @@ fs_file_contents(svn_stream_t **contents, svn_stream_t *file_stream; /* First create a dag_node_t from the root/path pair. */ - SVN_ERR(get_dag(&node, root, path, FALSE, pool)); + SVN_ERR(get_dag(&node, root, path, pool)); /* Then create a readable stream from the dag_node_t. */ SVN_ERR(svn_fs_fs__dag_get_contents(&file_stream, node, pool)); @@ -2689,7 +2566,7 @@ fs_try_process_file_contents(svn_boolean_t *success, apr_pool_t *pool) { dag_node_t *node; - SVN_ERR(get_dag(&node, root, path, FALSE, pool)); + SVN_ERR(get_dag(&node, root, path, pool)); return svn_fs_fs__dag_try_process_file_contents(success, node, processor, baton, pool); @@ -3071,8 +2948,8 @@ fs_contents_changed(svn_boolean_t *changed_p, (SVN_ERR_FS_GENERAL, NULL, _("'%s' is not a file"), path2); } - SVN_ERR(get_dag(&node1, root1, path1, TRUE, pool)); - SVN_ERR(get_dag(&node2, root2, path2, TRUE, pool)); + SVN_ERR(get_dag(&node1, root1, path1, pool)); + SVN_ERR(get_dag(&node2, root2, path2, pool)); return svn_fs_fs__dag_things_different(NULL, changed_p, node1, node2); } @@ -3092,10 +2969,10 @@ fs_get_file_delta_stream(svn_txdelta_stream_t **stream_p, dag_node_t *source_node, *target_node; if (source_root && source_path) - SVN_ERR(get_dag(&source_node, source_root, source_path, TRUE, pool)); + SVN_ERR(get_dag(&source_node, source_root, source_path, pool)); else source_node = NULL; - SVN_ERR(get_dag(&target_node, target_root, target_path, TRUE, pool)); + SVN_ERR(get_dag(&target_node, target_root, target_path, pool)); /* Create a delta stream that turns the source into the target. */ return svn_fs_fs__dag_get_file_delta_stream(stream_p, source_node, @@ -3588,7 +3465,7 @@ history_prev(void *baton, apr_pool_t *pool) SVN_ERR(svn_fs_fs__revision_root(©root_root, fs, copyroot_rev, pool)); - SVN_ERR(get_dag(&node, copyroot_root, copyroot_path, FALSE, pool)); + SVN_ERR(get_dag(&node, copyroot_root, copyroot_path, pool)); copy_dst = svn_fs_fs__dag_get_created_path(node); /* If our current path was the very destination of the copy, @@ -3785,7 +3662,7 @@ crawl_directory_dag_for_mergeinfo(svn_fs_root_t *root, svn_pool_clear(iterpool); kid_path = svn_fspath__join(this_path, dirent->name, iterpool); - SVN_ERR(get_dag(&kid_dag, root, kid_path, TRUE, iterpool)); + SVN_ERR(get_dag(&kid_dag, root, kid_path, iterpool)); SVN_ERR(svn_fs_fs__dag_has_mergeinfo(&has_mergeinfo, kid_dag)); SVN_ERR(svn_fs_fs__dag_has_descendants_with_mergeinfo(&go_down, kid_dag)); @@ -4031,7 +3908,7 @@ add_descendant_mergeinfo(svn_mergeinfo_catalog_t result_catalog, dag_node_t *this_dag; svn_boolean_t go_down; - SVN_ERR(get_dag(&this_dag, root, path, TRUE, scratch_pool)); + SVN_ERR(get_dag(&this_dag, root, path, scratch_pool)); SVN_ERR(svn_fs_fs__dag_has_descendants_with_mergeinfo(&go_down, this_dag)); if (go_down) |