Imported from /home/lorry/working-area/delta_subversion-tarball/subversion-1.8.13.tar.gz.subversion-1.8.13

15 files changed, 180 insertions, 205 deletions

diff --git a/subversion/libsvn_fs_base/bdb/bdb-err.c b/subversion/libsvn_fs_base/bdb/bdb-err.c
index dce98f3..3d51711 100644
--- a/subversion/libsvn_fs_base/bdb/bdb-err.c
+++ b/subversion/libsvn_fs_base/bdb/bdb-err.c
@@ -102,5 +102,5 @@ svn_fs_bdb__wrap_db(svn_fs_t *fs, const char *operation, int db_err)
   return svn_fs_bdb__dberrf
     (bfd->bdb, db_err,
      _("Berkeley DB error for filesystem '%s' while %s:\n"),
-     fs->path ? fs->path : "(none)", operation);
+     fs->path ? fs->path : "(none)", _(operation));
 }
diff --git a/subversion/libsvn_fs_base/bdb/changes-table.c b/subversion/libsvn_fs_base/bdb/changes-table.c
index fa0bfee..80ff468 100644
--- a/subversion/libsvn_fs_base/bdb/changes-table.c
+++ b/subversion/libsvn_fs_base/bdb/changes-table.c
@@ -25,6 +25,7 @@
 #include <apr_hash.h>
 #include <apr_tables.h>
 
+#include "svn_hash.h"
 #include "svn_fs.h"
 #include "svn_pools.h"
 #include "svn_path.h"
