subversion-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From i...@apache.org
Subject svn commit: r1658362 [10/34] - in /subversion/branches/remove-log-addressing: ./ build/ build/generator/ build/generator/templates/ notes/ subversion/bindings/cxxhl/include/svncxxhl/ subversion/bindings/javahl/native/ subversion/bindings/javahl/native/...
Date Mon, 09 Feb 2015 11:23:43 GMT
Modified: subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/hotcopy.c
URL: http://svn.apache.org/viewvc/subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/hotcopy.c?rev=1658362&r1=1658361&r2=1658362&view=diff
==============================================================================
--- subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/hotcopy.c (original)
+++ subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/hotcopy.c Mon Feb  9 11:23:39 2015
@@ -99,15 +99,15 @@ static svn_error_t *
 entry_name_to_utf8(const char **name_p,
                    const char *name,
                    const char *parent,
-                   apr_pool_t *pool)
+                   apr_pool_t *result_pool)
 {
-  svn_error_t *err = svn_path_cstring_to_utf8(name_p, name, pool);
+  svn_error_t *err = svn_path_cstring_to_utf8(name_p, name, result_pool);
   if (err && err->apr_err == APR_EINVAL)
     {
       return svn_error_createf(err->apr_err, err,
                                _("Error converting entry "
                                  "in directory '%s' to UTF-8"),
-                               svn_dirent_local_style(parent, pool));
+                               svn_dirent_local_style(parent, result_pool));
     }
   return err;
 }
@@ -125,7 +125,7 @@ hotcopy_io_copy_dir_recursively(svn_bool
                                 svn_boolean_t copy_perms,
                                 svn_cancel_func_t cancel_func,
                                 void *cancel_baton,
-                                apr_pool_t *pool)
+                                apr_pool_t *scratch_pool)
 {
   svn_node_kind_t kind;
   apr_status_t status;
@@ -135,10 +135,10 @@ hotcopy_io_copy_dir_recursively(svn_bool
   apr_int32_t flags = APR_FINFO_TYPE | APR_FINFO_NAME;
 
   /* Make a subpool for recursion */
-  apr_pool_t *subpool = svn_pool_create(pool);
+  apr_pool_t *subpool = svn_pool_create(scratch_pool);
 
   /* The 'dst_path' is simply dst_parent/dst_basename */
-  dst_path = svn_dirent_join(dst_parent, dst_basename, pool);
+  dst_path = svn_dirent_join(dst_parent, dst_basename, scratch_pool);
 
   /* Sanity checks:  SRC and DST_PARENT are directories, and
      DST_BASENAME doesn't already exist in DST_PARENT. */
@@ -146,19 +146,20 @@ hotcopy_io_copy_dir_recursively(svn_bool
   if (kind != svn_node_dir)
     return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
                              _("Source '%s' is not a directory"),
-                             svn_dirent_local_style(src, pool));
+                             svn_dirent_local_style(src, scratch_pool));
 
   SVN_ERR(svn_io_check_path(dst_parent, &kind, subpool));
   if (kind != svn_node_dir)
     return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
                              _("Destination '%s' is not a directory"),
-                             svn_dirent_local_style(dst_parent, pool));
+                             svn_dirent_local_style(dst_parent,
+                                                    scratch_pool));
 
   SVN_ERR(svn_io_check_path(dst_path, &kind, subpool));
 
   /* Create the new directory. */
   /* ### TODO: copy permissions (needs apr_file_attrs_get()) */
-  SVN_ERR(svn_io_make_dir_recursively(dst_path, pool));
+  SVN_ERR(svn_io_make_dir_recursively(dst_path, scratch_pool));
 
   /* Loop over the dirents in SRC.  ('.' and '..' are auto-excluded) */
   SVN_ERR(svn_io_dir_open(&this_dir, src, subpool));
@@ -225,12 +226,12 @@ hotcopy_io_copy_dir_recursively(svn_bool
 
   if (! (APR_STATUS_IS_ENOENT(status)))
     return svn_error_wrap_apr(status, _("Can't read directory '%s'"),
-                              svn_dirent_local_style(src, pool));
+                              svn_dirent_local_style(src, scratch_pool));
 
   status = apr_dir_close(this_dir);
   if (status)
     return svn_error_wrap_apr(status, _("Error closing directory '%s'"),
-                              svn_dirent_local_style(src, pool));
+                              svn_dirent_local_style(src, scratch_pool));
 
   /* Free any memory used by recursion */
   svn_pool_destroy(subpool);
@@ -297,7 +298,7 @@ hotcopy_copy_packed_shard(svn_boolean_t
   const char *src_subdir_packed_shard;
   svn_revnum_t revprop_rev;
   apr_pool_t *iterpool;
-  fs_x_data_t *src_ffd = src_fs->fsap_data;
+  svn_fs_x__data_t *src_ffd = src_fs->fsap_data;
 
   /* Copy the packed shard. */
   src_subdir = svn_dirent_join(src_fs->path, PATH_REVS_DIR, scratch_pool);
@@ -366,14 +367,14 @@ hotcopy_copy_packed_shard(svn_boolean_t
 }
 
 /* Remove file PATH, if it exists - even if it is read-only. 
- * Use POOL for temporary allocations. */
+ * Use SCRATCH_POOL for temporary allocations. */
 static svn_error_t *
 hotcopy_remove_file(const char *path,
-                    apr_pool_t *pool)
+                    apr_pool_t *scratch_pool)
 {
   /* Make the rev file writable and remove it. */
-  SVN_ERR(svn_io_set_file_read_write(path, TRUE, pool));
-  SVN_ERR(svn_io_remove_file2(path, TRUE, pool));
+  SVN_ERR(svn_io_set_file_read_write(path, TRUE, scratch_pool));
+  SVN_ERR(svn_io_remove_file2(path, TRUE, scratch_pool));
 
   return SVN_NO_ERROR;
 }
@@ -474,11 +475,10 @@ hotcopy_remove_revprop_files(svn_fs_t *d
  * hotcopy from SRC_FS. */
 static svn_error_t *
 hotcopy_incremental_check_preconditions(svn_fs_t *src_fs,
-                                        svn_fs_t *dst_fs,
-                                        apr_pool_t *pool)
+                                        svn_fs_t *dst_fs)
 {
-  fs_x_data_t *src_ffd = src_fs->fsap_data;
-  fs_x_data_t *dst_ffd = dst_fs->fsap_data;
+  svn_fs_x__data_t *src_ffd = src_fs->fsap_data;
+  svn_fs_x__data_t *dst_ffd = dst_fs->fsap_data;
 
   /* We only support incremental hotcopy between the same format. */
   if (src_ffd->format != dst_ffd->format)
@@ -508,16 +508,17 @@ hotcopy_incremental_check_preconditions(
 
 /* Remove folder PATH.  Ignore errors due to the sub-tree not being empty.
  * CANCEL_FUNC and CANCEL_BATON do the usual thing.
- * Use POOL for temporary allocations.
+ * Use SCRATCH_POOL for temporary allocations.
  */
 static svn_error_t *
 remove_folder(const char *path,
               svn_cancel_func_t cancel_func,
               void *cancel_baton,
-              apr_pool_t *pool)
+              apr_pool_t *scratch_pool)
 {
   svn_error_t *err = svn_io_remove_dir2(path, TRUE,
-                                        cancel_func, cancel_baton, pool);
+                                        cancel_func, cancel_baton,
+                                        scratch_pool);
 
   if (err && APR_STATUS_IS_ENOTEMPTY(err->apr_err))
     {
@@ -534,7 +535,7 @@ remove_folder(const char *path,
  * for every shard by updating the 'current' file if necessary.  Assume
  * the >= SVN_FS_FS__MIN_NO_GLOBAL_IDS_FORMAT filesystem format without
  * global next-ID counters.  Indicate progress via the optional NOTIFY_FUNC
- * callback using NOTIFY_BATON.  Use POOL for temporary allocations.
+ * callback using NOTIFY_BATON.  Use SCRATCH_POOL for temporary allocations.
  */
 static svn_error_t *
 hotcopy_revisions(svn_fs_t *src_fs,
@@ -550,9 +551,9 @@ hotcopy_revisions(svn_fs_t *src_fs,
                   void* notify_baton,
                   svn_cancel_func_t cancel_func,
                   void* cancel_baton,
-                  apr_pool_t *pool)
+                  apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *src_ffd = src_fs->fsap_data;
+  svn_fs_x__data_t *src_ffd = src_fs->fsap_data;
   int max_files_per_dir = src_ffd->max_files_per_dir;
   svn_revnum_t src_min_unpacked_rev;
   svn_revnum_t dst_min_unpacked_rev;
@@ -561,9 +562,9 @@ hotcopy_revisions(svn_fs_t *src_fs,
 
   /* Copy the min unpacked rev, and read its value. */
   SVN_ERR(svn_fs_x__read_min_unpacked_rev(&src_min_unpacked_rev, src_fs,
-                                          pool));
+                                          scratch_pool));
   SVN_ERR(svn_fs_x__read_min_unpacked_rev(&dst_min_unpacked_rev, dst_fs,
-                                          pool));
+                                          scratch_pool));
 
   /* We only support packs coming from the hotcopy source.
     * The destination should not be packed independently from
@@ -578,7 +579,7 @@ hotcopy_revisions(svn_fs_t *src_fs,
                              src_min_unpacked_rev - 1);
 
   SVN_ERR(svn_io_dir_file_copy(src_fs->path, dst_fs->path,
-                               PATH_MIN_UNPACKED_REV, pool));
+                               PATH_MIN_UNPACKED_REV, scratch_pool));
 
   if (cancel_func)
     SVN_ERR(cancel_func(cancel_baton));
@@ -587,7 +588,7 @@ hotcopy_revisions(svn_fs_t *src_fs,
    * Copy the necessary rev files.
    */
 
-  iterpool = svn_pool_create(pool);
+  iterpool = svn_pool_create(scratch_pool);
   /* First, copy packed shards. */
   for (rev = 0; rev < src_min_unpacked_rev; rev += max_files_per_dir)
     {
@@ -709,7 +710,7 @@ hotcopy_revisions(svn_fs_t *src_fs,
 }
 
 /* Baton for hotcopy_body(). */
-struct hotcopy_body_baton {
+typedef struct hotcopy_body_baton_t {
   svn_fs_t *src_fs;
   svn_fs_t *dst_fs;
   svn_boolean_t incremental;
@@ -717,7 +718,7 @@ struct hotcopy_body_baton {
   void *notify_baton;
   svn_cancel_func_t cancel_func;
   void *cancel_baton;
-};
+} hotcopy_body_baton_t;
 
 /* Perform a hotcopy, either normal or incremental.
  *
@@ -738,9 +739,10 @@ struct hotcopy_body_baton {
  * write-lock is held.
  */
 static svn_error_t *
-hotcopy_body(void *baton, apr_pool_t *pool)
+hotcopy_body(void *baton,
+             apr_pool_t *scratch_pool)
 {
-  struct hotcopy_body_baton *hbb = baton;
+  hotcopy_body_baton_t *hbb = baton;
   svn_fs_t *src_fs = hbb->src_fs;
   svn_fs_t *dst_fs = hbb->dst_fs;
   svn_boolean_t incremental = hbb->incremental;
@@ -765,7 +767,7 @@ hotcopy_body(void *baton, apr_pool_t *po
    * ### an error from this function, and that renders the hotcopy
    * ### unusable anyway. */
   SVN_ERR(svn_io_dir_file_copy(src_fs->path, dst_fs->path, PATH_CONFIG,
-                               pool));
+                               scratch_pool));
 
   if (cancel_func)
     SVN_ERR(cancel_func(cancel_baton));
@@ -775,10 +777,10 @@ hotcopy_body(void *baton, apr_pool_t *po
    * of revisions than the destination.
    * This also catches the case where users accidentally swap the
    * source and destination arguments. */
-  SVN_ERR(svn_fs_x__read_current(&src_youngest, src_fs, pool));
+  SVN_ERR(svn_fs_x__read_current(&src_youngest, src_fs, scratch_pool));
   if (incremental)
     {
-      SVN_ERR(svn_fs_x__youngest_rev(&dst_youngest, dst_fs, pool));
+      SVN_ERR(svn_fs_x__youngest_rev(&dst_youngest, dst_fs, scratch_pool));
       if (src_youngest < dst_youngest)
         return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
                  _("The hotcopy destination already contains more revisions "
@@ -789,15 +791,17 @@ hotcopy_body(void *baton, apr_pool_t *po
   else
     dst_youngest = 0;
 
-  src_revs_dir = svn_dirent_join(src_fs->path, PATH_REVS_DIR, pool);
-  dst_revs_dir = svn_dirent_join(dst_fs->path, PATH_REVS_DIR, pool);
-  src_revprops_dir = svn_dirent_join(src_fs->path, PATH_REVPROPS_DIR, pool);
-  dst_revprops_dir = svn_dirent_join(dst_fs->path, PATH_REVPROPS_DIR, pool);
+  src_revs_dir = svn_dirent_join(src_fs->path, PATH_REVS_DIR, scratch_pool);
+  dst_revs_dir = svn_dirent_join(dst_fs->path, PATH_REVS_DIR, scratch_pool);
+  src_revprops_dir = svn_dirent_join(src_fs->path, PATH_REVPROPS_DIR,
+                                     scratch_pool);
+  dst_revprops_dir = svn_dirent_join(dst_fs->path, PATH_REVPROPS_DIR,
+                                     scratch_pool);
 
   /* Ensure that the required folders exist in the destination
    * before actually copying the revisions and revprops. */
-  SVN_ERR(svn_io_make_dir_recursively(dst_revs_dir, pool));
-  SVN_ERR(svn_io_make_dir_recursively(dst_revprops_dir, pool));
+  SVN_ERR(svn_io_make_dir_recursively(dst_revs_dir, scratch_pool));
+  SVN_ERR(svn_io_make_dir_recursively(dst_revprops_dir, scratch_pool));
 
   if (cancel_func)
     SVN_ERR(cancel_func(cancel_baton));
@@ -810,30 +814,33 @@ hotcopy_body(void *baton, apr_pool_t *po
                             incremental, src_revs_dir, dst_revs_dir,
                             src_revprops_dir, dst_revprops_dir,
                             notify_func, notify_baton,
-                            cancel_func, cancel_baton, pool));
-  SVN_ERR(svn_fs_x__write_current(dst_fs, src_youngest, pool));
+                            cancel_func, cancel_baton, scratch_pool));
+  SVN_ERR(svn_fs_x__write_current(dst_fs, src_youngest, scratch_pool));
 
   /* Replace the locks tree.
    * This is racy in case readers are currently trying to list locks in
    * the destination. However, we need to get rid of stale locks.
    * This is the simplest way of doing this, so we accept this small race. */
-  dst_subdir = svn_dirent_join(dst_fs->path, PATH_LOCKS_DIR, pool);
+  dst_subdir = svn_dirent_join(dst_fs->path, PATH_LOCKS_DIR, scratch_pool);
   SVN_ERR(svn_io_remove_dir2(dst_subdir, TRUE, cancel_func, cancel_baton,
-                             pool));
-  src_subdir = svn_dirent_join(src_fs->path, PATH_LOCKS_DIR, pool);
-  SVN_ERR(svn_io_check_path(src_subdir, &kind, pool));
+                             scratch_pool));
+  src_subdir = svn_dirent_join(src_fs->path, PATH_LOCKS_DIR, scratch_pool);
+  SVN_ERR(svn_io_check_path(src_subdir, &kind, scratch_pool));
   if (kind == svn_node_dir)
     SVN_ERR(svn_io_copy_dir_recursively(src_subdir, dst_fs->path,
                                         PATH_LOCKS_DIR, TRUE,
-                                        cancel_func, cancel_baton, pool));
+                                        cancel_func, cancel_baton,
+                                        scratch_pool));
 
   /* Now copy the node-origins cache tree. */
