1 /* revs-txns.c : operations on revision and transactions
3 * ====================================================================
4 * Licensed to the Apache Software Foundation (ASF) under one
5 * or more contributor license agreements. See the NOTICE file
6 * distributed with this work for additional information
7 * regarding copyright ownership. The ASF licenses this file
8 * to you under the Apache License, Version 2.0 (the
9 * "License"); you may not use this file except in compliance
10 * with the License. You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing,
15 * software distributed under the License is distributed on an
16 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17 * KIND, either express or implied. See the License for the
18 * specific language governing permissions and limitations
20 * ====================================================================
25 #include <apr_tables.h>
26 #include <apr_pools.h>
28 #include "svn_pools.h"
31 #include "svn_props.h"
40 #include "revs-txns.h"
43 #include "bdb/rev-table.h"
44 #include "bdb/txn-table.h"
45 #include "bdb/copies-table.h"
46 #include "bdb/changes-table.h"
47 #include "../libsvn_fs/fs-loader.h"
49 #include "svn_private_config.h"
50 #include "private/svn_fs_util.h"
55 /* Set *txn_p to a transaction object allocated in POOL for the
56 transaction in FS whose id is TXN_ID. If EXPECT_DEAD is set, this
57 transaction must be a dead one, else an error is returned. If
58 EXPECT_DEAD is not set, the transaction must *not* be a dead one,
59 else an error is returned. */
61 get_txn(transaction_t **txn_p,
64 svn_boolean_t expect_dead,
69 SVN_ERR(svn_fs_bdb__get_txn(&txn, fs, txn_id, trail, pool));
70 if (expect_dead && (txn->kind != transaction_kind_dead))
71 return svn_error_createf(SVN_ERR_FS_TRANSACTION_NOT_DEAD, 0,
72 _("Transaction is not dead: '%s'"), txn_id);
73 if ((! expect_dead) && (txn->kind == transaction_kind_dead))
74 return svn_error_createf(SVN_ERR_FS_TRANSACTION_DEAD, 0,
75 _("Transaction is dead: '%s'"), txn_id);
81 /* This is only for symmetry with the get_txn() helper. */
82 #define put_txn svn_fs_bdb__put_txn
88 /* Return the committed transaction record *TXN_P and its ID *TXN_ID
89 (as long as those parameters aren't NULL) for the revision REV in
90 FS as part of TRAIL. */
92 get_rev_txn(transaction_t **txn_p,
102 SVN_ERR(svn_fs_bdb__get_rev(&revision, fs, rev, trail, pool));
103 if (revision->txn_id == NULL)
104 return svn_fs_base__err_corrupt_fs_revision(fs, rev);
106 SVN_ERR(get_txn(&txn, fs, revision->txn_id, FALSE, trail, pool));
107 if (txn->revision != rev)
108 return svn_fs_base__err_corrupt_txn(fs, revision->txn_id);
113 *txn_id = revision->txn_id;
119 svn_fs_base__rev_get_root(const svn_fs_id_t **root_id_p,
127 SVN_ERR(get_rev_txn(&txn, NULL, fs, rev, trail, pool));
128 if (txn->root_id == NULL)
129 return svn_fs_base__err_corrupt_fs_revision(fs, rev);
131 *root_id_p = txn->root_id;
137 svn_fs_base__rev_get_txn_id(const char **txn_id_p,
143 revision_t *revision;
145 SVN_ERR(svn_fs_bdb__get_rev(&revision, fs, rev, trail, pool));
146 if (revision->txn_id == NULL)
147 return svn_fs_base__err_corrupt_fs_revision(fs, rev);
149 *txn_id_p = revision->txn_id;
155 txn_body_youngest_rev(void *baton, trail_t *trail)
157 return svn_fs_bdb__youngest_rev(baton, trail->fs, trail, trail->pool);
162 svn_fs_base__youngest_rev(svn_revnum_t *youngest_p,
166 svn_revnum_t youngest;
167 SVN_ERR(svn_fs__check_fs(fs, TRUE));
168 SVN_ERR(svn_fs_base__retry_txn(fs, txn_body_youngest_rev, &youngest,
170 *youngest_p = youngest;
175 struct revision_proplist_args {
176 apr_hash_t **table_p;
182 txn_body_revision_proplist(void *baton, trail_t *trail)
184 struct revision_proplist_args *args = baton;
187 SVN_ERR(get_rev_txn(&txn, NULL, trail->fs, args->rev, trail, trail->pool));
188 *(args->table_p) = txn->proplist;
194 svn_fs_base__revision_proplist(apr_hash_t **table_p,
199 struct revision_proplist_args args;
202 SVN_ERR(svn_fs__check_fs(fs, TRUE));
204 args.table_p = &table;
206 SVN_ERR(svn_fs_base__retry_txn(fs, txn_body_revision_proplist, &args,
209 *table_p = table ? table : apr_hash_make(pool);
215 svn_fs_base__revision_prop(svn_string_t **value_p,
218 const char *propname,
221 struct revision_proplist_args args;
224 SVN_ERR(svn_fs__check_fs(fs, TRUE));
226 /* Get the proplist. */
227 args.table_p = &table;
229 SVN_ERR(svn_fs_base__retry_txn(fs, txn_body_revision_proplist, &args,
232 /* And then the prop from that list (if there was a list). */
233 *value_p = svn_hash_gets(table, propname);
240 svn_fs_base__set_rev_prop(svn_fs_t *fs,
243 const svn_string_t *const *old_value_p,
244 const svn_string_t *value,
251 SVN_ERR(get_rev_txn(&txn, &txn_id, fs, rev, trail, pool));
253 /* If there's no proplist, but we're just deleting a property, exit now. */
254 if ((! txn->proplist) && (! value))
257 /* Now, if there's no proplist, we know we need to make one. */
259 txn->proplist = apr_hash_make(pool);
261 /* Set the property. */
264 const svn_string_t *wanted_value = *old_value_p;
265 const svn_string_t *present_value = svn_hash_gets(txn->proplist, name);
266 if ((!wanted_value != !present_value)
267 || (wanted_value && present_value
268 && !svn_string_compare(wanted_value, present_value)))
270 /* What we expected isn't what we found. */
271 return svn_error_createf(SVN_ERR_FS_PROP_BASEVALUE_MISMATCH, NULL,
272 _("revprop '%s' has unexpected value in "
278 svn_hash_sets(txn->proplist, name, value);
280 /* Overwrite the revision. */
281 return put_txn(fs, txn, txn_id, trail, pool);
285 struct change_rev_prop_args {
288 const svn_string_t *const *old_value_p;
289 const svn_string_t *value;
294 txn_body_change_rev_prop(void *baton, trail_t *trail)
296 struct change_rev_prop_args *args = baton;
298 return svn_fs_base__set_rev_prop(trail->fs, args->rev,
299 args->name, args->old_value_p, args->value,
305 svn_fs_base__change_rev_prop(svn_fs_t *fs,
308 const svn_string_t *const *old_value_p,
309 const svn_string_t *value,
312 struct change_rev_prop_args args;
314 SVN_ERR(svn_fs__check_fs(fs, TRUE));
318 args.old_value_p = old_value_p;
320 return svn_fs_base__retry_txn(fs, txn_body_change_rev_prop, &args,
326 /*** Transactions ***/
329 svn_fs_base__txn_make_committed(svn_fs_t *fs,
330 const char *txn_name,
331 svn_revnum_t revision,
337 SVN_ERR_ASSERT(SVN_IS_VALID_REVNUM(revision));
339 /* Make sure the TXN is not committed already. */
340 SVN_ERR(get_txn(&txn, fs, txn_name, FALSE, trail, pool));
341 if (txn->kind != transaction_kind_normal)
342 return svn_fs_base__err_txn_not_mutable(fs, txn_name);
344 /* Convert TXN to a committed transaction. */
346 txn->revision = revision;
347 txn->kind = transaction_kind_committed;
348 return put_txn(fs, txn, txn_name, trail, pool);
353 svn_fs_base__txn_get_revision(svn_revnum_t *revision,
355 const char *txn_name,
360 SVN_ERR(get_txn(&txn, fs, txn_name, FALSE, trail, pool));
361 *revision = txn->revision;
367 svn_fs_base__get_txn_ids(const svn_fs_id_t **root_id_p,
368 const svn_fs_id_t **base_root_id_p,
370 const char *txn_name,
376 SVN_ERR(get_txn(&txn, fs, txn_name, FALSE, trail, pool));
377 if (txn->kind != transaction_kind_normal)
378 return svn_fs_base__err_txn_not_mutable(fs, txn_name);
380 *root_id_p = txn->root_id;
381 *base_root_id_p = txn->base_id;
387 svn_fs_base__set_txn_root(svn_fs_t *fs,
388 const char *txn_name,
389 const svn_fs_id_t *new_id,
395 SVN_ERR(get_txn(&txn, fs, txn_name, FALSE, trail, pool));
396 if (txn->kind != transaction_kind_normal)
397 return svn_fs_base__err_txn_not_mutable(fs, txn_name);
399 if (! svn_fs_base__id_eq(txn->root_id, new_id))
401 txn->root_id = new_id;
402 SVN_ERR(put_txn(fs, txn, txn_name, trail, pool));
409 svn_fs_base__set_txn_base(svn_fs_t *fs,
410 const char *txn_name,
411 const svn_fs_id_t *new_id,
417 SVN_ERR(get_txn(&txn, fs, txn_name, FALSE, trail, pool));
418 if (txn->kind != transaction_kind_normal)
419 return svn_fs_base__err_txn_not_mutable(fs, txn_name);
421 if (! svn_fs_base__id_eq(txn->base_id, new_id))
423 txn->base_id = new_id;
424 SVN_ERR(put_txn(fs, txn, txn_name, trail, pool));
431 svn_fs_base__add_txn_copy(svn_fs_t *fs,
432 const char *txn_name,
439 /* Get the transaction and ensure its mutability. */
440 SVN_ERR(get_txn(&txn, fs, txn_name, FALSE, trail, pool));
441 if (txn->kind != transaction_kind_normal)
442 return svn_fs_base__err_txn_not_mutable(fs, txn_name);
444 /* Allocate a new array if this transaction has no copies. */
446 txn->copies = apr_array_make(pool, 1, sizeof(copy_id));
448 /* Add COPY_ID to the array. */
449 APR_ARRAY_PUSH(txn->copies, const char *) = copy_id;
451 /* Finally, write out the transaction. */
452 return put_txn(fs, txn, txn_name, trail, pool);
457 /* Generic transaction operations. */
459 struct txn_proplist_args {
460 apr_hash_t **table_p;
466 txn_body_txn_proplist(void *baton, trail_t *trail)
469 struct txn_proplist_args *args = baton;
471 SVN_ERR(get_txn(&txn, trail->fs, args->id, FALSE, trail, trail->pool));
472 if (txn->kind != transaction_kind_normal)
473 return svn_fs_base__err_txn_not_mutable(trail->fs, args->id);
475 *(args->table_p) = txn->proplist;
482 svn_fs_base__txn_proplist_in_trail(apr_hash_t **table_p,
486 struct txn_proplist_args args;
489 args.table_p = &table;
491 SVN_ERR(txn_body_txn_proplist(&args, trail));
493 *table_p = table ? table : apr_hash_make(trail->pool);
500 svn_fs_base__txn_proplist(apr_hash_t **table_p,
504 struct txn_proplist_args args;
506 svn_fs_t *fs = txn->fs;
508 SVN_ERR(svn_fs__check_fs(fs, TRUE));
510 args.table_p = &table;
512 SVN_ERR(svn_fs_base__retry_txn(fs, txn_body_txn_proplist, &args,
515 *table_p = table ? table : apr_hash_make(pool);
521 svn_fs_base__txn_prop(svn_string_t **value_p,
523 const char *propname,
526 struct txn_proplist_args args;
528 svn_fs_t *fs = txn->fs;
530 SVN_ERR(svn_fs__check_fs(fs, TRUE));
532 /* Get the proplist. */
533 args.table_p = &table;
535 SVN_ERR(svn_fs_base__retry_txn(fs, txn_body_txn_proplist, &args,
538 /* And then the prop from that list (if there was a list). */
539 *value_p = svn_hash_gets(table, propname);
546 struct change_txn_prop_args {
550 const svn_string_t *value;
555 svn_fs_base__set_txn_prop(svn_fs_t *fs,
556 const char *txn_name,
558 const svn_string_t *value,
564 SVN_ERR(get_txn(&txn, fs, txn_name, FALSE, trail, pool));
565 if (txn->kind != transaction_kind_normal)
566 return svn_fs_base__err_txn_not_mutable(fs, txn_name);
568 /* If there's no proplist, but we're just deleting a property, exit now. */
569 if ((! txn->proplist) && (! value))
572 /* Now, if there's no proplist, we know we need to make one. */
574 txn->proplist = apr_hash_make(pool);
576 /* Set the property. */
577 svn_hash_sets(txn->proplist, name, value);
579 /* Now overwrite the transaction. */
580 return put_txn(fs, txn, txn_name, trail, pool);
585 txn_body_change_txn_prop(void *baton, trail_t *trail)
587 struct change_txn_prop_args *args = baton;
588 return svn_fs_base__set_txn_prop(trail->fs, args->id, args->name,
589 args->value, trail, trail->pool);
594 svn_fs_base__change_txn_prop(svn_fs_txn_t *txn,
596 const svn_string_t *value,
599 struct change_txn_prop_args args;
600 svn_fs_t *fs = txn->fs;
602 SVN_ERR(svn_fs__check_fs(fs, TRUE));
607 return svn_fs_base__retry_txn(fs, txn_body_change_txn_prop, &args,
613 svn_fs_base__change_txn_props(svn_fs_txn_t *txn,
614 const apr_array_header_t *props,
617 apr_pool_t *iterpool = svn_pool_create(pool);
620 for (i = 0; i < props->nelts; i++)
622 svn_prop_t *prop = &APR_ARRAY_IDX(props, i, svn_prop_t);
624 svn_pool_clear(iterpool);
626 SVN_ERR(svn_fs_base__change_txn_prop(txn, prop->name,
627 prop->value, iterpool));
629 svn_pool_destroy(iterpool);
635 /* Creating a transaction */
637 static txn_vtable_t txn_vtable = {
638 svn_fs_base__commit_txn,
639 svn_fs_base__abort_txn,
640 svn_fs_base__txn_prop,
641 svn_fs_base__txn_proplist,
642 svn_fs_base__change_txn_prop,
643 svn_fs_base__txn_root,
644 svn_fs_base__change_txn_props
648 /* Allocate and return a new transaction object in POOL for FS whose
649 transaction ID is ID. ID is not copied. */
650 static svn_fs_txn_t *
651 make_txn(svn_fs_t *fs,
653 svn_revnum_t base_rev,
656 svn_fs_txn_t *txn = apr_pcalloc(pool, sizeof(*txn));
660 txn->base_rev = base_rev;
661 txn->vtable = &txn_vtable;
662 txn->fsap_data = NULL;
668 struct begin_txn_args
670 svn_fs_txn_t **txn_p;
671 svn_revnum_t base_rev;
677 txn_body_begin_txn(void *baton, trail_t *trail)
679 struct begin_txn_args *args = baton;
680 const svn_fs_id_t *root_id;
683 SVN_ERR(svn_fs_base__rev_get_root(&root_id, trail->fs, args->base_rev,
684 trail, trail->pool));
685 SVN_ERR(svn_fs_bdb__create_txn(&txn_id, trail->fs, root_id,
686 trail, trail->pool));
688 if (args->flags & SVN_FS_TXN_CHECK_OOD)
690 struct change_txn_prop_args cpargs;
691 cpargs.fs = trail->fs;
693 cpargs.name = SVN_FS__PROP_TXN_CHECK_OOD;
694 cpargs.value = svn_string_create("true", trail->pool);
696 SVN_ERR(txn_body_change_txn_prop(&cpargs, trail));
699 if (args->flags & SVN_FS_TXN_CHECK_LOCKS)
701 struct change_txn_prop_args cpargs;
702 cpargs.fs = trail->fs;
704 cpargs.name = SVN_FS__PROP_TXN_CHECK_LOCKS;
705 cpargs.value = svn_string_create("true", trail->pool);
707 SVN_ERR(txn_body_change_txn_prop(&cpargs, trail));
710 *args->txn_p = make_txn(trail->fs, txn_id, args->base_rev, trail->pool);
714 /* Note: it is acceptable for this function to call back into
715 public FS API interfaces because it does not itself use trails. */
717 svn_fs_base__begin_txn(svn_fs_txn_t **txn_p,
724 struct begin_txn_args args;
727 SVN_ERR(svn_fs__check_fs(fs, TRUE));
732 SVN_ERR(svn_fs_base__retry_txn(fs, txn_body_begin_txn, &args, FALSE, pool));
736 /* Put a datestamp on the newly created txn, so we always know
737 exactly how old it is. (This will help sysadmins identify
738 long-abandoned txns that may need to be manually removed.) When
739 a txn is promoted to a revision, this property will be
740 automatically overwritten with a revision datestamp. */
741 date.data = svn_time_to_cstring(apr_time_now(), pool);
742 date.len = strlen(date.data);
743 return svn_fs_base__change_txn_prop(txn, SVN_PROP_REVISION_DATE,
750 svn_fs_txn_t **txn_p;
756 txn_body_open_txn(void *baton, trail_t *trail)
758 struct open_txn_args *args = baton;
759 transaction_t *fstxn;
760 svn_revnum_t base_rev = SVN_INVALID_REVNUM;
763 SVN_ERR(get_txn(&fstxn, trail->fs, args->name, FALSE, trail, trail->pool));
764 if (fstxn->kind != transaction_kind_committed)
766 txn_id = svn_fs_base__id_txn_id(fstxn->base_id);
767 SVN_ERR(svn_fs_base__txn_get_revision(&base_rev, trail->fs, txn_id,
768 trail, trail->pool));
771 *args->txn_p = make_txn(trail->fs, args->name, base_rev, trail->pool);
777 svn_fs_base__open_txn(svn_fs_txn_t **txn_p,
783 struct open_txn_args args;
785 SVN_ERR(svn_fs__check_fs(fs, TRUE));
789 SVN_ERR(svn_fs_base__retry_txn(fs, txn_body_open_txn, &args, FALSE, pool));
796 struct cleanup_txn_args
798 transaction_t **txn_p;
804 txn_body_cleanup_txn(void *baton, trail_t *trail)
806 struct cleanup_txn_args *args = baton;
807 return get_txn(args->txn_p, trail->fs, args->name, TRUE,
813 txn_body_cleanup_txn_copy(void *baton, trail_t *trail)
815 const char *copy_id = *(const char **)baton;
816 svn_error_t *err = svn_fs_bdb__delete_copy(trail->fs, copy_id, trail,
819 /* Copy doesn't exist? No sweat. */
820 if (err && (err->apr_err == SVN_ERR_FS_NO_SUCH_COPY))
822 svn_error_clear(err);
825 return svn_error_trace(err);
830 txn_body_cleanup_txn_changes(void *baton, trail_t *trail)
832 const char *key = *(const char **)baton;
834 return svn_fs_bdb__changes_delete(trail->fs, key, trail, trail->pool);
838 struct get_dirents_args
840 apr_hash_t **dirents;
841 const svn_fs_id_t *id;
847 txn_body_get_dirents(void *baton, trail_t *trail)
849 struct get_dirents_args *args = baton;
853 SVN_ERR(svn_fs_base__dag_get_node(&node, trail->fs, args->id,
854 trail, trail->pool));
856 /* If immutable, do nothing and return. */
857 if (! svn_fs_base__dag_check_mutable(node, args->txn_id))
860 /* If a directory, do nothing and return. */
861 *(args->dirents) = NULL;
862 if (svn_fs_base__dag_node_kind(node) != svn_node_dir)
865 /* Else it's mutable. Get its dirents. */
866 return svn_fs_base__dag_dir_entries(args->dirents, node,
871 struct remove_node_args
873 const svn_fs_id_t *id;
879 txn_body_remove_node(void *baton, trail_t *trail)
881 struct remove_node_args *args = baton;
882 return svn_fs_base__dag_remove_node(trail->fs, args->id, args->txn_id,
888 delete_txn_tree(svn_fs_t *fs,
889 const svn_fs_id_t *id,
893 struct get_dirents_args dirent_args;
894 struct remove_node_args rm_args;
895 apr_hash_t *dirents = NULL;
896 apr_hash_index_t *hi;
899 /* If this sucker isn't mutable, there's nothing to do. */
900 if (svn_fs_base__key_compare(svn_fs_base__id_txn_id(id), txn_id) != 0)
903 /* See if the thing has dirents that need to be recursed upon. If
904 you can't find the thing itself, don't sweat it. We probably
905 already cleaned it up. */
906 dirent_args.dirents = &dirents;
908 dirent_args.txn_id = txn_id;
909 err = svn_fs_base__retry_txn(fs, txn_body_get_dirents, &dirent_args,
911 if (err && (err->apr_err == SVN_ERR_FS_ID_NOT_FOUND))
913 svn_error_clear(err);
918 /* If there are dirents upon which to recurse ... recurse. */
921 apr_pool_t *subpool = svn_pool_create(pool);
923 /* Loop over hash entries */
924 for (hi = apr_hash_first(pool, dirents); hi; hi = apr_hash_next(hi))
927 svn_fs_dirent_t *dirent;
929 svn_pool_clear(subpool);
930 apr_hash_this(hi, NULL, NULL, &val);
932 SVN_ERR(delete_txn_tree(fs, dirent->id, txn_id, subpool));
934 svn_pool_destroy(subpool);
937 /* Remove the node. */
939 rm_args.txn_id = txn_id;
940 return svn_fs_base__retry_txn(fs, txn_body_remove_node, &rm_args,
946 txn_body_delete_txn(void *baton, trail_t *trail)
948 const char *txn_id = *(const char **)baton;
950 return svn_fs_bdb__delete_txn(trail->fs, txn_id, trail, trail->pool);
955 svn_fs_base__purge_txn(svn_fs_t *fs,
959 struct cleanup_txn_args args;
962 SVN_ERR(svn_fs__check_fs(fs, TRUE));
964 /* Open the transaction, expecting it to be dead. */
967 SVN_ERR(svn_fs_base__retry_txn(fs, txn_body_cleanup_txn, &args,
970 /* Delete the mutable portion of the tree hanging from the
971 transaction (which should gracefully recover if we've already
973 SVN_ERR(delete_txn_tree(fs, txn->root_id, txn_id, pool));
975 /* Kill the transaction's changes (which should gracefully recover
977 SVN_ERR(svn_fs_base__retry_txn(fs, txn_body_cleanup_txn_changes,
978 &txn_id, TRUE, pool));
980 /* Kill the transaction's copies (which should gracefully...). */
985 for (i = 0; i < txn->copies->nelts; i++)
987 SVN_ERR(svn_fs_base__retry_txn
988 (fs, txn_body_cleanup_txn_copy,
989 &APR_ARRAY_IDX(txn->copies, i, const char *),
994 /* Kill the transaction itself (which ... just kidding -- this has
995 no graceful failure mode). */
996 return svn_fs_base__retry_txn(fs, txn_body_delete_txn, &txn_id,
1001 static svn_error_t *
1002 txn_body_abort_txn(void *baton, trail_t *trail)
1004 svn_fs_txn_t *txn = baton;
1005 transaction_t *fstxn;
1007 /* Get the transaction by its id, set it to "dead", and store the
1009 SVN_ERR(get_txn(&fstxn, txn->fs, txn->id, FALSE, trail, trail->pool));
1010 if (fstxn->kind != transaction_kind_normal)
1011 return svn_fs_base__err_txn_not_mutable(txn->fs, txn->id);
1013 fstxn->kind = transaction_kind_dead;
1014 return put_txn(txn->fs, fstxn, txn->id, trail, trail->pool);
1019 svn_fs_base__abort_txn(svn_fs_txn_t *txn,
1022 SVN_ERR(svn_fs__check_fs(txn->fs, TRUE));
1024 /* Set the transaction to "dead". */
1025 SVN_ERR(svn_fs_base__retry_txn(txn->fs, txn_body_abort_txn, txn,
1028 /* Now, purge it. */
1029 SVN_ERR_W(svn_fs_base__purge_txn(txn->fs, txn->id, pool),
1030 _("Transaction aborted, but cleanup failed"));
1032 return SVN_NO_ERROR;
1036 struct list_transactions_args
1038 apr_array_header_t **names_p;
1042 static svn_error_t *
1043 txn_body_list_transactions(void* baton, trail_t *trail)
1045 struct list_transactions_args *args = baton;
1046 return svn_fs_bdb__get_txn_list(args->names_p, trail->fs,
1051 svn_fs_base__list_transactions(apr_array_header_t **names_p,
1055 apr_array_header_t *names;
1056 struct list_transactions_args args;
1058 SVN_ERR(svn_fs__check_fs(fs, TRUE));
1060 args.names_p = &names;
1062 SVN_ERR(svn_fs_base__retry(fs, txn_body_list_transactions, &args,
1066 return SVN_NO_ERROR;