subversion-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bre...@apache.org
Subject svn commit: r1655189 [2/9] - in /subversion/branches/svn-auth-x509: ./ build/ build/generator/ subversion/bindings/javahl/native/ subversion/include/ subversion/include/private/ subversion/libsvn_client/ subversion/libsvn_fs_base/ subversion/libsvn_fs_...
Date Tue, 27 Jan 2015 23:27:46 GMT
Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/dag.c
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/dag.c?rev=1655189&r1=1655188&r2=1655189&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/dag.c (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/dag.c Tue Jan 27 23:27:44 2015
@@ -54,10 +54,11 @@ struct dag_node_t
   svn_fs_x__id_t id;
 
   /* In the special case that this node is the root of a transaction
-     that has not yet been modified, the node revision ID for this dag
-     node's predecessor; otherwise NULL. (Used in
-     svn_fs_node_created_rev.) */
-  svn_fs_x__id_t fresh_root_predecessor_id;
+     that has not yet been modified, the revision of this node is the
+     respective txn's base rev.  Otherwise, this is SVN_INVALID_REVNUM
+     for txn nodes and the respective crev for committed nodes.
+     (Used in svn_fs_node_created_rev.) */
+  svn_revnum_t revision;
 
   /* The node's type (file, dir, etc.) */
   svn_node_kind_t kind;
@@ -76,6 +77,11 @@ struct dag_node_t
 
   /* the path at which this node was created. */
   const char *created_path;
+
+  /* Directory entry lookup hint to speed up consecutive calls to
+     svn_fs_x__rep_contents_dir_entry(). Only used for directory nodes.
+     Any value is legal but should default to APR_SIZE_MAX. */
+  apr_size_t hint;
 };
 
 