-  src_subdir = svn_dirent_join(src_fs->path, PATH_NODE_ORIGINS_DIR, pool);
-  SVN_ERR(svn_io_check_path(src_subdir, &kind, pool));
+  src_subdir = svn_dirent_join(src_fs->path, PATH_NODE_ORIGINS_DIR,
+                               scratch_pool);
+  SVN_ERR(svn_io_check_path(src_subdir, &kind, scratch_pool));
   if (kind == svn_node_dir)
     SVN_ERR(hotcopy_io_copy_dir_recursively(NULL, src_subdir, dst_fs->path,
                                             PATH_NODE_ORIGINS_DIR, TRUE,
-                                            cancel_func, cancel_baton, pool));
+                                            cancel_func, cancel_baton,
+                                            scratch_pool));
 
   /*
    * NB: Data copied below is only read by writers, not readers.
@@ -842,32 +849,27 @@ hotcopy_body(void *baton, apr_pool_t *po
 
   /* Copy the rep cache and then remove entries for revisions
    * younger than the destination's youngest revision. */
-  src_subdir = svn_dirent_join(src_fs->path, REP_CACHE_DB_NAME, pool);
-  dst_subdir = svn_dirent_join(dst_fs->path, REP_CACHE_DB_NAME, pool);
-  SVN_ERR(svn_io_check_path(src_subdir, &kind, pool));
+  src_subdir = svn_dirent_join(src_fs->path, REP_CACHE_DB_NAME, scratch_pool);
+  dst_subdir = svn_dirent_join(dst_fs->path, REP_CACHE_DB_NAME, scratch_pool);
+  SVN_ERR(svn_io_check_path(src_subdir, &kind, scratch_pool));
   if (kind == svn_node_file)
     {
       /* Copy the rep cache and then remove entries for revisions
        * that did not make it into the destination. */
-      src_subdir = svn_dirent_join(src_fs->path, REP_CACHE_DB_NAME, pool);
-      dst_subdir = svn_dirent_join(dst_fs->path, REP_CACHE_DB_NAME, pool);
-      SVN_ERR(svn_io_check_path(src_subdir, &kind, pool));
-      if (kind == svn_node_file)
-        {
-          SVN_ERR(svn_sqlite__hotcopy(src_subdir, dst_subdir, pool));
-          SVN_ERR(svn_fs_x__del_rep_reference(dst_fs, src_youngest, pool));
-        }
+      SVN_ERR(svn_sqlite__hotcopy(src_subdir, dst_subdir, scratch_pool));
+      SVN_ERR(svn_fs_x__del_rep_reference(dst_fs, src_youngest,
+                                          scratch_pool));
     }
 
   /* Copy the txn-current file. */
   SVN_ERR(svn_io_dir_file_copy(src_fs->path, dst_fs->path,
-                                PATH_TXN_CURRENT, pool));
+                                PATH_TXN_CURRENT, scratch_pool));
 
   /* If a revprop generation file exists in the source filesystem,
    * reset it to zero (since this is on a different path, it will not
    * overlap with data already in cache).  Also, clean up stale files
    * used for the named atomics implementation. */
-  SVN_ERR(svn_fs_x__reset_revprop_generation_file(dst_fs, pool));
+  SVN_ERR(svn_fs_x__reset_revprop_generation_file(dst_fs, scratch_pool));
 
   return SVN_NO_ERROR;
 }
@@ -876,12 +878,13 @@ hotcopy_body(void *baton, apr_pool_t *po
  * locks.
  */
 static svn_error_t *
-hotcopy_locking_src_body(void *baton, apr_pool_t *pool)
+hotcopy_locking_src_body(void *baton,
+                         apr_pool_t *scratch_pool)
 {
-  struct hotcopy_body_baton *hbb = baton;
+  hotcopy_body_baton_t *hbb = baton;
 
   return svn_error_trace(svn_fs_x__with_pack_lock(hbb->src_fs, hotcopy_body,
-                                                  baton, pool));
+                                                  baton, scratch_pool));
 }
 
 /* Create an empty filesystem at DST_FS at DST_PATH with the same
@@ -891,27 +894,30 @@ static svn_error_t *
 hotcopy_create_empty_dest(svn_fs_t *src_fs,
                           svn_fs_t *dst_fs,
                           const char *dst_path,
-                          apr_pool_t *pool)
+                          apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *src_ffd = src_fs->fsap_data;
+  svn_fs_x__data_t *src_ffd = src_fs->fsap_data;
 
   /* Create the DST_FS repository with the same layout as SRC_FS. */
   SVN_ERR(svn_fs_x__create_file_tree(dst_fs, dst_path, src_ffd->format,
-                                     src_ffd->max_files_per_dir, pool));
+                                     src_ffd->max_files_per_dir,
+                                     scratch_pool));
 
   /* Copy the UUID.  Hotcopy destination receives a new instance ID, but
    * has the same filesystem UUID as the source. */
-  SVN_ERR(svn_fs_x__set_uuid(dst_fs, src_fs->uuid, NULL, pool));
+  SVN_ERR(svn_fs_x__set_uuid(dst_fs, src_fs->uuid, NULL, scratch_pool));
 
   /* Remove revision 0 contents.  Otherwise, it may not get overwritten
    * due to having a newer timestamp. */
-  SVN_ERR(hotcopy_remove_file(svn_fs_x__path_rev(dst_fs, 0, pool), pool));
-  SVN_ERR(hotcopy_remove_file(svn_fs_x__path_revprops(dst_fs, 0, pool),
-                              pool));
+  SVN_ERR(hotcopy_remove_file(svn_fs_x__path_rev(dst_fs, 0, scratch_pool),
+                              scratch_pool));
+  SVN_ERR(hotcopy_remove_file(svn_fs_x__path_revprops(dst_fs, 0,
+                                                      scratch_pool),
+                              scratch_pool));
 
   /* This filesystem is ready.  Stamp it with a format number.  Fail if
    * the 'format' file should already exist. */
-  SVN_ERR(svn_fs_x__write_format(dst_fs, FALSE, pool));
+  SVN_ERR(svn_fs_x__write_format(dst_fs, FALSE, scratch_pool));
 
   return SVN_NO_ERROR;
 }
@@ -921,7 +927,7 @@ svn_fs_x__hotcopy_prepare_target(svn_fs_
                                  svn_fs_t *dst_fs,
                                  const char *dst_path,
                                  svn_boolean_t incremental,
-                                 apr_pool_t *pool)
+                                 apr_pool_t *scratch_pool)
 {
   if (incremental)
     {
@@ -930,27 +936,30 @@ svn_fs_x__hotcopy_prepare_target(svn_fs_
 
       /* Check destination format to be sure we know how to incrementally
        * hotcopy to the destination FS. */
-      dst_format_abspath = svn_dirent_join(dst_path, PATH_FORMAT, pool);
-      SVN_ERR(svn_io_check_path(dst_format_abspath, &dst_format_kind, pool));
+      dst_format_abspath = svn_dirent_join(dst_path, PATH_FORMAT,
+                                           scratch_pool);
+      SVN_ERR(svn_io_check_path(dst_format_abspath, &dst_format_kind,
+                                scratch_pool));
       if (dst_format_kind == svn_node_none)
         {
           /* Destination doesn't exist yet. Perform a normal hotcopy to a
            * empty destination using the same configuration as the source. */
-          SVN_ERR(hotcopy_create_empty_dest(src_fs, dst_fs, dst_path, pool));
+          SVN_ERR(hotcopy_create_empty_dest(src_fs, dst_fs, dst_path,
+                                            scratch_pool));
         }
       else
         {
           /* Check the existing repository. */
-          SVN_ERR(svn_fs_x__open(dst_fs, dst_path, pool));
-          SVN_ERR(hotcopy_incremental_check_preconditions(src_fs, dst_fs,
-                                                          pool));
+          SVN_ERR(svn_fs_x__open(dst_fs, dst_path, scratch_pool));
+          SVN_ERR(hotcopy_incremental_check_preconditions(src_fs, dst_fs));
         }
     }
   else
     {
       /* Start out with an empty destination using the same configuration
        * as the source. */
-      SVN_ERR(hotcopy_create_empty_dest(src_fs, dst_fs, dst_path, pool));
+      SVN_ERR(hotcopy_create_empty_dest(src_fs, dst_fs, dst_path,
+                                        scratch_pool));
     }
 
   return SVN_NO_ERROR;
@@ -964,9 +973,9 @@ svn_fs_x__hotcopy(svn_fs_t *src_fs,
                   void *notify_baton,
                   svn_cancel_func_t cancel_func,
                   void *cancel_baton,
-                  apr_pool_t *pool)
+                  apr_pool_t *scratch_pool)
 {
-  struct hotcopy_body_baton hbb;
+  hotcopy_body_baton_t hbb;
 
   hbb.src_fs = src_fs;
   hbb.dst_fs = dst_fs;
@@ -976,7 +985,7 @@ svn_fs_x__hotcopy(svn_fs_t *src_fs,
   hbb.cancel_func = cancel_func;
   hbb.cancel_baton = cancel_baton;
   SVN_ERR(svn_fs_x__with_all_locks(dst_fs, hotcopy_locking_src_body, &hbb,
-                                   pool));
+                                   scratch_pool));
 
   return SVN_NO_ERROR;
 }