@@ -90,7 +91,7 @@ svn_fs_bdb__changes_add(svn_fs_t *fs,
   svn_fs_base__str_to_dbt(&query, key);
   svn_fs_base__skel_to_dbt(&value, skel, pool);
   svn_fs_base__trail_debug(trail, "changes", "put");
-  return BDB_WRAP(fs, _("creating change"),
+  return BDB_WRAP(fs, N_("creating change"),
                   bfd->changes->put(bfd->changes, trail->db_txn,
                                     &query, &value, 0));
 }
@@ -114,7 +115,7 @@ svn_fs_bdb__changes_delete(svn_fs_t *fs,
      error should be propagated to the caller, though.  */
   if ((db_err) && (db_err != DB_NOTFOUND))
     {
-      SVN_ERR(BDB_WRAP(fs, _("deleting changes"), db_err));
+      SVN_ERR(BDB_WRAP(fs, N_("deleting changes"), db_err));
     }
 
   return SVN_NO_ERROR;
@@ -132,7 +133,7 @@ fold_change(apr_hash_t *changes,
   svn_fs_path_change2_t *old_change, *new_change;
   const char *path;
 
-  if ((old_change = apr_hash_get(changes, change->path, APR_HASH_KEY_STRING)))
+  if ((old_change = svn_hash_gets(changes, change->path)))
     {
       /* This path already exists in the hash, so we have to merge
          this change into the already existing one. */
@@ -244,7 +245,7 @@ fold_change(apr_hash_t *changes,
     }
 
   /* Add (or update) this path. */
-  apr_hash_set(changes, path, APR_HASH_KEY_STRING, new_change);
+  svn_hash_sets(changes, path, new_change);
 
   return SVN_NO_ERROR;
 }
@@ -268,7 +269,7 @@ svn_fs_bdb__changes_fetch(apr_hash_t **changes_p,
   /* Get a cursor on the first record matching KEY, and then loop over
      the records, adding them to the return array. */
   svn_fs_base__trail_debug(trail, "changes", "cursor");
-  SVN_ERR(BDB_WRAP(fs, _("creating cursor for reading changes"),
+  SVN_ERR(BDB_WRAP(fs, N_("creating cursor for reading changes"),
                    bfd->changes->cursor(bfd->changes, trail->db_txn,
                                         &cursor, 0)));
 
@@ -325,14 +326,14 @@ svn_fs_bdb__changes_fetch(apr_hash_t **changes_p,
               /* KEY is the path. */
               const void *hashkey;
               apr_ssize_t klen;
-              apr_hash_this(hi, &hashkey, &klen, NULL);
+              const char *child_relpath;
 
-              /* If we come across our own path, ignore it. */
-              if (strcmp(change->path, hashkey) == 0)
-                continue;
+              apr_hash_this(hi, &hashkey, &klen, NULL);
 
-              /* If we come across a child of our path, remove it. */
-              if (svn_fspath__is_child(change->path, hashkey, subpool))
+              /* If we come across our own path, ignore it.
+                 If we come across a child of our path, remove it. */
+              child_relpath = svn_fspath__skip_ancestor(change->path, hashkey);
+              if (child_relpath && *child_relpath)
                 apr_hash_set(changes, hashkey, klen, NULL);
             }
         }
@@ -352,7 +353,7 @@ svn_fs_bdb__changes_fetch(apr_hash_t **changes_p,
      finished.  Just return the (possibly empty) array.  Any other
      error, however, needs to get handled appropriately.  */
   if (db_err && (db_err != DB_NOTFOUND))
-    err = BDB_WRAP(fs, _("fetching changes"), db_err);
+    err = BDB_WRAP(fs, N_("fetching changes"), db_err);
 
  cleanup:
   /* Close the cursor. */
@@ -365,7 +366,7 @@ svn_fs_bdb__changes_fetch(apr_hash_t **changes_p,
   /* If our only error thus far was when we closed the cursor, return
      that error. */
   if (db_c_err)
-    SVN_ERR(BDB_WRAP(fs, _("closing changes cursor"), db_c_err));
+    SVN_ERR(BDB_WRAP(fs, N_("closing changes cursor"), db_c_err));
 
   /* Finally, set our return variable and get outta here. */
   *changes_p = changes;
@@ -391,7 +392,7 @@ svn_fs_bdb__changes_fetch_raw(apr_array_header_t **changes_p,
   /* Get a cursor on the first record matching KEY, and then loop over
      the records, adding them to the return array. */
   svn_fs_base__trail_debug(trail, "changes", "cursor");
-  SVN_ERR(BDB_WRAP(fs, _("creating cursor for reading changes"),
+  SVN_ERR(BDB_WRAP(fs, N_("creating cursor for reading changes"),
                    bfd->changes->cursor(bfd->changes, trail->db_txn,
                                         &cursor, 0)));
 
@@ -435,7 +436,7 @@ svn_fs_bdb__changes_fetch_raw(apr_array_header_t **changes_p,
      finished.  Just return the (possibly empty) array.  Any other
      error, however, needs to get handled appropriately.  */
   if (db_err && (db_err != DB_NOTFOUND))
-    err = BDB_WRAP(fs, _("fetching changes"), db_err);
+    err = BDB_WRAP(fs, N_("fetching changes"), db_err);
 
  cleanup:
   /* Close the cursor. */
@@ -448,7 +449,7 @@ svn_fs_bdb__changes_fetch_raw(apr_array_header_t **changes_p,
   /* If our only error thus far was when we closed the cursor, return
      that error. */
   if (db_c_err)
-    SVN_ERR(BDB_WRAP(fs, _("closing changes cursor"), db_c_err));
+    SVN_ERR(BDB_WRAP(fs, N_("closing changes cursor"), db_c_err));
 
   /* Finally, set our return variable and get outta here. */
   *changes_p = changes;
diff --git a/subversion/libsvn_fs_base/bdb/checksum-reps-table.c b/subversion/libsvn_fs_base/bdb/checksum-reps-table.c
index d985830..f4a34c3 100644
--- a/subversion/libsvn_fs_base/bdb/checksum-reps-table.c
+++ b/subversion/libsvn_fs_base/bdb/checksum-reps-table.c
@@ -139,7 +139,7 @@ svn_error_t *svn_fs_bdb__set_checksum_rep(svn_fs_t *fs,
   /* Create a value from our REP_KEY, and add this record to the table. */
   svn_fs_base__str_to_dbt(&value, rep_key);
   svn_fs_base__trail_debug(trail, "checksum-reps", "put");
-  SVN_ERR(BDB_WRAP(fs, _("storing checksum-reps record"),
+  SVN_ERR(BDB_WRAP(fs, N_("storing checksum-reps record"),
                    bfd->checksum_reps->put(bfd->checksum_reps, trail->db_txn,
                                            &key, &value, 0)));
   return SVN_NO_ERROR;
@@ -161,7 +161,7 @@ svn_error_t *svn_fs_bdb__delete_checksum_rep(svn_fs_t *fs,
 
   svn_fs_base__checksum_to_dbt(&key, checksum);
   svn_fs_base__trail_debug(trail, "checksum-reps", "del");
-  SVN_ERR(BDB_WRAP(fs, "deleting entry from 'checksum-reps' table",
+  SVN_ERR(BDB_WRAP(fs, N_("deleting entry from 'checksum-reps' table"),
                    bfd->checksum_reps->del(bfd->checksum_reps,
                                            trail->db_txn, &key, 0)));
   return SVN_NO_ERROR;
@@ -183,7 +183,7 @@ svn_error_t *svn_fs_bdb__reserve_rep_reuse_id(const char **id_p,
   /* Get the current value associated with the `next-key' key in the
      `checksum-reps' table.  */
   svn_fs_base__trail_debug(trail, "checksum-reps", "get");
-  SVN_ERR(BDB_WRAP(fs, _("allocating new representation reuse ID "
+  SVN_ERR(BDB_WRAP(fs, N_("allocating new representation reuse ID "
                          "(getting 'next-key')"),
                    bfd->checksum_reps->get(bfd->checksum_reps, trail->db_txn,
                                            &query,
@@ -204,5 +204,5 @@ svn_error_t *svn_fs_bdb__reserve_rep_reuse_id(const char **id_p,
                                    svn_fs_base__str_to_dbt(&result, next_key),
                                    0);
 
-  return BDB_WRAP(fs, _("bumping next representation reuse ID"), db_err);
+  return BDB_WRAP(fs, N_("bumping next representation reuse ID"), db_err);
 }
diff --git a/subversion/libsvn_fs_base/bdb/copies-table.c b/subversion/libsvn_fs_base/bdb/copies-table.c
index 919a390..7bf6ca8 100644
--- a/subversion/libsvn_fs_base/bdb/copies-table.c
+++ b/subversion/libsvn_fs_base/bdb/copies-table.c
@@ -89,7 +89,7 @@ put_copy(svn_fs_t *fs,
   svn_fs_base__str_to_dbt(&key, copy_id);
   svn_fs_base__skel_to_dbt(&value, copy_skel, pool);
   svn_fs_base__trail_debug(trail, "copies", "put");
-  return BDB_WRAP(fs, _("storing copy record"),
+  return BDB_WRAP(fs, N_("storing copy record"),
                   bfd->copies->put(bfd->copies, trail->db_txn,
                                    &key, &value, 0));
 }
@@ -112,7 +112,7 @@ svn_fs_bdb__reserve_copy_id(const char **id_p,
   /* Get the current value associated with the `next-key' key in the
      copies table.  */
   svn_fs_base__trail_debug(trail, "copies", "get");
-  SVN_ERR(BDB_WRAP(fs, _("allocating new copy ID (getting 'next-key')"),
+  SVN_ERR(BDB_WRAP(fs, N_("allocating new copy ID (getting 'next-key')"),
                    bfd->copies->get(bfd->copies, trail->db_txn, &query,
                                     svn_fs_base__result_dbt(&result),
                                     0)));
@@ -130,7 +130,7 @@ svn_fs_bdb__reserve_copy_id(const char **id_p,
                             svn_fs_base__str_to_dbt(&result, next_key),
                             0);
 
-  return BDB_WRAP(fs, _("bumping next copy key"), db_err);
+  return BDB_WRAP(fs, N_("bumping next copy key"), db_err);
 }
 
 
@@ -168,7 +168,7 @@ svn_fs_bdb__delete_copy(svn_fs_t *fs,
   db_err = bfd->copies->del(bfd->copies, trail->db_txn, &key, 0);
   if (db_err == DB_NOTFOUND)
     return svn_fs_base__err_no_such_copy(fs, copy_id);
-  return BDB_WRAP(fs, _("deleting entry from 'copies' table"), db_err);
+  return BDB_WRAP(fs, N_("deleting entry from 'copies' table"), db_err);
 }
 
 
@@ -196,7 +196,7 @@ svn_fs_bdb__get_copy(copy_t **copy_p,
 
   if (db_err == DB_NOTFOUND)
     return svn_fs_base__err_no_such_copy(fs, copy_id);
-  SVN_ERR(BDB_WRAP(fs, _("reading copy"), db_err));
+  SVN_ERR(BDB_WRAP(fs, N_("reading copy"), db_err));
 
   /* Unparse COPY skel */
   skel = svn_skel__parse(value.data, value.size, pool);
diff --git a/subversion/libsvn_fs_base/bdb/env.c b/subversion/libsvn_fs_base/bdb/env.c
index 436247e..7309a80 100644
--- a/subversion/libsvn_fs_base/bdb/env.c
+++ b/subversion/libsvn_fs_base/bdb/env.c
@@ -24,7 +24,6 @@
 
 #include <apr.h>
 #if APR_HAS_THREADS
-#include <apr_thread_mutex.h>
 #include <apr_thread_proc.h>
 #include <apr_time.h>
 #endif
@@ -32,10 +31,12 @@
 #include <apr_strings.h>
 #include <apr_hash.h>
 
+#include "svn_hash.h"
 #include "svn_path.h"
 #include "svn_pools.h"
 #include "svn_utf.h"
 #include "private/svn_atomic.h"
+#include "private/svn_mutex.h"
 
 #include "bdb-err.h"
 #include "bdb_compat.h"
@@ -226,7 +227,7 @@ bdb_error_gatherer(const DB_ENV *dbenv, const char *baton, const char *msg)
 
   SVN_BDB_ERROR_GATHERER_IGNORE(dbenv);
 
-  new_err = svn_error_createf(SVN_NO_ERROR, NULL, "bdb: %s", msg);
+  new_err = svn_error_createf(SVN_ERR_FS_BERKELEY_DB, NULL, "bdb: %s", msg);
   if (error_info->pending_errors)
     svn_error_compose(error_info->pending_errors, new_err);
   else
@@ -358,12 +359,11 @@ static apr_pool_t *bdb_cache_pool = NULL;
 /* The cache.  The items are bdb_env_t structures. */
 static apr_hash_t *bdb_cache = NULL;
 
-#if APR_HAS_THREADS
 /* The mutex that protects bdb_cache. */
-static apr_thread_mutex_t *bdb_cache_lock = NULL;
+static svn_mutex__t *bdb_cache_lock = NULL;
 
-/* Cleanup callback to NULL out the cache and its lock, so we don't try to
-   use them after the pool has been cleared during global shutdown. */
+/* Cleanup callback to NULL out the cache, so we don't try to use it after
+   the pool has been cleared during global shutdown. */
 static apr_status_t
 clear_cache(void *data)
 {
@@ -371,31 +371,18 @@ clear_cache(void *data)
   bdb_cache_lock = NULL;
   return APR_SUCCESS;
 }
-#endif /* APR_HAS_THREADS */
 
 static volatile svn_atomic_t bdb_cache_state = 0;
 
 static svn_error_t *
 bdb_init_cb(void *baton, apr_pool_t *pool)
 {
-#if APR_HAS_THREADS
-  apr_status_t apr_err;
-#endif
   bdb_cache_pool = svn_pool_create(pool);
   bdb_cache = apr_hash_make(bdb_cache_pool);
-#if APR_HAS_THREADS
-  apr_err = apr_thread_mutex_create(&bdb_cache_lock,
-                                    APR_THREAD_MUTEX_DEFAULT,
-                                    bdb_cache_pool);
-  if (apr_err)
-    {
-      return svn_error_create(apr_err, NULL,
-                              "Couldn't initialize the cache of"
-                              " Berkeley DB environment descriptors");
-    }
+
+  SVN_ERR(svn_mutex__init(&bdb_cache_lock, TRUE, bdb_cache_pool));
   apr_pool_cleanup_register(bdb_cache_pool, NULL, clear_cache,
                             apr_pool_cleanup_null);
-#endif /* APR_HAS_THREADS */
 
   return SVN_NO_ERROR;
 }
@@ -406,26 +393,6 @@ svn_fs_bdb__init(apr_pool_t* pool)
   return svn_atomic__init_once(&bdb_cache_state, bdb_init_cb, NULL, pool);
 }
 
-static APR_INLINE void
-acquire_cache_mutex(void)
-{
-#if APR_HAS_THREADS
-  if (bdb_cache_lock)
-    apr_thread_mutex_lock(bdb_cache_lock);
-#endif
-}
-
-
-static APR_INLINE void
-release_cache_mutex(void)
-{
-#if APR_HAS_THREADS
-  if (bdb_cache_lock)
-    apr_thread_mutex_unlock(bdb_cache_lock);
-#endif
-}
-
-
 /* Construct a cache key for the BDB environment at PATH in *KEYP.
    if DBCONFIG_FILE is not NULL, return the opened file handle.
    Allocate from POOL. */
@@ -523,13 +490,41 @@ bdb_close(bdb_env_t *bdb)
 }
 
 
+static svn_error_t *
+svn_fs_bdb__close_internal(bdb_env_t *bdb)
+{
+  svn_error_t *err = SVN_NO_ERROR;
+
+  if (--bdb->refcount != 0)
+    {
+      /* If the environment is panicked and automatic recovery is not
+         enabled, return an appropriate error. */
+#if !SVN_BDB_AUTO_RECOVER
+      if (svn_atomic_read(&bdb->panic))
+        err = svn_error_create(SVN_ERR_FS_BERKELEY_DB, NULL,
+                                db_strerror(DB_RUNRECOVERY));
+#endif
+    }
+  else
+    {
+      /* If the bdb cache has been set to NULL that means we are
+         shutting down, and the pool that holds the bdb cache has
+         already been destroyed, so accessing it here would be a Bad
+         Thing (tm) */
+      if (bdb_cache)
+        apr_hash_set(bdb_cache, &bdb->key, sizeof bdb->key, NULL);
+      err = bdb_close(bdb);
+    }
+  return svn_error_trace(err);
+}
+
 svn_error_t *
 svn_fs_bdb__close(bdb_env_baton_t *bdb_baton)
 {
-  svn_error_t *err = SVN_NO_ERROR;
   bdb_env_t *bdb = bdb_baton->bdb;
 
   SVN_ERR_ASSERT(bdb_baton->env == bdb_baton->bdb->env);
+  SVN_ERR_ASSERT(bdb_baton->error_info->refcount > 0);
 
   /* Neutralize bdb_baton's pool cleanup to prevent double-close. See
      cleanup_env_baton(). */
@@ -548,31 +543,10 @@ svn_fs_bdb__close(bdb_env_baton_t *bdb_baton)
 #endif
     }
 
-  acquire_cache_mutex();
-  if (--bdb->refcount != 0)
-    {
-      release_cache_mutex();
+  /* This may run during final pool cleanup when the lock is NULL. */
+  SVN_MUTEX__WITH_LOCK(bdb_cache_lock, svn_fs_bdb__close_internal(bdb));
 
-      /* If the environment is panicked and automatic recovery is not
-         enabled, return an appropriate error. */
-#if !SVN_BDB_AUTO_RECOVER
-      if (svn_atomic_read(&bdb->panic))
-        err = svn_error_create(SVN_ERR_FS_BERKELEY_DB, NULL,
-                               db_strerror(DB_RUNRECOVERY));
-#endif
-    }
-  else
-    {
-      /* If the bdb cache has been set to NULL that means we are
-         shutting down, and the pool that holds the bdb cache has
-         already been destroyed, so accessing it here would be a Bad
-         Thing (tm) */
-      if (bdb_cache)
-        apr_hash_set(bdb_cache, &bdb->key, sizeof bdb->key, NULL);
-      err = bdb_close(bdb);
-      release_cache_mutex();
-    }
-  return svn_error_trace(err);
+  return SVN_NO_ERROR;
 }
 
 
@@ -614,44 +588,32 @@ cleanup_env_baton(void *data)
 }
 
 
-svn_error_t *
-svn_fs_bdb__open(bdb_env_baton_t **bdb_batonp, const char *path,
-                 u_int32_t flags, int mode,
-                 apr_pool_t *pool)
+static svn_error_t *
+svn_fs_bdb__open_internal(bdb_env_baton_t **bdb_batonp,
+                          const char *path,
+                          u_int32_t flags, int mode,
+                          apr_pool_t *pool)
 {
-  svn_error_t *err = SVN_NO_ERROR;
   bdb_env_key_t key;
   bdb_env_t *bdb;
   svn_boolean_t panic;
 
-  acquire_cache_mutex();
-
   /* We can safely discard the open DB_CONFIG file handle.  If the
      environment descriptor is in the cache, the key's immutability is
      guaranteed.  If it's not, we don't care if the key changes,
      between here and the actual insertion of the newly-created
      environment into the cache, because no other thread can touch the
      cache in the meantime. */
-  err = bdb_cache_key(&key, NULL, path, pool);
-  if (err)
-    {
-      release_cache_mutex();
-      return svn_error_trace(err);
-    }
+  SVN_ERR(bdb_cache_key(&key, NULL, path, pool));
 
   bdb = bdb_cache_get(&key, &panic);
   if (panic)
-    {
-      release_cache_mutex();
-      return svn_error_create(SVN_ERR_FS_BERKELEY_DB, NULL,
-                              db_strerror(DB_RUNRECOVERY));
-    }
+    return svn_error_create(SVN_ERR_FS_BERKELEY_DB, NULL,
+                            db_strerror(DB_RUNRECOVERY));
 
   /* Make sure that the environment's open flags haven't changed. */
   if (bdb && bdb->flags != flags)
     {
-      release_cache_mutex();
-
       /* Handle changes to the DB_PRIVATE flag specially */
       if ((flags ^ bdb->flags) & DB_PRIVATE)
         {
@@ -673,41 +635,50 @@ svn_fs_bdb__open(bdb_env_baton_t **bdb_batonp, const char *path,
 
   if (!bdb)
     {
-      err = create_env(&bdb, path, svn_pool_create(bdb_cache_pool));
-      if (!err)
+      svn_error_t *err;
+
+      SVN_ERR(create_env(&bdb, path, svn_pool_create(bdb_cache_pool)));
+      err = bdb_open(bdb, flags, mode);
+      if (err)
         {
-          err = bdb_open(bdb, flags, mode);
-          if (!err)
-            {
-              apr_hash_set(bdb_cache, &bdb->key, sizeof bdb->key, bdb);
-              bdb->flags = flags;
-              bdb->refcount = 1;
-            }
-          else
-            {
-              /* Clean up, and we can't do anything about returned errors. */
-              svn_error_clear(bdb_close(bdb));
-            }
+          /* Clean up, and we can't do anything about returned errors. */
+          svn_error_clear(bdb_close(bdb));
+          return svn_error_trace(err);
         }
+
+      apr_hash_set(bdb_cache, &bdb->key, sizeof bdb->key, bdb);
+      bdb->flags = flags;
+      bdb->refcount = 1;
     }
   else
     {
       ++bdb->refcount;
     }
 
-  if (!err)
-    {
-      *bdb_batonp = apr_palloc(pool, sizeof **bdb_batonp);
-      (*bdb_batonp)->env = bdb->env;
-      (*bdb_batonp)->bdb = bdb;
-      (*bdb_batonp)->error_info = get_error_info(bdb);
-      ++(*bdb_batonp)->error_info->refcount;
-      apr_pool_cleanup_register(pool, *bdb_batonp, cleanup_env_baton,
-                                apr_pool_cleanup_null);
-    }
+  *bdb_batonp = apr_palloc(pool, sizeof **bdb_batonp);
+  (*bdb_batonp)->env = bdb->env;
+  (*bdb_batonp)->bdb = bdb;
+  (*bdb_batonp)->error_info = get_error_info(bdb);
+  ++(*bdb_batonp)->error_info->refcount;
+  apr_pool_cleanup_register(pool, *bdb_batonp, cleanup_env_baton,
+                            apr_pool_cleanup_null);
 
-  release_cache_mutex();
-  return svn_error_trace(err);
+  return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_fs_bdb__open(bdb_env_baton_t **bdb_batonp, const char *path,
+                 u_int32_t flags, int mode,
+                 apr_pool_t *pool)
+{
+  SVN_MUTEX__WITH_LOCK(bdb_cache_lock,
+                       svn_fs_bdb__open_internal(bdb_batonp,
+                                                 path,
+                                                 flags,
+                                                 mode,
+                                                 pool));
+
+  return SVN_NO_ERROR;
 }
 
 
diff --git a/subversion/libsvn_fs_base/bdb/lock-tokens-table.c b/subversion/libsvn_fs_base/bdb/lock-tokens-table.c
index 1de9ddd..e70ef17 100644
--- a/subversion/libsvn_fs_base/bdb/lock-tokens-table.c
+++ b/subversion/libsvn_fs_base/bdb/lock-tokens-table.c
@@ -84,7 +84,7 @@ svn_fs_bdb__lock_token_add(svn_fs_t *fs,
   svn_fs_base__str_to_dbt(&key, path);
   svn_fs_base__str_to_dbt(&value, lock_token);
   svn_fs_base__trail_debug(trail, "lock-tokens", "add");
-  return BDB_WRAP(fs, "storing lock token record",
+  return BDB_WRAP(fs, N_("storing lock token record"),
                   bfd->lock_tokens->put(bfd->lock_tokens, trail->db_txn,
                                         &key, &value, 0));
 }
@@ -104,8 +104,8 @@ svn_fs_bdb__lock_token_delete(svn_fs_t *fs,
   svn_fs_base__trail_debug(trail, "lock-tokens", "del");
   db_err = bfd->lock_tokens->del(bfd->lock_tokens, trail->db_txn, &key, 0);
   if (db_err == DB_NOTFOUND)
-    return SVN_FS__ERR_NO_SUCH_LOCK(fs, path, pool);
-  return BDB_WRAP(fs, "deleting entry from 'lock-tokens' table", db_err);
+    return SVN_FS__ERR_NO_SUCH_LOCK(fs, path);
+  return BDB_WRAP(fs, N_("deleting entry from 'lock-tokens' table"), db_err);
 }
 
 
@@ -131,8 +131,8 @@ svn_fs_bdb__lock_token_get(const char **lock_token_p,
   svn_fs_base__track_dbt(&value, pool);
 
   if (db_err == DB_NOTFOUND)
-    return SVN_FS__ERR_NO_SUCH_LOCK(fs, path, pool);
-  SVN_ERR(BDB_WRAP(fs, "reading lock token", db_err));
+    return SVN_FS__ERR_NO_SUCH_LOCK(fs, path);
+  SVN_ERR(BDB_WRAP(fs, N_("reading lock token"), db_err));
 
   lock_token = apr_pstrmemdup(pool, value.data, value.size);
 
diff --git a/subversion/libsvn_fs_base/bdb/locks-table.c b/subversion/libsvn_fs_base/bdb/locks-table.c
index 9ffe694..a22663f 100644
--- a/subversion/libsvn_fs_base/bdb/locks-table.c
+++ b/subversion/libsvn_fs_base/bdb/locks-table.c
@@ -26,6 +26,7 @@
 #include "bdb_compat.h"
 
 #include "svn_pools.h"
+#include "svn_path.h"
 #include "private/svn_skel.h"
 
 #include "dbt.h"
@@ -89,7 +90,7 @@ svn_fs_bdb__lock_add(svn_fs_t *fs,
   svn_fs_base__str_to_dbt(&key, lock_token);
   svn_fs_base__skel_to_dbt(&value, lock_skel, pool);
   svn_fs_base__trail_debug(trail, "lock", "add");
-  return BDB_WRAP(fs, "storing lock record",
+  return BDB_WRAP(fs, N_("storing lock record"),
                   bfd->locks->put(bfd->locks, trail->db_txn,
                                   &key, &value, 0));
 }
@@ -112,7 +113,7 @@ svn_fs_bdb__lock_delete(svn_fs_t *fs,
 
   if (db_err == DB_NOTFOUND)
     return svn_fs_base__err_bad_lock_token(fs, lock_token);
-  return BDB_WRAP(fs, "deleting lock from 'locks' table", db_err);
+  return BDB_WRAP(fs, N_("deleting lock from 'locks' table"), db_err);
 }
 
 
@@ -139,7 +140,7 @@ svn_fs_bdb__lock_get(svn_lock_t **lock_p,
 
   if (db_err == DB_NOTFOUND)
     return svn_fs_base__err_bad_lock_token(fs, lock_token);
-  SVN_ERR(BDB_WRAP(fs, "reading lock", db_err));
+  SVN_ERR(BDB_WRAP(fs, N_("reading lock"), db_err));
 
   /* Parse TRANSACTION skel */
   skel = svn_skel__parse(value.data, value.size, pool);
@@ -153,7 +154,7 @@ svn_fs_bdb__lock_get(svn_lock_t **lock_p,
   if (lock->expiration_date && (apr_time_now() > lock->expiration_date))
     {
       SVN_ERR(svn_fs_bdb__lock_delete(fs, lock_token, trail, pool));
-      return SVN_FS__ERR_LOCK_EXPIRED(fs, lock_token, pool);
+      return SVN_FS__ERR_LOCK_EXPIRED(fs, lock_token);
     }
 
   *lock_p = lock;
@@ -242,7 +243,8 @@ svn_fs_bdb__locks_get(svn_fs_t *fs,
   svn_fs_base__trail_debug(trail, "lock-tokens", "cursor");
   db_err = bfd->lock_tokens->cursor(bfd->lock_tokens, trail->db_txn,
                                     &cursor, 0);
-  SVN_ERR(BDB_WRAP(fs, "creating cursor for reading lock tokens", db_err));
+  SVN_ERR(BDB_WRAP(fs, N_("creating cursor for reading lock tokens"),
+                   db_err));
 
   /* Since the key is going to be returned as well as the value make
      sure BDB malloc's the returned key.  */
@@ -254,12 +256,12 @@ svn_fs_bdb__locks_get(svn_fs_t *fs,
   db_err = svn_bdb_dbc_get(cursor, &key, svn_fs_base__result_dbt(&value),
                            DB_SET_RANGE);
 
-  /* As long as the prefix of the returned KEY matches LOOKUP_PATH we
-     know it is either LOOKUP_PATH or a decendant thereof.  */
   if (!svn_fspath__is_root(path, strlen(path)))
     lookup_path = apr_pstrcat(pool, path, "/", (char *)NULL);
   lookup_len = strlen(lookup_path);
 
+  /* As long as the prefix of the returned KEY matches LOOKUP_PATH we
+     know it is either LOOKUP_PATH or a decendant thereof.  */
   while ((! db_err)
          && lookup_len < key.size
          && strncmp(lookup_path, key.data, lookup_len) == 0)
@@ -282,7 +284,7 @@ svn_fs_bdb__locks_get(svn_fs_t *fs,
              same set of results.  So just see if CHILD_PATH is an
              immediate child of PATH.  If not, we don't care about
              this item.   */
-          const char *rel_path = svn_fspath__is_child(path, child_path, subpool);
+          const char *rel_path = svn_fspath__skip_ancestor(path, child_path);
           if (!rel_path || (svn_path_component_count(rel_path) != 1))
             goto loop_it;
         }
@@ -316,9 +318,10 @@ svn_fs_bdb__locks_get(svn_fs_t *fs,
   db_c_err = svn_bdb_dbc_close(cursor);
 
   if (db_err && (db_err != DB_NOTFOUND))
-    SVN_ERR(BDB_WRAP(fs, "fetching lock tokens", db_err));
+    SVN_ERR(BDB_WRAP(fs, N_("fetching lock tokens"), db_err));
   if (db_c_err)
-    SVN_ERR(BDB_WRAP(fs, "fetching lock tokens (closing cursor)", db_c_err));
+    SVN_ERR(BDB_WRAP(fs, N_("fetching lock tokens (closing cursor)"),
+                     db_c_err));
 
   return SVN_NO_ERROR;
 }
diff --git a/subversion/libsvn_fs_base/bdb/miscellaneous-table.c b/subversion/libsvn_fs_base/bdb/miscellaneous-table.c
index c1baedd..21a05ca 100644
--- a/subversion/libsvn_fs_base/bdb/miscellaneous-table.c
+++ b/subversion/libsvn_fs_base/bdb/miscellaneous-table.c
@@ -92,7 +92,7 @@ svn_fs_bdb__miscellaneous_set(svn_fs_t *fs,
   if (val == NULL)
     {
       svn_fs_base__trail_debug(trail, "miscellaneous", "del");
-      return BDB_WRAP(fs, "deleting record from 'miscellaneous' table",
+      return BDB_WRAP(fs, N_("deleting record from 'miscellaneous' table"),
                       bfd->miscellaneous->del(bfd->miscellaneous,
                                               trail->db_txn, &key, 0));
     }
@@ -100,7 +100,7 @@ svn_fs_bdb__miscellaneous_set(svn_fs_t *fs,
     {
       svn_fs_base__str_to_dbt(&value, val);
       svn_fs_base__trail_debug(trail, "miscellaneous", "add");
-      return BDB_WRAP(fs, "storing miscellaneous record",
+      return BDB_WRAP(fs, N_("storing miscellaneous record"),
                       bfd->miscellaneous->put(bfd->miscellaneous,
                                               trail->db_txn,
                                               &key, &value, 0));
@@ -128,7 +128,7 @@ svn_fs_bdb__miscellaneous_get(const char **val,
 
   if (db_err != DB_NOTFOUND)
     {
-      SVN_ERR(BDB_WRAP(fs, "fetching miscellaneous record", db_err));
+      SVN_ERR(BDB_WRAP(fs, N_("fetching miscellaneous record"), db_err));
       *val = apr_pstrmemdup(pool, value.data, value.size);
     }
   return SVN_NO_ERROR;
diff --git a/subversion/libsvn_fs_base/bdb/node-origins-table.c b/subversion/libsvn_fs_base/bdb/node-origins-table.c
index 4715dd2..48dc43b 100644
--- a/subversion/libsvn_fs_base/bdb/node-origins-table.c
+++ b/subversion/libsvn_fs_base/bdb/node-origins-table.c
@@ -124,7 +124,7 @@ svn_error_t *svn_fs_bdb__set_node_origin(svn_fs_t *fs,
   /* Create a value from our ORIGIN_ID, and add this record to the table. */
   svn_fs_base__id_to_dbt(&value, origin_id, pool);
   svn_fs_base__trail_debug(trail, "node-origins", "put");
-  return BDB_WRAP(fs, _("storing node-origins record"),
+  return BDB_WRAP(fs, N_("storing node-origins record"),
                   bfd->node_origins->put(bfd->node_origins, trail->db_txn,
                                          &key, &value, 0));
 }
@@ -139,7 +139,7 @@ svn_error_t *svn_fs_bdb__delete_node_origin(svn_fs_t *fs,
 
   svn_fs_base__str_to_dbt(&key, node_id);
   svn_fs_base__trail_debug(trail, "node-origins", "del");
-  return BDB_WRAP(fs, "deleting entry from 'node-origins' table",
+  return BDB_WRAP(fs, N_("deleting entry from 'node-origins' table"),
                   bfd->node_origins->del(bfd->node_origins,
                                          trail->db_txn, &key, 0));
 }
diff --git a/subversion/libsvn_fs_base/bdb/nodes-table.c b/subversion/libsvn_fs_base/bdb/nodes-table.c
index ba84964..d0f475f 100644
--- a/subversion/libsvn_fs_base/bdb/nodes-table.c
+++ b/subversion/libsvn_fs_base/bdb/nodes-table.c
@@ -99,7 +99,7 @@ svn_fs_bdb__new_node_id(svn_fs_id_t **id_p,
   /* Get the current value associated with the `next-key' key in the table.  */
   svn_fs_base__str_to_dbt(&query, NEXT_KEY_KEY);
   svn_fs_base__trail_debug(trail, "nodes", "get");
-  SVN_ERR(BDB_WRAP(fs, _("allocating new node ID (getting 'next-key')"),
+  SVN_ERR(BDB_WRAP(fs, N_("allocating new node ID (getting 'next-key')"),
                    bfd->nodes->get(bfd->nodes, trail->db_txn,
                                    &query,
                                    svn_fs_base__result_dbt(&result),
@@ -117,7 +117,7 @@ svn_fs_bdb__new_node_id(svn_fs_id_t **id_p,
                            svn_fs_base__str_to_dbt(&query, NEXT_KEY_KEY),
                            svn_fs_base__str_to_dbt(&result, next_key),
                            0);
-  SVN_ERR(BDB_WRAP(fs, _("bumping next node ID key"), db_err));
+  SVN_ERR(BDB_WRAP(fs, N_("bumping next node ID key"), db_err));
 
   /* Create and return the new node id. */
   *id_p = svn_fs_base__id_create(next_node_id, copy_id, txn_id, pool);
@@ -179,7 +179,7 @@ svn_fs_bdb__delete_nodes_entry(svn_fs_t *fs,
   DBT key;
 
   svn_fs_base__trail_debug(trail, "nodes", "del");
-  return BDB_WRAP(fs, _("deleting entry from 'nodes' table"),
+  return BDB_WRAP(fs, N_("deleting entry from 'nodes' table"),
                   bfd->nodes->del(bfd->nodes,
                                   trail->db_txn,
                                   svn_fs_base__id_to_dbt(&key, id, pool),
@@ -217,7 +217,7 @@ svn_fs_bdb__get_node_revision(node_revision_t **noderev_p,
     return svn_fs_base__err_dangling_id(fs, id);
 
   /* Handle any other error conditions.  */
-  SVN_ERR(BDB_WRAP(fs, _("reading node revision"), db_err));
+  SVN_ERR(BDB_WRAP(fs, N_("reading node revision"), db_err));
 
   /* If our caller doesn't really care about the return value here,
      just return successfully. */
@@ -250,7 +250,7 @@ svn_fs_bdb__put_node_revision(svn_fs_t *fs,
   SVN_ERR(svn_fs_base__unparse_node_revision_skel(&skel, noderev,
                                                   bfd->format, pool));
   svn_fs_base__trail_debug(trail, "nodes", "put");
-  return BDB_WRAP(fs, _("storing node revision"),
+  return BDB_WRAP(fs, N_("storing node revision"),
                   bfd->nodes->put(bfd->nodes, db_txn,
                                   svn_fs_base__id_to_dbt(&key, id, pool),
                                   svn_fs_base__skel_to_dbt(&value, skel,
diff --git a/subversion/libsvn_fs_base/bdb/reps-table.c b/subversion/libsvn_fs_base/bdb/reps-table.c
index 1e83d2a..1c8ea6d 100644
--- a/subversion/libsvn_fs_base/bdb/reps-table.c
+++ b/subversion/libsvn_fs_base/bdb/reps-table.c
@@ -98,7 +98,7 @@ svn_fs_bdb__read_rep(representation_t **rep_p,
        _("No such representation '%s'"), key);
 
   /* Handle any other error conditions.  */
-  SVN_ERR(BDB_WRAP(fs, _("reading representation"), db_err));
+  SVN_ERR(BDB_WRAP(fs, N_("reading representation"), db_err));
 
   /* Parse the REPRESENTATION skel.  */
   skel = svn_skel__parse(result.data, result.size, pool);
@@ -125,7 +125,7 @@ svn_fs_bdb__write_rep(svn_fs_t *fs,
 
   /* Now write the record. */
   svn_fs_base__trail_debug(trail, "representations", "put");
-  return BDB_WRAP(fs, _("storing representation"),
+  return BDB_WRAP(fs, N_("storing representation"),
                   bfd->representations->put
                   (bfd->representations, trail->db_txn,
                    svn_fs_base__str_to_dbt(&query, key),
@@ -153,7 +153,7 @@ svn_fs_bdb__write_new_rep(const char **key,
   /* Get the current value associated with `next-key'.  */
   svn_fs_base__str_to_dbt(&query, NEXT_KEY_KEY);
   svn_fs_base__trail_debug(trail, "representations", "get");
-  SVN_ERR(BDB_WRAP(fs, _("allocating new representation (getting next-key)"),
+  SVN_ERR(BDB_WRAP(fs, N_("allocating new representation (getting next-key)"),
                    bfd->representations->get
                    (bfd->representations, trail->db_txn, &query,
                     svn_fs_base__result_dbt(&result), 0)));
@@ -174,7 +174,7 @@ svn_fs_bdb__write_new_rep(const char **key,
      svn_fs_base__str_to_dbt(&result, next_key),
      0);
 
-  return BDB_WRAP(fs, _("bumping next representation key"), db_err);
+  return BDB_WRAP(fs, N_("bumping next representation key"), db_err);
 }
 
 
@@ -200,5 +200,5 @@ svn_fs_bdb__delete_rep(svn_fs_t *fs,
        _("No such representation '%s'"), key);
 
   /* Handle any other error conditions.  */
-  return BDB_WRAP(fs, _("deleting representation"), db_err);
+  return BDB_WRAP(fs, N_("deleting representation"), db_err);
 }
diff --git a/subversion/libsvn_fs_base/bdb/rev-table.c b/subversion/libsvn_fs_base/bdb/rev-table.c
index 69e7446..b752249 100644
--- a/subversion/libsvn_fs_base/bdb/rev-table.c
+++ b/subversion/libsvn_fs_base/bdb/rev-table.c
@@ -92,7 +92,7 @@ svn_fs_bdb__get_rev(revision_t **revision_p,
     return svn_fs_base__err_dangling_rev(fs, rev);
 
   /* Handle any other error conditions.  */
-  SVN_ERR(BDB_WRAP(fs, _("reading filesystem revision"), db_err));
+  SVN_ERR(BDB_WRAP(fs, N_("reading filesystem revision"), db_err));
 
   /* Parse REVISION skel.  */
   skel = svn_skel__parse(value.data, value.size, pool);
@@ -138,7 +138,7 @@ svn_fs_bdb__put_rev(svn_revnum_t *rev,
         (bfd->revisions, trail->db_txn,
          svn_fs_base__set_dbt(&query, &recno, sizeof(recno)),
          svn_fs_base__skel_to_dbt(&result, skel, pool), 0);
-      return BDB_WRAP(fs, "updating filesystem revision", db_err);
+      return BDB_WRAP(fs, N_("updating filesystem revision"), db_err);
     }
 
   svn_fs_base__trail_debug(trail, "revisions", "put");
@@ -146,7 +146,7 @@ svn_fs_bdb__put_rev(svn_revnum_t *rev,
                                svn_fs_base__recno_dbt(&key, &recno),
                                svn_fs_base__skel_to_dbt(&value, skel, pool),
                                DB_APPEND);
-  SVN_ERR(BDB_WRAP(fs, "storing filesystem revision", db_err));
+  SVN_ERR(BDB_WRAP(fs, N_("storing filesystem revision"), db_err));
 
   /* Turn the record number into a Subversion revision number.
      Revisions are numbered starting with zero; Berkeley DB record
@@ -176,7 +176,7 @@ svn_fs_bdb__youngest_rev(svn_revnum_t *youngest_p,
 
   /* Create a database cursor.  */
   svn_fs_base__trail_debug(trail, "revisions", "cursor");
-  SVN_ERR(BDB_WRAP(fs, "getting youngest revision (creating cursor)",
+  SVN_ERR(BDB_WRAP(fs, N_("getting youngest revision (creating cursor)"),
                    bfd->revisions->cursor(bfd->revisions, trail->db_txn,
                                           &cursor, 0)));
 
@@ -200,7 +200,7 @@ svn_fs_bdb__youngest_rev(svn_revnum_t *youngest_p,
            "Corrupt DB: revision 0 missing from 'revisions' table, in "
            "filesystem '%s'", fs->path);
 
-      SVN_ERR(BDB_WRAP(fs, "getting youngest revision (finding last entry)",
+      SVN_ERR(BDB_WRAP(fs, N_("getting youngest revision (finding last entry)"),
                        db_err));
     }
 
@@ -210,7 +210,7 @@ svn_fs_bdb__youngest_rev(svn_revnum_t *youngest_p,
      reasons, and txn_commit shouldn't fail that way, and
      2) using a cursor after committing its transaction can cause
      undetectable database corruption.  */
-  SVN_ERR(BDB_WRAP(fs, "getting youngest revision (closing cursor)",
+  SVN_ERR(BDB_WRAP(fs, N_("getting youngest revision (closing cursor)"),
                    svn_bdb_dbc_close(cursor)));
 
   /* Turn the record number into a Subversion revision number.
diff --git a/subversion/libsvn_fs_base/bdb/strings-table.c b/subversion/libsvn_fs_base/bdb/strings-table.c
index 032d789..f5348e7 100644
--- a/subversion/libsvn_fs_base/bdb/strings-table.c
+++ b/subversion/libsvn_fs_base/bdb/strings-table.c
@@ -91,7 +91,7 @@ locate_key(apr_size_t *length,
   DBT result;
 
   svn_fs_base__trail_debug(trail, "strings", "cursor");
-  SVN_ERR(BDB_WRAP(fs, _("creating cursor for reading a string"),
+  SVN_ERR(BDB_WRAP(fs, N_("creating cursor for reading a string"),
                    bfd->strings->cursor(bfd->strings, trail->db_txn,
                                         cursor, 0)));
 
@@ -121,7 +121,7 @@ locate_key(apr_size_t *length,
       if (db_err != SVN_BDB_DB_BUFFER_SMALL)
         {
           svn_bdb_dbc_close(*cursor);
-          return BDB_WRAP(fs, "moving cursor", db_err);
+          return BDB_WRAP(fs, N_("moving cursor"), db_err);
         }
 
       /* We got an SVN_BDB_DB_BUFFER_SMALL (typical since we have a
@@ -133,7 +133,7 @@ locate_key(apr_size_t *length,
       if (db_err)
         {
           svn_bdb_dbc_close(*cursor);
-          return BDB_WRAP(fs, "rerunning cursor move", db_err);
+          return BDB_WRAP(fs, N_("rerunning cursor move"), db_err);
         }
     }
 
@@ -225,7 +225,7 @@ svn_fs_bdb__string_read(svn_fs_t *fs,
           return SVN_NO_ERROR;
         }
       if (db_err)
-        return BDB_WRAP(fs, "reading string", db_err);
+        return BDB_WRAP(fs, N_("reading string"), db_err);
     }
 
   /* The current record contains OFFSET. Fetch the contents now. Note that
@@ -244,14 +244,14 @@ svn_fs_bdb__string_read(svn_fs_t *fs,
       if (db_err)
         {
           svn_bdb_dbc_close(cursor);
-          return BDB_WRAP(fs, "reading string", db_err);
+          return BDB_WRAP(fs, N_("reading string"), db_err);
         }
 
       bytes_read += result.size;
       if (bytes_read == *len)
         {
           /* Done with the cursor. */
-          SVN_ERR(BDB_WRAP(fs, "closing string-reading cursor",
+          SVN_ERR(BDB_WRAP(fs, N_("closing string-reading cursor"),
                            svn_bdb_dbc_close(cursor)));
           break;
         }
@@ -262,7 +262,7 @@ svn_fs_bdb__string_read(svn_fs_t *fs,
       if (db_err == DB_NOTFOUND)
         break;
       if (db_err)
-        return BDB_WRAP(fs, "reading string", db_err);
+        return BDB_WRAP(fs, N_("reading string"), db_err);
 
       /* We'll be reading from the beginning of the next record */
       offset = 0;
@@ -297,7 +297,7 @@ get_key_and_bump(svn_fs_t *fs,
      write the new value -- that would append, not overwrite.  */
 
   svn_fs_base__trail_debug(trail, "strings", "cursor");
-  SVN_ERR(BDB_WRAP(fs, "creating cursor for reading a string",
+  SVN_ERR(BDB_WRAP(fs, N_("creating cursor for reading a string"),
                    bfd->strings->cursor(bfd->strings, trail->db_txn,
                                         &cursor, 0)));
 
@@ -310,7 +310,7 @@ get_key_and_bump(svn_fs_t *fs,
   if (db_err)
     {
       svn_bdb_dbc_close(cursor);
-      return BDB_WRAP(fs, "getting next-key value", db_err);
+      return BDB_WRAP(fs, N_("getting next-key value"), db_err);
     }
 
   svn_fs_base__track_dbt(&result, pool);
@@ -328,10 +328,10 @@ get_key_and_bump(svn_fs_t *fs,
     {
       svn_bdb_dbc_close(cursor); /* ignore the error, the original is
                                     more important. */
-      return BDB_WRAP(fs, "bumping next string key", db_err);
+      return BDB_WRAP(fs, N_("bumping next string key"), db_err);
     }
 
-  return BDB_WRAP(fs, "closing string-reading cursor",
+  return BDB_WRAP(fs, N_("closing string-reading cursor"),
                   svn_bdb_dbc_close(cursor));
 }
 
@@ -355,7 +355,7 @@ svn_fs_bdb__string_append(svn_fs_t *fs,
 
   /* Store a new record into the database. */
   svn_fs_base__trail_debug(trail, "strings", "put");
-  return BDB_WRAP(fs, "appending string",
+  return BDB_WRAP(fs, N_("appending string"),
                   bfd->strings->put
                   (bfd->strings, trail->db_txn,
                    svn_fs_base__str_to_dbt(&query, *key),
@@ -387,7 +387,7 @@ svn_fs_bdb__string_clear(svn_fs_t *fs,
        "No such string '%s'", key);
 
   /* Handle any other error conditions.  */
-  SVN_ERR(BDB_WRAP(fs, "clearing string", db_err));
+  SVN_ERR(BDB_WRAP(fs, N_("clearing string"), db_err));
 
   /* Shove empty data back in for this key. */
   svn_fs_base__clear_dbt(&result);
@@ -396,7 +396,7 @@ svn_fs_bdb__string_clear(svn_fs_t *fs,
   result.flags |= DB_DBT_USERMEM;
 
   svn_fs_base__trail_debug(trail, "strings", "put");
-  return BDB_WRAP(fs, "storing empty contents",
+  return BDB_WRAP(fs, N_("storing empty contents"),
                   bfd->strings->put(bfd->strings, trail->db_txn,
                                     &query, &result, 0));
 }
@@ -433,7 +433,7 @@ svn_fs_bdb__string_size(svn_filesize_t *size,
           return SVN_NO_ERROR;
         }
       if (db_err)
-        return BDB_WRAP(fs, "fetching string length", db_err);
+        return BDB_WRAP(fs, N_("fetching string length"), db_err);
 
       total += length;
     }
@@ -463,7 +463,7 @@ svn_fs_bdb__string_delete(svn_fs_t *fs,
        "No such string '%s'", key);
 
   /* Handle any other error conditions.  */
-  return BDB_WRAP(fs, "deleting string", db_err);
+  return BDB_WRAP(fs, N_("deleting string"), db_err);
 }
 
 
@@ -488,7 +488,7 @@ svn_fs_bdb__string_copy(svn_fs_t *fs,
   SVN_ERR(get_key_and_bump(fs, new_key, trail, pool));
 
   svn_fs_base__trail_debug(trail, "strings", "cursor");
-  SVN_ERR(BDB_WRAP(fs, "creating cursor for reading a string",
+  SVN_ERR(BDB_WRAP(fs, N_("creating cursor for reading a string"),
                    bfd->strings->cursor(bfd->strings, trail->db_txn,
                                         &cursor, 0)));
 
@@ -502,7 +502,7 @@ svn_fs_bdb__string_copy(svn_fs_t *fs,
   if (db_err)
     {
       svn_bdb_dbc_close(cursor);
-      return BDB_WRAP(fs, "getting next-key value", db_err);
+      return BDB_WRAP(fs, N_("getting next-key value"), db_err);
     }
 
   while (1)
@@ -521,7 +521,7 @@ svn_fs_bdb__string_copy(svn_fs_t *fs,
       if (db_err)
         {
           svn_bdb_dbc_close(cursor);
-          return BDB_WRAP(fs, "writing copied data", db_err);
+          return BDB_WRAP(fs, N_("writing copied data"), db_err);
         }
 
       /* Read the next chunk. Terminate loop if we're done. */
@@ -532,10 +532,10 @@ svn_fs_bdb__string_copy(svn_fs_t *fs,
       if (db_err)
         {
           svn_bdb_dbc_close(cursor);
-          return BDB_WRAP(fs, "fetching string data for a copy", db_err);
+          return BDB_WRAP(fs, N_("fetching string data for a copy"), db_err);
         }
     }
 
-  return BDB_WRAP(fs, "closing string-reading cursor",
+  return BDB_WRAP(fs, N_("closing string-reading cursor"),
                   svn_bdb_dbc_close(cursor));
 }
diff --git a/subversion/libsvn_fs_base/bdb/txn-table.c b/subversion/libsvn_fs_base/bdb/txn-table.c
index e19e89a..54a0e28 100644
--- a/subversion/libsvn_fs_base/bdb/txn-table.c
+++ b/subversion/libsvn_fs_base/bdb/txn-table.c
@@ -96,7 +96,7 @@ svn_fs_bdb__put_txn(svn_fs_t *fs,
   svn_fs_base__str_to_dbt(&key, txn_name);
   svn_fs_base__skel_to_dbt(&value, txn_skel, pool);
   svn_fs_base__trail_debug(trail, "transactions", "put");
-  return BDB_WRAP(fs, _("storing transaction record"),
+  return BDB_WRAP(fs, N_("storing transaction record"),
                   bfd->transactions->put(bfd->transactions, trail->db_txn,
                                          &key, &value, 0));
 }
@@ -120,7 +120,7 @@ allocate_txn_id(const char **id_p,
 
   /* Get the current value associated with the `next-key' key in the table.  */
   svn_fs_base__trail_debug(trail, "transactions", "get");
-  SVN_ERR(BDB_WRAP(fs, "allocating new transaction ID (getting 'next-key')",
+  SVN_ERR(BDB_WRAP(fs, N_("allocating new transaction ID (getting 'next-key')"),
                    bfd->transactions->get(bfd->transactions, trail->db_txn,
                                           &query,
                                           svn_fs_base__result_dbt(&result),
@@ -139,7 +139,7 @@ allocate_txn_id(const char **id_p,
   db_err = bfd->transactions->put(bfd->transactions, trail->db_txn,
                                   &query, &result, 0);
 
-  return BDB_WRAP(fs, "bumping next transaction key", db_err);
+  return BDB_WRAP(fs, N_("bumping next transaction key"), db_err);
 }
 
 
@@ -185,7 +185,7 @@ svn_fs_bdb__delete_txn(svn_fs_t *fs,
   /* Delete the transaction from the `transactions' table. */
   svn_fs_base__str_to_dbt(&key, txn_name);
   svn_fs_base__trail_debug(trail, "transactions", "del");
-  return BDB_WRAP(fs, "deleting entry from 'transactions' table",
+  return BDB_WRAP(fs, N_("deleting entry from 'transactions' table"),
                   bfd->transactions->del(bfd->transactions,
                                          trail->db_txn, &key, 0));
 }
@@ -215,7 +215,7 @@ svn_fs_bdb__get_txn(transaction_t **txn_p,
 
   if (db_err == DB_NOTFOUND)
     return svn_fs_base__err_no_such_txn(fs, txn_name);
-  SVN_ERR(BDB_WRAP(fs, "reading transaction", db_err));
+  SVN_ERR(BDB_WRAP(fs, N_("reading transaction"), db_err));
 
   /* Parse TRANSACTION skel */
   skel = svn_skel__parse(value.data, value.size, pool);
@@ -248,7 +248,7 @@ svn_fs_bdb__get_txn_list(apr_array_header_t **names_p,
 
   /* Create a database cursor to list the transaction names. */
   svn_fs_base__trail_debug(trail, "transactions", "cursor");
-  SVN_ERR(BDB_WRAP(fs, "reading transaction list (opening cursor)",
+  SVN_ERR(BDB_WRAP(fs, N_("reading transaction list (opening cursor)"),
                    bfd->transactions->cursor(bfd->transactions,
                                              trail->db_txn, &cursor, 0)));
 
@@ -311,10 +311,10 @@ svn_fs_bdb__get_txn_list(apr_array_header_t **names_p,
   db_c_err = svn_bdb_dbc_close(cursor);
   if (db_err != DB_NOTFOUND)
     {
-      SVN_ERR(BDB_WRAP(fs, "reading transaction list (listing keys)",
+      SVN_ERR(BDB_WRAP(fs, N_("reading transaction list (listing keys)"),
                        db_err));
     }
-  SVN_ERR(BDB_WRAP(fs, "reading transaction list (closing cursor)",
+  SVN_ERR(BDB_WRAP(fs, N_("reading transaction list (closing cursor)"),
                    db_c_err));
 
   /* Destroy the per-iteration subpool */
diff --git a/subversion/libsvn_fs_base/bdb/uuids-table.c b/subversion/libsvn_fs_base/bdb/uuids-table.c
index ecc967b..0481894 100644
--- a/subversion/libsvn_fs_base/bdb/uuids-table.c
+++ b/subversion/libsvn_fs_base/bdb/uuids-table.c
@@ -116,7 +116,7 @@ svn_error_t *svn_fs_bdb__get_uuid(svn_fs_t *fs,
   value.flags |= DB_DBT_USERMEM;
 
   svn_fs_base__trail_debug(trail, "uuids", "get");
-  SVN_ERR(BDB_WRAP(fs, _("get repository uuid"),
+  SVN_ERR(BDB_WRAP(fs, N_("get repository uuid"),
                    uuids->get(uuids, trail->db_txn, &key, &value, 0)));
 
   *uuid = apr_pstrmemdup(pool, value.data, value.size);
@@ -144,6 +144,6 @@ svn_error_t *svn_fs_bdb__set_uuid(svn_fs_t *fs,
   value.data = apr_pstrmemdup(pool, uuid, value.size + 1);
 
   svn_fs_base__trail_debug(trail, "uuids", "put");
-  return BDB_WRAP(fs, _("set repository uuid"),
+  return BDB_WRAP(fs, N_("set repository uuid"),
                   uuids->put(uuids, trail->db_txn, &key, &value, 0));
 }