@@ -248,6 +254,7 @@ svn_fs_x__dag_get_node(dag_node_t **node
   new_node = apr_pcalloc(result_pool, sizeof(*new_node));
   new_node->fs = fs;
   new_node->id = *id;
+  new_node->hint = APR_SIZE_MAX;
 
   /* Grab the contents so we can inspect the node's kind and created path. */
   new_node->node_pool = result_pool;
@@ -257,10 +264,12 @@ svn_fs_x__dag_get_node(dag_node_t **node
   new_node->kind = noderev->kind;
   new_node->created_path = apr_pstrdup(result_pool, noderev->created_path);
 
-  if (noderev->is_fresh_txn_root)
-    new_node->fresh_root_predecessor_id = noderev->predecessor_id;
-  else
-    svn_fs_x__id_reset(&new_node->fresh_root_predecessor_id);
+  /* Support our quirky svn_fs_node_created_rev API.
+     Untouched txn roots report the base rev as theirs. */
+  new_node->revision
+    = (  noderev->is_fresh_txn_root
+       ? svn_fs_x__get_revnum(noderev->predecessor_id.change_set)
+       : svn_fs_x__get_revnum(id->change_set));
 
   /* Return a fresh new node */
   *node = new_node;
@@ -271,16 +280,7 @@ svn_fs_x__dag_get_node(dag_node_t **node
 svn_revnum_t
 svn_fs_x__dag_get_revision(const dag_node_t *node)
 {
-  /* In the special case that this is an unmodified transaction root,
-     we need to actually get the revision of the noderev's predecessor
-     (the revision root); see Issue #2608. */
-  const svn_fs_x__id_t *correct_id
-    = svn_fs_x__id_used(&node->fresh_root_predecessor_id)
-        ? &node->fresh_root_predecessor_id
-        : &node->id;
-
-  /* Look up the committed revision from the Node-ID. */
-  return svn_fs_x__get_revnum(correct_id->change_set);
+  return node->revision;
 }
 
 
@@ -375,7 +375,8 @@ dir_entry_id_from_node(svn_fs_x__id_t *i
 
   /* Get a dirent hash for this directory. */
   SVN_ERR(svn_fs_x__rep_contents_dir_entry(&dirent, parent->fs, noderev,
-                                           name, scratch_pool, scratch_pool));
+                                           name, &parent->hint,
+                                           scratch_pool, scratch_pool));
   if (dirent)
     *id_p = dirent->id;
   else
@@ -408,16 +409,16 @@ set_entry(dag_node_t *parent,
 
   /* Set the new entry. */
   return svn_fs_x__set_entry(parent->fs, txn_id, parent_noderev, name, id,
-                             kind, scratch_pool);
+                             kind, parent->node_pool, scratch_pool);
 }
 
 
 /* Make a new entry named NAME in PARENT.  If IS_DIR is true, then the
    node revision the new entry points to will be a directory, else it
-   will be a file.  The new node will be allocated in POOL.  PARENT
+   will be a file.  The new node will be allocated in RESULT_POOL.  PARENT
    must be mutable, and must not have an entry named NAME.
 
-   Use POOL for all allocations, except caching the node_revision in PARENT.
+   Use SCRATCH_POOL for all temporary allocations.
  */
 static svn_error_t *
 make_entry(dag_node_t **child_p,
@@ -426,7 +427,8 @@ make_entry(dag_node_t **child_p,
            const char *name,
            svn_boolean_t is_dir,
            svn_fs_x__txn_id_t txn_id,
-           apr_pool_t *pool)
+           apr_pool_t *result_pool,
+           apr_pool_t *scratch_pool)
 {
   svn_fs_x__noderev_t new_noderev, *parent_noderev;
 
@@ -451,10 +453,10 @@ make_entry(dag_node_t **child_p,
   /* Create the new node's NODE-REVISION */
   memset(&new_noderev, 0, sizeof(new_noderev));
   new_noderev.kind = is_dir ? svn_node_dir : svn_node_file;
-  new_noderev.created_path = svn_fspath__join(parent_path, name, pool);
+  new_noderev.created_path = svn_fspath__join(parent_path, name, result_pool);
 
   SVN_ERR(get_node_revision(&parent_noderev, parent));
-  new_noderev.copyroot_path = apr_pstrdup(pool,
+  new_noderev.copyroot_path = apr_pstrdup(result_pool,
                                           parent_noderev->copyroot_path);
   new_noderev.copyroot_rev = parent_noderev->copyroot_rev;
   new_noderev.copyfrom_rev = SVN_INVALID_REVNUM;
@@ -463,24 +465,25 @@ make_entry(dag_node_t **child_p,
 
   SVN_ERR(svn_fs_x__create_node
           (svn_fs_x__dag_get_fs(parent), &new_noderev,
-           &parent_noderev->copy_id, txn_id, pool));
+           &parent_noderev->copy_id, txn_id, scratch_pool));
 
   /* Create a new dag_node_t for our new node */
   SVN_ERR(svn_fs_x__dag_get_node(child_p, svn_fs_x__dag_get_fs(parent),
-                                 &new_noderev.noderev_id, pool));
+                                 &new_noderev.noderev_id, result_pool));
 
   /* We can safely call set_entry because we already know that
      PARENT is mutable, and we just created CHILD, so we know it has
      no ancestors (therefore, PARENT cannot be an ancestor of CHILD) */
   return set_entry(parent, name, &new_noderev.noderev_id,
-                   new_noderev.kind, txn_id, pool);
+                   new_noderev.kind, txn_id, scratch_pool);
 }
 
 
 svn_error_t *
 svn_fs_x__dag_dir_entries(apr_array_header_t **entries,
                           dag_node_t *node,
-                          apr_pool_t *pool)
+                          apr_pool_t *result_pool,
+                          apr_pool_t *scratch_pool)
 {
   svn_fs_x__noderev_t *noderev;
 
@@ -490,7 +493,8 @@ svn_fs_x__dag_dir_entries(apr_array_head
     return svn_error_create(SVN_ERR_FS_NOT_DIRECTORY, NULL,
                             _("Can't get entries of non-directory"));
 
-  return svn_fs_x__rep_contents_dir(entries, node->fs, noderev, pool, pool);
+  return svn_fs_x__rep_contents_dir(entries, node->fs, noderev, result_pool,
+                                    scratch_pool);
 }
 
 
@@ -524,14 +528,16 @@ svn_fs_x__dag_set_entry(dag_node_t *node
 svn_error_t *
 svn_fs_x__dag_get_proplist(apr_hash_t **proplist_p,
                            dag_node_t *node,
-                           apr_pool_t *pool)
+                           apr_pool_t *result_pool,
+                           apr_pool_t *scratch_pool)
 {
   svn_fs_x__noderev_t *noderev;
   apr_hash_t *proplist = NULL;
 
   SVN_ERR(get_node_revision(&noderev, node));
 
-  SVN_ERR(svn_fs_x__get_proplist(&proplist, node->fs, noderev, pool));
+  SVN_ERR(svn_fs_x__get_proplist(&proplist, node->fs, noderev, result_pool,
+                                 scratch_pool));
 
   *proplist_p = proplist;
 
@@ -648,22 +654,23 @@ svn_error_t *
 svn_fs_x__dag_revision_root(dag_node_t **node_p,
                             svn_fs_t *fs,
                             svn_revnum_t rev,
-                            apr_pool_t *pool)
+                            apr_pool_t *result_pool)
 {
   dag_node_t *new_node;
 
   /* Construct the node. */
-  new_node = apr_pcalloc(pool, sizeof(*new_node));
+  new_node = apr_pcalloc(result_pool, sizeof(*new_node));
   new_node->fs = fs;
-  SVN_ERR(svn_fs_x__rev_get_root(&new_node->id, fs, rev, pool));
-  svn_fs_x__id_reset(&new_node->fresh_root_predecessor_id);
+  new_node->revision = rev;
+  svn_fs_x__init_rev_root(&new_node->id, rev);
 
   /* Grab the contents so we can inspect the node's kind and created path. */
-  new_node->node_pool = pool;
+  new_node->node_pool = result_pool;
 
   /* Initialize the KIND and CREATED_PATH attributes */
   new_node->kind = svn_node_dir;
   new_node->created_path = "/";
+  new_node->hint = APR_SIZE_MAX;
 
   /* Return a fresh new node */
   *node_p = new_node;
@@ -688,15 +695,16 @@ svn_error_t *
 svn_fs_x__dag_txn_base_root(dag_node_t **node_p,
                             svn_fs_t *fs,
                             svn_fs_x__txn_id_t txn_id,
-                            apr_pool_t *pool)
+                            apr_pool_t *result_pool,
+                            apr_pool_t *scratch_pool)
 {
   svn_fs_x__id_t base_root_id;
   svn_revnum_t base_rev;
 
-  SVN_ERR(svn_fs_x__get_base_rev(&base_rev, fs, txn_id, pool));
+  SVN_ERR(svn_fs_x__get_base_rev(&base_rev, fs, txn_id, scratch_pool));
 
   svn_fs_x__init_rev_root(&base_root_id, base_rev);
-  return svn_fs_x__dag_get_node(node_p, fs, &base_root_id, pool);
+  return svn_fs_x__dag_get_node(node_p, fs, &base_root_id, result_pool);
 }
 
 
@@ -708,12 +716,12 @@ svn_fs_x__dag_clone_child(dag_node_t **c
                           const svn_fs_x__id_t *copy_id,
                           svn_fs_x__txn_id_t txn_id,
                           svn_boolean_t is_parent_copyroot,
-                          apr_pool_t *pool)
+                          apr_pool_t *result_pool,
+                          apr_pool_t *scratch_pool)
 {
   dag_node_t *cur_entry; /* parent's current entry named NAME */
   const svn_fs_x__id_t *new_node_id; /* node id we'll put into NEW_NODE */
   svn_fs_t *fs = svn_fs_x__dag_get_fs(parent);
-  apr_pool_t *subpool = svn_pool_create(pool);
 
   /* First check that the parent is mutable. */
   if (! svn_fs_x__dag_check_mutable(parent))
@@ -728,7 +736,8 @@ svn_fs_x__dag_clone_child(dag_node_t **c
        "Attempted to make a child clone with an illegal name '%s'", name);
 
   /* Find the node named NAME in PARENT's entries list if it exists. */
-  SVN_ERR(svn_fs_x__dag_open(&cur_entry, parent, name, pool, subpool));
+  SVN_ERR(svn_fs_x__dag_open(&cur_entry, parent, name, scratch_pool,
+                             scratch_pool));
   if (! cur_entry)
     return svn_error_createf
       (SVN_ERR_FS_NOT_FOUND, NULL,
@@ -752,7 +761,7 @@ svn_fs_x__dag_clone_child(dag_node_t **c
         {
           SVN_ERR(get_node_revision(&parent_noderev, parent));
           noderev->copyroot_rev = parent_noderev->copyroot_rev;
-          noderev->copyroot_path = apr_pstrdup(pool,
+          noderev->copyroot_path = apr_pstrdup(scratch_pool,
                                                parent_noderev->copyroot_path);
         }
 
@@ -761,23 +770,24 @@ svn_fs_x__dag_clone_child(dag_node_t **c
 
       noderev->predecessor_id = noderev->noderev_id;
       noderev->predecessor_count++;
-      noderev->created_path = svn_fspath__join(parent_path, name, pool);
+      noderev->created_path = svn_fspath__join(parent_path, name,
+                                               scratch_pool);
 
       if (copy_id == NULL)
         copy_id = &noderev->copy_id;
 
-      SVN_ERR(svn_fs_x__create_successor(fs, noderev, copy_id, txn_id, pool));
+      SVN_ERR(svn_fs_x__create_successor(fs, noderev, copy_id, txn_id,
+                                         scratch_pool));
       new_node_id = &noderev->noderev_id;
 
       /* Replace the ID in the parent's ENTRY list with the ID which
          refers to the mutable clone of this child. */
       SVN_ERR(set_entry(parent, name, new_node_id, noderev->kind, txn_id,
-                        pool));
+                        scratch_pool));
     }
 
   /* Initialize the youngster. */
-  svn_pool_destroy(subpool);
-  return svn_fs_x__dag_get_node(child_p, fs, new_node_id, pool);
+  return svn_fs_x__dag_get_node(child_p, fs, new_node_id, result_pool);
 }
 
 
@@ -796,6 +806,55 @@ svn_fs_x__dag_clone_root(dag_node_t **ro
 }
 
 
+/* Delete all mutable node revisions reachable from node ID, including
+   ID itself, from FS's `nodes' table.  Also delete any mutable
+   representations and strings associated with that node revision.
+   ID may refer to a file or directory, which may be mutable or immutable.
+
+   Use SCRATCH_POOL for temporary allocations.
+ */
+static svn_error_t *
+delete_if_mutable(svn_fs_t *fs,
+                  const svn_fs_x__id_t *id,
+                  apr_pool_t *scratch_pool)
+{
+  dag_node_t *node;
+
+  /* Get the node. */
+  SVN_ERR(svn_fs_x__dag_get_node(&node, fs, id, scratch_pool));
+
+  /* If immutable, do nothing and return immediately. */
+  if (! svn_fs_x__dag_check_mutable(node))
+    return SVN_NO_ERROR;
+
+  /* Else it's mutable.  Recurse on directories... */
+  if (node->kind == svn_node_dir)
+    {
+      apr_array_header_t *entries;
+      int i;
+      apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+
+      /* Loop over directory entries */
+      SVN_ERR(svn_fs_x__dag_dir_entries(&entries, node, scratch_pool,
+                                        iterpool));
+      for (i = 0; i < entries->nelts; ++i)
+        {
+          const svn_fs_x__id_t *noderev_id
+            = &APR_ARRAY_IDX(entries, i, svn_fs_x__dirent_t *)->id;
+
+          svn_pool_clear(iterpool);
+          SVN_ERR(delete_if_mutable(fs, noderev_id, iterpool));
+        }
+
+      svn_pool_destroy(iterpool);
+    }
+
+  /* ... then delete the node itself, after deleting any mutable
+     representations and strings it points to. */
+  return svn_fs_x__delete_node_revision(fs, id, scratch_pool);
+}
+
+
 svn_error_t *
 svn_fs_x__dag_delete(dag_node_t *parent,
                      const char *name,
@@ -832,7 +891,8 @@ svn_fs_x__dag_delete(dag_node_t *parent,
 
   /* Search this directory for a dirent with that NAME. */
   SVN_ERR(svn_fs_x__rep_contents_dir_entry(&dirent, fs, parent_noderev,
-                                           name, subpool, subpool));
+                                           name, &parent->hint,
+                                           subpool, subpool));
 
   /* If we never found ID in ENTRIES (perhaps because there are no
      ENTRIES, perhaps because ID just isn't in the existing ENTRIES
@@ -843,68 +903,28 @@ svn_fs_x__dag_delete(dag_node_t *parent,
        "Delete failed--directory has no entry '%s'", name);
 
   /* If mutable, remove it and any mutable children from db. */
-  SVN_ERR(svn_fs_x__dag_delete_if_mutable(parent->fs, &dirent->id,
-                                          scratch_pool));
+  SVN_ERR(delete_if_mutable(parent->fs, &dirent->id, scratch_pool));
   svn_pool_destroy(subpool);
 
   /* Remove this entry from its parent's entries list. */
   return svn_fs_x__set_entry(parent->fs, txn_id, parent_noderev, name,
-                             NULL, svn_node_unknown, scratch_pool);
+                             NULL, svn_node_unknown, parent->node_pool,
+                             scratch_pool);
 }
 
 
 svn_error_t *
