Author: stefan2
Date: Sun Sep 15 16:58:14 2013
New Revision: 1523459
URL: http://svn.apache.org/r1523459
Log:
Further improve the scalability of fs_open() and related functions
in multi-threaded servers. Only the parts that actually access the
global_pool need to be serialized using the common_pool_lock.
Thus, we pass the common_pool_lock along with the common_pool in all
FS vtable functions and serialize the access FS-internally.
This patch is part of a series that improved 'svn info' scalability
in a threaded svnserve from about 2x (i.e. 2 cores) to over 5x.
* subversion/libsvn_fs/fs-loader.h
(fs_library_vtable_t): add common_pool_lock to all functions that
use the common_pool
* subversion/libsvn_fs/fs-loader.c
(svn_fs_create,
svn_fs_open,
svn_fs_upgrade2,
svn_fs_verify,
svn_fs_pack,
svn_fs_recover,
svn_fs_create_berkeley,
svn_fs_open_berkeley): remove global sync here and pass the mutex
to the vtable functions
* subversion/libsvn_fs_base/fs.c
(base_create,
base_open,
base_open_for_recovery,
base_upgrade,
base_verify,
base_bdb_pack): update; but no sync required since no-one actually
uses the common_pool
* subversion/libsvn_fs_fs/fs.c
(fs_create,
fs_open): update; serialize access to common_pool by fs_serialized_init
(fs_open_for_recovery): update
(fs_upgrade,
fs_verify,
fs_pack): update; simplify by calling fs_open
* subversion/libsvn_fs_x/fs.c
(x_create,
x_open): update; serialize access to common_pool by fs_serialized_init
(x_open_for_recovery): update
(x_upgrade,
x_verify,
x_pack): update; simplify by calling fs_open
Modified:
subversion/trunk/subversion/libsvn_fs/fs-loader.c
subversion/trunk/subversion/libsvn_fs/fs-loader.h
subversion/trunk/subversion/libsvn_fs_base/fs.c
subversion/trunk/subversion/libsvn_fs_fs/fs.c
subversion/trunk/subversion/libsvn_fs_x/fs.c
Modified: subversion/trunk/subversion/libsvn_fs/fs-loader.c
URL:
http://svn.apache.org/viewvc/subversion/trunk/subversion/libsvn_fs/fs-loader.c?rev=1523459&r1=1523458&r2=1523459&view=diff
==============================================================================
--- subversion/trunk/subversion/libsvn_fs/fs-loader.c (original)
+++ subversion/trunk/subversion/libsvn_fs/fs-loader.c Sun Sep 15 16:58:14 2013
@@ -485,8 +485,7 @@ svn_fs_create(svn_fs_t **fs_p, const cha
/* Perform the actual creation. */
*fs_p = fs_new(fs_config, pool);
- SVN_MUTEX__WITH_LOCK(common_pool_lock,
- vtable->create(*fs_p, path, pool, common_pool));
+ SVN_ERR(vtable->create(*fs_p, path, common_pool_lock, pool, common_pool));
SVN_ERR(vtable->set_svn_fs_open(*fs_p, svn_fs_open));
return SVN_NO_ERROR;
@@ -500,8 +499,7 @@ svn_fs_open(svn_fs_t **fs_p, const char
SVN_ERR(fs_library_vtable(&vtable, path, pool));
*fs_p = fs_new(fs_config, pool);
- SVN_MUTEX__WITH_LOCK(common_pool_lock,
- vtable->open_fs(*fs_p, path, pool, common_pool));
+ SVN_ERR(vtable->open_fs(*fs_p, path, common_pool_lock, pool, common_pool));
SVN_ERR(vtable->set_svn_fs_open(*fs_p, svn_fs_open));
return SVN_NO_ERROR;
@@ -521,11 +519,11 @@ svn_fs_upgrade2(const char *path,
SVN_ERR(fs_library_vtable(&vtable, path, pool));
fs = fs_new(NULL, pool);
- SVN_MUTEX__WITH_LOCK(common_pool_lock,
- vtable->upgrade_fs(fs, path,
- notify_func, notify_baton,
- cancel_func, cancel_baton,
- pool, common_pool));
+ SVN_ERR(vtable->upgrade_fs(fs, path,
+ notify_func, notify_baton,
+ cancel_func, cancel_baton,
+ common_pool_lock,
+ pool, common_pool));
return SVN_NO_ERROR;
}
@@ -552,11 +550,11 @@ svn_fs_verify(const char *path,
SVN_ERR(fs_library_vtable(&vtable, path, pool));
fs = fs_new(fs_config, pool);
- SVN_MUTEX__WITH_LOCK(common_pool_lock,
- vtable->verify_fs(fs, path, start, end,
- notify_func, notify_baton,
- cancel_func, cancel_baton,
- pool, common_pool));
+ SVN_ERR(vtable->verify_fs(fs, path, start, end,
+ notify_func, notify_baton,
+ cancel_func, cancel_baton,
+ common_pool_lock,
+ pool, common_pool));
return SVN_NO_ERROR;
}
@@ -667,10 +665,9 @@ svn_fs_pack(const char *path,
SVN_ERR(fs_library_vtable(&vtable, path, pool));
fs = fs_new(NULL, pool);
- SVN_MUTEX__WITH_LOCK(common_pool_lock,
- vtable->pack_fs(fs, path, notify_func, notify_baton,
- cancel_func, cancel_baton, pool,
- common_pool));
+ SVN_ERR(vtable->pack_fs(fs, path, notify_func, notify_baton,
+ cancel_func, cancel_baton, common_pool_lock,
+ pool, common_pool));
return SVN_NO_ERROR;
}
@@ -685,9 +682,8 @@ svn_fs_recover(const char *path,
SVN_ERR(fs_library_vtable(&vtable, path, pool));
fs = fs_new(NULL, pool);
- SVN_MUTEX__WITH_LOCK(common_pool_lock,
- vtable->open_fs_for_recovery(fs, path, pool,
- common_pool));
+ SVN_ERR(vtable->open_fs_for_recovery(fs, path, common_pool_lock,
+ pool, common_pool));
return svn_error_trace(vtable->recover(fs, cancel_func, cancel_baton,
pool));
}
@@ -728,8 +724,7 @@ svn_fs_create_berkeley(svn_fs_t *fs, con
SVN_ERR(write_fs_type(path, SVN_FS_TYPE_BDB, fs->pool));
/* Perform the actual creation. */
- SVN_MUTEX__WITH_LOCK(common_pool_lock,
- vtable->create(fs, path, fs->pool, common_pool));
+ SVN_ERR(vtable->create(fs, path, common_pool_lock, fs->pool, common_pool));
SVN_ERR(vtable->set_svn_fs_open(fs, svn_fs_open));
return SVN_NO_ERROR;
@@ -741,8 +736,7 @@ svn_fs_open_berkeley(svn_fs_t *fs, const
fs_library_vtable_t *vtable;
SVN_ERR(fs_library_vtable(&vtable, path, fs->pool));
- SVN_MUTEX__WITH_LOCK(common_pool_lock,
- vtable->open_fs(fs, path, fs->pool, common_pool));
+ SVN_ERR(vtable->open_fs(fs, path, common_pool_lock, fs->pool, common_pool));
SVN_ERR(vtable->set_svn_fs_open(fs, svn_fs_open));
return SVN_NO_ERROR;
Modified: subversion/trunk/subversion/libsvn_fs/fs-loader.h
URL:
http://svn.apache.org/viewvc/subversion/trunk/subversion/libsvn_fs/fs-loader.h?rev=1523459&r1=1523458&r2=1523459&view=diff
==============================================================================
--- subversion/trunk/subversion/libsvn_fs/fs-loader.h (original)
+++ subversion/trunk/subversion/libsvn_fs/fs-loader.h Sun Sep 15 16:58:14 2013
@@ -27,6 +27,7 @@
#include "svn_types.h"
#include "svn_fs.h"
+#include "private/svn_mutex.h"
#ifdef __cplusplus
extern "C" {
@@ -72,17 +73,22 @@ typedef struct fs_library_vtable_t
this statement, now that the minor version has increased. */
const svn_version_t *(*get_version)(void);
- /* The open_fs/create/open_fs_for_recovery/upgrade_fs functions are
- serialized so that they may use the common_pool parameter to
- allocate fs-global objects such as the bdb env cache. */
- svn_error_t *(*create)(svn_fs_t *fs, const char *path, apr_pool_t *pool,
+ /* The open_fs/create/open_fs_for_recovery/upgrade_fs functions must
+ use the common_pool_lock to serialize the access to the common_pool
+ parameter for allocating fs-global objects such as an env cache. */
+ svn_error_t *(*create)(svn_fs_t *fs, const char *path,
+ svn_mutex__t *common_pool_lock,
+ apr_pool_t *pool,
apr_pool_t *common_pool);
- svn_error_t *(*open_fs)(svn_fs_t *fs, const char *path, apr_pool_t *pool,
+ svn_error_t *(*open_fs)(svn_fs_t *fs, const char *path,
+ svn_mutex__t *common_pool_lock,
+ apr_pool_t *pool,
apr_pool_t *common_pool);
/* open_for_recovery() is like open(), but used to fill in an fs pointer
that will be passed to recover(). We assume that the open() method
might not be immediately appropriate for recovery. */
svn_error_t *(*open_fs_for_recovery)(svn_fs_t *fs, const char *path,
+ svn_mutex__t *common_pool_lock,
apr_pool_t *pool,
apr_pool_t *common_pool);
svn_error_t *(*upgrade_fs)(svn_fs_t *fs,
@@ -91,6 +97,7 @@ typedef struct fs_library_vtable_t
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
+ svn_mutex__t *common_pool_lock,
apr_pool_t *pool,
apr_pool_t *common_pool);
svn_error_t *(*verify_fs)(svn_fs_t *fs, const char *path,
@@ -100,6 +107,7 @@ typedef struct fs_library_vtable_t
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
+ svn_mutex__t *common_pool_lock,
apr_pool_t *pool,
apr_pool_t *common_pool);
svn_error_t *(*delete_fs)(const char *path, apr_pool_t *pool);
@@ -115,6 +123,7 @@ typedef struct fs_library_vtable_t
svn_error_t *(*pack_fs)(svn_fs_t *fs, const char *path,
svn_fs_pack_notify_t notify_func, void *notify_baton,
svn_cancel_func_t cancel_func, void *cancel_baton,
+ svn_mutex__t *common_pool_lock,
apr_pool_t *pool, apr_pool_t *common_pool);
/* Provider-specific functions should go here, even if they could go
Modified: subversion/trunk/subversion/libsvn_fs_base/fs.c
URL:
http://svn.apache.org/viewvc/subversion/trunk/subversion/libsvn_fs_base/fs.c?rev=1523459&r1=1523458&r2=1523459&view=diff
==============================================================================
--- subversion/trunk/subversion/libsvn_fs_base/fs.c (original)
+++ subversion/trunk/subversion/libsvn_fs_base/fs.c Sun Sep 15 16:58:14 2013
@@ -729,7 +729,10 @@ populate_opened_fs(svn_fs_t *fs, apr_poo
}
static svn_error_t *
-base_create(svn_fs_t *fs, const char *path, apr_pool_t *pool,
+base_create(svn_fs_t *fs,
+ const char *path,
+ svn_mutex__t *common_pool_lock,
+ apr_pool_t *pool,
apr_pool_t *common_pool)
{
int format = SVN_FS_BASE__FORMAT_NUMBER;
@@ -805,7 +808,10 @@ check_format(int format)
}
static svn_error_t *
-base_open(svn_fs_t *fs, const char *path, apr_pool_t *pool,
+base_open(svn_fs_t *fs,
+ const char *path,
+ svn_mutex__t *common_pool_lock,
+ apr_pool_t *pool,
apr_pool_t *common_pool)
{
int format;
@@ -888,7 +894,10 @@ bdb_recover(const char *path, svn_boolea
}
static svn_error_t *
-base_open_for_recovery(svn_fs_t *fs, const char *path, apr_pool_t *pool,
+base_open_for_recovery(svn_fs_t *fs,
+ const char *path,
+ svn_mutex__t *common_pool_lock,
+ apr_pool_t *pool,
apr_pool_t *common_pool)
{
/* Just stash the path in the fs pointer - it's all we really need. */
@@ -904,6 +913,7 @@ base_upgrade(svn_fs_t *fs,
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
+ svn_mutex__t *common_pool_lock,
apr_pool_t *pool,
apr_pool_t *common_pool)
{
@@ -946,7 +956,7 @@ base_upgrade(svn_fs_t *fs,
But it's better to use the existing encapsulation of "opening
the filesystem" rather than duplicating (or worse, partially
duplicating) that logic here. */
- SVN_ERR(base_open(fs, path, subpool, common_pool));
+ SVN_ERR(base_open(fs, path, common_pool_lock, subpool, common_pool));
/* Fetch the youngest rev, and record it */
SVN_ERR(svn_fs_base__youngest_rev(&youngest_rev, fs, subpool));
@@ -968,6 +978,7 @@ base_verify(svn_fs_t *fs, const char *pa
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
+ svn_mutex__t *common_pool_lock,
apr_pool_t *pool,
apr_pool_t *common_pool)
{
@@ -992,6 +1003,7 @@ base_bdb_pack(svn_fs_t *fs,
void *notify_baton,
svn_cancel_func_t cancel,
void *cancel_baton,
+ svn_mutex__t *common_pool_lock,
apr_pool_t *pool,
apr_pool_t *common_pool)
{
Modified: subversion/trunk/subversion/libsvn_fs_fs/fs.c
URL:
http://svn.apache.org/viewvc/subversion/trunk/subversion/libsvn_fs_fs/fs.c?rev=1523459&r1=1523458&r2=1523459&view=diff
==============================================================================
--- subversion/trunk/subversion/libsvn_fs_fs/fs.c (original)
+++ subversion/trunk/subversion/libsvn_fs_fs/fs.c Sun Sep 15 16:58:14 2013
@@ -229,9 +229,12 @@ initialize_fs_struct(svn_fs_t *fs)
/* This implements the fs_library_vtable_t.create() API. Create a new
fsfs-backed Subversion filesystem at path PATH and link it into
*FS. Perform temporary allocations in POOL, and fs-global allocations
- in COMMON_POOL. */
+ in COMMON_POOL. The latter must be serialized using COMMON_POOL_LOCK. */
static svn_error_t *
-fs_create(svn_fs_t *fs, const char *path, apr_pool_t *pool,
+fs_create(svn_fs_t *fs,
+ const char *path,
+ svn_mutex__t *common_pool_lock,
+ apr_pool_t *pool,
apr_pool_t *common_pool)
{
SVN_ERR(svn_fs__check_fs(fs, FALSE));
@@ -241,7 +244,10 @@ fs_create(svn_fs_t *fs, const char *path
SVN_ERR(svn_fs_fs__create(fs, path, pool));
SVN_ERR(svn_fs_fs__initialize_caches(fs, pool));
- return fs_serialized_init(fs, common_pool, pool);
+ SVN_MUTEX__WITH_LOCK(common_pool_lock,
+ fs_serialized_init(fs, common_pool, pool));
+
+ return SVN_NO_ERROR;
}
@@ -251,17 +257,26 @@ fs_create(svn_fs_t *fs, const char *path
/* This implements the fs_library_vtable_t.open() API. Open an FSFS
Subversion filesystem located at PATH, set *FS to point to the
correct vtable for the filesystem. Use POOL for any temporary
- allocations, and COMMON_POOL for fs-global allocations. */
+ allocations, and COMMON_POOL for fs-global allocations.
+ The latter must be serialized using COMMON_POOL_LOCK. */
static svn_error_t *
-fs_open(svn_fs_t *fs, const char *path, apr_pool_t *pool,
+fs_open(svn_fs_t *fs,
+ const char *path,
+ svn_mutex__t *common_pool_lock,
+ apr_pool_t *pool,
apr_pool_t *common_pool)
{
+ SVN_ERR(svn_fs__check_fs(fs, FALSE));
+
SVN_ERR(initialize_fs_struct(fs));
SVN_ERR(svn_fs_fs__open(fs, path, pool));
SVN_ERR(svn_fs_fs__initialize_caches(fs, pool));
- return fs_serialized_init(fs, common_pool, pool);
+ SVN_MUTEX__WITH_LOCK(common_pool_lock,
+ fs_serialized_init(fs, common_pool, pool));
+
+ return SVN_NO_ERROR;
}
@@ -270,7 +285,9 @@ fs_open(svn_fs_t *fs, const char *path,
static svn_error_t *
fs_open_for_recovery(svn_fs_t *fs,
const char *path,
- apr_pool_t *pool, apr_pool_t *common_pool)
+ svn_mutex__t *common_pool_lock,
+ apr_pool_t *pool,
+ apr_pool_t *common_pool)
{
/* Recovery for FSFS is currently limited to recreating the 'current'
file from the latest revision. */
@@ -288,7 +305,7 @@ fs_open_for_recovery(svn_fs_t *fs,
"0 1 1\n", pool));
/* Now open the filesystem properly by calling the vtable method directly. */
- return fs_open(fs, path, pool, common_pool);
+ return fs_open(fs, path, common_pool_lock, pool, common_pool);
}
@@ -301,14 +318,11 @@ fs_upgrade(svn_fs_t *fs,
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
+ svn_mutex__t *common_pool_lock,
apr_pool_t *pool,
apr_pool_t *common_pool)
{
- SVN_ERR(svn_fs__check_fs(fs, FALSE));
- SVN_ERR(initialize_fs_struct(fs));
- SVN_ERR(svn_fs_fs__open(fs, path, pool));
- SVN_ERR(svn_fs_fs__initialize_caches(fs, pool));
- SVN_ERR(fs_serialized_init(fs, common_pool, pool));
+ SVN_ERR(fs_open(fs, path, common_pool_lock, pool, common_pool));
return svn_fs_fs__upgrade(fs, notify_func, notify_baton,
cancel_func, cancel_baton, pool);
}
@@ -321,14 +335,11 @@ fs_verify(svn_fs_t *fs, const char *path
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
+ svn_mutex__t *common_pool_lock,
apr_pool_t *pool,
apr_pool_t *common_pool)
{
- SVN_ERR(svn_fs__check_fs(fs, FALSE));
- SVN_ERR(initialize_fs_struct(fs));
- SVN_ERR(svn_fs_fs__open(fs, path, pool));
- SVN_ERR(svn_fs_fs__initialize_caches(fs, pool));
- SVN_ERR(fs_serialized_init(fs, common_pool, pool));
+ SVN_ERR(fs_open(fs, path, common_pool_lock, pool, common_pool));
return svn_fs_fs__verify(fs, start, end, notify_func, notify_baton,
cancel_func, cancel_baton, pool);
}
@@ -340,14 +351,11 @@ fs_pack(svn_fs_t *fs,
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
+ svn_mutex__t *common_pool_lock,
apr_pool_t *pool,
apr_pool_t *common_pool)
{
- SVN_ERR(svn_fs__check_fs(fs, FALSE));
- SVN_ERR(initialize_fs_struct(fs));
- SVN_ERR(svn_fs_fs__open(fs, path, pool));
- SVN_ERR(svn_fs_fs__initialize_caches(fs, pool));
- SVN_ERR(fs_serialized_init(fs, common_pool, pool));
+ SVN_ERR(fs_open(fs, path, common_pool_lock, pool, common_pool));
return svn_fs_fs__pack(fs, notify_func, notify_baton,
cancel_func, cancel_baton, pool);
}
Modified: subversion/trunk/subversion/libsvn_fs_x/fs.c
URL:
http://svn.apache.org/viewvc/subversion/trunk/subversion/libsvn_fs_x/fs.c?rev=1523459&r1=1523458&r2=1523459&view=diff
==============================================================================
--- subversion/trunk/subversion/libsvn_fs_x/fs.c (original)
+++ subversion/trunk/subversion/libsvn_fs_x/fs.c Sun Sep 15 16:58:14 2013
@@ -229,10 +229,13 @@ initialize_fs_struct(svn_fs_t *fs)
/* This implements the fs_library_vtable_t.create() API. Create a new
fsx-backed Subversion filesystem at path PATH and link it into
*FS. Perform temporary allocations in POOL, and fs-global allocations
- in COMMON_POOL. */
+ in COMMON_POOL. The latter must be serialized using COMMON_POOL_LOCK. */
static svn_error_t *
-x_create(svn_fs_t *fs, const char *path, apr_pool_t *pool,
- apr_pool_t *common_pool)
+x_create(svn_fs_t *fs,
+ const char *path,
+ svn_mutex__t *common_pool_lock,
+ apr_pool_t *pool,
+ apr_pool_t *common_pool)
{
SVN_ERR(svn_fs__check_fs(fs, FALSE));
@@ -241,7 +244,10 @@ x_create(svn_fs_t *fs, const char *path,
SVN_ERR(svn_fs_x__create(fs, path, pool));
SVN_ERR(svn_fs_x__initialize_caches(fs, pool));
- return x_serialized_init(fs, common_pool, pool);
+ SVN_MUTEX__WITH_LOCK(common_pool_lock,
+ x_serialized_init(fs, common_pool, pool));
+
+ return SVN_NO_ERROR;
}
@@ -251,17 +257,26 @@ x_create(svn_fs_t *fs, const char *path,
/* This implements the fs_library_vtable_t.open() API. Open an FSX
Subversion filesystem located at PATH, set *FS to point to the
correct vtable for the filesystem. Use POOL for any temporary
- allocations, and COMMON_POOL for fs-global allocations. */
+ allocations, and COMMON_POOL for fs-global allocations.
+ The latter must be serialized using COMMON_POOL_LOCK. */
static svn_error_t *
-x_open(svn_fs_t *fs, const char *path, apr_pool_t *pool,
- apr_pool_t *common_pool)
+x_open(svn_fs_t *fs,
+ const char *path,
+ svn_mutex__t *common_pool_lock,
+ apr_pool_t *pool,
+ apr_pool_t *common_pool)
{
+ SVN_ERR(svn_fs__check_fs(fs, FALSE));
+
SVN_ERR(initialize_fs_struct(fs));
SVN_ERR(svn_fs_x__open(fs, path, pool));
SVN_ERR(svn_fs_x__initialize_caches(fs, pool));
- return x_serialized_init(fs, common_pool, pool);
+ SVN_MUTEX__WITH_LOCK(common_pool_lock,
+ x_serialized_init(fs, common_pool, pool));
+
+ return SVN_NO_ERROR;
}
@@ -270,7 +285,9 @@ x_open(svn_fs_t *fs, const char *path, a
static svn_error_t *
x_open_for_recovery(svn_fs_t *fs,
const char *path,
- apr_pool_t *pool, apr_pool_t *common_pool)
+ svn_mutex__t *common_pool_lock,
+ apr_pool_t *pool,
+ apr_pool_t *common_pool)
{
/* Recovery for FSX is currently limited to recreating the 'current'
file from the latest revision. */
@@ -288,7 +305,7 @@ x_open_for_recovery(svn_fs_t *fs,
"0 1 1\n", pool));
/* Now open the filesystem properly by calling the vtable method directly. */
- return x_open(fs, path, pool, common_pool);
+ return x_open(fs, path, common_pool_lock, pool, common_pool);
}
@@ -301,14 +318,11 @@ x_upgrade(svn_fs_t *fs,
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
+ svn_mutex__t *common_pool_lock,
apr_pool_t *pool,
apr_pool_t *common_pool)
{
- SVN_ERR(svn_fs__check_fs(fs, FALSE));
- SVN_ERR(initialize_fs_struct(fs));
- SVN_ERR(svn_fs_x__open(fs, path, pool));
- SVN_ERR(svn_fs_x__initialize_caches(fs, pool));
- SVN_ERR(x_serialized_init(fs, common_pool, pool));
+ SVN_ERR(x_open(fs, path, common_pool_lock, pool, common_pool));
return svn_fs_x__upgrade(fs, notify_func, notify_baton,
cancel_func, cancel_baton, pool);
}
@@ -321,14 +335,11 @@ x_verify(svn_fs_t *fs, const char *path,
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
+ svn_mutex__t *common_pool_lock,
apr_pool_t *pool,
apr_pool_t *common_pool)
{
- SVN_ERR(svn_fs__check_fs(fs, FALSE));
- SVN_ERR(initialize_fs_struct(fs));
- SVN_ERR(svn_fs_x__open(fs, path, pool));
- SVN_ERR(svn_fs_x__initialize_caches(fs, pool));
- SVN_ERR(x_serialized_init(fs, common_pool, pool));
+ SVN_ERR(x_open(fs, path, common_pool_lock, pool, common_pool));
return svn_fs_x__verify(fs, start, end, notify_func, notify_baton,
cancel_func, cancel_baton, pool);
}
@@ -340,14 +351,11 @@ x_pack(svn_fs_t *fs,
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
+ svn_mutex__t *common_pool_lock,
apr_pool_t *pool,
apr_pool_t *common_pool)
{
- SVN_ERR(svn_fs__check_fs(fs, FALSE));
- SVN_ERR(initialize_fs_struct(fs));
- SVN_ERR(svn_fs_x__open(fs, path, pool));
- SVN_ERR(svn_fs_x__initialize_caches(fs, pool));
- SVN_ERR(x_serialized_init(fs, common_pool, pool));
+ SVN_ERR(x_open(fs, path, common_pool_lock, pool, common_pool));
return svn_fs_x__pack(fs, notify_func, notify_baton,
cancel_func, cancel_baton, pool);
}