Modified: subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/hotcopy.h
URL: http://svn.apache.org/viewvc/subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/hotcopy.h?rev=1658362&r1=1658361&r2=1658362&view=diff
==============================================================================
--- subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/hotcopy.h (original)
+++ subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/hotcopy.h Mon Feb  9 11:23:39 2015
@@ -27,25 +27,27 @@
 
 /* Create an empty copy of the fsfs filesystem SRC_FS into a new DST_FS at
  * DST_PATH.  If INCREMENTAL is TRUE, perform a few pre-checks only if
- * a repo already exists at DST_PATH. Use POOL for temporary allocations. */
+ * a repo already exists at DST_PATH.
+ * Use SCRATCH_POOL for temporary allocations. */
 svn_error_t *
 svn_fs_x__hotcopy_prepare_target(svn_fs_t *src_fs,
                                  svn_fs_t *dst_fs,
                                  const char *dst_path,
                                  svn_boolean_t incremental,
-                                 apr_pool_t *pool);
+                                 apr_pool_t *scratch_pool);
 
 /* Copy the fsfs filesystem SRC_FS into DST_FS. If INCREMENTAL is TRUE, do
  * not re-copy data which already exists in DST_FS.  Indicate progress via
- * the optional NOTIFY_FUNC callback using NOTIFY_BATON.  Use POOL for
- * temporary allocations. */
-svn_error_t * svn_fs_x__hotcopy(svn_fs_t *src_fs,
-                                svn_fs_t *dst_fs,
-                                svn_boolean_t incremental,
-                                svn_fs_hotcopy_notify_t notify_func,
-                                void *notify_baton,
-                                svn_cancel_func_t cancel_func,
-                                void *cancel_baton,
-                                apr_pool_t *pool);
+ * the optional NOTIFY_FUNC callback using NOTIFY_BATON.
+ * Use SCRATCH_POOL for temporary allocations. */
+svn_error_t * 
+svn_fs_x__hotcopy(svn_fs_t *src_fs,
+                  svn_fs_t *dst_fs,
+                  svn_boolean_t incremental,
+                  svn_fs_hotcopy_notify_t notify_func,
+                  void *notify_baton,
+                  svn_cancel_func_t cancel_func,
+                  void *cancel_baton,
+                  apr_pool_t *scratch_pool);
 
 #endif

Modified: subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/id.c
URL: http://svn.apache.org/viewvc/subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/id.c?rev=1658362&r1=1658361&r2=1658362&view=diff
==============================================================================
--- subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/id.c (original)
+++ subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/id.c Mon Feb  9 11:23:39 2015
@@ -1,4 +1,4 @@
-/* id.c : operations on node-revision IDs
+/* id.c : implements FSX-internal ID functions
  *
  * ====================================================================
  *    Licensed to the Apache Software Foundation (ASF) under one
@@ -21,32 +21,14 @@
  */
 
 #include <assert.h>
-#include <string.h>
-#include <stdlib.h>
 
 #include "id.h"
 #include "index.h"
 #include "util.h"
 
-#include "../libsvn_fs/fs-loader.h"
-#include "private/svn_temp_serializer.h"
 #include "private/svn_string_private.h"
 
 
-typedef struct fs_x__id_t
-{
-  /* API visible part */
-  svn_fs_id_t generic_id;
-
-  /* private members */
-  svn_fs_x__id_part_t node_id;
-  svn_fs_x__id_part_t copy_id;
-  svn_fs_x__id_part_t noderev_id;
-
-  apr_pool_t *pool; /* pool that was used to allocate this struct */
-} fs_x__id_t;
-
-
 
 svn_boolean_t
 svn_fs_x__is_txn(svn_fs_x__change_set_t change_set)
