You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@subversion.apache.org by st...@apache.org on 2012/11/30 00:19:55 UTC
svn commit: r1415451 [6/9] - in
/subversion/branches/fsfs-format7/subversion/libsvn_fs_fs: fs.c fs_fs.c
fs_fs.h low_level.c low_level.h rep-cache.c revprops.c revprops.h util.c
util.h
Copied: subversion/branches/fsfs-format7/subversion/libsvn_fs_fs/revprops.c (from r1413382, subversion/trunk/subversion/libsvn_fs_fs/fs_fs.c)
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_fs/revprops.c?p2=subversion/branches/fsfs-format7/subversion/libsvn_fs_fs/revprops.c&p1=subversion/trunk/subversion/libsvn_fs_fs/fs_fs.c&r1=1413382&r2=1415451&rev=1415451&view=diff
==============================================================================
--- subversion/trunk/subversion/libsvn_fs_fs/fs_fs.c (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_fs/revprops.c Thu Nov 29 23:19:53 2012
@@ -1,4 +1,4 @@
-/* fs_fs.c --- filesystem operations specific to fs_fs
+/* revprops.c --- everything needed to handle revprops in FSFS
*
* ====================================================================
* Licensed to the Apache Software Foundation (ASF) under one
@@ -20,80 +20,21 @@
* ====================================================================
*/
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <ctype.h>
#include <assert.h>
-#include <errno.h>
-
-#include <apr_general.h>
-#include <apr_pools.h>
-#include <apr_file_io.h>
-#include <apr_uuid.h>
-#include <apr_lib.h>
-#include <apr_md5.h>
-#include <apr_sha1.h>
-#include <apr_strings.h>
-#include <apr_thread_mutex.h>
#include "svn_pools.h"
-#include "svn_fs.h"
-#include "svn_dirent_uri.h"
-#include "svn_path.h"
#include "svn_hash.h"
-#include "svn_props.h"
-#include "svn_sorts.h"
-#include "svn_string.h"
-#include "svn_time.h"
-#include "svn_mergeinfo.h"
-#include "svn_config.h"
-#include "svn_ctype.h"
-
-#include "fs.h"
-#include "tree.h"
-#include "lock.h"
-#include "key-gen.h"
+#include "svn_dirent_uri.h"
+
#include "fs_fs.h"
-#include "id.h"
-#include "rep-cache.h"
-#include "temp_serializer.h"
+#include "revprops.h"
+#include "util.h"
-#include "private/svn_string_private.h"
-#include "private/svn_fs_util.h"
-#include "private/svn_subr_private.h"
#include "private/svn_delta_private.h"
+#include "private/svn_string_private.h"
#include "../libsvn_fs/fs-loader.h"
#include "svn_private_config.h"
-#include "temp_serializer.h"
-
-/* An arbitrary maximum path length, so clients can't run us out of memory
- * by giving us arbitrarily large paths. */
-#define FSFS_MAX_PATH_LEN 4096
-
-/* The default maximum number of files per directory to store in the
- rev and revprops directory. The number below is somewhat arbitrary,
- and can be overridden by defining the macro while compiling; the
- figure of 1000 is reasonable for VFAT filesystems, which are by far
- the worst performers in this area. */
-#ifndef SVN_FS_FS_DEFAULT_MAX_FILES_PER_DIR
-#define SVN_FS_FS_DEFAULT_MAX_FILES_PER_DIR 1000
-#endif
-
-/* Begin deltification after a node history exceeded this this limit.
- Useful values are 4 to 64 with 16 being a good compromise between
- computational overhead and repository size savings.
- Should be a power of 2.
- Values < 2 will result in standard skip-delta behavior. */
-#define SVN_FS_FS_MAX_LINEAR_DELTIFICATION 16
-
-/* Finding a deltification base takes operations proportional to the
- number of changes being skipped. To prevent exploding runtime
- during commits, limit the deltification range to this value.
- Should be a power of 2 minus one.
- Values < 1 disable deltification. */
-#define SVN_FS_FS_MAX_DELTIFICATION_WALK 1023
/* Give writing processes 10 seconds to replace an existing revprop
file with a new one. After that time, we assume that the writing
@@ -106,11182 +47,1653 @@
#define ATOMIC_REVPROP_TIMEOUT "rev-prop-timeout"
#define ATOMIC_REVPROP_NAMESPACE "rev-prop-atomics"
-/* Following are defines that specify the textual elements of the
- native filesystem directories and revision files. */
-
-/* Headers used to describe node-revision in the revision file. */
-#define HEADER_ID "id"
-#define HEADER_TYPE "type"
-#define HEADER_COUNT "count"
-#define HEADER_PROPS "props"
-#define HEADER_TEXT "text"
-#define HEADER_CPATH "cpath"
-#define HEADER_PRED "pred"
-#define HEADER_COPYFROM "copyfrom"
-#define HEADER_COPYROOT "copyroot"
-#define HEADER_FRESHTXNRT "is-fresh-txn-root"
-#define HEADER_MINFO_HERE "minfo-here"
-#define HEADER_MINFO_CNT "minfo-cnt"
-
-/* Kinds that a change can be. */
-#define ACTION_MODIFY "modify"
-#define ACTION_ADD "add"
-#define ACTION_DELETE "delete"
-#define ACTION_REPLACE "replace"
-#define ACTION_RESET "reset"
-
-/* True and False flags. */
-#define FLAG_TRUE "true"
-#define FLAG_FALSE "false"
-
-/* Kinds that a node-rev can be. */
-#define KIND_FILE "file"
-#define KIND_DIR "dir"
-
-/* Kinds of representation. */
-#define REP_PLAIN "PLAIN"
-#define REP_DELTA "DELTA"
-
-/* Notes:
-
-To avoid opening and closing the rev-files all the time, it would
-probably be advantageous to keep each rev-file open for the
-lifetime of the transaction object. I'll leave that as a later
-optimization for now.
-
-I didn't keep track of pool lifetimes at all in this code. There
-are likely some errors because of that.
-
-*/
-
-/* The vtable associated with an open transaction object. */
-static txn_vtable_t txn_vtable = {
- svn_fs_fs__commit_txn,
- svn_fs_fs__abort_txn,
- svn_fs_fs__txn_prop,
- svn_fs_fs__txn_proplist,
- svn_fs_fs__change_txn_prop,
- svn_fs_fs__txn_root,
- svn_fs_fs__change_txn_props
-};
-
-/* Declarations. */
+/* In the filesystem FS, pack all revprop shards up to min_unpacked_rev.
+ * Use SCRATCH_POOL for temporary allocations.
+ */
+svn_error_t *
+upgrade_pack_revprops(svn_fs_t *fs,
+ apr_pool_t *scratch_pool)
+{
+ fs_fs_data_t *ffd = fs->fsap_data;
+ const char *revprops_shard_path;
+ const char *revprops_pack_file_dir;
+ apr_int64_t shard;
+ apr_int64_t first_unpacked_shard
+ = ffd->min_unpacked_rev / ffd->max_files_per_dir;
-static svn_error_t *
-read_min_unpacked_rev(svn_revnum_t *min_unpacked_rev,
- const char *path,
- apr_pool_t *pool);
+ apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+ const char *revsprops_dir = svn_dirent_join(fs->path, PATH_REVPROPS_DIR,
+ scratch_pool);
+ int compression_level = ffd->compress_packed_revprops
+ ? SVN_DELTA_COMPRESSION_LEVEL_DEFAULT
+ : SVN_DELTA_COMPRESSION_LEVEL_NONE;
-static svn_error_t *
-update_min_unpacked_rev(svn_fs_t *fs, apr_pool_t *pool);
+ /* first, pack all revprops shards to match the packed revision shards */
+ for (shard = 0; shard < first_unpacked_shard; ++shard)
+ {
+ revprops_pack_file_dir = svn_dirent_join(revsprops_dir,
+ apr_psprintf(iterpool,
+ "%" APR_INT64_T_FMT PATH_EXT_PACKED_SHARD,
+ shard),
+ iterpool);
+ revprops_shard_path = svn_dirent_join(revsprops_dir,
+ apr_psprintf(iterpool, "%" APR_INT64_T_FMT, shard),
+ iterpool);
-static svn_error_t *
-get_youngest(svn_revnum_t *youngest_p, const char *fs_path, apr_pool_t *pool);
+ SVN_ERR(pack_revprops_shard(revprops_pack_file_dir, revprops_shard_path,
+ shard, ffd->max_files_per_dir,
+ (int)(0.9 * ffd->revprop_pack_size),
+ compression_level,
+ NULL, NULL, iterpool));
+ svn_pool_clear(iterpool);
+ }
-/* Pathname helper functions */
+ /* delete the non-packed revprops shards afterwards */
+ for (shard = 0; shard < first_unpacked_shard; ++shard)
+ {
+ revprops_shard_path = svn_dirent_join(revsprops_dir,
+ apr_psprintf(iterpool, "%" APR_INT64_T_FMT, shard),
+ iterpool);
+ SVN_ERR(delete_revprops_shard(revprops_shard_path,
+ shard, ffd->max_files_per_dir,
+ NULL, NULL, iterpool));
+ svn_pool_clear(iterpool);
+ }
-/* Return TRUE is REV is packed in FS, FALSE otherwise. */
-static svn_boolean_t
-is_packed_rev(svn_fs_t *fs, svn_revnum_t rev)
-{
- fs_fs_data_t *ffd = fs->fsap_data;
+ svn_pool_destroy(iterpool);
- return (rev < ffd->min_unpacked_rev);
+ return SVN_NO_ERROR;
}
-/* Return TRUE is REV is packed in FS, FALSE otherwise. */
-static svn_boolean_t
-is_packed_revprop(svn_fs_t *fs, svn_revnum_t rev)
-{
- fs_fs_data_t *ffd = fs->fsap_data;
-
- /* rev 0 will not be packed */
- return (rev < ffd->min_unpacked_rev)
- && (rev != 0)
- && (ffd->format >= SVN_FS_FS__MIN_PACKED_REVPROP_FORMAT);
-}
+/* Revprop caching management.
+ *
+ * Mechanism:
+ * ----------
+ *
+ * Revprop caching needs to be activated and will be deactivated for the
+ * respective FS instance if the necessary infrastructure could not be
+ * initialized. In deactivated mode, there is almost no runtime overhead
+ * associated with revprop caching. As long as no revprops are being read
+ * or changed, revprop caching imposes no overhead.
+ *
+ * When activated, we cache revprops using (revision, generation) pairs
+ * as keys with the generation being incremented upon every revprop change.
+ * Since the cache is process-local, the generation needs to be tracked
+ * for at least as long as the process lives but may be reset afterwards.
+ *
+ * To track the revprop generation, we use two-layer approach. On the lower
+ * level, we use named atomics to have a system-wide consistent value for
+ * the current revprop generation. However, those named atomics will only
+ * remain valid for as long as at least one process / thread in the system
+ * accesses revprops in the respective repository. The underlying shared
+ * memory gets cleaned up afterwards.
+ *
+ * On the second level, we will use a persistent file to track the latest
+ * revprop generation. It will be written upon each revprop change but
+ * only be read if we are the first process to initialize the named atomics
+ * with that value.
+ *
+ * The overhead for the second and following accesses to revprops is
+ * almost zero on most systems.
+ *
+ *
+ * Tech aspects:
+ * -------------
+ *
+ * A problem is that we need to provide a globally available file name to
+ * back the SHM implementation on OSes that need it. We can only assume
+ * write access to some file within the respective repositories. Because
+ * a given server process may access thousands of repositories during its
+ * lifetime, keeping the SHM data alive for all of them is also not an
+ * option.
+ *
+ * So, we store the new revprop generation on disk as part of each
+ * setrevprop call, i.e. this write will be serialized and the write order
+ * be guaranteed by the repository write lock.
+ *
+ * The only racy situation occurs when the data is being read again by two
+ * processes concurrently but in that situation, the first process to
+ * finish that procedure is guaranteed to be the only one that initializes
+ * the SHM data. Since even writers will first go through that
+ * initialization phase, they will never operate on stale data.
+ */
-static const char *
-path_format(svn_fs_t *fs, apr_pool_t *pool)
+/* Read revprop generation as stored on disk for repository FS. The result
+ * is returned in *CURRENT. Default to 2 if no such file is available.
+ */
+static svn_error_t *
+read_revprop_generation_file(apr_int64_t *current,
+ svn_fs_t *fs,
+ apr_pool_t *pool)
{
- return svn_dirent_join(fs->path, PATH_FORMAT, pool);
-}
+ svn_error_t *err;
+ apr_file_t *file;
+ char buf[80];
+ apr_size_t len;
+ const char *path = path_revprop_generation(fs, pool);
-static APR_INLINE const char *
-path_uuid(svn_fs_t *fs, apr_pool_t *pool)
-{
- return svn_dirent_join(fs->path, PATH_UUID, pool);
-}
+ err = svn_io_file_open(&file, path,
+ APR_READ | APR_BUFFERED,
+ APR_OS_DEFAULT, pool);
+ if (err && APR_STATUS_IS_ENOENT(err->apr_err))
+ {
+ svn_error_clear(err);
+ *current = 2;
-const char *
-svn_fs_fs__path_current(svn_fs_t *fs, apr_pool_t *pool)
-{
- return svn_dirent_join(fs->path, PATH_CURRENT, pool);
-}
+ return SVN_NO_ERROR;
+ }
+ SVN_ERR(err);
-static APR_INLINE const char *
-path_txn_current(svn_fs_t *fs, apr_pool_t *pool)
-{
- return svn_dirent_join(fs->path, PATH_TXN_CURRENT, pool);
-}
+ len = sizeof(buf);
+ SVN_ERR(svn_io_read_length_line(file, buf, &len, pool));
-static APR_INLINE const char *
-path_txn_current_lock(svn_fs_t *fs, apr_pool_t *pool)
-{
- return svn_dirent_join(fs->path, PATH_TXN_CURRENT_LOCK, pool);
-}
+ /* Check that the first line contains only digits. */
+ SVN_ERR(check_file_buffer_numeric(buf, 0, path,
+ "Revprop Generation", pool));
+ SVN_ERR(svn_cstring_atoi64(current, buf));
-static APR_INLINE const char *
-path_lock(svn_fs_t *fs, apr_pool_t *pool)
-{
- return svn_dirent_join(fs->path, PATH_LOCK_FILE, pool);
+ return svn_io_file_close(file, pool);
}
-static const char *
-path_revprop_generation(svn_fs_t *fs, apr_pool_t *pool)
+/* Write the CURRENT revprop generation to disk for repository FS.
+ */
+svn_error_t *
+write_revprop_generation_file(svn_fs_t *fs,
+ apr_int64_t current,
+ apr_pool_t *pool)
{
- return svn_dirent_join(fs->path, PATH_REVPROP_GENERATION, pool);
-}
+ apr_file_t *file;
+ const char *tmp_path;
-static const char *
-path_rev_packed(svn_fs_t *fs, svn_revnum_t rev, const char *kind,
- apr_pool_t *pool)
-{
- fs_fs_data_t *ffd = fs->fsap_data;
+ char buf[SVN_INT64_BUFFER_SIZE];
+ apr_size_t len = svn__i64toa(buf, current);
+ buf[len] = '\n';
- assert(ffd->max_files_per_dir);
- assert(is_packed_rev(fs, rev));
+ SVN_ERR(svn_io_open_unique_file3(&file, &tmp_path, fs->path,
+ svn_io_file_del_none, pool, pool));
+ SVN_ERR(svn_io_file_write_full(file, buf, len + 1, NULL, pool));
+ SVN_ERR(svn_io_file_close(file, pool));
- return svn_dirent_join_many(pool, fs->path, PATH_REVS_DIR,
- apr_psprintf(pool,
- "%ld" PATH_EXT_PACKED_SHARD,
- rev / ffd->max_files_per_dir),
- kind, NULL);
+ return move_into_place(tmp_path, path_revprop_generation(fs, pool),
+ tmp_path, pool);
}
-static const char *
-path_rev_shard(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
+/* Make sure the revprop_namespace member in FS is set. */
+static svn_error_t *
+ensure_revprop_namespace(svn_fs_t *fs)
{
fs_fs_data_t *ffd = fs->fsap_data;
- assert(ffd->max_files_per_dir);
- return svn_dirent_join_many(pool, fs->path, PATH_REVS_DIR,
- apr_psprintf(pool, "%ld",
- rev / ffd->max_files_per_dir),
- NULL);
+ return ffd->revprop_namespace == NULL
+ ? svn_atomic_namespace__create(&ffd->revprop_namespace,
+ svn_dirent_join(fs->path,
+ ATOMIC_REVPROP_NAMESPACE,
+ fs->pool),
+ fs->pool)
+ : SVN_NO_ERROR;
}
-static const char *
-path_rev(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
+/* Make sure the revprop_namespace member in FS is set. */
+svn_error_t *
+cleanup_revprop_namespace(svn_fs_t *fs)
{
- fs_fs_data_t *ffd = fs->fsap_data;
-
- assert(! is_packed_rev(fs, rev));
-
- if (ffd->max_files_per_dir)
- {
- return svn_dirent_join(path_rev_shard(fs, rev, pool),
- apr_psprintf(pool, "%ld", rev),
- pool);
- }
-
- return svn_dirent_join_many(pool, fs->path, PATH_REVS_DIR,
- apr_psprintf(pool, "%ld", rev), NULL);
+ const char *name = svn_dirent_join(fs->path,
+ ATOMIC_REVPROP_NAMESPACE,
+ fs->pool);
+ return svn_error_trace(svn_atomic_namespace__cleanup(name, fs->pool));
}
-svn_error_t *
-svn_fs_fs__path_rev_absolute(const char **path,
- svn_fs_t *fs,
- svn_revnum_t rev,
- apr_pool_t *pool)
+/* Make sure the revprop_generation member in FS is set and, if necessary,
+ * initialized with the latest value stored on disk.
+ */
+static svn_error_t *
+ensure_revprop_generation(svn_fs_t *fs, apr_pool_t *pool)
{
fs_fs_data_t *ffd = fs->fsap_data;
- if (ffd->format < SVN_FS_FS__MIN_PACKED_FORMAT
- || ! is_packed_rev(fs, rev))
- {
- *path = path_rev(fs, rev, pool);
- }
- else
+ SVN_ERR(ensure_revprop_namespace(fs));
+ if (ffd->revprop_generation == NULL)
{
- *path = path_rev_packed(fs, rev, PATH_PACKED, pool);
+ apr_int64_t current = 0;
+
+ SVN_ERR(svn_named_atomic__get(&ffd->revprop_generation,
+ ffd->revprop_namespace,
+ ATOMIC_REVPROP_GENERATION,
+ TRUE));
+
+ /* If the generation is at 0, we just created a new namespace
+ * (it would be at least 2 otherwise). Read the latest generation
+ * from disk and if we are the first one to initialize the atomic
+ * (i.e. is still 0), set it to the value just gotten.
+ */
+ SVN_ERR(svn_named_atomic__read(¤t, ffd->revprop_generation));
+ if (current == 0)
+ {
+ SVN_ERR(read_revprop_generation_file(¤t, fs, pool));
+ SVN_ERR(svn_named_atomic__cmpxchg(NULL, current, 0,
+ ffd->revprop_generation));
+ }
}
return SVN_NO_ERROR;
}
-static const char *
-path_revprops_shard(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
+/* Make sure the revprop_timeout member in FS is set. */
+static svn_error_t *
+ensure_revprop_timeout(svn_fs_t *fs)
{
fs_fs_data_t *ffd = fs->fsap_data;
- assert(ffd->max_files_per_dir);
- return svn_dirent_join_many(pool, fs->path, PATH_REVPROPS_DIR,
- apr_psprintf(pool, "%ld",
- rev / ffd->max_files_per_dir),
- NULL);
+ SVN_ERR(ensure_revprop_namespace(fs));
+ return ffd->revprop_timeout == NULL
+ ? svn_named_atomic__get(&ffd->revprop_timeout,
+ ffd->revprop_namespace,
+ ATOMIC_REVPROP_TIMEOUT,
+ TRUE)
+ : SVN_NO_ERROR;
}
-static const char *
-path_revprops_pack_shard(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
+/* Create an error object with the given MESSAGE and pass it to the
+ WARNING member of FS. */
+static void
+log_revprop_cache_init_warning(svn_fs_t *fs,
+ svn_error_t *underlying_err,
+ const char *message)
{
- fs_fs_data_t *ffd = fs->fsap_data;
-
- assert(ffd->max_files_per_dir);
- return svn_dirent_join_many(pool, fs->path, PATH_REVPROPS_DIR,
- apr_psprintf(pool, "%ld" PATH_EXT_PACKED_SHARD,
- rev / ffd->max_files_per_dir),
- NULL);
-}
+ svn_error_t *err = svn_error_createf(SVN_ERR_FS_REPPROP_CACHE_INIT_FAILURE,
+ underlying_err,
+ message, fs->path);
+
+ if (fs->warning)
+ (fs->warning)(fs->warning_baton, err);
+
+ svn_error_clear(err);
+}
-static const char *
-path_revprops(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
+/* Test whether revprop cache and necessary infrastructure are
+ available in FS. */
+static svn_boolean_t
+has_revprop_cache(svn_fs_t *fs, apr_pool_t *pool)
{
fs_fs_data_t *ffd = fs->fsap_data;
+ svn_error_t *error;
+
+ /* is the cache (still) enabled? */
+ if (ffd->revprop_cache == NULL)
+ return FALSE;
- if (ffd->max_files_per_dir)
+ /* is it efficient? */
+ if (!svn_named_atomic__is_efficient())
{
- return svn_dirent_join(path_revprops_shard(fs, rev, pool),
- apr_psprintf(pool, "%ld", rev),
- pool);
+ /* access to it would be quite slow
+ * -> disable the revprop cache for good
+ */
+ ffd->revprop_cache = NULL;
+ log_revprop_cache_init_warning(fs, NULL,
+ "Revprop caching for '%s' disabled"
+ " because it would be inefficient.");
+
+ return FALSE;
}
- return svn_dirent_join_many(pool, fs->path, PATH_REVPROPS_DIR,
- apr_psprintf(pool, "%ld", rev), NULL);
-}
+ /* try to access our SHM-backed infrastructure */
+ error = ensure_revprop_generation(fs, pool);
+ if (error)
+ {
+ /* failure -> disable revprop cache for good */
-static APR_INLINE const char *
-path_txn_dir(svn_fs_t *fs, const char *txn_id, apr_pool_t *pool)
-{
- SVN_ERR_ASSERT_NO_RETURN(txn_id != NULL);
- return svn_dirent_join_many(pool, fs->path, PATH_TXNS_DIR,
- apr_pstrcat(pool, txn_id, PATH_EXT_TXN,
- (char *)NULL),
- NULL);
-}
+ ffd->revprop_cache = NULL;
+ log_revprop_cache_init_warning(fs, error,
+ "Revprop caching for '%s' disabled "
+ "because SHM infrastructure for revprop "
+ "caching failed to initialize.");
-/* Return the name of the sha1->rep mapping file in transaction TXN_ID
- * within FS for the given SHA1 checksum. Use POOL for allocations.
- */
-static APR_INLINE const char *
-path_txn_sha1(svn_fs_t *fs, const char *txn_id, svn_checksum_t *sha1,
- apr_pool_t *pool)
-{
- return svn_dirent_join(path_txn_dir(fs, txn_id, pool),
- svn_checksum_to_cstring(sha1, pool),
- pool);
-}
+ return FALSE;
+ }
-static APR_INLINE const char *
-path_txn_changes(svn_fs_t *fs, const char *txn_id, apr_pool_t *pool)
-{
- return svn_dirent_join(path_txn_dir(fs, txn_id, pool), PATH_CHANGES, pool);
+ return TRUE;
}
-static APR_INLINE const char *
-path_txn_props(svn_fs_t *fs, const char *txn_id, apr_pool_t *pool)
+/* Baton structure for revprop_generation_fixup. */
+typedef struct revprop_generation_fixup_t
{
- return svn_dirent_join(path_txn_dir(fs, txn_id, pool), PATH_TXN_PROPS, pool);
-}
+ /* revprop generation to read */
+ apr_int64_t *generation;
-static APR_INLINE const char *
-path_txn_next_ids(svn_fs_t *fs, const char *txn_id, apr_pool_t *pool)
-{
- return svn_dirent_join(path_txn_dir(fs, txn_id, pool), PATH_NEXT_IDS, pool);
-}
+ /* containing the revprop_generation member to query */
+ fs_fs_data_t *ffd;
+} revprop_generation_upgrade_t;
-static APR_INLINE const char *
-path_min_unpacked_rev(svn_fs_t *fs, apr_pool_t *pool)
+/* If the revprop generation has an odd value, it means the original writer
+ of the revprop got killed. We don't know whether that process as able
+ to change the revprop data but we assume that it was. Therefore, we
+ increase the generation in that case to basically invalidate everyones
+ cache content.
+ Execute this onlx while holding the write lock to the repo in baton->FFD.
+ */
+static svn_error_t *
+revprop_generation_fixup(void *void_baton,
+ apr_pool_t *pool)
{
- return svn_dirent_join(fs->path, PATH_MIN_UNPACKED_REV, pool);
-}
+ revprop_generation_upgrade_t *baton = void_baton;
+ assert(baton->ffd->has_write_lock);
+
+ /* Maybe, either the original revprop writer or some other reader has
+ already corrected / bumped the revprop generation. Thus, we need
+ to read it again. */
+ SVN_ERR(svn_named_atomic__read(baton->generation,
+ baton->ffd->revprop_generation));
+ /* Cause everyone to re-read revprops upon their next access, if the
+ last revprop write did not complete properly. */
+ while (*baton->generation % 2)
+ SVN_ERR(svn_named_atomic__add(baton->generation,
+ 1,
+ baton->ffd->revprop_generation));
-static APR_INLINE const char *
-path_txn_proto_rev(svn_fs_t *fs, const char *txn_id, apr_pool_t *pool)
-{
- fs_fs_data_t *ffd = fs->fsap_data;
- if (ffd->format >= SVN_FS_FS__MIN_PROTOREVS_DIR_FORMAT)
- return svn_dirent_join_many(pool, fs->path, PATH_TXN_PROTOS_DIR,
- apr_pstrcat(pool, txn_id, PATH_EXT_REV,
- (char *)NULL),
- NULL);
- else
- return svn_dirent_join(path_txn_dir(fs, txn_id, pool), PATH_REV, pool);
+ return SVN_NO_ERROR;
}
-static APR_INLINE const char *
-path_txn_proto_rev_lock(svn_fs_t *fs, const char *txn_id, apr_pool_t *pool)
+/* Read the current revprop generation and return it in *GENERATION.
+ Also, detect aborted / crashed writers and recover from that.
+ Use the access object in FS to set the shared mem values. */
+static svn_error_t *
+read_revprop_generation(apr_int64_t *generation,
+ svn_fs_t *fs,
+ apr_pool_t *pool)
{
+ apr_int64_t current = 0;
fs_fs_data_t *ffd = fs->fsap_data;
- if (ffd->format >= SVN_FS_FS__MIN_PROTOREVS_DIR_FORMAT)
- return svn_dirent_join_many(pool, fs->path, PATH_TXN_PROTOS_DIR,
- apr_pstrcat(pool, txn_id, PATH_EXT_REV_LOCK,
- (char *)NULL),
- NULL);
- else
- return svn_dirent_join(path_txn_dir(fs, txn_id, pool), PATH_REV_LOCK,
- pool);
-}
-
-static const char *
-path_txn_node_rev(svn_fs_t *fs, const svn_fs_id_t *id, apr_pool_t *pool)
-{
- const char *txn_id = svn_fs_fs__id_txn_id(id);
- const char *node_id = svn_fs_fs__id_node_id(id);
- const char *copy_id = svn_fs_fs__id_copy_id(id);
- const char *name = apr_psprintf(pool, PATH_PREFIX_NODE "%s.%s",
- node_id, copy_id);
-
- return svn_dirent_join(path_txn_dir(fs, txn_id, pool), name, pool);
-}
-
-static APR_INLINE const char *
-path_txn_node_props(svn_fs_t *fs, const svn_fs_id_t *id, apr_pool_t *pool)
-{
- return apr_pstrcat(pool, path_txn_node_rev(fs, id, pool), PATH_EXT_PROPS,
- (char *)NULL);
-}
-static APR_INLINE const char *
-path_txn_node_children(svn_fs_t *fs, const svn_fs_id_t *id, apr_pool_t *pool)
-{
- return apr_pstrcat(pool, path_txn_node_rev(fs, id, pool),
- PATH_EXT_CHILDREN, (char *)NULL);
-}
+ /* read the current revprop generation number */
+ SVN_ERR(ensure_revprop_generation(fs, pool));
+ SVN_ERR(svn_named_atomic__read(¤t, ffd->revprop_generation));
-static APR_INLINE const char *
-path_node_origin(svn_fs_t *fs, const char *node_id, apr_pool_t *pool)
-{
- size_t len = strlen(node_id);
- const char *node_id_minus_last_char =
- (len == 1) ? "0" : apr_pstrmemdup(pool, node_id, len - 1);
- return svn_dirent_join_many(pool, fs->path, PATH_NODE_ORIGINS_DIR,
- node_id_minus_last_char, NULL);
-}
+ /* is an unfinished revprop write under the way? */
+ if (current % 2)
+ {
+ apr_int64_t timeout = 0;
-static APR_INLINE const char *
-path_and_offset_of(apr_file_t *file, apr_pool_t *pool)
-{
- const char *path;
- apr_off_t offset = 0;
+ /* read timeout for the write operation */
+ SVN_ERR(ensure_revprop_timeout(fs));
+ SVN_ERR(svn_named_atomic__read(&timeout, ffd->revprop_timeout));
- if (apr_file_name_get(&path, file) != APR_SUCCESS)
- path = "(unknown)";
+ /* has the writer process been aborted,
+ * i.e. has the timeout been reached?
+ */
+ if (apr_time_now() > timeout)
+ {
+ revprop_generation_upgrade_t baton;
+ baton.generation = ¤t;
+ baton.ffd = ffd;
- if (apr_file_seek(file, APR_CUR, &offset) != APR_SUCCESS)
- offset = -1;
+ /* Ensure that the original writer process no longer exists by
+ * acquiring the write lock to this repository. Then, fix up
+ * the revprop generation.
+ */
+ if (ffd->has_write_lock)
+ SVN_ERR(revprop_generation_fixup(&baton, pool));
+ else
+ SVN_ERR(svn_fs_fs__with_write_lock(fs, revprop_generation_fixup,
+ &baton, pool));
+ }
+ }
- return apr_psprintf(pool, "%s:%" APR_OFF_T_FMT, path, offset);
+ /* return the value we just got */
+ *generation = current;
+ return SVN_NO_ERROR;
}
-
-
-/* Functions for working with shared transaction data. */
-
-/* Return the transaction object for transaction TXN_ID from the
- transaction list of filesystem FS (which must already be locked via the
- txn_list_lock mutex). If the transaction does not exist in the list,
- then create a new transaction object and return it (if CREATE_NEW is
- true) or return NULL (otherwise). */
-static fs_fs_shared_txn_data_t *
-get_shared_txn(svn_fs_t *fs, const char *txn_id, svn_boolean_t create_new)
+/* Set the revprop generation to the next odd number to indicate that
+ there is a revprop write process under way. If that times out,
+ readers shall recover from that state & re-read revprops.
+ Use the access object in FS to set the shared mem value. */
+static svn_error_t *
+begin_revprop_change(svn_fs_t *fs, apr_pool_t *pool)
{
+ apr_int64_t current;
fs_fs_data_t *ffd = fs->fsap_data;
- fs_fs_shared_data_t *ffsd = ffd->shared;
- fs_fs_shared_txn_data_t *txn;
- for (txn = ffsd->txns; txn; txn = txn->next)
- if (strcmp(txn->txn_id, txn_id) == 0)
- break;
-
- if (txn || !create_new)
- return txn;
-
- /* Use the transaction object from the (single-object) freelist,
- if one is available, or otherwise create a new object. */
- if (ffsd->free_txn)
- {
- txn = ffsd->free_txn;
- ffsd->free_txn = NULL;
- }
- else
+ /* set the timeout for the write operation */
+ SVN_ERR(ensure_revprop_timeout(fs));
+ SVN_ERR(svn_named_atomic__write(NULL,
+ apr_time_now() + REVPROP_CHANGE_TIMEOUT,
+ ffd->revprop_timeout));
+
+ /* set the revprop generation to an odd value to indicate
+ * that a write is in progress
+ */
+ SVN_ERR(ensure_revprop_generation(fs, pool));
+ do
{
- apr_pool_t *subpool = svn_pool_create(ffsd->common_pool);
- txn = apr_palloc(subpool, sizeof(*txn));
- txn->pool = subpool;
+ SVN_ERR(svn_named_atomic__add(¤t,
+ 1,
+ ffd->revprop_generation));
}
+ while (current % 2 == 0);
- assert(strlen(txn_id) < sizeof(txn->txn_id));
- apr_cpystrn(txn->txn_id, txn_id, sizeof(txn->txn_id));
- txn->being_written = FALSE;
-
- /* Link this transaction into the head of the list. We will typically
- be dealing with only one active transaction at a time, so it makes
- sense for searches through the transaction list to look at the
- newest transactions first. */
- txn->next = ffsd->txns;
- ffsd->txns = txn;
-
- return txn;
+ return SVN_NO_ERROR;
}
-/* Free the transaction object for transaction TXN_ID, and remove it
- from the transaction list of filesystem FS (which must already be
- locked via the txn_list_lock mutex). Do nothing if the transaction
- does not exist. */
-static void
-free_shared_txn(svn_fs_t *fs, const char *txn_id)
+/* Set the revprop generation to the next even number to indicate that
+ a) readers shall re-read revprops, and
+ b) the write process has been completed (no recovery required)
+ Use the access object in FS to set the shared mem value. */
+static svn_error_t *
+end_revprop_change(svn_fs_t *fs, apr_pool_t *pool)
{
+ apr_int64_t current = 1;
fs_fs_data_t *ffd = fs->fsap_data;
- fs_fs_shared_data_t *ffsd = ffd->shared;
- fs_fs_shared_txn_data_t *txn, *prev = NULL;
- for (txn = ffsd->txns; txn; prev = txn, txn = txn->next)
- if (strcmp(txn->txn_id, txn_id) == 0)
- break;
-
- if (!txn)
- return;
-
- if (prev)
- prev->next = txn->next;
- else
- ffsd->txns = txn->next;
+ /* set the revprop generation to an even value to indicate
+ * that a write has been completed
+ */
+ SVN_ERR(ensure_revprop_generation(fs, pool));
+ do
+ {
+ SVN_ERR(svn_named_atomic__add(¤t,
+ 1,
+ ffd->revprop_generation));
+ }
+ while (current % 2);
- /* As we typically will be dealing with one transaction after another,
- we will maintain a single-object free list so that we can hopefully
- keep reusing the same transaction object. */
- if (!ffsd->free_txn)
- ffsd->free_txn = txn;
- else
- svn_pool_destroy(txn->pool);
+ /* Save the latest generation to disk. FS is currently in a "locked"
+ * state such that we can be sure the be the only ones to write that
+ * file.
+ */
+ return write_revprop_generation_file(fs, current, pool);
}
-
-/* Obtain a lock on the transaction list of filesystem FS, call BODY
- with FS, BATON, and POOL, and then unlock the transaction list.
- Return what BODY returned. */
-static svn_error_t *
-with_txnlist_lock(svn_fs_t *fs,
- svn_error_t *(*body)(svn_fs_t *fs,
- const void *baton,
- apr_pool_t *pool),
- const void *baton,
- apr_pool_t *pool)
+/* Container for all data required to access the packed revprop file
+ * for a given REVISION. This structure will be filled incrementally
+ * by read_pack_revprops() its sub-routines.
+ */
+typedef struct packed_revprops_t
{
- fs_fs_data_t *ffd = fs->fsap_data;
- fs_fs_shared_data_t *ffsd = ffd->shared;
+ /* revision number to read (not necessarily the first in the pack) */
+ svn_revnum_t revision;
- SVN_MUTEX__WITH_LOCK(ffsd->txn_list_lock,
- body(fs, baton, pool));
+ /* current revprop generation. Used when populating the revprop cache */
+ apr_int64_t generation;
- return SVN_NO_ERROR;
-}
+ /* the actual revision properties */
+ apr_hash_t *properties;
+ /* their size when serialized to a single string
+ * (as found in PACKED_REVPROPS) */
+ apr_size_t serialized_size;
-/* Get a lock on empty file LOCK_FILENAME, creating it in POOL. */
-static svn_error_t *
-get_lock_on_filesystem(const char *lock_filename,
- apr_pool_t *pool)
-{
- svn_error_t *err = svn_io_file_lock2(lock_filename, TRUE, FALSE, pool);
- if (err && APR_STATUS_IS_ENOENT(err->apr_err))
- {
- /* No lock file? No big deal; these are just empty files
- anyway. Create it and try again. */
- svn_error_clear(err);
- err = NULL;
+ /* name of the pack file (without folder path) */
+ const char *filename;
- SVN_ERR(svn_io_file_create(lock_filename, "", pool));
- SVN_ERR(svn_io_file_lock2(lock_filename, TRUE, FALSE, pool));
- }
+ /* packed shard folder path */
+ const char *folder;
- return svn_error_trace(err);
-}
+ /* sum of values in SIZES */
+ apr_size_t total_size;
-/* Reset the HAS_WRITE_LOCK member in the FFD given as BATON_VOID.
- When registered with the pool holding the lock on the lock file,
- this makes sure the flag gets reset just before we release the lock. */
-static apr_status_t
-reset_lock_flag(void *baton_void)
-{
- fs_fs_data_t *ffd = baton_void;
- ffd->has_write_lock = FALSE;
- return APR_SUCCESS;
-}
+ /* first revision in the pack */
+ svn_revnum_t start_revision;
-/* Obtain a write lock on the file LOCK_FILENAME (protecting with
- LOCK_MUTEX if APR is threaded) in a subpool of POOL, call BODY with
- BATON and that subpool, destroy the subpool (releasing the write
- lock) and return what BODY returned. If IS_GLOBAL_LOCK is set,
- set the HAS_WRITE_LOCK flag while we keep the write lock. */
-static svn_error_t *
-with_some_lock_file(svn_fs_t *fs,
- svn_error_t *(*body)(void *baton,
- apr_pool_t *pool),
- void *baton,
- const char *lock_filename,
- svn_boolean_t is_global_lock,
- apr_pool_t *pool)
-{
- apr_pool_t *subpool = svn_pool_create(pool);
- svn_error_t *err = get_lock_on_filesystem(lock_filename, subpool);
+ /* size of the revprops in PACKED_REVPROPS */
+ apr_array_header_t *sizes;
- if (!err)
- {
- fs_fs_data_t *ffd = fs->fsap_data;
+ /* offset of the revprops in PACKED_REVPROPS */
+ apr_array_header_t *offsets;
- if (is_global_lock)
- {
- /* set the "got the lock" flag and register reset function */
- apr_pool_cleanup_register(subpool,
- ffd,
- reset_lock_flag,
- apr_pool_cleanup_null);
- ffd->has_write_lock = TRUE;
- }
- /* nobody else will modify the repo state
- => read HEAD & pack info once */
- if (ffd->format >= SVN_FS_FS__MIN_PACKED_FORMAT)
- SVN_ERR(update_min_unpacked_rev(fs, pool));
- SVN_ERR(get_youngest(&ffd->youngest_rev_cache, fs->path,
- pool));
- err = body(baton, subpool);
- }
+ /* concatenation of the serialized representation of all revprops
+ * in the pack, i.e. the pack content without header and compression */
+ svn_stringbuf_t *packed_revprops;
- svn_pool_destroy(subpool);
+ /* content of the manifest.
+ * Maps long(rev - START_REVISION) to const char* pack file name */
+ apr_array_header_t *manifest;
+} packed_revprops_t;
- return svn_error_trace(err);
-}
-
-svn_error_t *
-svn_fs_fs__with_write_lock(svn_fs_t *fs,
- svn_error_t *(*body)(void *baton,
- apr_pool_t *pool),
- void *baton,
- apr_pool_t *pool)
-{
- fs_fs_data_t *ffd = fs->fsap_data;
- fs_fs_shared_data_t *ffsd = ffd->shared;
-
- SVN_MUTEX__WITH_LOCK(ffsd->fs_write_lock,
- with_some_lock_file(fs, body, baton,
- path_lock(fs, pool),
- TRUE,
- pool));
-
- return SVN_NO_ERROR;
-}
-
-/* Run BODY (with BATON and POOL) while the txn-current file
- of FS is locked. */
+/* Parse the serialized revprops in CONTENT and return them in *PROPERTIES.
+ * Also, put them into the revprop cache, if activated, for future use.
+ * Three more parameters are being used to update the revprop cache: FS is
+ * our file system, the revprops belong to REVISION and the global revprop
+ * GENERATION is used as well.
+ *
+ * The returned hash will be allocated in POOL, SCRATCH_POOL is being used
+ * for temporary allocations.
+ */
static svn_error_t *
-with_txn_current_lock(svn_fs_t *fs,
- svn_error_t *(*body)(void *baton,
- apr_pool_t *pool),
- void *baton,
- apr_pool_t *pool)
+parse_revprop(apr_hash_t **properties,
+ svn_fs_t *fs,
+ svn_revnum_t revision,
+ apr_int64_t generation,
+ svn_string_t *content,
+ apr_pool_t *pool,
+ apr_pool_t *scratch_pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
- fs_fs_shared_data_t *ffsd = ffd->shared;
+ svn_stream_t *stream = svn_stream_from_string(content, scratch_pool);
+ *properties = apr_hash_make(pool);
+
+ SVN_ERR(svn_hash_read2(*properties, stream, SVN_HASH_TERMINATOR, pool));
+ if (has_revprop_cache(fs, pool))
+ {
+ fs_fs_data_t *ffd = fs->fsap_data;
+ pair_cache_key_t key;
- SVN_MUTEX__WITH_LOCK(ffsd->txn_current_lock,
- with_some_lock_file(fs, body, baton,
- path_txn_current_lock(fs, pool),
- FALSE,
- pool));
+ key.revision = revision;
+ key.second = generation;
+ SVN_ERR(svn_cache__set(ffd->revprop_cache, &key, *properties,
+ scratch_pool));
+ }
return SVN_NO_ERROR;
}
-/* A structure used by unlock_proto_rev() and unlock_proto_rev_body(),
- which see. */
-struct unlock_proto_rev_baton
-{
- const char *txn_id;
- void *lockcookie;
-};
-
-/* Callback used in the implementation of unlock_proto_rev(). */
+/* Read the non-packed revprops for revision REV in FS, put them into the
+ * revprop cache if activated and return them in *PROPERTIES. GENERATION
+ * is the current revprop generation.
+ *
+ * If the data could not be read due to an otherwise recoverable error,
+ * leave *PROPERTIES unchanged. No error will be returned in that case.
+ *
+ * Allocations will be done in POOL.
+ */
static svn_error_t *
-unlock_proto_rev_body(svn_fs_t *fs, const void *baton, apr_pool_t *pool)
+read_non_packed_revprop(apr_hash_t **properties,
+ svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_int64_t generation,
+ apr_pool_t *pool)
{
- const struct unlock_proto_rev_baton *b = baton;
- const char *txn_id = b->txn_id;
- apr_file_t *lockfile = b->lockcookie;
- fs_fs_shared_txn_data_t *txn = get_shared_txn(fs, txn_id, FALSE);
- apr_status_t apr_err;
+ svn_stringbuf_t *content = NULL;
+ apr_pool_t *iterpool = svn_pool_create(pool);
+ svn_boolean_t missing = FALSE;
+ int i;
- if (!txn)
- return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
- _("Can't unlock unknown transaction '%s'"),
- txn_id);
- if (!txn->being_written)
- return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
- _("Can't unlock nonlocked transaction '%s'"),
- txn_id);
+ for (i = 0; i < RECOVERABLE_RETRY_COUNT && !missing && !content; ++i)
+ {
+ svn_pool_clear(iterpool);
+ SVN_ERR(try_stringbuf_from_file(&content,
+ &missing,
+ path_revprops(fs, rev, iterpool),
+ i + 1 < RECOVERABLE_RETRY_COUNT,
+ iterpool));
+ }
- apr_err = apr_file_unlock(lockfile);
- if (apr_err)
- return svn_error_wrap_apr
- (apr_err,
- _("Can't unlock prototype revision lockfile for transaction '%s'"),
- txn_id);
- apr_err = apr_file_close(lockfile);
- if (apr_err)
- return svn_error_wrap_apr
- (apr_err,
- _("Can't close prototype revision lockfile for transaction '%s'"),
- txn_id);
+ if (content)
+ SVN_ERR(parse_revprop(properties, fs, rev, generation,
+ svn_stringbuf__morph_into_string(content),
+ pool, iterpool));
- txn->being_written = FALSE;
+ svn_pool_clear(iterpool);
return SVN_NO_ERROR;
}
-/* Unlock the prototype revision file for transaction TXN_ID in filesystem
- FS using cookie LOCKCOOKIE. The original prototype revision file must
- have been closed _before_ calling this function.
-
- Perform temporary allocations in POOL. */
-static svn_error_t *
-unlock_proto_rev(svn_fs_t *fs, const char *txn_id, void *lockcookie,
- apr_pool_t *pool)
-{
- struct unlock_proto_rev_baton b;
-
- b.txn_id = txn_id;
- b.lockcookie = lockcookie;
- return with_txnlist_lock(fs, unlock_proto_rev_body, &b, pool);
-}
-
-/* Same as unlock_proto_rev(), but requires that the transaction list
- lock is already held. */
-static svn_error_t *
-unlock_proto_rev_list_locked(svn_fs_t *fs, const char *txn_id,
- void *lockcookie,
- apr_pool_t *pool)
-{
- struct unlock_proto_rev_baton b;
-
- b.txn_id = txn_id;
- b.lockcookie = lockcookie;
- return unlock_proto_rev_body(fs, &b, pool);
-}
-
-/* A structure used by get_writable_proto_rev() and
- get_writable_proto_rev_body(), which see. */
-struct get_writable_proto_rev_baton
-{
- apr_file_t **file;
- void **lockcookie;
- const char *txn_id;
-};
-
-/* Callback used in the implementation of get_writable_proto_rev(). */
+/* Given FS and REVPROPS->REVISION, fill the FILENAME, FOLDER and MANIFEST
+ * members. Use POOL for allocating results and SCRATCH_POOL for temporaries.
+ */
static svn_error_t *
-get_writable_proto_rev_body(svn_fs_t *fs, const void *baton, apr_pool_t *pool)
+get_revprop_packname(svn_fs_t *fs,
+ packed_revprops_t *revprops,
+ apr_pool_t *pool,
+ apr_pool_t *scratch_pool)
{
- const struct get_writable_proto_rev_baton *b = baton;
- apr_file_t **file = b->file;
- void **lockcookie = b->lockcookie;
- const char *txn_id = b->txn_id;
- svn_error_t *err;
- fs_fs_shared_txn_data_t *txn = get_shared_txn(fs, txn_id, TRUE);
-
- /* First, ensure that no thread in this process (including this one)
- is currently writing to this transaction's proto-rev file. */
- if (txn->being_written)
- return svn_error_createf(SVN_ERR_FS_REP_BEING_WRITTEN, NULL,
- _("Cannot write to the prototype revision file "
- "of transaction '%s' because a previous "
- "representation is currently being written by "
- "this process"),
- txn_id);
-
-
- /* We know that no thread in this process is writing to the proto-rev
- file, and by extension, that no thread in this process is holding a
- lock on the prototype revision lock file. It is therefore safe
- for us to attempt to lock this file, to see if any other process
- is holding a lock. */
-
- {
- apr_file_t *lockfile;
- apr_status_t apr_err;
- const char *lockfile_path = path_txn_proto_rev_lock(fs, txn_id, pool);
-
- /* Open the proto-rev lockfile, creating it if necessary, as it may
- not exist if the transaction dates from before the lockfiles were
- introduced.
-
- ### We'd also like to use something like svn_io_file_lock2(), but
- that forces us to create a subpool just to be able to unlock
- the file, which seems a waste. */
- SVN_ERR(svn_io_file_open(&lockfile, lockfile_path,
- APR_WRITE | APR_CREATE, APR_OS_DEFAULT, pool));
-
- apr_err = apr_file_lock(lockfile,
- APR_FLOCK_EXCLUSIVE | APR_FLOCK_NONBLOCK);
- if (apr_err)
- {
- svn_error_clear(svn_io_file_close(lockfile, pool));
-
- if (APR_STATUS_IS_EAGAIN(apr_err))
- return svn_error_createf(SVN_ERR_FS_REP_BEING_WRITTEN, NULL,
- _("Cannot write to the prototype revision "
- "file of transaction '%s' because a "
- "previous representation is currently "
- "being written by another process"),
- txn_id);
-
- return svn_error_wrap_apr(apr_err,
- _("Can't get exclusive lock on file '%s'"),
- svn_dirent_local_style(lockfile_path, pool));
- }
-
- *lockcookie = lockfile;
- }
+ fs_fs_data_t *ffd = fs->fsap_data;
+ svn_stringbuf_t *content = NULL;
+ const char *manifest_file_path;
+ int idx;
- /* We've successfully locked the transaction; mark it as such. */
- txn->being_written = TRUE;
+ /* read content of the manifest file */
+ revprops->folder = path_revprops_pack_shard(fs, revprops->revision, pool);
+ manifest_file_path = svn_dirent_join(revprops->folder, PATH_MANIFEST, pool);
+ SVN_ERR(read_content(&content, manifest_file_path, pool));
- /* Now open the prototype revision file and seek to the end. */
- err = svn_io_file_open(file, path_txn_proto_rev(fs, txn_id, pool),
- APR_WRITE | APR_BUFFERED, APR_OS_DEFAULT, pool);
-
- /* You might expect that we could dispense with the following seek
- and achieve the same thing by opening the file using APR_APPEND.
- Unfortunately, APR's buffered file implementation unconditionally
- places its initial file pointer at the start of the file (even for
- files opened with APR_APPEND), so we need this seek to reconcile
- the APR file pointer to the OS file pointer (since we need to be
- able to read the current file position later). */
- if (!err)
+ /* parse the manifest. Every line is a file name */
+ revprops->manifest = apr_array_make(pool, ffd->max_files_per_dir,
+ sizeof(const char*));
+ while (content->data)
{
- apr_off_t offset = 0;
- err = svn_io_file_seek(*file, APR_END, &offset, pool);
+ APR_ARRAY_PUSH(revprops->manifest, const char*) = content->data;
+ content->data = strchr(content->data, '\n');
+ if (content->data)
+ {
+ *content->data = 0;
+ content->data++;
+ }
}
- if (err)
- {
- err = svn_error_compose_create(
- err,
- unlock_proto_rev_list_locked(fs, txn_id, *lockcookie, pool));
-
- *lockcookie = NULL;
- }
+ /* Index for our revision. Rev 0 is excluded from the first shard. */
+ idx = (int)(revprops->revision % ffd->max_files_per_dir);
+ if (revprops->revision < ffd->max_files_per_dir)
+ --idx;
- return svn_error_trace(err);
-}
+ if (revprops->manifest->nelts <= idx)
+ return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
+ _("Packed revprop manifest for rev %ld too "
+ "small"), revprops->revision);
-/* Get a handle to the prototype revision file for transaction TXN_ID in
- filesystem FS, and lock it for writing. Return FILE, a file handle
- positioned at the end of the file, and LOCKCOOKIE, a cookie that
- should be passed to unlock_proto_rev() to unlock the file once FILE
- has been closed.
+ /* Now get the file name */
+ revprops->filename = APR_ARRAY_IDX(revprops->manifest, idx, const char*);
- If the prototype revision file is already locked, return error
- SVN_ERR_FS_REP_BEING_WRITTEN.
+ return SVN_NO_ERROR;
+}
- Perform all allocations in POOL. */
+/* Given FS and the full packed file content in REVPROPS->PACKED_REVPROPS,
+ * fill the START_REVISION, SIZES, OFFSETS members. Also, make
+ * PACKED_REVPROPS point to the first serialized revprop.
+ *
+ * Parse the revprops for REVPROPS->REVISION and set the PROPERTIES as
+ * well as the SERIALIZED_SIZE member. If revprop caching has been
+ * enabled, parse all revprops in the pack and cache them.
+ */
static svn_error_t *
-get_writable_proto_rev(apr_file_t **file,
- void **lockcookie,
- svn_fs_t *fs, const char *txn_id,
- apr_pool_t *pool)
+parse_packed_revprops(svn_fs_t *fs,
+ packed_revprops_t *revprops,
+ apr_pool_t *pool,
+ apr_pool_t *scratch_pool)
{
- struct get_writable_proto_rev_baton b;
-
- b.file = file;
- b.lockcookie = lockcookie;
- b.txn_id = txn_id;
+ svn_stream_t *stream;
+ apr_int64_t first_rev, count, i;
+ apr_off_t offset;
+ const char *header_end;
+ apr_pool_t *iterpool = svn_pool_create(scratch_pool);
- return with_txnlist_lock(fs, get_writable_proto_rev_body, &b, pool);
-}
+ /* decompress (even if the data is only "stored", there is still a
+ * length header to remove) */
+ svn_string_t *compressed
+ = svn_stringbuf__morph_into_string(revprops->packed_revprops);
+ svn_stringbuf_t *uncompressed = svn_stringbuf_create_empty(pool);
+ SVN_ERR(svn__decompress(compressed, uncompressed, 0x1000000));
-/* Callback used in the implementation of purge_shared_txn(). */
-static svn_error_t *
-purge_shared_txn_body(svn_fs_t *fs, const void *baton, apr_pool_t *pool)
-{
- const char *txn_id = baton;
+ /* read first revision number and number of revisions in the pack */
+ stream = svn_stream_from_stringbuf(uncompressed, scratch_pool);
+ SVN_ERR(read_number_from_stream(&first_rev, NULL, stream, iterpool));
+ SVN_ERR(read_number_from_stream(&count, NULL, stream, iterpool));
- free_shared_txn(fs, txn_id);
- svn_fs_fs__reset_txn_caches(fs);
+ /* make PACKED_REVPROPS point to the first char after the header.
+ * This is where the serialized revprops are. */
+ header_end = strstr(uncompressed->data, "\n\n");
+ if (header_end == NULL)
+ return svn_error_create(SVN_ERR_FS_CORRUPT, NULL,
+ _("Header end not found"));
- return SVN_NO_ERROR;
-}
+ offset = header_end - uncompressed->data + 2;
-/* Purge the shared data for transaction TXN_ID in filesystem FS.
- Perform all allocations in POOL. */
-static svn_error_t *
-purge_shared_txn(svn_fs_t *fs, const char *txn_id, apr_pool_t *pool)
-{
- return with_txnlist_lock(fs, purge_shared_txn_body, txn_id, pool);
-}
-
+ revprops->packed_revprops = svn_stringbuf_create_empty(pool);
+ revprops->packed_revprops->data = uncompressed->data + offset;
+ revprops->packed_revprops->len = (apr_size_t)(uncompressed->len - offset);
+ revprops->packed_revprops->blocksize = (apr_size_t)(uncompressed->blocksize - offset);
+ /* STREAM still points to the first entry in the sizes list.
+ * Init / construct REVPROPS members. */
+ revprops->start_revision = (svn_revnum_t)first_rev;
+ revprops->sizes = apr_array_make(pool, (int)count, sizeof(offset));
+ revprops->offsets = apr_array_make(pool, (int)count, sizeof(offset));
-/* Fetch the current offset of FILE into *OFFSET_P. */
-static svn_error_t *
-get_file_offset(apr_off_t *offset_p, apr_file_t *file, apr_pool_t *pool)
-{
- apr_off_t offset;
+ /* Now parse, revision by revision, the size and content of each
+ * revisions' revprops. */
+ for (i = 0, offset = 0, revprops->total_size = 0; i < count; ++i)
+ {
+ apr_int64_t size;
+ svn_string_t serialized;
+ apr_hash_t *properties;
+ svn_revnum_t revision = (svn_revnum_t)(first_rev + i);
- /* Note that, for buffered files, one (possibly surprising) side-effect
- of this call is to flush any unwritten data to disk. */
- offset = 0;
- SVN_ERR(svn_io_file_seek(file, APR_CUR, &offset, pool));
- *offset_p = offset;
+ /* read & check the serialized size */
+ SVN_ERR(read_number_from_stream(&size, NULL, stream, iterpool));
+ if (size + offset > (apr_int64_t)revprops->packed_revprops->len)
+ return svn_error_create(SVN_ERR_FS_CORRUPT, NULL,
+ _("Packed revprop size exceeds pack file size"));
- return SVN_NO_ERROR;
-}
+ /* Parse this revprops list, if necessary */
+ serialized.data = revprops->packed_revprops->data + offset;
+ serialized.len = (apr_size_t)size;
+ if (revision == revprops->revision)
+ {
+ SVN_ERR(parse_revprop(&revprops->properties, fs, revision,
+ revprops->generation, &serialized,
+ pool, iterpool));
+ revprops->serialized_size = serialized.len;
+ }
+ else
+ {
+ /* If revprop caching is enabled, parse any revprops.
+ * They will get cached as a side-effect of this. */
+ if (has_revprop_cache(fs, pool))
+ SVN_ERR(parse_revprop(&properties, fs, revision,
+ revprops->generation, &serialized,
+ iterpool, iterpool));
+ }
-/* Check that BUF, a nul-terminated buffer of text from file PATH,
- contains only digits at OFFSET and beyond, raising an error if not.
- TITLE contains a user-visible description of the file, usually the
- short file name.
+ /* fill REVPROPS data structures */
+ APR_ARRAY_PUSH(revprops->sizes, apr_off_t) = serialized.len;
+ APR_ARRAY_PUSH(revprops->offsets, apr_off_t) = offset;
+ revprops->total_size += serialized.len;
- Uses POOL for temporary allocation. */
-static svn_error_t *
-check_file_buffer_numeric(const char *buf, apr_off_t offset,
- const char *path, const char *title,
- apr_pool_t *pool)
-{
- const char *p;
+ offset += serialized.len;
- for (p = buf + offset; *p; p++)
- if (!svn_ctype_isdigit(*p))
- return svn_error_createf(SVN_ERR_BAD_VERSION_FILE_FORMAT, NULL,
- _("%s file '%s' contains unexpected non-digit '%c' within '%s'"),
- title, svn_dirent_local_style(path, pool), *p, buf);
+ svn_pool_clear(iterpool);
+ }
return SVN_NO_ERROR;
}
-/* Check that BUF, a nul-terminated buffer of text from format file PATH,
- contains only digits at OFFSET and beyond, raising an error if not.
-
- Uses POOL for temporary allocation. */
+/* In filesystem FS, read the packed revprops for revision REV into
+ * *REVPROPS. Use GENERATION to populate the revprop cache, if enabled.
+ * Allocate data in POOL.
+ */
static svn_error_t *
-check_format_file_buffer_numeric(const char *buf, apr_off_t offset,
- const char *path, apr_pool_t *pool)
+read_pack_revprop(packed_revprops_t **revprops,
+ svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_int64_t generation,
+ apr_pool_t *pool)
{
- return check_file_buffer_numeric(buf, offset, path, "Format", pool);
-}
-
-/* Read the format number and maximum number of files per directory
- from PATH and return them in *PFORMAT and *MAX_FILES_PER_DIR
- respectively.
+ apr_pool_t *iterpool = svn_pool_create(pool);
+ svn_boolean_t missing = FALSE;
+ svn_error_t *err;
+ packed_revprops_t *result;
+ int i;
- *MAX_FILES_PER_DIR is obtained from the 'layout' format option, and
- will be set to zero if a linear scheme should be used.
-
- Use POOL for temporary allocation. */
-static svn_error_t *
-read_format(int *pformat, int *max_files_per_dir,
- const char *path, apr_pool_t *pool)
-{
- svn_error_t *err;
- svn_stream_t *stream;
- svn_stringbuf_t *content;
- svn_stringbuf_t *buf;
- svn_boolean_t eos = FALSE;
+ /* someone insisted that REV is packed. Double-check if necessary */
+ if (!is_packed_revprop(fs, rev))
+ SVN_ERR(update_min_unpacked_rev(fs, iterpool));
- err = svn_stringbuf_from_file2(&content, path, pool);
- if (err && APR_STATUS_IS_ENOENT(err->apr_err))
- {
- /* Treat an absent format file as format 1. Do not try to
- create the format file on the fly, because the repository
- might be read-only for us, or this might be a read-only
- operation, and the spirit of FSFS is to make no changes
- whatseover in read-only operations. See thread starting at
- http://subversion.tigris.org/servlets/ReadMsg?list=dev&msgNo=97600
- for more. */
- svn_error_clear(err);
- *pformat = 1;
- *max_files_per_dir = 0;
+ if (!is_packed_revprop(fs, rev))
+ return svn_error_createf(SVN_ERR_FS_NO_SUCH_REVISION, NULL,
+ _("No such packed revision %ld"), rev);
- return SVN_NO_ERROR;
- }
- SVN_ERR(err);
+ /* initialize the result data structure */
+ result = apr_pcalloc(pool, sizeof(*result));
+ result->revision = rev;
+ result->generation = generation;
- stream = svn_stream_from_stringbuf(content, pool);
- SVN_ERR(svn_stream_readline(stream, &buf, "\n", &eos, pool));
- if (buf->len == 0 && eos)
+ /* try to read the packed revprops. This may require retries if we have
+ * concurrent writers. */
+ for (i = 0; i < RECOVERABLE_RETRY_COUNT && !result->packed_revprops; ++i)
{
- /* Return a more useful error message. */
- return svn_error_createf(SVN_ERR_BAD_VERSION_FILE_FORMAT, NULL,
- _("Can't read first line of format file '%s'"),
- svn_dirent_local_style(path, pool));
- }
+ const char *file_path;
- /* Check that the first line contains only digits. */
- SVN_ERR(check_format_file_buffer_numeric(buf->data, 0, path, pool));
- SVN_ERR(svn_cstring_atoi(pformat, buf->data));
+ /* there might have been concurrent writes.
+ * Re-read the manifest and the pack file.
+ */
+ SVN_ERR(get_revprop_packname(fs, result, pool, iterpool));
+ file_path = svn_dirent_join(result->folder,
+ result->filename,
+ iterpool);
+ SVN_ERR(try_stringbuf_from_file(&result->packed_revprops,
+ &missing,
+ file_path,
+ i + 1 < RECOVERABLE_RETRY_COUNT,
+ pool));
- /* Set the default values for anything that can be set via an option. */
- *max_files_per_dir = 0;
+ /* If we could not find the file, there was a write.
+ * So, we should refresh our revprop generation info as well such
+ * that others may find data we will put into the cache. They would
+ * consider it outdated, otherwise.
+ */
+ if (missing && has_revprop_cache(fs, pool))
+ SVN_ERR(read_revprop_generation(&result->generation, fs, pool));
- /* Read any options. */
- while (!eos)
- {
- SVN_ERR(svn_stream_readline(stream, &buf, "\n", &eos, pool));
- if (buf->len == 0)
- break;
+ svn_pool_clear(iterpool);
+ }
- if (*pformat >= SVN_FS_FS__MIN_LAYOUT_FORMAT_OPTION_FORMAT &&
- strncmp(buf->data, "layout ", 7) == 0)
- {
- if (strcmp(buf->data + 7, "linear") == 0)
- {
- *max_files_per_dir = 0;
- continue;
- }
+ /* the file content should be available now */
+ if (!result->packed_revprops)
+ return svn_error_createf(SVN_ERR_FS_PACKED_REPPROP_READ_FAILURE, NULL,
+ _("Failed to read revprop pack file for rev %ld"), rev);
- if (strncmp(buf->data + 7, "sharded ", 8) == 0)
- {
- /* Check that the argument is numeric. */
- SVN_ERR(check_format_file_buffer_numeric(buf->data, 15, path, pool));
- SVN_ERR(svn_cstring_atoi(max_files_per_dir, buf->data + 15));
- continue;
- }
- }
+ /* parse it. RESULT will be complete afterwards. */
+ err = parse_packed_revprops(fs, result, pool, iterpool);
+ svn_pool_destroy(iterpool);
+ if (err)
+ return svn_error_createf(SVN_ERR_FS_CORRUPT, err,
+ _("Revprop pack file for rev %ld is corrupt"), rev);
- return svn_error_createf(SVN_ERR_BAD_VERSION_FILE_FORMAT, NULL,
- _("'%s' contains invalid filesystem format option '%s'"),
- svn_dirent_local_style(path, pool), buf->data);
- }
+ *revprops = result;
return SVN_NO_ERROR;
}
-/* Write the format number and maximum number of files per directory
- to a new format file in PATH, possibly expecting to overwrite a
- previously existing file.
-
- Use POOL for temporary allocation. */
-static svn_error_t *
-write_format(const char *path, int format, int max_files_per_dir,
- svn_boolean_t overwrite, apr_pool_t *pool)
+/* Read the revprops for revision REV in FS and return them in *PROPERTIES_P.
+ *
+ * Allocations will be done in POOL.
+ */
+svn_error_t *
+get_revision_proplist(apr_hash_t **proplist_p,
+ svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool)
{
- svn_stringbuf_t *sb;
+ fs_fs_data_t *ffd = fs->fsap_data;
+ apr_int64_t generation = 0;
- SVN_ERR_ASSERT(1 <= format && format <= SVN_FS_FS__FORMAT_NUMBER);
+ /* not found, yet */
+ *proplist_p = NULL;
- sb = svn_stringbuf_createf(pool, "%d\n", format);
+ /* should they be available at all? */
+ SVN_ERR(svn_fs_fs__ensure_revision_exists(rev, fs, pool));
- if (format >= SVN_FS_FS__MIN_LAYOUT_FORMAT_OPTION_FORMAT)
+ /* Try cache lookup first. */
+ if (has_revprop_cache(fs, pool))
{
- if (max_files_per_dir)
- svn_stringbuf_appendcstr(sb, apr_psprintf(pool, "layout sharded %d\n",
- max_files_per_dir));
- else
- svn_stringbuf_appendcstr(sb, "layout linear\n");
- }
+ svn_boolean_t is_cached;
+ pair_cache_key_t key;
- /* svn_io_write_version_file() does a load of magic to allow it to
- replace version files that already exist. We only need to do
- that when we're allowed to overwrite an existing file. */
- if (! overwrite)
- {
- /* Create the file */
- SVN_ERR(svn_io_file_create(path, sb->data, pool));
+ SVN_ERR(read_revprop_generation(&generation, fs, pool));
+
+ key.revision = rev;
+ key.second = generation;
+ SVN_ERR(svn_cache__get((void **) proplist_p, &is_cached,
+ ffd->revprop_cache, &key, pool));
+ if (is_cached)
+ return SVN_NO_ERROR;
}
- else
- {
- const char *path_tmp;
- SVN_ERR(svn_io_write_unique(&path_tmp,
- svn_dirent_dirname(path, pool),
- sb->data, sb->len,
- svn_io_file_del_none, pool));
+ /* if REV had not been packed when we began, try reading it from the
+ * non-packed shard. If that fails, we will fall through to packed
+ * shard reads. */
+ if (!is_packed_revprop(fs, rev))
+ {
+ svn_error_t *err = read_non_packed_revprop(proplist_p, fs, rev,
+ generation, pool);
+ if (err)
+ {
+ if (!APR_STATUS_IS_ENOENT(err->apr_err)
+ || ffd->format < SVN_FS_FS__MIN_PACKED_REVPROP_FORMAT)
+ return svn_error_trace(err);
- /* rename the temp file as the real destination */
- SVN_ERR(svn_io_file_rename(path_tmp, path, pool));
+ svn_error_clear(err);
+ *proplist_p = NULL; /* in case read_non_packed_revprop changed it */
+ }
}
- /* And set the perms to make it read only */
- return svn_io_set_file_read_only(path, FALSE, pool);
-}
+ /* if revprop packing is available and we have not read the revprops, yet,
+ * try reading them from a packed shard. If that fails, REV is most
+ * likely invalid (or its revprops highly contested). */
+ if (ffd->format >= SVN_FS_FS__MIN_PACKED_REVPROP_FORMAT && !*proplist_p)
+ {
+ packed_revprops_t *packed_revprops;
+ SVN_ERR(read_pack_revprop(&packed_revprops, fs, rev, generation, pool));
+ *proplist_p = packed_revprops->properties;
+ }
-/* Return the error SVN_ERR_FS_UNSUPPORTED_FORMAT if FS's format
- number is not the same as a format number supported by this
- Subversion. */
-static svn_error_t *
-check_format(int format)
-{
- /* Blacklist. These formats may be either younger or older than
- SVN_FS_FS__FORMAT_NUMBER, but we don't support them. */
- if (format == SVN_FS_FS__PACKED_REVPROP_SQLITE_DEV_FORMAT)
- return svn_error_createf(SVN_ERR_FS_UNSUPPORTED_FORMAT, NULL,
- _("Found format '%d', only created by "
- "unreleased dev builds; see "
- "http://subversion.apache.org"
- "/docs/release-notes/1.7#revprop-packing"),
- format);
-
- /* We support all formats from 1-current simultaneously */
- if (1 <= format && format <= SVN_FS_FS__FORMAT_NUMBER)
- return SVN_NO_ERROR;
-
- return svn_error_createf(SVN_ERR_FS_UNSUPPORTED_FORMAT, NULL,
- _("Expected FS format between '1' and '%d'; found format '%d'"),
- SVN_FS_FS__FORMAT_NUMBER, format);
-}
+ /* The revprops should have been there. Did we get them? */
+ if (!*proplist_p)
+ return svn_error_createf(SVN_ERR_FS_NO_SUCH_REVISION, NULL,
+ _("Could not read revprops for revision %ld"),
+ rev);
-svn_boolean_t
-svn_fs_fs__fs_supports_mergeinfo(svn_fs_t *fs)
-{
- fs_fs_data_t *ffd = fs->fsap_data;
- return ffd->format >= SVN_FS_FS__MIN_MERGEINFO_FORMAT;
+ return SVN_NO_ERROR;
}
-/* Read the configuration information of the file system at FS_PATH
- * and set the respective values in FFD. Use POOL for allocations.
+/* Serialize the revision property list PROPLIST of revision REV in
+ * filesystem FS to a non-packed file. Return the name of that temporary
+ * file in *TMP_PATH and the file path that it must be moved to in
+ * *FINAL_PATH.
+ *
+ * Use POOL for allocations.
*/
static svn_error_t *
-read_config(fs_fs_data_t *ffd,
- const char *fs_path,
- apr_pool_t *pool)
+write_non_packed_revprop(const char **final_path,
+ const char **tmp_path,
+ svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_hash_t *proplist,
+ apr_pool_t *pool)
{
- SVN_ERR(svn_config_read2(&ffd->config,
- svn_dirent_join(fs_path, PATH_CONFIG, pool),
- FALSE, FALSE, pool));
-
- /* Initialize ffd->rep_sharing_allowed. */
- if (ffd->format >= SVN_FS_FS__MIN_REP_SHARING_FORMAT)
- SVN_ERR(svn_config_get_bool(ffd->config, &ffd->rep_sharing_allowed,
- CONFIG_SECTION_REP_SHARING,
- CONFIG_OPTION_ENABLE_REP_SHARING, TRUE));
- else
- ffd->rep_sharing_allowed = FALSE;
-
- /* Initialize deltification settings in ffd. */
- if (ffd->format >= SVN_FS_FS__MIN_DELTIFICATION_FORMAT)
- {
- SVN_ERR(svn_config_get_bool(ffd->config, &ffd->deltify_directories,
- CONFIG_SECTION_DELTIFICATION,
- CONFIG_OPTION_ENABLE_DIR_DELTIFICATION,
- FALSE));
- SVN_ERR(svn_config_get_bool(ffd->config, &ffd->deltify_properties,
- CONFIG_SECTION_DELTIFICATION,
- CONFIG_OPTION_ENABLE_PROPS_DELTIFICATION,
- FALSE));
- SVN_ERR(svn_config_get_int64(ffd->config, &ffd->max_deltification_walk,
- CONFIG_SECTION_DELTIFICATION,
- CONFIG_OPTION_MAX_DELTIFICATION_WALK,
- SVN_FS_FS_MAX_DELTIFICATION_WALK));
- SVN_ERR(svn_config_get_int64(ffd->config, &ffd->max_linear_deltification,
- CONFIG_SECTION_DELTIFICATION,
- CONFIG_OPTION_MAX_LINEAR_DELTIFICATION,
- SVN_FS_FS_MAX_LINEAR_DELTIFICATION));
- }
- else
- {
- ffd->deltify_directories = FALSE;
- ffd->deltify_properties = FALSE;
- ffd->max_deltification_walk = SVN_FS_FS_MAX_DELTIFICATION_WALK;
- ffd->max_linear_deltification = SVN_FS_FS_MAX_LINEAR_DELTIFICATION;
- }
-
- /* Initialize revprop packing settings in ffd. */
- if (ffd->format >= SVN_FS_FS__MIN_PACKED_REVPROP_FORMAT)
- {
- SVN_ERR(svn_config_get_bool(ffd->config, &ffd->compress_packed_revprops,
- CONFIG_SECTION_PACKED_REVPROPS,
- CONFIG_OPTION_COMPRESS_PACKED_REVPROPS,
- FALSE));
- SVN_ERR(svn_config_get_int64(ffd->config, &ffd->revprop_pack_size,
- CONFIG_SECTION_PACKED_REVPROPS,
- CONFIG_OPTION_REVPROP_PACK_SIZE,
- ffd->compress_packed_revprops
- ? 0x100
- : 0x40));
+ svn_stream_t *stream;
+ *final_path = path_revprops(fs, rev, pool);
- ffd->revprop_pack_size *= 1024;
- }
- else
- {
- ffd->revprop_pack_size = 0x10000;
- ffd->compress_packed_revprops = FALSE;
- }
+ /* ### 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_hash_write2(proplist, stream, SVN_HASH_TERMINATOR, pool));
+ SVN_ERR(svn_stream_close(stream));
return SVN_NO_ERROR;
}
+/* After writing the new revprop file(s), call this function to move the
+ * file at TMP_PATH to FINAL_PATH and give it the permissions from
+ * PERMS_REFERENCE.
+ *
+ * If indicated in BUMP_GENERATION, increase FS' revprop generation.
+ * Finally, delete all the temporary files given in FILES_TO_DELETE.
+ * The latter may be NULL.
+ *
+ * Use POOL for temporary allocations.
+ */
static svn_error_t *
-write_config(svn_fs_t *fs,
- apr_pool_t *pool)
-{
-#define NL APR_EOL_STR
- static const char * const fsfs_conf_contents =
-"### This file controls the configuration of the FSFS filesystem." NL
-"" NL
-"[" SVN_CACHE_CONFIG_CATEGORY_MEMCACHED_SERVERS "]" NL
-"### These options name memcached servers used to cache internal FSFS" NL
-"### data. See http://www.danga.com/memcached/ for more information on" NL
-"### memcached. To use memcached with FSFS, run one or more memcached" NL
-"### servers, and specify each of them as an option like so:" NL
-"# first-server = 127.0.0.1:11211" NL
-"# remote-memcached = mymemcached.corp.example.com:11212" NL
-"### The option name is ignored; the value is of the form HOST:PORT." NL
-"### memcached servers can be shared between multiple repositories;" NL
-"### however, if you do this, you *must* ensure that repositories have" NL
-"### distinct UUIDs and paths, or else cached data from one repository" NL
-"### might be used by another accidentally. Note also that memcached has" NL
-"### no authentication for reads or writes, so you must ensure that your" NL
-"### memcached servers are only accessible by trusted users." NL
-"" NL
-"[" CONFIG_SECTION_CACHES "]" NL
-"### When a cache-related error occurs, normally Subversion ignores it" NL
-"### and continues, logging an error if the server is appropriately" NL
-"### configured (and ignoring it with file:// access). To make" NL
-"### Subversion never ignore cache errors, uncomment this line." NL
-"# " CONFIG_OPTION_FAIL_STOP " = true" NL
-"" NL
-"[" CONFIG_SECTION_REP_SHARING "]" NL
-"### To conserve space, the filesystem can optionally avoid storing" NL
-"### duplicate representations. This comes at a slight cost in" NL
-"### performance, as maintaining a database of shared representations can" NL
-"### increase commit times. The space savings are dependent upon the size" NL
-"### of the repository, the number of objects it contains and the amount of" NL
-"### duplication between them, usually a function of the branching and" NL
-"### merging process." NL
-"###" NL
-"### The following parameter enables rep-sharing in the repository. It can" NL
-"### be switched on and off at will, but for best space-saving results" NL
-"### should be enabled consistently over the life of the repository." NL
-"### 'svnadmin verify' will check the rep-cache regardless of this setting." NL
-"### rep-sharing is enabled by default." NL
-"# " CONFIG_OPTION_ENABLE_REP_SHARING " = true" NL
-"" NL
-"[" CONFIG_SECTION_DELTIFICATION "]" NL
-"### To conserve space, the filesystem stores data as differences against" NL
-"### existing representations. This comes at a slight cost in performance," NL
-"### as calculating differences can increase commit times. Reading data" NL
-"### will also create higher CPU load and the data will be fragmented." NL
-"### Since deltification tends to save significant amounts of disk space," NL
-"### the overall I/O load can actually be lower." NL
-"###" NL
-"### The options in this section allow for tuning the deltification" NL
-"### strategy. Their effects on data size and server performance may vary" NL
-"### from one repository to another. Versions prior to 1.8 will ignore" NL
-"### this section." NL
-"###" NL
-"### The following parameter enables deltification for directories. It can" NL
-"### be switched on and off at will, but for best space-saving results" NL
-"### should be enabled consistently over the life of the repository." NL
-"### Repositories containing large directories will benefit greatly." NL
-"### In rarely read repositories, the I/O overhead may be significant as" NL
-"### cache hit rates will most likely be low" NL
-"### directory deltification is disabled by default." NL
-"# " CONFIG_OPTION_ENABLE_DIR_DELTIFICATION " = false" NL
-"###" NL
-"### The following parameter enables deltification for properties on files" NL
-"### and directories. Overall, this is a minor tuning option but can save" NL
-"### some disk space if you merge frequently or frequently change node" NL
-"### properties. You should not activate this if rep-sharing has been" NL
-"### disabled because this may result in a net increase in repository size." NL
-"### property deltification is disabled by default." NL
-"# " CONFIG_OPTION_ENABLE_PROPS_DELTIFICATION " = false" NL
-"###" NL
-"### During commit, the server may need to walk the whole change history of" NL
-"### of a given node to find a suitable deltification base. This linear" NL
-"### process can impact commit times, svnadmin load and similar operations." NL
-"### This setting limits the depth of the deltification history. If the" NL
-"### threshold has been reached, the node will be stored as fulltext and a" NL
-"### new deltification history begins." NL
-"### Note, this is unrelated to svn log." NL
-"### Very large values rarely provide significant additional savings but" NL
-"### can impact performance greatly - in particular if directory" NL
-"### deltification has been activated. Very small values may be useful in" NL
-"### repositories that are dominated by large, changing binaries." NL
-"### Should be a power of two minus 1. A value of 0 will effectively" NL
-"### disable deltification." NL
-"### For 1.8, the default value is 1023; earlier versions have no limit." NL
-"# " CONFIG_OPTION_MAX_DELTIFICATION_WALK " = 1023" NL
-"###" NL
-"### The skip-delta scheme used by FSFS tends to repeatably store redundant" NL
-"### delta information where a simple delta against the latest version is" NL
-"### often smaller. By default, 1.8+ will therefore use skip deltas only" NL
-"### after the linear chain of deltas has grown beyond the threshold" NL
-"### specified by this setting." NL
-"### Values up to 64 can result in some reduction in repository size for" NL
-"### the cost of quickly increasing I/O and CPU costs. Similarly, smaller" NL
-"### numbers can reduce those costs at the cost of more disk space. For" NL
-"### rarely read repositories or those containing larger binaries, this may" NL
-"### present a better trade-off." NL
-"### Should be a power of two. A value of 1 or smaller will cause the" NL
-"### exclusive use of skip-deltas (as in pre-1.8)." NL
-"### For 1.8, the default value is 16; earlier versions use 1." NL
-"# " CONFIG_OPTION_MAX_LINEAR_DELTIFICATION " = 16" NL
-"" NL
-"[" CONFIG_SECTION_PACKED_REVPROPS "]" NL
-"### This parameter controls the size (in kBytes) of packed revprop files." NL
-"### Revprops of consecutive revisions will be concatenated into a single" NL
-"### file up to but not exceeding the threshold given here. However, each" NL
-"### pack file may be much smaller and revprops of a single revision may be" NL
-"### much larger than the limit set here. The threshold will be applied" NL
-"### before optional compression takes place." NL
-"### Large values will reduce disk space usage at the expense of increased" NL
-"### latency and CPU usage reading and changing individual revprops. They" NL
-"### become an advantage when revprop caching has been enabled because a" NL
-"### lot of data can be read in one go. Values smaller than 4 kByte will" NL
-"### not improve latency any further and quickly render revprop packing" NL
-"### ineffective." NL
-"### revprop-pack-size is 64 kBytes by default for non-compressed revprop" NL
-"### pack files and 256 kBytes when compression has been enabled." NL
-"# " CONFIG_OPTION_REVPROP_PACK_SIZE " = 64" NL
-"###" NL
-"### To save disk space, packed revprop files may be compressed. Standard" NL
-"### revprops tend to allow for very effective compression. Reading and" NL
-"### even more so writing, become significantly more CPU intensive. With" NL
-"### revprop caching enabled, the overhead can be offset by reduced I/O" NL
-"### unless you often modify revprops after packing." NL
-"### Compressing packed revprops is disabled by default." NL
-"# " CONFIG_OPTION_COMPRESS_PACKED_REVPROPS " = false" NL
-;
-#undef NL
- return svn_io_file_create(svn_dirent_join(fs->path, PATH_CONFIG, pool),
- fsfs_conf_contents, pool);
-}
-
-static svn_error_t *
-read_min_unpacked_rev(svn_revnum_t *min_unpacked_rev,
- const char *path,
+switch_to_new_revprop(svn_fs_t *fs,
+ const char *final_path,
+ const char *tmp_path,
+ const char *perms_reference,
+ apr_array_header_t *files_to_delete,
+ svn_boolean_t bump_generation,
apr_pool_t *pool)
{
- char buf[80];
- apr_file_t *file;
- apr_size_t len;
-
- SVN_ERR(svn_io_file_open(&file, path, APR_READ | APR_BUFFERED,
- APR_OS_DEFAULT, pool));
- len = sizeof(buf);
- SVN_ERR(svn_io_read_length_line(file, buf, &len, pool));
- SVN_ERR(svn_io_file_close(file, pool));
+ /* Now, we may actually be replacing revprops. Make sure that all other
+ threads and processes will know about this. */
+ if (bump_generation)
+ SVN_ERR(begin_revprop_change(fs, pool));
- *min_unpacked_rev = SVN_STR_TO_REV(buf);
- return SVN_NO_ERROR;
-}
+ SVN_ERR(move_into_place(tmp_path, final_path, perms_reference, pool));
-static svn_error_t *
-update_min_unpacked_rev(svn_fs_t *fs, apr_pool_t *pool)
-{
- fs_fs_data_t *ffd = fs->fsap_data;
+ /* Indicate that the update (if relevant) has been completed. */
+ if (bump_generation)
+ SVN_ERR(end_revprop_change(fs, pool));
- SVN_ERR_ASSERT(ffd->format >= SVN_FS_FS__MIN_PACKED_FORMAT);
+ /* Clean up temporary files, if necessary. */
+ if (files_to_delete)
+ {
+ apr_pool_t *iterpool = svn_pool_create(pool);
+ int i;
+
+ for (i = 0; i < files_to_delete->nelts; ++i)
+ {
+ const char *path = APR_ARRAY_IDX(files_to_delete, i, const char*);
+ SVN_ERR(svn_io_remove_file2(path, TRUE, iterpool));
+ svn_pool_clear(iterpool);
+ }
- return read_min_unpacked_rev(&ffd->min_unpacked_rev,
- path_min_unpacked_rev(fs, pool),
- pool);
+ svn_pool_destroy(iterpool);
+ }
+ return SVN_NO_ERROR;
}
-svn_error_t *
-svn_fs_fs__open(svn_fs_t *fs, const char *path, apr_pool_t *pool)
+/* Write a pack file header to STREAM that starts at revision START_REVISION
+ * and contains the indexes [START,END) of SIZES.
+ */
+static svn_error_t *
+serialize_revprops_header(svn_stream_t *stream,
+ svn_revnum_t start_revision,
+ apr_array_header_t *sizes,
+ int start,
+ int end,
+ apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
- apr_file_t *uuid_file;
- int format, max_files_per_dir;
- char buf[APR_UUID_FORMATTED_LENGTH + 2];
- apr_size_t limit;
+ apr_pool_t *iterpool = svn_pool_create(pool);
+ int i;
- fs->path = apr_pstrdup(fs->pool, path);
+ SVN_ERR_ASSERT(start < end);
- /* Read the FS format number. */
- SVN_ERR(read_format(&format, &max_files_per_dir,
- path_format(fs, pool), pool));
- SVN_ERR(check_format(format));
+ /* start revision and entry count */
+ SVN_ERR(svn_stream_printf(stream, pool, "%ld\n", start_revision));
+ SVN_ERR(svn_stream_printf(stream, pool, "%d\n", end - start));
- /* Now we've got a format number no matter what. */
- ffd->format = format;
- ffd->max_files_per_dir = max_files_per_dir;
+ /* the sizes array */
+ for (i = start; i < end; ++i)
+ {
+ apr_off_t size = APR_ARRAY_IDX(sizes, i, apr_off_t);
+ SVN_ERR(svn_stream_printf(stream, iterpool, "%" APR_OFF_T_FMT "\n",
+ size));
+ }
- /* Read in and cache the repository uuid. */
- SVN_ERR(svn_io_file_open(&uuid_file, path_uuid(fs, pool),
- APR_READ | APR_BUFFERED, APR_OS_DEFAULT, pool));
+ /* the double newline char indicates the end of the header */
+ SVN_ERR(svn_stream_printf(stream, iterpool, "\n"));
- limit = sizeof(buf);
- SVN_ERR(svn_io_read_length_line(uuid_file, buf, &limit, pool));
- fs->uuid = apr_pstrdup(fs->pool, buf);
+ svn_pool_clear(iterpool);
+ return SVN_NO_ERROR;
+}
- SVN_ERR(svn_io_file_close(uuid_file, pool));
-
- /* Read the min unpacked revision. */
- if (ffd->format >= SVN_FS_FS__MIN_PACKED_FORMAT)
- SVN_ERR(update_min_unpacked_rev(fs, pool));
-
- /* Read the configuration file. */
- SVN_ERR(read_config(ffd, fs->path, pool));
-
- return get_youngest(&(ffd->youngest_rev_cache), path, pool);
-}
-
-/* Wrapper around svn_io_file_create which ignores EEXIST. */
-static svn_error_t *
-create_file_ignore_eexist(const char *file,
- const char *contents,
- apr_pool_t *pool)
-{
- svn_error_t *err = svn_io_file_create(file, contents, pool);
- if (err && APR_STATUS_IS_EEXIST(err->apr_err))
- {
- svn_error_clear(err);
- err = SVN_NO_ERROR;
- }
- return svn_error_trace(err);
-}
-
-/* forward declarations */
-
-static svn_error_t *
-pack_revprops_shard(const char *pack_file_dir,
- const char *shard_path,
- apr_int64_t shard,
- int max_files_per_dir,
- apr_off_t max_pack_size,
- int compression_level,
- svn_cancel_func_t cancel_func,
- void *cancel_baton,
- apr_pool_t *scratch_pool);
-
-static svn_error_t *
-delete_revprops_shard(const char *shard_path,
- apr_int64_t shard,
- int max_files_per_dir,
- svn_cancel_func_t cancel_func,
- void *cancel_baton,
[... 10346 lines stripped ...]