-svn_fs_x__dag_delete_if_mutable(svn_fs_t *fs,
-                                const svn_fs_x__id_t *id,
-                                apr_pool_t *scratch_pool)
-{
-  dag_node_t *node;
-
-  /* Get the node. */
-  SVN_ERR(svn_fs_x__dag_get_node(&node, fs, id, scratch_pool));
-
-  /* If immutable, do nothing and return immediately. */
-  if (! svn_fs_x__dag_check_mutable(node))
-    return SVN_NO_ERROR;
-
-  /* Else it's mutable.  Recurse on directories... */
-  if (node->kind == svn_node_dir)
-    {
-      apr_array_header_t *entries;
-      int i;
-      apr_pool_t *iterpool = svn_pool_create(scratch_pool);
-
-      /* Loop over directory entries */
-      SVN_ERR(svn_fs_x__dag_dir_entries(&entries, node, scratch_pool));
-      if (entries)
-        for (i = 0; i < entries->nelts; ++i)
-          {
-            const svn_fs_x__id_t *noderev_id
-              = &APR_ARRAY_IDX(entries, i, svn_fs_x__dirent_t *)->id;
-
-            svn_pool_clear(iterpool);
-            SVN_ERR(svn_fs_x__dag_delete_if_mutable(fs, noderev_id,
-                                                    scratch_pool));
-          }
-
-      svn_pool_destroy(iterpool);
-    }
-
-  /* ... then delete the node itself, after deleting any mutable
-     representations and strings it points to. */
-  return svn_fs_x__delete_node_revision(fs, id, scratch_pool);
-}
-
-svn_error_t *
 svn_fs_x__dag_make_file(dag_node_t **child_p,
                         dag_node_t *parent,
                         const char *parent_path,
                         const char *name,
                         svn_fs_x__txn_id_t txn_id,
-                        apr_pool_t *pool)
+                        apr_pool_t *result_pool,
+                        apr_pool_t *scratch_pool)
 {
   /* Call our little helper function */
-  return make_entry(child_p, parent, parent_path, name, FALSE, txn_id, pool);
+  return make_entry(child_p, parent, parent_path, name, FALSE, txn_id,
+                    result_pool, scratch_pool);
 }
 
 
@@ -914,17 +934,19 @@ svn_fs_x__dag_make_dir(dag_node_t **chil
                        const char *parent_path,
                        const char *name,
                        svn_fs_x__txn_id_t txn_id,
-                       apr_pool_t *pool)
+                       apr_pool_t *result_pool,
+                       apr_pool_t *scratch_pool)
 {
   /* Call our little helper function */
-  return make_entry(child_p, parent, parent_path, name, TRUE, txn_id, pool);
+  return make_entry(child_p, parent, parent_path, name, TRUE, txn_id,
+                    result_pool, scratch_pool);
 }
 
 
 svn_error_t *
 svn_fs_x__dag_get_contents(svn_stream_t **contents_p,
                            dag_node_t *file,
-                           apr_pool_t *pool)
+                           apr_pool_t *result_pool)
 {
   svn_fs_x__noderev_t *noderev;
   svn_stream_t *contents;
@@ -940,7 +962,7 @@ svn_fs_x__dag_get_contents(svn_stream_t
 
   /* Get a stream to the contents. */
   SVN_ERR(svn_fs_x__get_contents(&contents, file->fs,
-                                 noderev->data_rep, TRUE, pool));
+                                 noderev->data_rep, TRUE, result_pool));
 
   *contents_p = contents;
 
@@ -952,7 +974,8 @@ svn_error_t *
 svn_fs_x__dag_get_file_delta_stream(svn_txdelta_stream_t **stream_p,
                                     dag_node_t *source,
                                     dag_node_t *target,
-                                    apr_pool_t *pool)
+                                    apr_pool_t *result_pool,
+                                    apr_pool_t *scratch_pool)
 {
   svn_fs_x__noderev_t *src_noderev;
   svn_fs_x__noderev_t *tgt_noderev;
@@ -973,7 +996,8 @@ svn_fs_x__dag_get_file_delta_stream(svn_
 
   /* Get the delta stream. */
   return svn_fs_x__get_file_delta_stream(stream_p, target->fs,
-                                         src_noderev, tgt_noderev, pool);
+                                         src_noderev, tgt_noderev,
+                                         result_pool, scratch_pool);
 }
 
 
@@ -982,7 +1006,7 @@ svn_fs_x__dag_try_process_file_contents(
                                         dag_node_t *node,
                                         svn_fs_process_contents_func_t processor,
                                         void* baton,
-                                        apr_pool_t *pool)
+                                        apr_pool_t *scratch_pool)
 {
   svn_fs_x__noderev_t *noderev;
 
@@ -991,7 +1015,7 @@ svn_fs_x__dag_try_process_file_contents(
 
   return svn_fs_x__try_process_file_contents(success, node->fs,
                                              noderev,
-                                             processor, baton, pool);
+                                             processor, baton, scratch_pool);
 }
 
 