@@ -95,7 +77,7 @@ svn_fs_x__change_set_by_txn(apr_int64_t
 /* Parse the NUL-terminated ID part at DATA and write the result into *PART.
  * Return TRUE if no errors were detected. */
 static svn_boolean_t
-part_parse(svn_fs_x__id_part_t *part,
+part_parse(svn_fs_x__id_t *part,
            const char *data)
 {
   part->number = svn__base36toui64(&data, data);
@@ -119,7 +101,7 @@ part_parse(svn_fs_x__id_part_t *part,
  */
 static char *
 part_unparse(char *p,
-             const svn_fs_x__id_part_t *part)
+             const svn_fs_x__id_t *part)
 {
   p += svn__ui64tobase36(p, part->number);
   if (part->change_set >= 0)
@@ -141,151 +123,71 @@ part_unparse(char *p,
 /* Operations on ID parts */
 
 svn_boolean_t
-svn_fs_x__id_part_is_root(const svn_fs_x__id_part_t* part)
+svn_fs_x__id_is_root(const svn_fs_x__id_t* part)
 {
   return part->change_set == 0 && part->number == 0;
 }
 
 svn_boolean_t
-svn_fs_x__id_part_eq(const svn_fs_x__id_part_t *lhs,
-                     const svn_fs_x__id_part_t *rhs)
+svn_fs_x__id_eq(const svn_fs_x__id_t *lhs,
+                const svn_fs_x__id_t *rhs)
 {
   return lhs->change_set == rhs->change_set && lhs->number == rhs->number;
 }
 
-
-
-/* Accessing ID Pieces.  */
-
-const svn_fs_x__id_part_t *
-svn_fs_x__id_node_id(const svn_fs_id_t *fs_id)
-{
-  const fs_x__id_t *id = (const fs_x__id_t *)fs_id;
-
-  return &id->node_id;
-}
-
-
-const svn_fs_x__id_part_t *
-svn_fs_x__id_copy_id(const svn_fs_id_t *fs_id)
-{
-  const fs_x__id_t *id = (const fs_x__id_t *)fs_id;
-
-  return &id->copy_id;
-}
-
-
-svn_fs_x__txn_id_t
-svn_fs_x__id_txn_id(const svn_fs_id_t *fs_id)
-{
-  const fs_x__id_t *id = (const fs_x__id_t *)fs_id;
-
-  return svn_fs_x__get_txn_id(id->noderev_id.change_set);
-}
-
-
-const svn_fs_x__id_part_t *
-svn_fs_x__id_noderev_id(const svn_fs_id_t *fs_id)
-{
-  const fs_x__id_t *id = (const fs_x__id_t *)fs_id;
-
-  return &id->noderev_id;
-}
-
-svn_revnum_t
-svn_fs_x__id_rev(const svn_fs_id_t *fs_id)
-{
-  const fs_x__id_t *id = (const fs_x__id_t *)fs_id;
-
-  return svn_fs_x__get_revnum(id->noderev_id.change_set);
-}
-
-
-apr_uint64_t
-svn_fs_x__id_item(const svn_fs_id_t *fs_id)
+svn_error_t *
+svn_fs_x__id_parse(svn_fs_x__id_t *part,
+                   const char *data)
 {
-  const fs_x__id_t *id = (const fs_x__id_t *)fs_id;
+  if (!part_parse(part, data))
+    return svn_error_createf(SVN_ERR_FS_MALFORMED_NODEREV_ID, NULL,
+                             "Malformed ID string");
 
-  return id->noderev_id.number;
+  return SVN_NO_ERROR;
 }
 
-svn_boolean_t
-svn_fs_x__id_is_txn(const svn_fs_id_t *fs_id)
+svn_string_t *
+svn_fs_x__id_unparse(const svn_fs_x__id_t *id,
+                     apr_pool_t *result_pool)
 {
-  const fs_x__id_t *id = (const fs_x__id_t *)fs_id;
+  char string[2 * SVN_INT64_BUFFER_SIZE + 1];
+  char *p = part_unparse(string, id);
 
-  return svn_fs_x__is_txn(id->noderev_id.change_set);
+  return svn_string_ncreate(string, p - string, result_pool);
 }
 
-svn_string_t *
-svn_fs_x__id_unparse(const svn_fs_id_t *fs_id,
-                     apr_pool_t *pool)
+void
+svn_fs_x__id_reset(svn_fs_x__id_t *part)
 {
-  char string[6 * SVN_INT64_BUFFER_SIZE + 10];
-  const fs_x__id_t *id = (const fs_x__id_t *)fs_id;
-
-  char *p = part_unparse(string, &id->node_id);
-  *(p++) = '.';
-  p = part_unparse(p, &id->copy_id);
-  *(p++) = '.';
-  p = part_unparse(p, &id->noderev_id);
-
-  return svn_string_ncreate(string, p - string, pool);
+  part->change_set = SVN_FS_X__INVALID_CHANGE_SET;
+  part->number = 0;
 }
 
-
-/*** Comparing node IDs ***/
-
 svn_boolean_t
-svn_fs_x__id_eq(const svn_fs_id_t *a,
-                const svn_fs_id_t *b)
+svn_fs_x__id_used(const svn_fs_x__id_t *part)
 {
-  const fs_x__id_t *id_a = (const fs_x__id_t *)a;
-  const fs_x__id_t *id_b = (const fs_x__id_t *)b;
-
-  if (a == b)
-    return TRUE;
-
-  return svn_fs_x__id_part_eq(&id_a->node_id, &id_b->node_id)
-      && svn_fs_x__id_part_eq(&id_a->copy_id, &id_b->copy_id)
-      && svn_fs_x__id_part_eq(&id_a->noderev_id, &id_b->noderev_id);
+  return part->change_set != SVN_FS_X__INVALID_CHANGE_SET;
 }
 
-
-svn_boolean_t
-svn_fs_x__id_check_related(const svn_fs_id_t *a,
-                           const svn_fs_id_t *b)
+void
+svn_fs_x__init_txn_root(svn_fs_x__id_t *noderev_id,
+                        svn_fs_x__txn_id_t txn_id)
 {
-  const fs_x__id_t *id_a = (const fs_x__id_t *)a;
-  const fs_x__id_t *id_b = (const fs_x__id_t *)b;
-
-  if (a == b)
-    return TRUE;
-
-  /* Items from different txns are unrelated. */
-  if (   svn_fs_x__is_txn(id_a->noderev_id.change_set)
-      && svn_fs_x__is_txn(id_b->noderev_id.change_set)
-      && id_a->noderev_id.change_set != id_b->noderev_id.change_set)
-    return FALSE;
-
-  /* related if they trace back to the same node creation */
-  return svn_fs_x__id_part_eq(&id_a->node_id, &id_b->node_id);
+  noderev_id->change_set = svn_fs_x__change_set_by_txn(txn_id);
+  noderev_id->number = SVN_FS_X__ITEM_INDEX_ROOT_NODE;
 }
 
-
-svn_fs_node_relation_t
-svn_fs_x__id_compare(const svn_fs_id_t *a,
-                     const svn_fs_id_t *b)
+void
+svn_fs_x__init_rev_root(svn_fs_x__id_t *noderev_id,
+                        svn_revnum_t rev)
 {
-  if (svn_fs_x__id_eq(a, b))
-    return svn_fs_node_same;
-  return (svn_fs_x__id_check_related(a, b) ? svn_fs_node_common_ancestor
-                                           : svn_fs_node_unrelated);
+  noderev_id->change_set = svn_fs_x__change_set_by_rev(rev);
+  noderev_id->number = SVN_FS_X__ITEM_INDEX_ROOT_NODE;
 }
 
 int
-svn_fs_x__id_part_compare(const svn_fs_x__id_part_t *a,
-                          const svn_fs_x__id_part_t *b)
+svn_fs_x__id_compare(const svn_fs_x__id_t *a,
+                     const svn_fs_x__id_t *b)
 {
   if (a->change_set < b->change_set)
     return -1;
@@ -294,210 +196,3 @@ svn_fs_x__id_part_compare(const svn_fs_x
 
   return a->number < b->number ? -1 : a->number == b->number ? 0 : 1;
 }
-
-
-
-/* Creating ID's.  */
-
-static id_vtable_t id_vtable = {
-  svn_fs_x__id_unparse,
-  svn_fs_x__id_compare
-};
-
-svn_fs_id_t *
-svn_fs_x__id_txn_create_root(svn_fs_x__txn_id_t txn_id,
-                             apr_pool_t *pool)
-{
-  fs_x__id_t *id = apr_pcalloc(pool, sizeof(*id));
-
-  /* node ID and copy ID are "0" */
-
-  id->noderev_id.change_set = svn_fs_x__change_set_by_txn(txn_id);
-  id->noderev_id.number = SVN_FS_X__ITEM_INDEX_ROOT_NODE;
-
-  id->generic_id.vtable = &id_vtable;
-  id->generic_id.fsap_data = id;
-  id->pool = pool;
-
-  return (svn_fs_id_t *)id;
-}
-
-svn_fs_id_t *svn_fs_x__id_create_root(const svn_revnum_t revision,
-                                      apr_pool_t *pool)
-{
-  fs_x__id_t *id = apr_pcalloc(pool, sizeof(*id));
-
-  /* node ID and copy ID are "0" */
-
-  id->noderev_id.change_set = svn_fs_x__change_set_by_rev(revision);
-  id->noderev_id.number = SVN_FS_X__ITEM_INDEX_ROOT_NODE;
-
-  id->generic_id.vtable = &id_vtable;
-  id->generic_id.fsap_data = id;
-  id->pool = pool;
-
-  return (svn_fs_id_t *)id;
-}
-
-svn_fs_id_t *
-svn_fs_x__id_txn_create(const svn_fs_x__id_part_t *node_id,
-                        const svn_fs_x__id_part_t *copy_id,
-                        svn_fs_x__txn_id_t txn_id,
-                        apr_uint64_t item,
-                        apr_pool_t *pool)
-{
-  fs_x__id_t *id = apr_pcalloc(pool, sizeof(*id));
-
-  id->node_id = *node_id;
-  id->copy_id = *copy_id;
-
-  id->noderev_id.change_set = svn_fs_x__change_set_by_txn(txn_id);
-  id->noderev_id.number = item;
-
-  id->generic_id.vtable = &id_vtable;
-  id->generic_id.fsap_data = id;
-  id->pool = pool;
-
-  return (svn_fs_id_t *)id;
-}
-
-
-svn_fs_id_t *
-svn_fs_x__id_create(const svn_fs_x__id_part_t *node_id,
-                    const svn_fs_x__id_part_t *copy_id,
-                    const svn_fs_x__id_part_t *noderev_id,
-                    apr_pool_t *pool)
-{
-  fs_x__id_t *id = apr_pcalloc(pool, sizeof(*id));
-
-  id->node_id = *node_id;
-  id->copy_id = *copy_id;
-  id->noderev_id = *noderev_id;
-
-  id->generic_id.vtable = &id_vtable;
-  id->generic_id.fsap_data = id;
-  id->pool = pool;
-
-  return (svn_fs_id_t *)id;
-}
-
-
-svn_fs_id_t *
-svn_fs_x__id_copy(const svn_fs_id_t *source, apr_pool_t *pool)
-{
-  const fs_x__id_t *id = (const fs_x__id_t *)source;
-  fs_x__id_t *new_id = apr_pmemdup(pool, id, sizeof(*new_id));
-
-  new_id->generic_id.fsap_data = new_id;
-  new_id->pool = pool;
-
-  return (svn_fs_id_t *)new_id;
-}
-
-/* Return an ID resulting from parsing the string DATA, or NULL if DATA is
-   an invalid ID string. *DATA will be modified / invalidated by this call. */
-static svn_fs_id_t *
-id_parse(char *data,
-         apr_pool_t *pool)
-{
-  fs_x__id_t *id;
-  char *str;
-
-  /* Alloc a new svn_fs_id_t structure. */
-  id = apr_pcalloc(pool, sizeof(*id));
-  id->generic_id.vtable = &id_vtable;
-  id->generic_id.fsap_data = id;
-  id->pool = pool;
-
-  /* Now, we basically just need to "split" this data on `.'
-     characters.  We will use svn_cstring_tokenize, which will put
-     terminators where each of the '.'s used to be.  Then our new
-     id field will reference string locations inside our duplicate
-     string.*/
-
-  /* Node Id */
-  str = svn_cstring_tokenize(".", &data);
-  if (str == NULL)
-    return NULL;
-  if (! part_parse(&id->node_id, str))
-    return NULL;
-
-  /* Copy Id */
-  str = svn_cstring_tokenize(".", &data);
-  if (str == NULL)
-    return NULL;
-  if (! part_parse(&id->copy_id, str))
-    return NULL;
-
-  /* NodeRev Id */
-  str = svn_cstring_tokenize(".", &data);
-  if (str == NULL)
-    return NULL;
-
-  if (! part_parse(&id->noderev_id, str))
-    return NULL;
-
-  return (svn_fs_id_t *)id;
-}
-
-svn_error_t *
-svn_fs_x__id_parse(const svn_fs_id_t **id_p,
-                   char *data,
-                   apr_pool_t *pool)
-{
-  svn_fs_id_t *id = id_parse(data, pool);
-  if (id == NULL)
-    return svn_error_createf(SVN_ERR_FS_MALFORMED_NODEREV_ID, NULL,
-                             "Malformed node revision ID string");
-
-  *id_p = id;
-
-  return SVN_NO_ERROR;
-}
-
-/* (de-)serialization support */
-
-/* Serialize an ID within the serialization CONTEXT.
- */
-void
-svn_fs_x__id_serialize(svn_temp_serializer__context_t *context,
-                       const svn_fs_id_t * const *in)
-{
-  const fs_x__id_t *id = (const fs_x__id_t *)*in;
-
-  /* nothing to do for NULL ids */
-  if (id == NULL)
-    return;
-
-  /* serialize the id data struct itself */
-  svn_temp_serializer__add_leaf(context,
-                                (const void * const *)in,
-                                sizeof(fs_x__id_t));
-}
-
-/* Deserialize an ID inside the BUFFER.
- */
-void
-svn_fs_x__id_deserialize(void *buffer,
-                         svn_fs_id_t **in_out,
-                         apr_pool_t *pool)
-{
-    fs_x__id_t *id;
-
-  /* The id maybe all what is in the whole buffer.
-   * Don't try to fixup the pointer in that case*/
-  if (*in_out != buffer)
-    svn_temp_deserializer__resolve(buffer, (void**)in_out);
-
-  id = (fs_x__id_t *)*in_out;
-
-  /* no id, no sub-structure fixup necessary */
-  if (id == NULL)
-    return;
-
-  /* the stored vtable is bogus at best -> set the right one */
-  id->generic_id.vtable = &id_vtable;
-  id->generic_id.fsap_data = id;
-  id->pool = pool;
-}
-

Modified: subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/id.h
URL: http://svn.apache.org/viewvc/subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/id.h?rev=1658362&r1=1658361&r2=1658362&view=diff
==============================================================================
--- subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/id.h (original)
+++ subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/id.h Mon Feb  9 11:23:39 2015
@@ -1,4 +1,4 @@
-/* id.h : interface to node ID functions, private to libsvn_fs_x
+/* id.h : interface to FSX-internal ID functions
  *
  * ====================================================================
  *    Licensed to the Apache Software Foundation (ASF) under one
@@ -45,149 +45,88 @@ typedef apr_int64_t svn_fs_x__change_set
 
 /* Return TRUE iff the CHANGE_SET refers to a revision
    (will return FALSE for SVN_INVALID_REVNUM). */
-svn_boolean_t svn_fs_x__is_revision(svn_fs_x__change_set_t change_set);
+svn_boolean_t
+svn_fs_x__is_revision(svn_fs_x__change_set_t change_set);
 
 /* Return TRUE iff the CHANGE_SET refers to a transaction
    (will return FALSE for SVN_FS_X__INVALID_TXN_ID). */
-svn_boolean_t svn_fs_x__is_txn(svn_fs_x__change_set_t change_set);
+svn_boolean_t
+svn_fs_x__is_txn(svn_fs_x__change_set_t change_set);
 
 /* Return the revision number that corresponds to CHANGE_SET.
    Will SVN_INVALID_REVNUM for transactions. */
-svn_revnum_t svn_fs_x__get_revnum(svn_fs_x__change_set_t change_set);
+svn_revnum_t
+svn_fs_x__get_revnum(svn_fs_x__change_set_t change_set);
 
 /* Return the transaction ID that corresponds to CHANGE_SET.
    Will SVN_FS_X__INVALID_TXN_ID for revisions. */
-apr_int64_t svn_fs_x__get_txn_id(svn_fs_x__change_set_t change_set);
+svn_fs_x__txn_id_t
+svn_fs_x__get_txn_id(svn_fs_x__change_set_t change_set);
 
 /* Convert REVNUM into a change set number */
-svn_fs_x__change_set_t svn_fs_x__change_set_by_rev(svn_revnum_t revnum);
+svn_fs_x__change_set_t
+svn_fs_x__change_set_by_rev(svn_revnum_t revnum);
 
 /* Convert TXN_ID into a change set number */
-svn_fs_x__change_set_t svn_fs_x__change_set_by_txn(apr_int64_t txn_id);
+svn_fs_x__change_set_t
+svn_fs_x__change_set_by_txn(svn_fs_x__txn_id_t txn_id);
 
-/* A rev node ID in FSX consists of a 3 of sub-IDs ("parts") that consist
- * of a creation CHANGE_SET number and some revision-local counter value
- * (NUMBER).
+/* An ID in FSX consists of a creation CHANGE_SET number and some changeset-
+ * local counter value (NUMBER).
  */
-typedef struct svn_fs_x__id_part_t
+typedef struct svn_fs_x__id_t
 {
   svn_fs_x__change_set_t change_set;
 
   apr_uint64_t number;
-} svn_fs_x__id_part_t;
+} svn_fs_x__id_t;
 
 
 /*** Operations on ID parts. ***/
 
 /* Return TRUE, if both elements of the PART is 0, i.e. this is the default
  * value if e.g. no copies were made of this node. */
-svn_boolean_t svn_fs_x__id_part_is_root(const svn_fs_x__id_part_t *part);
+svn_boolean_t
+svn_fs_x__id_is_root(const svn_fs_x__id_t *part);
 
 /* Return TRUE, if all element values of *LHS and *RHS match. */
-svn_boolean_t svn_fs_x__id_part_eq(const svn_fs_x__id_part_t *lhs,
-                                   const svn_fs_x__id_part_t *rhs);
+svn_boolean_t
+svn_fs_x__id_eq(const svn_fs_x__id_t *lhs,
+                const svn_fs_x__id_t *rhs);
 
-
-/*** ID accessor functions. ***/
-
-/* Get the "node id" portion of ID. */
-const svn_fs_x__id_part_t *svn_fs_x__id_node_id(const svn_fs_id_t *id);
-
-/* Get the "copy id" portion of ID. */
-const svn_fs_x__id_part_t *svn_fs_x__id_copy_id(const svn_fs_id_t *id);
-
-/* Get the "txn id" portion of ID,
- * or SVN_FS_X__INVALID_TXN_ID if it is a permanent ID. */
-svn_fs_x__txn_id_t svn_fs_x__id_txn_id(const svn_fs_id_t *id);
-
-/* Get the "noderev id" portion of ID. */
-const svn_fs_x__id_part_t *svn_fs_x__id_noderev_id(const svn_fs_id_t *id);
-
-/* Get the "rev" portion of ID, or SVN_INVALID_REVNUM if it is a
-   transaction ID. */
-svn_revnum_t svn_fs_x__id_rev(const svn_fs_id_t *id);
-
-/* Access the "item" portion of the ID, or 0 if it is a transaction
-   ID. */
-apr_uint64_t svn_fs_x__id_item(const svn_fs_id_t *id);
-
-/* Return TRUE, if this is a transaction ID. */
-svn_boolean_t svn_fs_x__id_is_txn(const svn_fs_id_t *id);
-
-/* Convert ID into string form, allocated in POOL. */
-svn_string_t *svn_fs_x__id_unparse(const svn_fs_id_t *id,
-                                   apr_pool_t *pool);
+/* Parse the NUL-terminated ID part at DATA and write the result into *PART.
+ */
+svn_error_t *
+svn_fs_x__id_parse(svn_fs_x__id_t *part,
+                   const char *data);
 
-/* Return true if A and B are equal. */
-svn_boolean_t svn_fs_x__id_eq(const svn_fs_id_t *a,
-                              const svn_fs_id_t *b);
+/* Convert ID into string form, allocated in RESULT_POOL. */
+svn_string_t *
+svn_fs_x__id_unparse(const svn_fs_x__id_t*id,
+                     apr_pool_t *result_pool);
 
-/* Return true if A and B are related. */
-svn_boolean_t svn_fs_x__id_check_related(const svn_fs_id_t *a,
-                                         const svn_fs_id_t *b);
+/* Set *PART to "unused". */
+void
+svn_fs_x__id_reset(svn_fs_x__id_t *part);
 
-/* Return the noderev relationship between A and B. */
-svn_fs_node_relation_t svn_fs_x__id_compare(const svn_fs_id_t *a,
-                                            const svn_fs_id_t *b);
+/* Return TRUE if *PART is belongs to either a revision or transaction. */
+svn_boolean_t
+svn_fs_x__id_used(const svn_fs_x__id_t *part);
 
 /* Return 0 if A and B are equal, 1 if A is "greater than" B, -1 otherwise. */
-int svn_fs_x__id_part_compare(const svn_fs_x__id_part_t *a,
-                              const svn_fs_x__id_part_t *b);
-
-/* Create the txn root ID for transaction TXN_ID.  Allocate it in POOL. */
-svn_fs_id_t *svn_fs_x__id_txn_create_root(svn_fs_x__txn_id_t txnnum,
-                                          apr_pool_t *pool);
-
-/* Create the root ID for REVISION.  Allocate it in POOL. */
-svn_fs_id_t *svn_fs_x__id_create_root(const svn_revnum_t revision,
-                                      apr_pool_t *pool);
-
-/* Create an ID within a transaction based on NODE_ID, COPY_ID, TXN_ID
-   and ITEM number, allocated in POOL. */
-svn_fs_id_t *svn_fs_x__id_txn_create(const svn_fs_x__id_part_t *node_id,
-                                     const svn_fs_x__id_part_t *copy_id,
-                                     svn_fs_x__txn_id_t txn_id,
-                                     apr_uint64_t item,
-                                     apr_pool_t *pool);
-
-/* Create a permanent ID based on NODE_ID, COPY_ID and NODEREV_ID,
-   allocated in POOL. */
-svn_fs_id_t *svn_fs_x__id_create(const svn_fs_x__id_part_t *node_id,
-                                 const svn_fs_x__id_part_t *copy_id,
-                                 const svn_fs_x__id_part_t *noderev_id,
-                                 apr_pool_t *pool);
-
-/* Return a copy of ID, allocated from POOL. */
-svn_fs_id_t *svn_fs_x__id_copy(const svn_fs_id_t *id,
-                               apr_pool_t *pool);
-
-/* Return an ID in *ID_P resulting from parsing the string DATA, or an error
-   if DATA is an invalid ID string. *DATA will be modified / invalidated by
-   this call. */
-svn_error_t *
-svn_fs_x__id_parse(const svn_fs_id_t **id_p,
-                   char *data,
-                   apr_pool_t *pool);
-
+int
+svn_fs_x__id_compare(const svn_fs_x__id_t *a,
+                     const svn_fs_x__id_t *b);
 
-/* (de-)serialization support*/
-
-struct svn_temp_serializer__context_t;
-
-/**
- * Serialize an @a id within the serialization @a context.
- */
+/* Set *NODEREV_ID to the root node ID of transaction TXN_ID. */
 void
-svn_fs_x__id_serialize(struct svn_temp_serializer__context_t *context,
-                        const svn_fs_id_t * const *id);
+svn_fs_x__init_txn_root(svn_fs_x__id_t *noderev_id,
+                        svn_fs_x__txn_id_t txn_id);
 
-/**
- * Deserialize an @a id within the @a buffer and associate it with @a pool.
- */
+/* Set *NODEREV_ID to the root node ID of revision REV. */
 void
-svn_fs_x__id_deserialize(void *buffer,
-                         svn_fs_id_t **id,
-                         apr_pool_t *pool);
+svn_fs_x__init_rev_root(svn_fs_x__id_t *noderev_id,
+                        svn_revnum_t rev);
 
 #ifdef __cplusplus
 }

Modified: subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/index.c
URL: http://svn.apache.org/viewvc/subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/index.c?rev=1658362&r1=1658361&r2=1658362&view=diff
==============================================================================
--- subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/index.c (original)
+++ subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/index.c Mon Feb  9 11:23:39 2015
@@ -234,10 +234,10 @@ stream_error_create(svn_fs_x__packed_num
                     const char *message)
 {
   const char *file_name;
-  apr_off_t offset = 0;
+  apr_off_t offset;
   SVN_ERR(svn_io_file_name_get(&file_name, stream->file,
                                stream->pool));
-  SVN_ERR(svn_io_file_seek(stream->file, APR_CUR, &offset, stream->pool));
+  SVN_ERR(svn_fs_x__get_file_offset(&offset, stream->file, stream->pool));
 
   return svn_error_createf(err, NULL, message, file_name,
                            apr_psprintf(stream->pool,
@@ -905,7 +905,7 @@ svn_fs_x__l2p_index_append(svn_checksum_
                            apr_pool_t * result_pool,
                            apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *ffd = fs->fsap_data;
+  svn_fs_x__data_t *ffd = fs->fsap_data;
   apr_file_t *proto_index = NULL;
   svn_stream_t *stream;
   int i;
@@ -1076,7 +1076,7 @@ svn_fs_x__l2p_index_append(svn_checksum_
 static svn_revnum_t
 base_revision(svn_fs_t *fs, svn_revnum_t revision)
 {
-  fs_x_data_t *ffd = fs->fsap_data;
+  svn_fs_x__data_t *ffd = fs->fsap_data;
   return svn_fs_x__is_packed_rev(fs, revision)
        ? revision - (revision % ffd->max_files_per_dir)
        : revision;
@@ -1241,7 +1241,7 @@ auto_open_l2p_index(svn_fs_x__revision_f
 {
   if (rev_file->l2p_stream == NULL)
     {
-      fs_x_data_t *ffd = fs->fsap_data;
+      svn_fs_x__data_t *ffd = fs->fsap_data;
 
       SVN_ERR(svn_fs_x__auto_read_footer(rev_file));
       SVN_ERR(packed_stream_open(&rev_file->l2p_stream,
@@ -1269,7 +1269,7 @@ get_l2p_header_body(l2p_header_t **heade
                     apr_pool_t *result_pool,
                     apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *ffd = fs->fsap_data;
+  svn_fs_x__data_t *ffd = fs->fsap_data;
   apr_uint64_t value;
   apr_size_t i;
   apr_size_t page, page_count;
@@ -1280,7 +1280,7 @@ get_l2p_header_body(l2p_header_t **heade
   apr_array_header_t *expanded_values
     = apr_array_make(scratch_pool, 16, sizeof(apr_uint64_t));
 
-  pair_cache_key_t key;
+  svn_fs_x__pair_cache_key_t key;
   key.revision = rev_file->start_revision;
   key.second = rev_file->is_packed;
 
@@ -1397,13 +1397,13 @@ get_l2p_page_info(l2p_page_info_baton_t
                   svn_fs_t *fs,
                   apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *ffd = fs->fsap_data;
+  svn_fs_x__data_t *ffd = fs->fsap_data;
   l2p_header_t *result;
   svn_boolean_t is_cached = FALSE;
   void *dummy = NULL;
 
   /* try to find the info in the cache */
-  pair_cache_key_t key;
+  svn_fs_x__pair_cache_key_t key;
   key.revision = base_revision(fs, baton->revision);
   key.second = svn_fs_x__is_packed_rev(fs, baton->revision);
   SVN_ERR(svn_cache__get_partial((void**)&dummy, &is_cached,
@@ -1435,11 +1435,11 @@ get_l2p_header(l2p_header_t **header,
                apr_pool_t *result_pool,
                apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *ffd = fs->fsap_data;
+  svn_fs_x__data_t *ffd = fs->fsap_data;
   svn_boolean_t is_cached = FALSE;
 
   /* first, try cache lookop */
-  pair_cache_key_t key;
+  svn_fs_x__pair_cache_key_t key;
   key.revision = rev_file->start_revision;
   key.second = rev_file->is_packed;
   SVN_ERR(svn_cache__get((void**)header, &is_cached, ffd->l2p_header_cache,
@@ -1556,20 +1556,21 @@ typedef struct l2p_page_baton_t
 
 /* Return the rev / pack file offset of the item at BATON->PAGE_OFFSET in
  * OFFSETS of PAGE and write it to *OFFSET.
+ * Allocate temporaries in SCRATCH_POOL.
  */
 static svn_error_t *
 l2p_page_get_offset(l2p_page_baton_t *baton,
                     const l2p_page_t *page,
                     const apr_off_t *offsets,
                     const apr_uint32_t *sub_items,
-                    apr_pool_t *pool)
+                    apr_pool_t *scratch_pool)
 {
   /* overflow check */
   if (page->entry_count <= baton->page_offset)
     return svn_error_createf(SVN_ERR_FS_INDEX_OVERFLOW , NULL,
                              _("Item index %s too large in"
                                " revision %ld"),
-                             apr_psprintf(pool, "%" APR_UINT64_T_FMT,
+                             apr_psprintf(scratch_pool, "%" APR_UINT64_T_FMT,
                                           baton->item_index),
                              baton->revision);
 
@@ -1667,11 +1668,11 @@ get_l2p_page_table(apr_array_header_t *p
                    svn_revnum_t revision,
                    apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *ffd = fs->fsap_data;
+  svn_fs_x__data_t *ffd = fs->fsap_data;
   svn_boolean_t is_cached = FALSE;
   l2p_page_table_baton_t baton;
 
-  pair_cache_key_t key;
+  svn_fs_x__pair_cache_key_t key;
   key.revision = base_revision(fs, revision);
   key.second = svn_fs_x__is_packed_rev(fs, revision);
 
@@ -1707,7 +1708,7 @@ prefetch_l2p_pages(svn_boolean_t *end,
                    apr_off_t max_offset,
                    apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *ffd = fs->fsap_data;
+  svn_fs_x__data_t *ffd = fs->fsap_data;
   int i;
   apr_pool_t *iterpool;
   svn_fs_x__page_cache_key_t key = { 0 };
@@ -1794,7 +1795,7 @@ l2p_index_lookup(apr_off_t *offset,
                  apr_uint64_t item_index,
                  apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *ffd = fs->fsap_data;
+  svn_fs_x__data_t *ffd = fs->fsap_data;
   l2p_page_info_baton_t info_baton;
   l2p_page_baton_t page_baton;
   l2p_page_t *page = NULL;
@@ -2000,13 +2001,12 @@ svn_fs_x__l2p_get_max_ids(apr_array_head
  */
 svn_fs_x__p2l_entry_t *
 svn_fs_x__p2l_entry_dup(const svn_fs_x__p2l_entry_t *entry,
-                        apr_pool_t *pool)
+                        apr_pool_t *result_pool)
 {
-  svn_fs_x__p2l_entry_t *new_entry = apr_palloc(pool, sizeof(*new_entry));
-  *new_entry = *entry;
-
+  svn_fs_x__p2l_entry_t *new_entry = apr_pmemdup(result_pool, entry,
+                                                 sizeof(*new_entry));
   if (new_entry->item_count)
-    new_entry->items = apr_pmemdup(pool,
+    new_entry->items = apr_pmemdup(result_pool,
                                    entry->items,
                                    entry->item_count * sizeof(*entry->items));
 
@@ -2063,7 +2063,7 @@ svn_fs_x__p2l_proto_index_add_entry(apr_
   /* Add sub-items. */
   for (i = 0; i < entry->item_count; ++i)
     {
-      const svn_fs_x__id_part_t *sub_item = &entry->items[i];
+      const svn_fs_x__id_t *sub_item = &entry->items[i];
 
       /* Make sure all signed elements of ENTRY have non-negative values.
        *
@@ -2128,7 +2128,7 @@ read_p2l_sub_items_from_proto_index(apr_
   for (i = 0; i < entry->item_count; ++i)
     {
       apr_uint64_t revision;
-      svn_fs_x__id_part_t *sub_item = &entry->items[i];
+      svn_fs_x__id_t *sub_item = &entry->items[i];
 
       SVN_ERR(read_uint64_from_proto_index(proto_index, &revision,
                                            eof, scratch_pool));
@@ -2204,7 +2204,7 @@ svn_fs_x__p2l_index_append(svn_checksum_
                            apr_pool_t *result_pool,
                            apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *ffd = fs->fsap_data;
+  svn_fs_x__data_t *ffd = fs->fsap_data;
   apr_uint64_t page_size = ffd->p2l_page_size;
   apr_file_t *proto_index = NULL;
   svn_stream_t *stream;
@@ -2392,7 +2392,7 @@ auto_open_p2l_index(svn_fs_x__revision_f
 {
   if (rev_file->p2l_stream == NULL)
     {
-      fs_x_data_t *ffd = fs->fsap_data;
+      svn_fs_x__data_t *ffd = fs->fsap_data;
 
       SVN_ERR(svn_fs_x__auto_read_footer(rev_file));
       SVN_ERR(packed_stream_open(&rev_file->p2l_stream,
@@ -2509,7 +2509,7 @@ get_p2l_header(p2l_header_t **header,
                apr_pool_t *result_pool,
                apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *ffd = fs->fsap_data;
+  svn_fs_x__data_t *ffd = fs->fsap_data;
   apr_uint64_t value;
   apr_size_t i;
   apr_off_t offset;
@@ -2517,7 +2517,7 @@ get_p2l_header(p2l_header_t **header,
   svn_boolean_t is_cached = FALSE;
 
   /* look for the header data in our cache */
-  pair_cache_key_t key;
+  svn_fs_x__pair_cache_key_t key;
   key.revision = rev_file->start_revision;
   key.second = rev_file->is_packed;
 
@@ -2595,13 +2595,13 @@ get_p2l_page_info(p2l_page_info_baton_t
                   svn_fs_t *fs,
                   apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *ffd = fs->fsap_data;
+  svn_fs_x__data_t *ffd = fs->fsap_data;
   p2l_header_t *header;
   svn_boolean_t is_cached = FALSE;
   void *dummy = NULL;
 
   /* look for the header data in our cache */
-  pair_cache_key_t key;
+  svn_fs_x__pair_cache_key_t key;
   key.revision = base_revision(fs, baton->revision);
   key.second = svn_fs_x__is_packed_rev(fs, baton->revision);
 
@@ -2803,7 +2803,7 @@ prefetch_p2l_page(svn_boolean_t *end,
                   apr_off_t min_offset,
                   apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *ffd = fs->fsap_data;
+  svn_fs_x__data_t *ffd = fs->fsap_data;
   svn_boolean_t already_cached;
   apr_array_header_t *page;
   svn_fs_x__page_cache_key_t key = { 0 };
@@ -2954,7 +2954,7 @@ append_p2l_entries(apr_array_header_t *e
       /* Copy the items of that entries. */
       if (entry->item_count)
         {
-          const svn_fs_x__id_part_t *items
+          const svn_fs_x__id_t *items
             = resolve_ptr
             ? svn_temp_deserializer__ptr(page_entries->elts,
                                          (const void * const *)&entry->items)
@@ -3014,7 +3014,7 @@ p2l_index_lookup(apr_array_header_t *ent
                  apr_off_t block_end,
                  apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *ffd = fs->fsap_data;
+  svn_fs_x__data_t *ffd = fs->fsap_data;
   svn_fs_x__page_cache_key_t key;
   svn_boolean_t is_cached = FALSE;
   p2l_page_info_baton_t page_info;
@@ -3241,7 +3241,7 @@ get_p2l_entry_from_cached_page(const voi
       svn_fs_x__p2l_entry_t *result
         = apr_pmemdup(result_pool, entry, sizeof(*result));
       result->items
-        = (svn_fs_x__id_part_t *)svn_temp_deserializer__ptr(entries->elts,
+        = (svn_fs_x__id_t *)svn_temp_deserializer__ptr(entries->elts,
                                      (const void *const *)&entry->items);
       return result;
     }
@@ -3280,7 +3280,7 @@ p2l_entry_lookup(svn_fs_x__p2l_entry_t *
                  apr_pool_t *result_pool,
                  apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *ffd = fs->fsap_data;
+  svn_fs_x__data_t *ffd = fs->fsap_data;
   svn_fs_x__page_cache_key_t key = { 0 };
   svn_boolean_t is_cached = FALSE;
   p2l_page_info_baton_t page_info;
@@ -3338,7 +3338,7 @@ typedef struct p2l_item_lookup_baton_t
 } p2l_item_lookup_baton_t;
 
 /* Implements svn_cache__partial_getter_func_t for P2L index pages, copying
- * the svn_fs_x__id_part_t for the item described 2l_item_lookup_baton_t
+ * the svn_fs_x__id_t for the item described 2l_item_lookup_baton_t
  * *BATON.  *OUT will be NULL if there is no matching index entry or the
  * sub-item is out of range.
  */
@@ -3366,7 +3366,7 @@ p2l_item_lookup_func(void **out,
 }
 
 svn_error_t *
-svn_fs_x__p2l_item_lookup(svn_fs_x__id_part_t **item,
+svn_fs_x__p2l_item_lookup(svn_fs_x__id_t **item,
                           svn_fs_t *fs,
                           svn_fs_x__revision_file_t *rev_file,
                           svn_revnum_t revision,
@@ -3375,7 +3375,7 @@ svn_fs_x__p2l_item_lookup(svn_fs_x__id_p
                           apr_pool_t *result_pool,
                           apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *ffd = fs->fsap_data;
+  svn_fs_x__data_t *ffd = fs->fsap_data;
   svn_fs_x__page_cache_key_t key = { 0 };
   svn_boolean_t is_cached = FALSE;
   p2l_page_info_baton_t page_info;
@@ -3432,13 +3432,13 @@ svn_fs_x__p2l_get_max_offset(apr_off_t *
                              svn_revnum_t revision,
                              apr_pool_t *scratch_pool)
 {
-  fs_x_data_t *ffd = fs->fsap_data;
+  svn_fs_x__data_t *ffd = fs->fsap_data;
   p2l_header_t *header;
   svn_boolean_t is_cached = FALSE;
   apr_off_t *offset_p;
 
   /* look for the header data in our cache */
-  pair_cache_key_t key;
+  svn_fs_x__pair_cache_key_t key;
   key.revision = base_revision(fs, revision);
   key.second = svn_fs_x__is_packed_rev(fs, revision);
 
@@ -3464,7 +3464,7 @@ svn_fs_x__item_offset(apr_off_t *absolut
                       apr_uint32_t *sub_item,
                       svn_fs_t *fs,
                       svn_fs_x__revision_file_t *rev_file,
-                      const svn_fs_x__id_part_t *item_id,
+                      const svn_fs_x__id_t *item_id,
                       apr_pool_t *scratch_pool)
 {
   if (svn_fs_x__is_txn(item_id->change_set))
@@ -3583,15 +3583,15 @@ typedef struct sub_item_ordered_t
 
   /* Array of pointers into ENTRY->ITEMS, sorted by their revision member
    * _descending_ order.  May be NULL if ENTRY->ITEM_COUNT < 2. */
-  svn_fs_x__id_part_t **order;
+  svn_fs_x__id_t **order;
 } sub_item_ordered_t;
 
 /* implements compare_fn_t. Place LHS before RHS, if the latter is younger.
  * Used to sort sub_item_ordered_t::order
  */
 static int
-compare_sub_items(const svn_fs_x__id_part_t * const * lhs,
-                  const svn_fs_x__id_part_t * const * rhs)
+compare_sub_items(const svn_fs_x__id_t * const * lhs,
+                  const svn_fs_x__id_t * const * rhs)
 {
   return (*lhs)->change_set < (*rhs)->change_set
        ? 1
@@ -3605,8 +3605,8 @@ static int
 compare_p2l_info_rev(const sub_item_ordered_t * lhs,
                      const sub_item_ordered_t * rhs)
 {
-  svn_fs_x__id_part_t *lhs_part;
-  svn_fs_x__id_part_t *rhs_part;
+  svn_fs_x__id_t *lhs_part;
+  svn_fs_x__id_t *rhs_part;
   
   assert(lhs != rhs);
   if (lhs->entry->item_count == 0)
@@ -3697,7 +3697,7 @@ svn_fs_x__l2p_index_from_p2l_entries(con
   /* write index entries */
   for (i = 0; i < count; ++i)
     {
-      svn_fs_x__id_part_t *sub_item;
+      svn_fs_x__id_t *sub_item;
       sub_item_ordered_t *ordered = svn_priority_queue__peek(queue);
 
       if (ordered->entry->item_count > 0)

Modified: subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/index.h
URL: http://svn.apache.org/viewvc/subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/index.h?rev=1658362&r1=1658361&r2=1658362&view=diff
==============================================================================
--- subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/index.h (original)
+++ subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/index.h Mon Feb  9 11:23:39 2015
@@ -77,14 +77,14 @@ typedef struct svn_fs_x__p2l_entry_t
   apr_uint32_t item_count;
 
   /* List of items in that block / container */
-  svn_fs_x__id_part_t *items;
+  svn_fs_x__id_t *items;
 } svn_fs_x__p2l_entry_t;
 
-/* Return a (deep) copy of ENTRY, allocated in POOL.
+/* Return a (deep) copy of ENTRY, allocated in RESULT_POOL.
  */
 svn_fs_x__p2l_entry_t *
 svn_fs_x__p2l_entry_dup(const svn_fs_x__p2l_entry_t *entry,
-                        apr_pool_t *pool);
+                        apr_pool_t *result_pool);
 
 /* Open / create a log-to-phys index file with the full file path name
  * FILE_NAME.  Return the open file in *PROTO_INDEX allocated in
@@ -220,7 +220,7 @@ svn_fs_x__p2l_entry_lookup(svn_fs_x__p2l
                            apr_pool_t *result_pool,
                            apr_pool_t *scratch_pool);
 
-/* Use the phys-to-log mapping files in FS to return the svn_fs_x__id_part_t
+/* Use the phys-to-log mapping files in FS to return the svn_fs_x__id_t
  * for the SUB_ITEM of the container starting at global OFFSET in the rep /
  * pack file containing REVISION in *ITEM, allocated in RESULT_POOL.  Sets
  * *ITEM to NULL if no element starts at exactly that offset or if it
@@ -229,7 +229,7 @@ svn_fs_x__p2l_entry_lookup(svn_fs_x__p2l
  * Use SCRATCH_POOL for temporary allocations.
  */
 svn_error_t *
-svn_fs_x__p2l_item_lookup(svn_fs_x__id_part_t **item,
+svn_fs_x__p2l_item_lookup(svn_fs_x__id_t **item,
                           svn_fs_t *fs,
                           svn_fs_x__revision_file_t *rev_file,
                           svn_revnum_t revision,
@@ -254,7 +254,7 @@ svn_fs_x__item_offset(apr_off_t *absolut
                       apr_uint32_t *sub_item,
                       svn_fs_t *fs,
                       svn_fs_x__revision_file_t *rev_file,
-                      const svn_fs_x__id_part_t *item_id,
+                      const svn_fs_x__id_t *item_id,
                       apr_pool_t *scratch_pool);
 
 /* Use the log-to-phys indexes in FS to determine the maximum item indexes

Modified: subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/lock.c
URL: http://svn.apache.org/viewvc/subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/lock.c?rev=1658362&r1=1658361&r2=1658362&view=diff
==============================================================================
--- subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/lock.c (original)
+++ subversion/branches/remove-log-addressing/subversion/libsvn_fs_x/lock.c Mon Feb  9 11:23:39 2015
@@ -37,6 +37,7 @@
 #include "tree.h"
 #include "fs_x.h"
 #include "transaction.h"
+#include "util.h"
 #include "../libsvn_fs/fs-loader.h"
 
 #include "private/svn_fs_util.h"
@@ -103,8 +104,7 @@ hash_store(apr_hash_t *hash,
    of that value (if it exists). */
 static const char *
 hash_fetch(apr_hash_t *hash,
-           const char *key,
-           apr_pool_t *pool)
+           const char *key)
 {
   svn_string_t *str = svn_hash_gets(hash, key);
   return str ? str->data : NULL;
@@ -161,7 +161,7 @@ digest_path_from_path(const char **diges
    empty, if the versioned path in FS represented by DIGEST_PATH has
    no children) and LOCK (which may be NULL if that versioned path is
    lock itself locked).  Set the permissions of DIGEST_PATH to those of
-   PERMS_REFERENCE.  Use POOL for all allocations.
+   PERMS_REFERENCE.  Use POOL for temporary allocations.
  */
 static svn_error_t *
 write_digest_file(apr_hash_t *children,
@@ -169,45 +169,53 @@ write_digest_file(apr_hash_t *children,
                   const char *fs_path,
                   const char *digest_path,
                   const char *perms_reference,
-                  apr_pool_t *pool)
+                  apr_pool_t *scratch_pool)
 {
   svn_error_t *err = SVN_NO_ERROR;
   svn_stream_t *stream;
   apr_hash_index_t *hi;
-  apr_hash_t *hash = apr_hash_make(pool);
+  apr_hash_t *hash = apr_hash_make(scratch_pool);
   const char *tmp_path;
 
   SVN_ERR(svn_fs_x__ensure_dir_exists(svn_dirent_join(fs_path, PATH_LOCKS_DIR,
-                                                      pool), fs_path, pool));
-  SVN_ERR(svn_fs_x__ensure_dir_exists(svn_dirent_dirname(digest_path, pool),
-                                      fs_path, pool));
+                                                      scratch_pool),
+                                      fs_path, scratch_pool));
+  SVN_ERR(svn_fs_x__ensure_dir_exists(svn_dirent_dirname(digest_path,
+                                                         scratch_pool),
+                                      fs_path, scratch_pool));
 
   if (lock)
     {
       const char *creation_date = NULL, *expiration_date = NULL;
       if (lock->creation_date)
-        creation_date = svn_time_to_cstring(lock->creation_date, pool);
+        creation_date = svn_time_to_cstring(lock->creation_date,
+                                            scratch_pool);
       if (lock->expiration_date)
-        expiration_date = svn_time_to_cstring(lock->expiration_date, pool);
+        expiration_date = svn_time_to_cstring(lock->expiration_date,
+                                              scratch_pool);
+
       hash_store(hash, PATH_KEY, sizeof(PATH_KEY)-1,
-                 lock->path, APR_HASH_KEY_STRING, pool);
+                 lock->path, APR_HASH_KEY_STRING, scratch_pool);
       hash_store(hash, TOKEN_KEY, sizeof(TOKEN_KEY)-1,
-                 lock->token, APR_HASH_KEY_STRING, pool);
+                 lock->token, APR_HASH_KEY_STRING, scratch_pool);
       hash_store(hash, OWNER_KEY, sizeof(OWNER_KEY)-1,
-                 lock->owner, APR_HASH_KEY_STRING, pool);
+                 lock->owner, APR_HASH_KEY_STRING, scratch_pool);
       hash_store(hash, COMMENT_KEY, sizeof(COMMENT_KEY)-1,
-                 lock->comment, APR_HASH_KEY_STRING, pool);
+                 lock->comment, APR_HASH_KEY_STRING, scratch_pool);
       hash_store(hash, IS_DAV_COMMENT_KEY, sizeof(IS_DAV_COMMENT_KEY)-1,
-                 lock->is_dav_comment ? "1" : "0", 1, pool);
+                 lock->is_dav_comment ? "1" : "0", 1, scratch_pool);
       hash_store(hash, CREATION_DATE_KEY, sizeof(CREATION_DATE_KEY)-1,
-                 creation_date, APR_HASH_KEY_STRING, pool);
+                 creation_date, APR_HASH_KEY_STRING, scratch_pool);
       hash_store(hash, EXPIRATION_DATE_KEY, sizeof(EXPIRATION_DATE_KEY)-1,
-                 expiration_date, APR_HASH_KEY_STRING, pool);
+                 expiration_date, APR_HASH_KEY_STRING, scratch_pool);
     }
   if (apr_hash_count(children))
     {
-      svn_stringbuf_t *children_list = svn_stringbuf_create_empty(pool);
-      for (hi = apr_hash_first(pool, children); hi; hi = apr_hash_next(hi))
+      svn_stringbuf_t *children_list
+        = svn_stringbuf_create_empty(scratch_pool);
+      for (hi = apr_hash_first(scratch_pool, children);
+           hi;
+           hi = apr_hash_next(hi))
         {
           svn_stringbuf_appendbytes(children_list,
                                     apr_hash_this_key(hi),
@@ -215,24 +223,28 @@ write_digest_file(apr_hash_t *children,
           svn_stringbuf_appendbyte(children_list, '\n');
         }
       hash_store(hash, CHILDREN_KEY, sizeof(CHILDREN_KEY)-1,
-                 children_list->data, children_list->len, pool);
+                 children_list->data, children_list->len, scratch_pool);
     }
 
   SVN_ERR(svn_stream_open_unique(&stream, &tmp_path,
-                                 svn_dirent_dirname(digest_path, pool),
-                                 svn_io_file_del_none, pool, pool));
-  if ((err = svn_hash_write2(hash, stream, SVN_HASH_TERMINATOR, pool)))
+                                 svn_dirent_dirname(digest_path,
+                                                    scratch_pool),
+                                 svn_io_file_del_none, scratch_pool,
+                                 scratch_pool));
+  if ((err = svn_hash_write2(hash, stream, SVN_HASH_TERMINATOR,
+                             scratch_pool)))
     {
       svn_error_clear(svn_stream_close(stream));
       return svn_error_createf(err->apr_err,
                                err,
                                _("Cannot write lock/entries hashfile '%s'"),
-                               svn_dirent_local_style(tmp_path, pool));
+                               svn_dirent_local_style(tmp_path,
+                                                      scratch_pool));
     }
 
   SVN_ERR(svn_stream_close(stream));
-  SVN_ERR(svn_io_file_rename(tmp_path, digest_path, pool));
-  SVN_ERR(svn_io_copy_perms(perms_reference, digest_path, pool));
+  SVN_ERR(svn_io_file_rename(tmp_path, digest_path, scratch_pool));
+  SVN_ERR(svn_io_copy_perms(perms_reference, digest_path, scratch_pool));
   return SVN_NO_ERROR;
 }
 
@@ -284,7 +296,7 @@ read_digest_file(apr_hash_t **children_p
 
   /* If our caller cares, see if we have a lock path in our hash. If
      so, we'll assume we have a lock here. */
-  val = hash_fetch(hash, PATH_KEY, pool);
+  val = hash_fetch(hash, PATH_KEY);
   if (val && lock_p)
     {
       const char *path = val;
@@ -293,30 +305,30 @@ read_digest_file(apr_hash_t **children_p
       lock = svn_lock_create(pool);
       lock->path = path;
 
-      if (! ((lock->token = hash_fetch(hash, TOKEN_KEY, pool))))
+      if (! ((lock->token = hash_fetch(hash, TOKEN_KEY))))
         return svn_error_trace(err_corrupt_lockfile(fs_path, path));
 
-      if (! ((lock->owner = hash_fetch(hash, OWNER_KEY, pool))))
+      if (! ((lock->owner = hash_fetch(hash, OWNER_KEY))))
         return svn_error_trace(err_corrupt_lockfile(fs_path, path));
 
-      if (! ((val = hash_fetch(hash, IS_DAV_COMMENT_KEY, pool))))
+      if (! ((val = hash_fetch(hash, IS_DAV_COMMENT_KEY))))
         return svn_error_trace(err_corrupt_lockfile(fs_path, path));
       lock->is_dav_comment = (val[0] == '1');
 
-      if (! ((val = hash_fetch(hash, CREATION_DATE_KEY, pool))))
+      if (! ((val = hash_fetch(hash, CREATION_DATE_KEY))))
         return svn_error_trace(err_corrupt_lockfile(fs_path, path));
       SVN_ERR(svn_time_from_cstring(&(lock->creation_date), val, pool));
 
-      if ((val = hash_fetch(hash, EXPIRATION_DATE_KEY, pool)))
+      if ((val = hash_fetch(hash, EXPIRATION_DATE_KEY)))
         SVN_ERR(svn_time_from_cstring(&(lock->expiration_date), val, pool));
 
-      lock->comment = hash_fetch(hash, COMMENT_KEY, pool);
+      lock->comment = hash_fetch(hash, COMMENT_KEY);
 
       *lock_p = lock;
     }
 
   /* If our caller cares, see if we have any children for this path. */
-  val = hash_fetch(hash, CHILDREN_KEY, pool);
+  val = hash_fetch(hash, CHILDREN_KEY);
   if (val && children_p)
     {
       apr_array_header_t *kiddos = svn_cstring_split(val, "\n", FALSE, pool);
@@ -345,19 +357,21 @@ static svn_error_t *
 set_lock(const char *fs_path,
          svn_lock_t *lock,
          const char *perms_reference,
-         apr_pool_t *pool)
+         apr_pool_t *scratch_pool)
 {
   const char *digest_path;
   apr_hash_t *children;
 
-  SVN_ERR(digest_path_from_path(&digest_path, fs_path, lock->path, pool));
+  SVN_ERR(digest_path_from_path(&digest_path, fs_path, lock->path,
+                                scratch_pool));
 
   /* We could get away without reading the file as children should
      always come back empty. */
-  SVN_ERR(read_digest_file(&children, NULL, fs_path, digest_path, pool));
+  SVN_ERR(read_digest_file(&children, NULL, fs_path, digest_path,
+                           scratch_pool));
 
   SVN_ERR(write_digest_file(children, lock, fs_path, digest_path, 
-                            perms_reference, pool));
+                            perms_reference, scratch_pool));
 
   return SVN_NO_ERROR;
 }
@@ -365,13 +379,13 @@ set_lock(const char *fs_path,
 static svn_error_t *
 delete_lock(const char *fs_path,
             const char *path,
-            apr_pool_t *pool)
+            apr_pool_t *scratch_pool)
 {
   const char *digest_path;
 
-  SVN_ERR(digest_path_from_path(&digest_path, fs_path, path, pool));
+  SVN_ERR(digest_path_from_path(&digest_path, fs_path, path, scratch_pool));
 
-  SVN_ERR(svn_io_remove_file2(digest_path, TRUE, pool));
+  SVN_ERR(svn_io_remove_file2(digest_path, TRUE, scratch_pool));
 
   return SVN_NO_ERROR;
 }
@@ -381,7 +395,7 @@ add_to_digest(const char *fs_path,
               apr_array_header_t *paths,
               const char *index_path,
               const char *perms_reference,
-              apr_pool_t *pool)
+              apr_pool_t *scratch_pool)
 {
   const char *index_digest_path;
   apr_hash_t *children;
@@ -389,9 +403,10 @@ add_to_digest(const char *fs_path,
   int i;
   unsigned int original_count;
 
-  SVN_ERR(digest_path_from_path(&index_digest_path, fs_path, index_path, pool));
-
-  SVN_ERR(read_digest_file(&children, &lock, fs_path, index_digest_path, pool));
+  SVN_ERR(digest_path_from_path(&index_digest_path, fs_path, index_path,
+                                scratch_pool));
+  SVN_ERR(read_digest_file(&children, &lock, fs_path, index_digest_path,
+                           scratch_pool));
 
   original_count = apr_hash_count(children);
 
@@ -400,14 +415,15 @@ add_to_digest(const char *fs_path,
       const char *path = APR_ARRAY_IDX(paths, i, const char *);
       const char *digest_path, *digest_file;
 
-      SVN_ERR(digest_path_from_path(&digest_path, fs_path, path, pool));
+      SVN_ERR(digest_path_from_path(&digest_path, fs_path, path,
+                                    scratch_pool));
       digest_file = svn_dirent_basename(digest_path, NULL);
       svn_hash_sets(children, digest_file, (void *)1);
     }
 
   if (apr_hash_count(children) != original_count)
     SVN_ERR(write_digest_file(children, lock, fs_path, index_digest_path, 
-                              perms_reference, pool));
+                              perms_reference, scratch_pool));
 
   return SVN_NO_ERROR;
 }
@@ -417,32 +433,34 @@ delete_from_digest(const char *fs_path,
                    apr_array_header_t *paths,
                    const char *index_path,
                    const char *perms_reference,
-                   apr_pool_t *pool)
+                   apr_pool_t *scratch_pool)
 {
   const char *index_digest_path;
   apr_hash_t *children;
   svn_lock_t *lock;
   int i;
 
-  SVN_ERR(digest_path_from_path(&index_digest_path, fs_path, index_path, pool));
-
-  SVN_ERR(read_digest_file(&children, &lock, fs_path, index_digest_path, pool));
+  SVN_ERR(digest_path_from_path(&index_digest_path, fs_path, index_path,
+                                scratch_pool));
+  SVN_ERR(read_digest_file(&children, &lock, fs_path, index_digest_path,
+                           scratch_pool));
 
   for (i = 0; i < paths->nelts; ++i)
     {
       const char *path = APR_ARRAY_IDX(paths, i, const char *);
       const char *digest_path, *digest_file;
 
-      SVN_ERR(digest_path_from_path(&digest_path, fs_path, path, pool));
+      SVN_ERR(digest_path_from_path(&digest_path, fs_path, path,
+                                    scratch_pool));
       digest_file = svn_dirent_basename(digest_path, NULL);
       svn_hash_sets(children, digest_file, NULL);
     }
 
   if (apr_hash_count(children) || lock)
     SVN_ERR(write_digest_file(children, lock, fs_path, index_digest_path, 
-                              perms_reference, pool));
+                              perms_reference, scratch_pool));
   else
-    SVN_ERR(svn_io_remove_file2(index_digest_path, TRUE, pool));
+    SVN_ERR(svn_io_remove_file2(index_digest_path, TRUE, scratch_pool));
 
   return SVN_NO_ERROR;
 }
@@ -529,11 +547,12 @@ get_lock_helper(svn_fs_t *fs,
 
 
 /* Baton for locks_walker(). */
-struct walk_locks_baton {
+typedef struct walk_locks_baton_t
+{
   svn_fs_get_locks_callback_t get_locks_func;
   void *get_locks_baton;
   svn_fs_t *fs;
-};
+} walk_locks_baton_t;
 
 /* Implements walk_digests_callback_t. */
 static svn_error_t *
@@ -545,7 +564,7 @@ locks_walker(void *baton,
              svn_boolean_t have_write_lock,
              apr_pool_t *pool)
 {
-  struct walk_locks_baton *wlb = baton;
+  walk_locks_baton_t *wlb = baton;
 
   if (lock)
     {
@@ -632,7 +651,7 @@ walk_locks(svn_fs_t *fs,
            svn_boolean_t have_write_lock,
            apr_pool_t *pool)
 {
-  struct walk_locks_baton wlb;
+  walk_locks_baton_t wlb;
 
   wlb.get_locks_func = get_locks_func;
   wlb.get_locks_baton = get_locks_baton;
@@ -652,8 +671,7 @@ walk_locks(svn_fs_t *fs,
  */
 static svn_error_t *
 verify_lock(svn_fs_t *fs,
-            svn_lock_t *lock,
-            apr_pool_t *pool)
+            svn_lock_t *lock)
 {
   if ((! fs->access_ctx) || (! fs->access_ctx->username))
     return svn_error_createf
@@ -684,7 +702,7 @@ get_locks_callback(void *baton,
                    svn_lock_t *lock,
                    apr_pool_t *pool)
 {
-  return verify_lock(baton, lock, pool);
+  return verify_lock(baton, lock);
 }
 
 
@@ -694,30 +712,32 @@ svn_fs_x__allow_locked_operation(const c
                                  svn_fs_t *fs,
                                  svn_boolean_t recurse,
                                  svn_boolean_t have_write_lock,
-                                 apr_pool_t *pool)
+                                 apr_pool_t *scratch_pool)
 {
-  path = svn_fs__canonicalize_abspath(path, pool);
+  path = svn_fs__canonicalize_abspath(path, scratch_pool);
   if (recurse)
     {
       /* Discover all locks at or below the path. */
       const char *digest_path;
-      SVN_ERR(digest_path_from_path(&digest_path, fs->path, path, pool));
+      SVN_ERR(digest_path_from_path(&digest_path, fs->path, path,
+                                    scratch_pool));
       SVN_ERR(walk_locks(fs, digest_path, get_locks_callback,
-                         fs, have_write_lock, pool));
+                         fs, have_write_lock, scratch_pool));
     }
   else
     {
       /* Discover and verify any lock attached to the path. */
       svn_lock_t *lock;
-      SVN_ERR(get_lock_helper(fs, &lock, path, have_write_lock, pool));
+      SVN_ERR(get_lock_helper(fs, &lock, path, have_write_lock,
+                              scratch_pool));
       if (lock)
-        SVN_ERR(verify_lock(fs, lock, pool));
+        SVN_ERR(verify_lock(fs, lock));
     }
   return SVN_NO_ERROR;
 }
 
 /* The effective arguments for lock_body() below. */
-struct lock_baton {
+typedef struct lock_baton_t {
   svn_fs_t *fs;
   apr_array_header_t *targets;
   apr_array_header_t *infos;
@@ -726,13 +746,13 @@ struct lock_baton {
   apr_time_t expiration_date;
   svn_boolean_t steal_lock;
   apr_pool_t *result_pool;
-};
+} lock_baton_t;
 
 static svn_error_t *
 check_lock(svn_error_t **fs_err,
            const char *path,
            const svn_fs_lock_target_t *target,
-           struct lock_baton *lb,
+           lock_baton_t *lb,
            svn_fs_root_t *root,
            apr_pool_t *pool)
 {
@@ -826,16 +846,16 @@ check_lock(svn_error_t **fs_err,
   return SVN_NO_ERROR;
 }
 
-struct lock_info_t {
+typedef struct lock_info_t {
   const char *path;
   const char *component;
   svn_lock_t *lock;
   svn_error_t *fs_err;
-};
+} lock_info_t;
 
 /* The body of svn_fs_x__lock(), which see.
 
-   BATON is a 'struct lock_baton *' holding the effective arguments.
+   BATON is a 'lock_baton_t *' holding the effective arguments.
    BATON->targets is an array of 'svn_sort__item_t' targets, sorted by
    path, mapping canonical path to 'svn_fs_lock_target_t'.  Set
    BATON->infos to an array of 'lock_info_t' holding the results.  For
@@ -847,7 +867,7 @@ struct lock_info_t {
 static svn_error_t *
 lock_body(void *baton, apr_pool_t *pool)
 {
-  struct lock_baton *lb = baton;
+  lock_baton_t *lb = baton;
   svn_fs_root_t *root;
   svn_revnum_t youngest;
   const char *rev_0_path;
@@ -855,7 +875,7 @@ lock_body(void *baton, apr_pool_t *pool)
   apr_pool_t *iterpool = svn_pool_create(pool);
 
   lb->infos = apr_array_make(lb->result_pool, lb->targets->nelts,
-                             sizeof(struct lock_info_t));
+                             sizeof(lock_info_t));
 
   /* Until we implement directory locks someday, we only allow locks
      on files or non-existent paths. */
@@ -869,7 +889,7 @@ lock_body(void *baton, apr_pool_t *pool)
       const svn_sort__item_t *item = &APR_ARRAY_IDX(lb->targets, i,
                                                     svn_sort__item_t);
       const svn_fs_lock_target_t *target = item->value;
-      struct lock_info_t info;
+      lock_info_t info;
 
       svn_pool_clear(iterpool);
 
@@ -877,7 +897,7 @@ lock_body(void *baton, apr_pool_t *pool)
       SVN_ERR(check_lock(&info.fs_err, info.path, target, lb, root, iterpool));
       info.lock = NULL;
       info.component = NULL;
-      APR_ARRAY_PUSH(lb->infos, struct lock_info_t) = info;
+      APR_ARRAY_PUSH(lb->infos, lock_info_t) = info;
       if (!info.fs_err)
         ++outstanding;
     }
@@ -915,8 +935,7 @@ lock_body(void *baton, apr_pool_t *pool)
 
       for (i = 0; i < lb->infos->nelts; ++i)
         {
-          struct lock_info_t *info = &APR_ARRAY_IDX(lb->infos, i,
-                                                    struct lock_info_t);
+          lock_info_t *info = &APR_ARRAY_IDX(lb->infos, i, lock_info_t);
           const svn_sort__item_t *item = &APR_ARRAY_IDX(lb->targets, i,
                                                         svn_sort__item_t);
           const svn_fs_lock_target_t *target = item->value;
@@ -994,7 +1013,7 @@ lock_body(void *baton, apr_pool_t *pool)
 }
 
 /* The effective arguments for unlock_body() below. */
-struct unlock_baton {
+typedef struct unlock_baton_t {
   svn_fs_t *fs;
   apr_array_header_t *targets;
   apr_array_header_t *infos;
@@ -1002,13 +1021,13 @@ struct unlock_baton {
   svn_boolean_t skip_check;
   svn_boolean_t break_lock;
   apr_pool_t *result_pool;
-};
+} unlock_baton_t;
 
 static svn_error_t *
 check_unlock(svn_error_t **fs_err,
              const char *path,
              const char *token,
-             struct unlock_baton *ub,
+             unlock_baton_t *ub,
              svn_fs_root_t *root,
              apr_pool_t *pool)
 {
@@ -1028,17 +1047,17 @@ check_unlock(svn_error_t **fs_err,
   return SVN_NO_ERROR;
 }
 
-struct unlock_info_t {
+typedef struct unlock_info_t {
   const char *path;
   const char *component;
   svn_error_t *fs_err;
   svn_boolean_t done;
   int components;
-};
+} unlock_info_t;
 
 /* The body of svn_fs_x__unlock(), which see.
 
-   BATON is a 'struct unlock_baton *' holding the effective arguments.
+   BATON is a 'unlock_baton_t *' holding the effective arguments.
    BATON->targets is an array of 'svn_sort__item_t' targets, sorted by
    path, mapping canonical path to (const char *) token.  Set
    BATON->infos to an array of 'unlock_info_t' results.  For the other
@@ -1050,7 +1069,7 @@ struct unlock_info_t {
 static svn_error_t *
 unlock_body(void *baton, apr_pool_t *pool)
 {
-  struct unlock_baton *ub = baton;
+  unlock_baton_t *ub = baton;
   svn_fs_root_t *root;
   svn_revnum_t youngest;
   const char *rev_0_path;
@@ -1058,7 +1077,7 @@ unlock_body(void *baton, apr_pool_t *poo
   apr_pool_t *iterpool = svn_pool_create(pool);
 
   ub->infos = apr_array_make(ub->result_pool, ub->targets->nelts,
-                             sizeof(struct unlock_info_t));
+                             sizeof( unlock_info_t));
 
   SVN_ERR(ub->fs->vtable->youngest_rev(&youngest, ub->fs, pool));
   SVN_ERR(ub->fs->vtable->revision_root(&root, ub->fs, youngest, pool));
@@ -1068,7 +1087,7 @@ unlock_body(void *baton, apr_pool_t *poo
       const svn_sort__item_t *item = &APR_ARRAY_IDX(ub->targets, i,
                                                     svn_sort__item_t);
       const char *token = item->value;
-      struct unlock_info_t info = { 0 };
+      unlock_info_t info = { 0 };
 
       svn_pool_clear(iterpool);
 
@@ -1093,7 +1112,7 @@ unlock_body(void *baton, apr_pool_t *poo
 
           ++outstanding;
         }
-      APR_ARRAY_PUSH(ub->infos, struct unlock_info_t) = info;
+      APR_ARRAY_PUSH(ub->infos, unlock_info_t) = info;
     }
 
   rev_0_path = svn_fs_x__path_rev_absolute(ub->fs, 0, pool);
@@ -1109,8 +1128,7 @@ unlock_body(void *baton, apr_pool_t *poo
 
       for (j = 0; j < ub->infos->nelts; ++j)
         {
-          struct unlock_info_t *info = &APR_ARRAY_IDX(ub->infos, j,
-                                                      struct unlock_info_t);
+          unlock_info_t *info = &APR_ARRAY_IDX(ub->infos, j, unlock_info_t);
 
           if (!info->fs_err && info->path)
             {
@@ -1168,11 +1186,11 @@ unlock_body(void *baton, apr_pool_t *poo
 static svn_error_t *
 unlock_single(svn_fs_t *fs,
               svn_lock_t *lock,
-              apr_pool_t *pool)
+              apr_pool_t *scratch_pool)
 {
-  struct unlock_baton ub;
+  unlock_baton_t ub;
   svn_sort__item_t item;
-  apr_array_header_t *targets = apr_array_make(pool, 1,
+  apr_array_header_t *targets = apr_array_make(scratch_pool, 1,
                                                sizeof(svn_sort__item_t));
   item.key = lock->path;
   item.klen = strlen(item.key);
@@ -1182,10 +1200,10 @@ unlock_single(svn_fs_t *fs,
   ub.fs = fs;
   ub.targets = targets;
   ub.skip_check = TRUE;
-  ub.result_pool = pool;
+  ub.result_pool = scratch_pool;
 
   /* No ub.infos[].fs_err error because skip_check is TRUE. */
-  SVN_ERR(unlock_body(&ub, pool));
+  SVN_ERR(unlock_body(&ub, scratch_pool));
 
   return SVN_NO_ERROR;
 }
@@ -1205,7 +1223,7 @@ svn_fs_x__lock(svn_fs_t *fs,
                apr_pool_t *result_pool,
                apr_pool_t *scratch_pool)
 {
-  struct lock_baton lb;
+  lock_baton_t lb;
   apr_array_header_t *sorted_targets;
   apr_hash_t *canonical_targets = apr_hash_make(scratch_pool);
   apr_hash_index_t *hi;
@@ -1299,7 +1317,7 @@ svn_fs_x__unlock(svn_fs_t *fs,
                  apr_pool_t *result_pool,
                  apr_pool_t *scratch_pool)
 {
-  struct unlock_baton ub;
+  unlock_baton_t ub;
   apr_array_header_t *sorted_targets;
   apr_hash_t *canonical_targets = apr_hash_make(scratch_pool);
   apr_hash_index_t *hi;
@@ -1338,8 +1356,7 @@ svn_fs_x__unlock(svn_fs_t *fs,
   err = svn_fs_x__with_write_lock(fs, unlock_body, &ub, scratch_pool);
   for (i = 0; i < ub.infos->nelts; ++i)
     {
-      struct unlock_info_t *info = &APR_ARRAY_IDX(ub.infos, i,
-                                                  struct unlock_info_t);
+      unlock_info_t *info = &APR_ARRAY_IDX(ub.infos, i, unlock_info_t);
       if (!cb_err && lock_callback)
         {
           if (!info->done && !info->fs_err)
@@ -1434,13 +1451,13 @@ svn_fs_x__get_locks(svn_fs_t *fs,
                     svn_depth_t depth,
                     svn_fs_get_locks_callback_t get_locks_func,
                     void *get_locks_baton,
-                    apr_pool_t *pool)
+                    apr_pool_t *scratch_pool)
 {
   const char *digest_path;
   get_locks_filter_baton_t glfb;
 
   SVN_ERR(svn_fs__check_fs(fs, TRUE));
-  path = svn_fs__canonicalize_abspath(path, pool);
+  path = svn_fs__canonicalize_abspath(path, scratch_pool);
 
   glfb.path = path;
   glfb.requested_depth = depth;
@@ -1448,8 +1465,8 @@ svn_fs_x__get_locks(svn_fs_t *fs,
   glfb.get_locks_baton = get_locks_baton;
 
   /* Get the top digest path in our tree of interest, and then walk it. */
-  SVN_ERR(digest_path_from_path(&digest_path, fs->path, path, pool));
+  SVN_ERR(digest_path_from_path(&digest_path, fs->path, path, scratch_pool));
   SVN_ERR(walk_locks(fs, digest_path, get_locks_filter_func, &glfb,
-                     FALSE, pool));
+                     FALSE, scratch_pool));
   return SVN_NO_ERROR;
 }



Mime
View raw message