@@ -1036,7 +1060,7 @@ svn_fs_x__dag_file_checksum(svn_checksum
 svn_error_t *
 svn_fs_x__dag_get_edit_stream(svn_stream_t **contents,
                               dag_node_t *file,
-                              apr_pool_t *pool)
+                              apr_pool_t *result_pool)
 {
   svn_fs_x__noderev_t *noderev;
   svn_stream_t *ws;
@@ -1056,7 +1080,7 @@ svn_fs_x__dag_get_edit_stream(svn_stream
   /* Get the node revision. */
   SVN_ERR(get_node_revision(&noderev, file));
 
-  SVN_ERR(svn_fs_x__set_contents(&ws, file->fs, noderev, pool));
+  SVN_ERR(svn_fs_x__set_contents(&ws, file->fs, noderev, result_pool));
 
   *contents = ws;
 
@@ -1227,7 +1251,7 @@ svn_fs_x__dag_copy(dag_node_t *to_node,
                    svn_revnum_t from_rev,
                    const char *from_path,
                    svn_fs_x__txn_id_t txn_id,
-                   apr_pool_t *pool)
+                   apr_pool_t *scratch_pool)
 {
   const svn_fs_x__id_t *id;
 
@@ -1239,10 +1263,10 @@ svn_fs_x__dag_copy(dag_node_t *to_node,
 
       /* Make a copy of the original node revision. */
       SVN_ERR(get_node_revision(&from_noderev, from_node));
-      to_noderev = copy_node_revision(from_noderev, pool);
+      to_noderev = copy_node_revision(from_noderev, scratch_pool);
 
       /* Reserve a copy ID for this new copy. */
-      SVN_ERR(svn_fs_x__reserve_copy_id(&copy_id, fs, txn_id, pool));
+      SVN_ERR(svn_fs_x__reserve_copy_id(&copy_id, fs, txn_id, scratch_pool));
 
       /* Create a successor with its predecessor pointing at the copy
          source. */
@@ -1250,15 +1274,15 @@ svn_fs_x__dag_copy(dag_node_t *to_node,
       to_noderev->predecessor_count++;
       to_noderev->created_path =
         svn_fspath__join(svn_fs_x__dag_get_created_path(to_node), entry,
-                         pool);
-      to_noderev->copyfrom_path = apr_pstrdup(pool, from_path);
+                         scratch_pool);
+      to_noderev->copyfrom_path = apr_pstrdup(scratch_pool, from_path);
       to_noderev->copyfrom_rev = from_rev;
 
       /* Set the copyroot equal to our own id. */
       to_noderev->copyroot_path = NULL;
 
       SVN_ERR(svn_fs_x__create_successor(fs, to_noderev,
-                                         &copy_id, txn_id, pool));
+                                         &copy_id, txn_id, scratch_pool));
       id = &to_noderev->noderev_id;
     }
   else  /* don't preserve history */
@@ -1268,7 +1292,7 @@ svn_fs_x__dag_copy(dag_node_t *to_node,
 
   /* Set the entry in to_node to the new id. */
   return svn_fs_x__dag_set_entry(to_node, entry, id, from_node->kind,
-                                 txn_id, pool);
+                                 txn_id, scratch_pool);
 }
 
 

Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/dag.h
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/dag.h?rev=1655189&r1=1655188&r2=1655189&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/dag.h (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/dag.h Tue Jan 27 23:27:44 2015
@@ -208,12 +208,13 @@ svn_fs_x__dag_node_kind(dag_node_t *node
    If properties do not exist on NODE, *PROPLIST_P will be set to
    NULL.
 
-   Use POOL for all allocations.
+   Allocate the result in RESULT_POOL and use SCRATCH_POOL for temporaries. 
  */
 svn_error_t *
 svn_fs_x__dag_get_proplist(apr_hash_t **proplist_p,
                            dag_node_t *node,
-                           apr_pool_t *pool);
+                           apr_pool_t *result_pool,
+                           apr_pool_t *scratch_pool);
 
 /* Set the property list of NODE to PROPLIST, allocating from POOL.
    The node being changed must be mutable.
@@ -251,16 +252,16 @@ svn_fs_x__dag_set_has_mergeinfo(dag_node
 
 
 /* Open the root of revision REV of filesystem FS, allocating from
-   POOL.  Set *NODE_P to the new node.  */
+   RESULT_POOL.  Set *NODE_P to the new node. */
 svn_error_t *
 svn_fs_x__dag_revision_root(dag_node_t **node_p,
                             svn_fs_t *fs,
                             svn_revnum_t rev,
-                            apr_pool_t *pool);
+                            apr_pool_t *result_pool);
 
 
 /* Set *NODE_P to the root of transaction TXN_ID in FS, allocating
-   from POOL.
+   from RESULT_POOL.
 
    Note that the root node of TXN_ID is not necessarily mutable.  If
    no changes have been made in the transaction, then it may share its
@@ -270,16 +271,18 @@ svn_error_t *
 svn_fs_x__dag_txn_root(dag_node_t **node_p,
                        svn_fs_t *fs,
                        svn_fs_x__txn_id_t txn_id,
-                       apr_pool_t *pool);
+                       apr_pool_t *result_pool);
 
 
 /* Set *NODE_P to the base root of transaction TXN_ID in FS,
-   allocating from POOL.  Allocate the node in TRAIL->pool.  */
+   allocating from RESULT_POOL.  Allocate the node in TRAIL->pool.
+   Use SCRATCH_POOL for temporaries. */
 svn_error_t *
 svn_fs_x__dag_txn_base_root(dag_node_t **node_p,
                             svn_fs_t *fs,
                             svn_fs_x__txn_id_t txn_id,
-                            apr_pool_t *pool);
+                            apr_pool_t *result_pool,
+                            apr_pool_t *scratch_pool);
 
 
 /* Clone the root directory of TXN_ID in FS, and update the
@@ -312,11 +315,12 @@ svn_fs_x__dag_open(dag_node_t **child_p,
 
 /* Set *ENTRIES_P to an array of NODE's entries, sorted by entry names,
    and the values are svn_fs_x__dirent_t. The returned table (and elements)
-   is allocated in POOL, which is also used for temporary allocations. */
+   is allocated in RESULT_POOL, temporaries in SCRATCH_POOL. */
 svn_error_t *
 svn_fs_x__dag_dir_entries(apr_array_header_t **entries_p,
                           dag_node_t *node,
-                          apr_pool_t *pool);
+                          apr_pool_t *result_pool,
+                          apr_pool_t *scratch_pool);
 
 /* Set ENTRY_NAME in NODE to point to ID (with kind KIND), allocating
    from POOL.  NODE must be a mutable directory.  ID can refer to a
@@ -352,7 +356,7 @@ svn_fs_x__dag_set_entry(dag_node_t *node
 
    TXN_ID is the Subversion transaction under which this occurs.
 
-   Use POOL for all allocations.
+   Allocate *CHILD_P in RESULT_POOL and use SCRATCH_POOL for temporaries.
  */
 svn_error_t *
 svn_fs_x__dag_clone_child(dag_node_t **child_p,
@@ -362,7 +366,8 @@ svn_fs_x__dag_clone_child(dag_node_t **c
                           const svn_fs_x__id_t *copy_id,
                           svn_fs_x__txn_id_t txn_id,
                           svn_boolean_t is_parent_copyroot,
-                          apr_pool_t *pool);
+                          apr_pool_t *result_pool,
+                          apr_pool_t *scratch_pool);
 
 
 /* Delete the directory entry named NAME from PARENT, allocating from
@@ -384,21 +389,8 @@ svn_fs_x__dag_delete(dag_node_t *parent,
                      apr_pool_t *scratch_pool);
 
 
-/* Delete all mutable node revisions reachable from node ID, including
-   ID itself, from FS's `nodes' table.  Also delete any mutable
-   representations and strings associated with that node revision.
-   ID may refer to a file or directory, which may be mutable or immutable.
-
-   Use SCRATCH_POOL for temporary allocations.
- */
-svn_error_t *
-svn_fs_x__dag_delete_if_mutable(svn_fs_t *fs,
-                                const svn_fs_x__id_t *id,
-                                apr_pool_t *scratch_pool);
-
-
 /* Create a new mutable directory named NAME in PARENT.  Set *CHILD_P
-   to a reference to the new node, allocated in POOL.  The new
+   to a reference to the new node, allocated in RESULT_POOL.  The new
    directory has no contents, and no properties.  PARENT must be
    mutable.  NAME must be a single path component; it cannot be a
    slash-separated directory path.  PARENT_PATH must be the
@@ -406,7 +398,7 @@ svn_fs_x__dag_delete_if_mutable(svn_fs_t
    not currently have an entry named NAME.  TXN_ID is the Subversion
    transaction under which this occurs.
 
-   Use POOL for all allocations.
+   Use SCRATCH_POOL for temporary allocations.
  */
 svn_error_t *
 svn_fs_x__dag_make_dir(dag_node_t **child_p,
@@ -414,7 +406,8 @@ svn_fs_x__dag_make_dir(dag_node_t **chil
                        const char *parent_path,
                        const char *name,
                        svn_fs_x__txn_id_t txn_id,
-                       apr_pool_t *pool);
+                       apr_pool_t *result_pool,
+                       apr_pool_t *scratch_pool);
 
 
 
@@ -422,59 +415,56 @@ svn_fs_x__dag_make_dir(dag_node_t **chil
 
 
 /* Set *CONTENTS to a readable generic stream which yields the
-   contents of FILE.  Allocate the stream in POOL.
+   contents of FILE.  Allocate the stream in RESULT_POOL.
 
    If FILE is not a file, return SVN_ERR_FS_NOT_FILE.
-
-   Use POOL for all allocations.
  */
 svn_error_t *
 svn_fs_x__dag_get_contents(svn_stream_t **contents,
                            dag_node_t *file,
-                           apr_pool_t *pool);
+                           apr_pool_t *result_pool);
 
 /* Attempt to fetch the contents of NODE and pass it along with the BATON
    to the PROCESSOR.   Set *SUCCESS only of the data could be provided
    and the processor had been called.
 
-   Use POOL for all allocations.
+   Use SCRATCH_POOL for temporary allocations.
  */
 svn_error_t *
 svn_fs_x__dag_try_process_file_contents(svn_boolean_t *success,
                                         dag_node_t *node,
                                         svn_fs_process_contents_func_t processor,
                                         void* baton,
-                                        apr_pool_t *pool);
+                                        apr_pool_t *scratch_pool);
 
 
 /* Set *STREAM_P to a delta stream that will turn the contents of SOURCE into
-   the contents of TARGET, allocated in POOL.  If SOURCE is null, the empty
-   string will be used.
+   the contents of TARGET, allocated in RESULT_POOL.  If SOURCE is null, the
+   empty string will be used is its stead.
 
-   Use POOL for all allocations.
+   Use SCRATCH_POOL for temporary allocations.
  */
 svn_error_t *
 svn_fs_x__dag_get_file_delta_stream(svn_txdelta_stream_t **stream_p,
                                     dag_node_t *source,
                                     dag_node_t *target,
-                                    apr_pool_t *pool);
+                                    apr_pool_t *result_pool,
+                                    apr_pool_t *scratch_pool);
 
 /* Return a generic writable stream in *CONTENTS with which to set the
-   contents of FILE.  Allocate the stream in POOL.
+   contents of FILE.  Allocate the stream in RESULT_POOL.
 
    Any previous edits on the file will be deleted, and a new edit
    stream will be constructed.
-
-   Use POOL for all allocations.
  */
 svn_error_t *
 svn_fs_x__dag_get_edit_stream(svn_stream_t **contents,
                               dag_node_t *file,
-                              apr_pool_t *pool);
+                              apr_pool_t *result_pool);
 
 
 /* Signify the completion of edits to FILE made using the stream
-   returned by svn_fs_x__dag_get_edit_stream, allocating from POOL.
+   returned by svn_fs_x__dag_get_edit_stream.
 
    If CHECKSUM is non-null, it must match the checksum for FILE's
    contents (note: this is not recalculated, the recorded checksum is
@@ -509,14 +499,14 @@ svn_fs_x__dag_file_checksum(svn_checksum
                             apr_pool_t *result_pool);
 
 /* Create a new mutable file named NAME in PARENT.  Set *CHILD_P to a
-   reference to the new node, allocated in POOL.  The new file's
+   reference to the new node, allocated in RESULT_POOL.  The new file's
    contents are the empty string, and it has no properties.  PARENT
    must be mutable.  NAME must be a single path component; it cannot
    be a slash-separated directory path.  PARENT_PATH must be the
    canonicalized absolute path of the parent directory.  TXN_ID is the
    Subversion transaction under which this occurs.
 
-   Use POOL for all allocations.
+   Use SCRATCH_POOL for temporary allocations.
  */
 svn_error_t *
 svn_fs_x__dag_make_file(dag_node_t **child_p,
@@ -524,15 +514,15 @@ svn_fs_x__dag_make_file(dag_node_t **chi
                         const char *parent_path,
                         const char *name,
                         svn_fs_x__txn_id_t txn_id,
-                        apr_pool_t *pool);
+                        apr_pool_t *result_pool,
+                        apr_pool_t *scratch_pool);
 
 
 
 /* Copies */
 
-/* Make ENTRY in TO_NODE be a copy of FROM_NODE, allocating from POOL.
-   TO_NODE must be mutable.  TXN_ID is the Subversion transaction
-   under which this occurs.
+/* Make ENTRY in TO_NODE be a copy of FROM_NODE.  TO_NODE must be mutable.
+   TXN_ID is the Subversion transaction under which this occurs.
 
    If PRESERVE_HISTORY is true, the new node will record that it was
    copied from FROM_PATH in FROM_REV; therefore, FROM_NODE should be
@@ -542,7 +532,7 @@ svn_fs_x__dag_make_file(dag_node_t **chi
 
    If PRESERVE_HISTORY is false, FROM_PATH and FROM_REV are ignored.
 
-   Use POOL for all allocations.
+   Use SCRATCH_POOL for temporary allocations.
  */
 svn_error_t *
 svn_fs_x__dag_copy(dag_node_t *to_node,
@@ -552,7 +542,7 @@ svn_fs_x__dag_copy(dag_node_t *to_node,
                    svn_revnum_t from_rev,
                    const char *from_path,
                    svn_fs_x__txn_id_t txn_id,
-                   apr_pool_t *pool);
+                   apr_pool_t *scratch_pool);
 
 
 /* Comparison */

Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/fs.c
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/fs.c?rev=1655189&r1=1655188&r2=1655189&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/fs.c (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/fs.c Tue Jan 27 23:27:44 2015
@@ -150,17 +150,17 @@ x_set_errcall(svn_fs_t *fs,
   return SVN_NO_ERROR;
 }
 
-struct x_freeze_baton_t {
+typedef struct x_freeze_baton_t {
   svn_fs_t *fs;
   svn_fs_freeze_func_t freeze_func;
   void *freeze_baton;
-};
+} x_freeze_baton_t;
 
 static svn_error_t *
 x_freeze_body(void *baton,
               apr_pool_t *scratch_pool)
 {
-  struct x_freeze_baton_t *b = baton;
+  x_freeze_baton_t *b = baton;
   svn_boolean_t exists;
 
   SVN_ERR(svn_fs_x__exists_rep_cache(&exists, b->fs, scratch_pool));
@@ -176,7 +176,7 @@ static svn_error_t *
 x_freeze_body2(void *baton,
                apr_pool_t *scratch_pool)
 {
-  struct x_freeze_baton_t *b = baton;
+  x_freeze_baton_t *b = baton;
   SVN_ERR(svn_fs_x__with_write_lock(b->fs, x_freeze_body, baton,
                                     scratch_pool));
 
@@ -189,7 +189,7 @@ x_freeze(svn_fs_t *fs,
          void *freeze_baton,
          apr_pool_t *scratch_pool)
 {
-  struct x_freeze_baton_t b;
+  x_freeze_baton_t b;
 
   b.fs = fs;
   b.freeze_func = freeze_func;
@@ -241,6 +241,21 @@ x_set_uuid(svn_fs_t *fs,
   return svn_error_trace(svn_fs_x__set_uuid(fs, uuid, NULL, scratch_pool));
 }
 
+/* Wrapper around svn_fs_x__begin_txn() providing the scratch pool. */
+static svn_error_t *
+x_begin_txn(svn_fs_txn_t **txn_p,
+            svn_fs_t *fs,
+            svn_revnum_t rev,
+            apr_uint32_t flags,
+            apr_pool_t *pool)
+{
+  apr_pool_t *scratch_pool = svn_pool_create(pool);
+  SVN_ERR(svn_fs_x__begin_txn(txn_p, fs, rev, flags, pool, scratch_pool));
+  svn_pool_destroy(scratch_pool);
+
+  return SVN_NO_ERROR;
+}
+
 
 
 /* The vtable associated with a specific open filesystem. */
@@ -251,7 +266,7 @@ static fs_vtable_t fs_vtable = {
   svn_fs_x__change_rev_prop,
   x_set_uuid,
   svn_fs_x__revision_root,
-  svn_fs_x__begin_txn,
+  x_begin_txn,
   svn_fs_x__open_txn,
   svn_fs_x__purge_txn,
   svn_fs_x__list_transactions,

Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/fs.h
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/fs.h?rev=1655189&r1=1655188&r2=1655189&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/fs.h (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/fs.h Tue Jan 27 23:27:44 2015
@@ -217,14 +217,16 @@ typedef struct svn_fs_x__pair_cache_key_
   apr_int64_t second;
 } svn_fs_x__pair_cache_key_t;
 
-/* Key type that identifies a representation / rep header. */
+/* Key type that identifies a representation / rep header.
+
+   Note: Cache keys should require no padding. */
 typedef struct svn_fs_x__representation_cache_key_t
 {
   /* Revision that contains the representation */
-  svn_revnum_t revision;
+  apr_int64_t revision;
 
-  /* Packed or non-packed representation? */
-  svn_boolean_t is_packed;
+  /* Packed or non-packed representation (boolean)? */
+  apr_int64_t is_packed;
 
   /* Item index of the representation */
   apr_uint64_t item_index;

Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/fs_x.c
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/fs_x.c?rev=1655189&r1=1655188&r2=1655189&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/fs_x.c (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/fs_x.c Tue Jan 27 23:27:44 2015
@@ -201,8 +201,7 @@ static svn_error_t *
 verify_block_size(apr_int64_t block_size,
                   apr_size_t item_size,
                   const char *name,
-                  apr_pool_t *scratch_pool
-                 )
+                  apr_pool_t *scratch_pool)
 {
   /* Limit range. */
   if (block_size <= 0)
@@ -594,14 +593,14 @@ svn_fs_x__open(svn_fs_t *fs,
 
 /* Baton type bridging svn_fs_x__upgrade and upgrade_body carrying 
  * parameters over between them. */
-struct upgrade_baton_t
+typedef struct upgrade_baton_t
 {
   svn_fs_t *fs;
   svn_fs_upgrade_notify_t notify_func;
   void *notify_baton;
   svn_cancel_func_t cancel_func;
   void *cancel_baton;
-};
+} upgrade_baton_t;
 
 /* Upgrade the FS given in upgrade_baton_t *)BATON to the latest format
  * version.  Apply options an invoke callback from that BATON.
@@ -614,7 +613,7 @@ static svn_error_t *
 upgrade_body(void *baton,
              apr_pool_t *scratch_pool)
 {
-  struct upgrade_baton_t *upgrade_baton = baton;
+  upgrade_baton_t *upgrade_baton = baton;
   svn_fs_t *fs = upgrade_baton->fs;
   int format, max_files_per_dir;
   const char *format_path = svn_fs_x__path_format(fs, scratch_pool);
@@ -640,7 +639,7 @@ svn_fs_x__upgrade(svn_fs_t *fs,
                   void *cancel_baton,
                   apr_pool_t *scratch_pool)
 {
-  struct upgrade_baton_t baton;
+  upgrade_baton_t baton;
   baton.fs = fs;
   baton.notify_func = notify_func;
   baton.notify_baton = notify_baton;
@@ -789,8 +788,10 @@ svn_fs_x__prop_rep_equal(svn_boolean_t *
 
   /* At least one of the reps has been modified in a txn.
      Fetch and compare them. */
-  SVN_ERR(svn_fs_x__get_proplist(&proplist_a, fs, a, scratch_pool));
-  SVN_ERR(svn_fs_x__get_proplist(&proplist_b, fs, b, scratch_pool));
+  SVN_ERR(svn_fs_x__get_proplist(&proplist_a, fs, a, scratch_pool,
+                                 scratch_pool));
+  SVN_ERR(svn_fs_x__get_proplist(&proplist_b, fs, b, scratch_pool,
+                                 scratch_pool));
 
   *equal = svn_fs__prop_lists_equal(proplist_a, proplist_b, scratch_pool);
   return SVN_NO_ERROR;
@@ -1124,22 +1125,22 @@ svn_fs_x__revision_prop(svn_string_t **v
 
 
 /* Baton used for change_rev_prop_body below. */
-struct change_rev_prop_baton {
+typedef struct change_rev_prop_baton_t {
   svn_fs_t *fs;
   svn_revnum_t rev;
   const char *name;
   const svn_string_t *const *old_value_p;
   const svn_string_t *value;
-};
+} change_rev_prop_baton_t;
 
 /* The work-horse for svn_fs_x__change_rev_prop, called with the FS
    write lock.  This implements the svn_fs_x__with_write_lock()
-   'body' callback type.  BATON is a 'struct change_rev_prop_baton *'. */
+   'body' callback type.  BATON is a 'change_rev_prop_baton_t *'. */
 static svn_error_t *
 change_rev_prop_body(void *baton,
                      apr_pool_t *scratch_pool)
 {
-  struct change_rev_prop_baton *cb = baton;
+  change_rev_prop_baton_t *cb = baton;
   apr_hash_t *table;
 
   SVN_ERR(svn_fs_x__revision_proplist(&table, cb->fs, cb->rev, scratch_pool));
@@ -1174,7 +1175,7 @@ svn_fs_x__change_rev_prop(svn_fs_t *fs,
                           const svn_string_t *value,
                           apr_pool_t *scratch_pool)
 {
-  struct change_rev_prop_baton cb;
+  change_rev_prop_baton_t cb;
 
   SVN_ERR(svn_fs__check_fs(fs, TRUE));
 

Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/hotcopy.c
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/hotcopy.c?rev=1655189&r1=1655188&r2=1655189&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/hotcopy.c (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/hotcopy.c Tue Jan 27 23:27:44 2015
@@ -710,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;
@@ -718,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.
  *
@@ -742,7 +742,7 @@ static svn_error_t *
 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;
@@ -881,7 +881,7 @@ static svn_error_t *
 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, scratch_pool));
@@ -975,7 +975,7 @@ svn_fs_x__hotcopy(svn_fs_t *src_fs,
                   void *cancel_baton,
                   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;

Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/lock.c
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/lock.c?rev=1655189&r1=1655188&r2=1655189&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/lock.c (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/lock.c Tue Jan 27 23:27:44 2015
@@ -104,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;
@@ -297,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;
@@ -306,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);
@@ -548,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 *
@@ -564,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)
     {
@@ -651,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;
@@ -671,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
@@ -703,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);
 }
 
 
@@ -732,13 +731,13 @@ svn_fs_x__allow_locked_operation(const c
       SVN_ERR(get_lock_helper(fs, &lock, path, have_write_lock,
                               scratch_pool));
       if (lock)
-        SVN_ERR(verify_lock(fs, lock, scratch_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;
@@ -747,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)
 {
@@ -847,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
@@ -868,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;
@@ -876,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. */
@@ -890,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);
 
@@ -898,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;
     }
@@ -936,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;
@@ -1015,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;
@@ -1023,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)
 {
@@ -1049,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
@@ -1071,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;
@@ -1079,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));
@@ -1089,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);
 
@@ -1114,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);
@@ -1130,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)
             {
@@ -1191,7 +1188,7 @@ unlock_single(svn_fs_t *fs,
               svn_lock_t *lock,
               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(scratch_pool, 1,
                                                sizeof(svn_sort__item_t));
@@ -1226,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;
@@ -1320,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;
@@ -1359,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)

Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/pack.c
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/pack.c?rev=1655189&r1=1655188&r2=1655189&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/pack.c (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/pack.c Tue Jan 27 23:27:44 2015
@@ -2229,19 +2229,19 @@ pack_shard(const char *revs_dir,
   return SVN_NO_ERROR;
 }
 
-struct pack_baton
+typedef struct pack_baton_t
 {
   svn_fs_t *fs;
   svn_fs_pack_notify_t notify_func;
   void *notify_baton;
   svn_cancel_func_t cancel_func;
   void *cancel_baton;
-};
+} pack_baton_t;
 
 
 /* The work-horse for svn_fs_x__pack, called with the FS write lock.
    This implements the svn_fs_x__with_write_lock() 'body' callback
-   type.  BATON is a 'struct pack_baton *'.
+   type.  BATON is a 'pack_baton_t *'.
 
    WARNING: if you add a call to this function, please note:
      The code currently assumes that any piece of code running with
@@ -2257,7 +2257,7 @@ static svn_error_t *
 pack_body(void *baton,
           apr_pool_t *scratch_pool)
 {
-  struct pack_baton *pb = baton;
+  pack_baton_t *pb = baton;
   svn_fs_x__data_t *ffd = pb->fs->fsap_data;
   apr_int64_t completed_shards;
   apr_int64_t i;
@@ -2313,7 +2313,7 @@ svn_fs_x__pack(svn_fs_t *fs,
                void *cancel_baton,
                apr_pool_t *scratch_pool)
 {
-  struct pack_baton pb = { 0 };
+  pack_baton_t pb = { 0 };
   pb.fs = fs;
   pb.notify_func = notify_func;
   pb.notify_baton = notify_baton;

Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/recovery.c
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/recovery.c?rev=1655189&r1=1655188&r2=1655189&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/recovery.c (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/recovery.c Tue Jan 27 23:27:44 2015
@@ -106,25 +106,26 @@ recover_get_largest_revision(svn_fs_t *f
 }
 
 /* Baton used for recover_body below. */
-struct recover_baton {
+typedef struct recover_baton_t {
   svn_fs_t *fs;
   svn_cancel_func_t cancel_func;
   void *cancel_baton;
-};
+} recover_baton_t;
 
 /* The work-horse for svn_fs_x__recover, called with the FS
    write lock.  This implements the svn_fs_x__with_write_lock()
-   'body' callback type.  BATON is a 'struct recover_baton *'. */
+   'body' callback type.  BATON is a 'recover_baton_t *'. */
 static svn_error_t *
 recover_body(void *baton,
              apr_pool_t *scratch_pool)
 {
-  struct recover_baton *b = baton;
+  recover_baton_t *b = baton;
   svn_fs_t *fs = b->fs;
   svn_fs_x__data_t *ffd = fs->fsap_data;
   svn_revnum_t max_rev;
   svn_revnum_t youngest_rev;
-  svn_node_kind_t youngest_revprops_kind;
+  svn_boolean_t revprop_missing = TRUE;
+  svn_boolean_t revprop_accessible = FALSE;
 
   /* Lose potentially corrupted data in temp files */
   SVN_ERR(svn_fs_x__reset_revprop_generation_file(fs, scratch_pool));
@@ -179,35 +180,49 @@ recover_body(void *baton,
 
   /* Before setting current, verify that there is a revprops file
      for the youngest revision.  (Issue #2992) */
-  SVN_ERR(svn_io_check_path(svn_fs_x__path_revprops(fs, max_rev, scratch_pool),
-                            &youngest_revprops_kind, scratch_pool));
-  if (youngest_revprops_kind == svn_node_none)
+  if (svn_fs_x__is_packed_revprop(fs, max_rev))
     {
-      svn_boolean_t missing = TRUE;
-      if (!svn_fs_x__packed_revprop_available(&missing, fs, max_rev, scratch_pool))
+      revprop_accessible
+        = svn_fs_x__packed_revprop_available(&revprop_missing, fs, max_rev,
+                                             scratch_pool);
+    }
+  else
+    {
+      svn_node_kind_t youngest_revprops_kind;
+      SVN_ERR(svn_io_check_path(svn_fs_x__path_revprops(fs, max_rev,
+                                                        scratch_pool),
+                                &youngest_revprops_kind, scratch_pool));
+
+      if (youngest_revprops_kind == svn_node_file)
+        {
+          revprop_missing = FALSE;
+          revprop_accessible = TRUE;
+        }
+      else if (youngest_revprops_kind != svn_node_none)
         {
-          if (missing)
-            {
-              return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
-                                      _("Revision %ld has a revs file but no "
-                                        "revprops file"),
-                                      max_rev);
-            }
-          else
-            {
-              return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
-                                      _("Revision %ld has a revs file but the "
-                                        "revprops file is inaccessible"),
-                                      max_rev);
-            }
-          }
+          return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
+                                  _("Revision %ld has a non-file where its "
+                                    "revprops file should be"),
+                                  max_rev);
+        }
     }
-  else if (youngest_revprops_kind != svn_node_file)
+
+  if (!revprop_accessible)
     {
-      return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
-                               _("Revision %ld has a non-file where its "
-                                 "revprops file should be"),
-                               max_rev);
+      if (revprop_missing)
+        {
+          return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
+                                  _("Revision %ld has a revs file but no "
+                                    "revprops file"),
+                                  max_rev);
+        }
+      else
+        {
+          return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
+                                  _("Revision %ld has a revs file but the "
+                                    "revprops file is inaccessible"),
+                                  max_rev);
+        }
     }
 
   /* Prune younger-than-(newfound-youngest) revisions from the rep
@@ -217,7 +232,8 @@ recover_body(void *baton,
     {
       svn_boolean_t rep_cache_exists;
 
-      SVN_ERR(svn_fs_x__exists_rep_cache(&rep_cache_exists, fs, scratch_pool));
+      SVN_ERR(svn_fs_x__exists_rep_cache(&rep_cache_exists, fs,
+                                         scratch_pool));
       if (rep_cache_exists)
         SVN_ERR(svn_fs_x__del_rep_reference(fs, max_rev, scratch_pool));
     }
@@ -230,10 +246,11 @@ recover_body(void *baton,
 /* This implements the fs_library_vtable_t.recover() API. */
 svn_error_t *
 svn_fs_x__recover(svn_fs_t *fs,
-                  svn_cancel_func_t cancel_func, void *cancel_baton,
+                  svn_cancel_func_t cancel_func,
+                  void *cancel_baton,
                   apr_pool_t *scratch_pool)
 {
-  struct recover_baton b;
+  recover_baton_t b;
 
   /* We have no way to take out an exclusive lock in FSX, so we're
      restricted as to the types of recovery we can do.  Luckily,

Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/rep-cache.c
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/rep-cache.c?rev=1655189&r1=1655188&r2=1655189&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/rep-cache.c (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/rep-cache.c Tue Jan 27 23:27:44 2015
@@ -239,7 +239,8 @@ svn_error_t *
 svn_fs_x__get_rep_reference(svn_fs_x__representation_t **rep,
                             svn_fs_t *fs,
                             svn_checksum_t *checksum,
-                            apr_pool_t *pool)
+                            apr_pool_t *result_pool,
+                            apr_pool_t *scratch_pool)
 {
   svn_fs_x__data_t *ffd = fs->fsap_data;
   svn_sqlite__stmt_t *stmt;
@@ -247,7 +248,7 @@ svn_fs_x__get_rep_reference(svn_fs_x__re
 
   SVN_ERR_ASSERT(ffd->rep_sharing_allowed);
   if (! ffd->rep_cache_db)
-    SVN_ERR(svn_fs_x__open_rep_cache(fs, pool));
+    SVN_ERR(svn_fs_x__open_rep_cache(fs, scratch_pool));
 
   /* We only allow SHA1 checksums in this table. */
   if (checksum->kind != svn_checksum_sha1)
@@ -257,12 +258,12 @@ svn_fs_x__get_rep_reference(svn_fs_x__re
 
   SVN_ERR(svn_sqlite__get_statement(&stmt, ffd->rep_cache_db, STMT_GET_REP));
   SVN_ERR(svn_sqlite__bindf(stmt, "s",
-                            svn_checksum_to_cstring(checksum, pool)));
+                            svn_checksum_to_cstring(checksum, scratch_pool)));
 
   SVN_ERR(svn_sqlite__step(&have_row, stmt));
   if (have_row)
     {
-      *rep = apr_pcalloc(pool, sizeof(**rep));
+      *rep = apr_pcalloc(result_pool, sizeof(**rep));
       memcpy((*rep)->sha1_digest, checksum->digest,
              sizeof((*rep)->sha1_digest));
       (*rep)->has_sha1 = TRUE;
@@ -280,12 +281,12 @@ svn_fs_x__get_rep_reference(svn_fs_x__re
     {
       /* Check that REP refers to a revision that exists in FS. */
       svn_revnum_t revision = svn_fs_x__get_revnum((*rep)->id.change_set);
-      svn_error_t *err = svn_fs_x__ensure_revision_exists(revision, fs, pool);
+      svn_error_t *err = svn_fs_x__ensure_revision_exists(revision, fs,
+                                                          scratch_pool);
       if (err)
         return svn_error_createf(SVN_ERR_FS_CORRUPT, err,
-                                 "Checksum '%s' in rep-cache is beyond HEAD",
-                                 svn_checksum_to_cstring_display(checksum,
-                                                                 pool));
+                   "Checksum '%s' in rep-cache is beyond HEAD",
+                   svn_checksum_to_cstring_display(checksum, scratch_pool));
     }
 
   return SVN_NO_ERROR;
@@ -335,7 +336,7 @@ svn_fs_x__set_rep_reference(svn_fs_t *fs
          should exist.  If so that's cool -- just do nothing.  If not,
          that's a red flag!  */
       SVN_ERR(svn_fs_x__get_rep_reference(&old_rep, fs, &checksum,
-                                          scratch_pool));
+                                          scratch_pool, scratch_pool));
 
       if (!old_rep)
         {

Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/rep-cache.h
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/rep-cache.h?rev=1655189&r1=1655188&r2=1655189&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/rep-cache.h (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/rep-cache.h Tue Jan 27 23:27:44 2015
@@ -61,14 +61,15 @@ svn_fs_x__walk_rep_reference(svn_fs_t *f
                              apr_pool_t *scratch_pool);
 
 /* Return the representation REP in FS which has fulltext CHECKSUM.
-   REP is allocated in POOL.  If the rep cache database has not been
-   opened, just set *REP to NULL.  Returns SVN_ERR_FS_CORRUPT if
-   a reference beyond HEAD is detected. */
+   REP is allocated in RESULT_POOL.  If the rep cache database has not been
+   opened, just set *REP to NULL.  Returns SVN_ERR_FS_CORRUPT if a reference
+   beyond HEAD is detected.  Uses SCRATCH_POOL for temporary allocations. */
 svn_error_t *
 svn_fs_x__get_rep_reference(svn_fs_x__representation_t **rep,
                             svn_fs_t *fs,
                             svn_checksum_t *checksum,
-                            apr_pool_t *pool);
+                            apr_pool_t *result_pool,
+                            apr_pool_t *scratch_pool);
 
 /* Set the representation REP in FS, using REP->CHECKSUM.
    Use SCRATCH_POOL for temporary allocations.  Returns SVN_ERR_FS_CORRUPT

Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/revprops.c
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/revprops.c?rev=1655189&r1=1655188&r2=1655189&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/revprops.c (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/revprops.c Tue Jan 27 23:27:44 2015
@@ -677,7 +677,7 @@ parse_revprop(apr_hash_t **properties,
 
   SVN_ERR(svn_hash_read2(*properties, stream, SVN_HASH_TERMINATOR,
                          result_pool));
-  if (has_revprop_cache(fs, result_pool))
+  if (has_revprop_cache(fs, scratch_pool))
     {
       svn_fs_x__data_t *ffd = fs->fsap_data;
       svn_fs_x__pair_cache_key_t key = { 0 };

Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/temp_serializer.c
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/temp_serializer.c?rev=1655189&r1=1655188&r2=1655189&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/temp_serializer.c (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/temp_serializer.c Tue Jan 27 23:27:44 2015
@@ -795,6 +795,23 @@ find_entry(svn_fs_x__dirent_t **entries,
   return lower;
 }
 
+/* Utility function that returns TRUE if entry number IDX in ENTRIES has the
+ * name NAME.
+ */
+static svn_boolean_t
+found_entry(const svn_fs_x__dirent_t * const *entries,
+            const char *name,
+            apr_size_t idx)
+{
+  /* check whether we actually found a match */
+  const svn_fs_x__dirent_t *entry =
+    svn_temp_deserializer__ptr(entries, (const void *const *)&entries[idx]);
+  const char* entry_name =
+    svn_temp_deserializer__ptr(entry, (const void *const *)&entry->name);
+
+  return strcmp(entry_name, name) == 0;
+}
+
 svn_error_t *
 svn_fs_x__extract_dir_entry(void **out,
                             const void *data,
@@ -803,8 +820,9 @@ svn_fs_x__extract_dir_entry(void **out,
                             apr_pool_t *pool)
 {
   const dir_data_t *dir_data = data;
-  const char* name = baton;
+  svn_fs_x__ede_baton_t *b = baton;
   svn_boolean_t found;
+  apr_size_t pos;
 
   /* resolve the reference to the entries array */
   const svn_fs_x__dirent_t * const *entries =
@@ -814,14 +832,33 @@ svn_fs_x__extract_dir_entry(void **out,
   const apr_uint32_t *lengths =
     svn_temp_deserializer__ptr(data, (const void *const *)&dir_data->lengths);
 
-  /* binary search for the desired entry by name */
-  apr_size_t pos = find_entry((svn_fs_x__dirent_t **)entries,
-                              name,
-                              dir_data->count,
-                              &found);
+  /* Special case: Early out for empty directories.
+     That simplifies tests further down the road. */
+  *out = NULL;
+  if (dir_data->count == 0)
+    return SVN_NO_ERROR;
+
+  /* HINT _might_ be the position we hit last time.
+     If within valid range, check whether HINT+1 is a hit. */
+  if (   b->hint < dir_data->count - 1
+      && found_entry(entries, b->name, b->hint + 1))
+    {
+      /* Got lucky. */
+      pos = b->hint + 1;
+      found = TRUE;
+    }
+  else
+    {
+      /* Binary search for the desired entry by name. */
+      pos = find_entry((svn_fs_x__dirent_t **)entries, b->name,
+                       dir_data->count, &found);
+    }
+
+  /* Remember the hit index - if we FOUND the entry. */
+  if (found)
+    b->hint = pos;
 
   /* de-serialize that entry or return NULL, if no match has been found */
-  *out = NULL;
   if (found)
     {
       const svn_fs_x__dirent_t *source =

Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/temp_serializer.h
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/temp_serializer.h?rev=1655189&r1=1655188&r2=1655189&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/temp_serializer.h (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/temp_serializer.h Tue Jan 27 23:27:44 2015
@@ -194,9 +194,20 @@ svn_fs_x__get_sharded_offset(void **out,
                              apr_pool_t *pool);
 
 /**
+ * Baton type to be used with svn_fs_x__extract_dir_entry. */
+typedef struct svn_fs_x__ede_baton_t
+{
+  /* Name of the directory entry to find. */
+  const char *name;
+
+  /* Lookup hint [in / out] */
+  apr_size_t hint;
+} svn_fs_x__ede_baton_t;
+
+/**
  * Implements #svn_cache__partial_getter_func_t for a single
  * #svn_fs_x__dirent_t within a serialized directory contents hash,
- * identified by its name (const char @a *baton).
+ * identified by its name (given in @a svn_fs_x__ede_baton_t @a *baton).
  */
 svn_error_t *
 svn_fs_x__extract_dir_entry(void **out,



Mime
View raw message