Support reftable ref backend for Git

652 lines not on this page · raw message

index 5e7698ae654..3d541fa5c0c 100644
@@ -14,7 +14,7 @@ int block_test_main(int argc, const char **argv);
 int merged_test_main(int argc, const char **argv);
 int record_test_main(int argc, const char **argv);
 int refname_test_main(int argc, const char **argv);
-int reftable_test_main(int argc, const char **argv);
+int readwrite_test_main(int argc, const char **argv);
 int stack_test_main(int argc, const char **argv);
 int tree_test_main(int argc, const char **argv);
 int reftable_dump_main(int argc, char *const *argv);

index 050551fa698..898aba836fd 100644
@@ -6,6 +6,7 @@ int cmd__reftable(int argc, const char **argv)
 	basics_test_main(argc, argv);
 	block_test_main(argc, argv);
 	record_test_main(argc, argv);
+	readwrite_test_main(argc, argv);
 	tree_test_main(argc, argv);
 	return 0;
 }

115 lines not on this page · raw message

new file mode 100644
index 00000000000..385d2fb139a
@@ -0,0 +1,32 @@
+/*
+Copyright 2020 Google LLC
+
+Use of this source code is governed by a BSD-style
+license that can be found in the LICENSE file or at
+https://developers.google.com/open-source/licenses/bsd
+*/
+
+#ifndef PQ_H
+#define PQ_H
+
+#include "record.h"
+
+struct pq_entry {
+	int index;
+	struct reftable_record rec;
+};
+
+struct merged_iter_pqueue {
+	struct pq_entry *heap;
+	size_t len;
+	size_t cap;
+};
+
+struct pq_entry merged_iter_pqueue_top(struct merged_iter_pqueue pq);
+int merged_iter_pqueue_is_empty(struct merged_iter_pqueue pq);
+void merged_iter_pqueue_check(struct merged_iter_pqueue pq);
+struct pq_entry merged_iter_pqueue_remove(struct merged_iter_pqueue *pq);
+void merged_iter_pqueue_add(struct merged_iter_pqueue *pq, struct pq_entry e);
+void merged_iter_pqueue_release(struct merged_iter_pqueue *pq);
+
+#endif

72 lines not on this page · raw message

index 3d541fa5c0c..0019cbcfa49 100644
@@ -12,6 +12,7 @@ license that can be found in the LICENSE file or at
 int basics_test_main(int argc, const char **argv);
 int block_test_main(int argc, const char **argv);
 int merged_test_main(int argc, const char **argv);
+int pq_test_main(int argc, const char **argv);
 int record_test_main(int argc, const char **argv);
 int refname_test_main(int argc, const char **argv);
 int readwrite_test_main(int argc, const char **argv);

index 898aba836fd..0b5a1701df1 100644
@@ -5,6 +5,7 @@ int cmd__reftable(int argc, const char **argv)
 {
 	basics_test_main(argc, argv);
 	block_test_main(argc, argv);
+	pq_test_main(argc, argv);
 	record_test_main(argc, argv);
 	readwrite_test_main(argc, argv);
 	tree_test_main(argc, argv);

362 lines not on this page · raw message

new file mode 100644
index 00000000000..8c4d4d58d77
@@ -0,0 +1,35 @@
+/*
+Copyright 2020 Google LLC
+
+Use of this source code is governed by a BSD-style
+license that can be found in the LICENSE file or at
+https://developers.google.com/open-source/licenses/bsd
+*/
+
+#ifndef MERGED_H
+#define MERGED_H
+
+#include "pq.h"
+
+struct reftable_merged_table {
+	struct reftable_table *stack;
+	size_t stack_len;
+	uint32_t hash_id;
+	int suppress_deletions;
+
+	uint64_t min;
+	uint64_t max;
+};
+
+struct merged_iter {
+	struct reftable_iterator *stack;
+	uint32_t hash_id;
+	size_t stack_len;
+	uint8_t typ;
+	int suppress_deletions;
+	struct merged_iter_pqueue pq;
+};
+
+void merged_table_release(struct reftable_merged_table *mt);
+
+#endif

292 lines not on this page · raw message

72 lines not on this page · raw message

index 0b5a1701df1..8087f2da4e6 100644
@@ -5,6 +5,7 @@ int cmd__reftable(int argc, const char **argv)
 {
 	basics_test_main(argc, argv);
 	block_test_main(argc, argv);
+	merged_test_main(argc, argv);
 	pq_test_main(argc, argv);
 	record_test_main(argc, argv);
 	readwrite_test_main(argc, argv);

209 lines not on this page · raw message

new file mode 100644
index 00000000000..a24b40fcb42
@@ -0,0 +1,29 @@
+/*
+  Copyright 2020 Google LLC
+
+  Use of this source code is governed by a BSD-style
+  license that can be found in the LICENSE file or at
+  https://developers.google.com/open-source/licenses/bsd
+*/
+#ifndef REFNAME_H
+#define REFNAME_H
+
+#include "reftable-record.h"
+#include "reftable-generic.h"
+
+struct modification {
+	struct reftable_table tab;
+
+	char **add;
+	size_t add_len;
+
+	char **del;
+	size_t del_len;
+};
+
+int validate_ref_record_addition(struct reftable_table tab,
+				 struct reftable_ref_record *recs, size_t sz);
+
+int modification_validate(struct modification *mod);
+
+#endif

102 lines not on this page · raw message

index 8087f2da4e6..c8db6852c35 100644
@@ -8,6 +8,7 @@ int cmd__reftable(int argc, const char **argv)
 	merged_test_main(argc, argv);
 	pq_test_main(argc, argv);
 	record_test_main(argc, argv);
+	refname_test_main(argc, argv);
 	readwrite_test_main(argc, argv);
 	tree_test_main(argc, argv);
 	return 0;

128 lines not on this page · raw message

1,396 lines not on this page · raw message

41 lines not on this page · raw message

948 lines not on this page · raw message

index c8db6852c35..996da85f7b5 100644
@@ -10,6 +10,7 @@ int cmd__reftable(int argc, const char **argv)
 	record_test_main(argc, argv);
 	refname_test_main(argc, argv);
 	readwrite_test_main(argc, argv);
+	stack_test_main(argc, argv);
 	tree_test_main(argc, argv);
 	return 0;
 }

index 1fcd229725..ac1aed8a76 100644
@@ -24,7 +24,7 @@ static int binsearch_func(size_t i, void *void_args)
 	return args->key < args->arr[i];
 }
 
-static void test_binsearch(void)
+static void test_binsearch(const char *fn_name)
 {
 	int arr[] = { 2, 4, 6, 8, 10 };
 	size_t sz = ARRAY_SIZE(arr);

@@ -49,13 +49,13 @@ static void test_binsearch(void)
 	}
 }
 
-static void test_names_length(void)
+static void test_names_length(const char *fn_name)
 {
 	char *a[] = { "a", "b", NULL };
 	EXPECT(names_length(a) == 2);
 }
 
-static void test_parse_names_normal(void)
+static void test_parse_names_normal(const char *fn_name)
 {
 	char in[] = "a\nb\n";
 	char **out = NULL;

@@ -66,7 +66,7 @@ static void test_parse_names_normal(void)
 	free_names(out);
 }
 
-static void test_parse_names_drop_empty(void)
+static void test_parse_names_drop_empty(const char *fn_name)
 {
 	char in[] = "a\n\n";
 	char **out = NULL;

@@ -76,7 +76,7 @@ static void test_parse_names_drop_empty(void)
 	free_names(out);
 }
 
-static void test_common_prefix(void)
+static void test_common_prefix(const char *fn_name)
 {
 	struct strbuf s1 = STRBUF_INIT;
 	struct strbuf s2 = STRBUF_INIT;

index 4b3ea262dc..8e21189f8d 100644
@@ -16,7 +16,7 @@ license that can be found in the LICENSE file or at
 #include "test_framework.h"
 #include "reftable-tests.h"
 
-static void test_block_read_write(void)
+static void test_block_read_write(const char *fn_name)
 {
 	const int header_off = 21; /* random */
 	char *names[30];

index 1e2afe37b8..f58e44003e 100644
@@ -95,7 +95,7 @@ static void readers_destroy(struct reftable_reader **readers, size_t n)
 	reftable_free(readers);
 }
 
-static void test_merged_between(void)
+static void test_merged_between(const char *fn_name)
 {
 	uint8_t hash1[GIT_SHA1_RAWSZ] = { 1, 2, 3, 0 };
 

@@ -137,7 +137,7 @@ static void test_merged_between(void)
 	reftable_free(bs);
 }
 
-static void test_merged(void)
+static void test_merged(const char *fn_name)
 {
 	uint8_t hash1[GIT_SHA1_RAWSZ] = { 1 };
 	uint8_t hash2[GIT_SHA1_RAWSZ] = { 2 };

@@ -237,7 +237,7 @@ static void test_merged(void)
 	reftable_free(bs);
 }
 
-static void test_default_write_opts(void)
+static void test_default_write_opts(const char *fn_name)
 {
 	struct reftable_write_options opts = { 0 };
 	struct strbuf buf = STRBUF_INIT;

index ad21673e85..3537def65c 100644
@@ -15,7 +15,7 @@ license that can be found in the LICENSE file or at
 #include "reftable-tests.h"
 #include "test_framework.h"
 
-static void test_pq(void)
+static void test_pq(const char *fn_name)
 {
 	char *names[54] = { NULL };
 	int N = ARRAY_SIZE(names) - 1;

index 5f6bcc2f77..5534f7fb67 100644
@@ -20,7 +20,7 @@ license that can be found in the LICENSE file or at
 
 static const int update_index = 5;
 
-static void test_buffer(void)
+static void test_buffer(const char *fn_name)
 {
 	struct strbuf buf = STRBUF_INIT;
 	struct reftable_block_source source = { NULL };

@@ -114,7 +114,7 @@ static void write_table(char ***names, struct strbuf *buf, int N,
 	reftable_writer_free(w);
 }
 
-static void test_log_buffer_size(void)
+static void test_log_buffer_size(const char *fn_name)
 {
 	struct strbuf buf = STRBUF_INIT;
 	struct reftable_write_options opts = {

@@ -155,7 +155,7 @@ static void test_log_buffer_size(void)
 	strbuf_release(&buf);
 }
 
-static void test_log_write_read(void)
+static void test_log_write_read(const char *fn_name)
 {
 	int N = 2;
 	char **names = reftable_calloc(sizeof(char *) * (N + 1));

@@ -254,7 +254,7 @@ static void test_log_write_read(void)
 	reader_close(&rd);
 }
 
-static void test_table_read_write_sequential(void)
+static void test_table_read_write_sequential(const char *fn_name)
 {
 	char **names;
 	struct strbuf buf = STRBUF_INIT;

@@ -296,7 +296,7 @@ static void test_table_read_write_sequential(void)
 	reader_close(&rd);
 }
 
-static void test_table_write_small_table(void)
+static void test_table_write_small_table(const char *fn_name)
 {
 	char **names;
 	struct strbuf buf = STRBUF_INIT;

@@ -307,7 +307,7 @@ static void test_table_write_small_table(void)
 	free_names(names);
 }
 
-static void test_table_read_api(void)
+static void test_table_read_api(const char *fn_name)
 {
 	char **names;
 	struct strbuf buf = STRBUF_INIT;

@@ -406,17 +406,17 @@ static void test_table_read_write_seek(int index, int hash_id)
 	reader_close(&rd);
 }
 
-static void test_table_read_write_seek_linear(void)
+static void test_table_read_write_seek_linear(const char *fn_name)
 {
 	test_table_read_write_seek(0, GIT_SHA1_FORMAT_ID);
 }
 
-static void test_table_read_write_seek_linear_sha256(void)
+static void test_table_read_write_seek_linear_sha256(const char *fn_name)
 {
 	test_table_read_write_seek(0, GIT_SHA256_FORMAT_ID);
 }
 
-static void test_table_read_write_seek_index(void)
+static void test_table_read_write_seek_index(const char *fn_name)
 {
 	test_table_read_write_seek(1, GIT_SHA1_FORMAT_ID);
 }

@@ -522,17 +522,17 @@ static void test_table_refs_for(int indexed)
 	reader_close(&rd);
 }
 
-static void test_table_refs_for_no_index(void)
+static void test_table_refs_for_no_index(const char *fn_name)
 {
 	test_table_refs_for(0);
 }
 
-static void test_table_refs_for_obj_index(void)
+static void test_table_refs_for_obj_index(const char *fn_name)
 {
 	test_table_refs_for(1);
 }
 
-static void test_write_empty_table(void)
+static void test_write_empty_table(const char *fn_name)
 {
 	struct reftable_write_options opts = { 0 };
 	struct strbuf buf = STRBUF_INIT;

@@ -568,7 +568,7 @@ static void test_write_empty_table(void)
 	strbuf_release(&buf);
 }
 
-static void test_write_key_order(void)
+static void test_write_key_order(const char *fn_name)
 {
 	struct reftable_write_options opts = { 0 };
 	struct strbuf buf = STRBUF_INIT;

@@ -604,7 +604,7 @@ static void test_write_key_order(void)
 	strbuf_release(&buf);
 }
 
-static void test_corrupt_table_empty(void)
+static void test_corrupt_table_empty(const char *fn_name)
 {
 	struct strbuf buf = STRBUF_INIT;
 	struct reftable_block_source source = { NULL };

@@ -616,7 +616,7 @@ static void test_corrupt_table_empty(void)
 	EXPECT(err == REFTABLE_FORMAT_ERROR);
 }
 
-static void test_corrupt_table(void)
+static void test_corrupt_table(const char *fn_name)
 {
 	uint8_t zeros[1024] = { 0 };
 	struct strbuf buf = STRBUF_INIT;

index f4ad7cace4..f88a72b154 100644
@@ -36,7 +36,7 @@ static void test_copy(struct reftable_record *rec)
 	reftable_record_destroy(&copy);
 }
 
-static void test_varint_roundtrip(void)
+static void test_varint_roundtrip(const char *fn_name)
 {
 	uint64_t inputs[] = { 0,
 			      1,

@@ -68,7 +68,7 @@ static void test_varint_roundtrip(void)
 	}
 }
 
-static void test_common_prefix(void)
+static void test_common_prefix(const char *fn_name)
 {
 	struct {
 		const char *a, *b;

@@ -101,7 +101,7 @@ static void set_hash(uint8_t *h, int j)
 	}
 }
 
-static void test_reftable_ref_record_roundtrip(void)
+static void test_reftable_ref_record_roundtrip(const char *fn_name)
 {
 	int i = 0;
 

@@ -164,7 +164,7 @@ static void test_reftable_ref_record_roundtrip(void)
 	}
 }
 
-static void test_reftable_log_record_equal(void)
+static void test_reftable_log_record_equal(const char *fn_name)
 {
 	struct reftable_log_record in[2] = {
 		{

@@ -184,7 +184,7 @@ static void test_reftable_log_record_equal(void)
 	reftable_log_record_release(&in[1]);
 }
 
-static void test_reftable_log_record_roundtrip(void)
+static void test_reftable_log_record_roundtrip(const char *fn_name)
 {
 	int i;
 	struct reftable_log_record in[2] = {

@@ -258,7 +258,7 @@ static void test_reftable_log_record_roundtrip(void)
 	}
 }
 
-static void test_u24_roundtrip(void)
+static void test_u24_roundtrip(const char *fn_name)
 {
 	uint32_t in = 0x112233;
 	uint8_t dest[3];

@@ -268,7 +268,7 @@ static void test_u24_roundtrip(void)
 	EXPECT(in == out);
 }
 
-static void test_key_roundtrip(void)
+static void test_key_roundtrip(const char *fn_name)
 {
 	uint8_t buffer[1024] = { 0 };
 	struct string_view dest = {

@@ -300,7 +300,7 @@ static void test_key_roundtrip(void)
 	strbuf_release(&roundtrip);
 }
 
-static void test_reftable_obj_record_roundtrip(void)
+static void test_reftable_obj_record_roundtrip(const char *fn_name)
 {
 	uint8_t testHash1[GIT_SHA1_RAWSZ] = { 1, 2, 3, 4, 0 };
 	uint64_t till9[] = { 1, 2, 3, 4, 500, 600, 700, 800, 9000 };

@@ -358,7 +358,7 @@ static void test_reftable_obj_record_roundtrip(void)
 	}
 }
 
-static void test_reftable_index_record_roundtrip(void)
+static void test_reftable_index_record_roundtrip(const char *fn_name)
 {
 	struct reftable_index_record in = {
 		.offset = 42,

index 8645cd93bb..81772179f9 100644
@@ -26,7 +26,7 @@ struct testcase {
 	int error_code;
 };
 
-static void test_conflict(void)
+static void test_conflict(const char *fn_name)
 {
 	struct reftable_write_options opts = { 0 };
 	struct strbuf buf = STRBUF_INIT;

266 lines not on this page · raw message

index 774cb275bf..4a40a8780a 100644
@@ -42,7 +42,7 @@ license that can be found in the LICENSE file or at
 #define RUN_TEST(f)                          \
 	fprintf(stderr, "running %s\n", #f); \
 	fflush(stderr);                      \
-	f();
+	f(#f);
 
 void set_test_hash(uint8_t *p, int i);
 

index 09a970e17b..4883f0de65 100644
@@ -31,7 +31,7 @@ static void check_increasing(void *arg, void *key)
 	c->last = key;
 }
 
-static void test_tree(void)
+static void test_tree(const char *fn_name)
 {
 	struct tree_node *root = NULL;
 

index 890a5c0199..f6b542b259 100644
@@ -46,25 +46,26 @@ static int count_dir_entries(const char *dirname)
 	return len;
 }
 
-static char *get_tmp_template(const char *prefix)
+static char *get_tmp_template(const int line)
 {
 	const char *tmp = getenv("TMPDIR");
 	static char template[1024];
-	snprintf(template, sizeof(template) - 1, "%s/%s.XXXXXX",
-		 tmp ? tmp : "/tmp", prefix);
+	snprintf(template, sizeof(template) - 1, "%s/stack-test.c-%d.XXXXXX",
+		 tmp ? tmp : "/tmp", line);
+	fprintf(stderr, "have template %s\n", template);
 	return template;
 }
 
-static char *get_tmp_dir(const char *prefix)
+static char *get_tmp_dir(const int line)
 {
-	char *dir = get_tmp_template(prefix);
+	char *dir = get_tmp_template(line);
 	EXPECT(mkdtemp(dir));
 	return dir;
 }
 
 static void test_read_file(void)
 {
-	char *fn = get_tmp_template(__FUNCTION__);
+	char *fn = get_tmp_template(__LINE__);
 	int fd = mkstemp(fn);
 	char out[1024] = "line1\n\nline2\nline3";
 	int n, err;

@@ -133,7 +134,7 @@ static int write_test_log(struct reftable_writer *wr, void *arg)
 
 static void test_reftable_stack_add_one(void)
 {
-	char *dir = get_tmp_dir(__FUNCTION__);
+	char *dir = get_tmp_dir(__LINE__);
 
 	struct reftable_write_options cfg = { 0 };
 	struct reftable_stack *st = NULL;

@@ -174,7 +175,7 @@ static void test_reftable_stack_uptodate(void)
 	struct reftable_write_options cfg = { 0 };
 	struct reftable_stack *st1 = NULL;
 	struct reftable_stack *st2 = NULL;
-	char *dir = get_tmp_dir(__FUNCTION__);
+	char *dir = get_tmp_dir(__LINE__);
 
 	int err;
 	struct reftable_ref_record ref1 = {

@@ -218,7 +219,7 @@ static void test_reftable_stack_uptodate(void)
 
 static void test_reftable_stack_transaction_api(void)
 {
-	char *dir = get_tmp_dir(__FUNCTION__);
+	char *dir = get_tmp_dir(__LINE__);
 
 	struct reftable_write_options cfg = { 0 };
 	struct reftable_stack *st = NULL;

@@ -265,7 +266,7 @@ static void test_reftable_stack_validate_refname(void)
 	struct reftable_write_options cfg = { 0 };
 	struct reftable_stack *st = NULL;
 	int err;
-	char *dir = get_tmp_dir(__FUNCTION__);
+	char *dir = get_tmp_dir(__LINE__);
 
 	int i;
 	struct reftable_ref_record ref = {

@@ -305,7 +306,7 @@ static int write_error(struct reftable_writer *wr, void *arg)
 
 static void test_reftable_stack_update_index_check(void)
 {
-	char *dir = get_tmp_dir(__FUNCTION__);
+	char *dir = get_tmp_dir(__LINE__);
 
 	struct reftable_write_options cfg = { 0 };
 	struct reftable_stack *st = NULL;

@@ -337,7 +338,7 @@ static void test_reftable_stack_update_index_check(void)
 
 static void test_reftable_stack_lock_failure(void)
 {
-	char *dir = get_tmp_dir(__FUNCTION__);
+	char *dir = get_tmp_dir(__LINE__);
 
 	struct reftable_write_options cfg = { 0 };
 	struct reftable_stack *st = NULL;

@@ -362,7 +363,7 @@ static void test_reftable_stack_add(void)
 		.exact_log_message = 1,
 	};
 	struct reftable_stack *st = NULL;
-	char *dir = get_tmp_dir(__FUNCTION__);
+	char *dir = get_tmp_dir(__LINE__);
 
 	struct reftable_ref_record refs[2] = { { NULL } };
 	struct reftable_log_record logs[2] = { { NULL } };

@@ -443,7 +444,7 @@ static void test_reftable_stack_log_normalize(void)
 		0,
 	};
 	struct reftable_stack *st = NULL;
-	char *dir = get_tmp_dir(__FUNCTION__);
+	char *dir = get_tmp_dir(__LINE__);
 
 
 	uint8_t h1[GIT_SHA1_RAWSZ] = { 0x01 }, h2[GIT_SHA1_RAWSZ] = { 0x02 };

@@ -495,7 +496,7 @@ static void test_reftable_stack_log_normalize(void)
 static void test_reftable_stack_tombstone(void)
 {
 	int i = 0;
-	char *dir = get_tmp_dir(__FUNCTION__);
+	char *dir = get_tmp_dir(__LINE__);
 
 	struct reftable_write_options cfg = { 0 };
 	struct reftable_stack *st = NULL;

@@ -577,7 +578,7 @@ static void test_reftable_stack_tombstone(void)
 
 static void test_reftable_stack_hash_id(void)
 {
-	char *dir = get_tmp_dir(__FUNCTION__);
+	char *dir = get_tmp_dir(__LINE__);
 
 	struct reftable_write_options cfg = { 0 };
 	struct reftable_stack *st = NULL;

@@ -685,7 +686,7 @@ static void test_suggest_compaction_segment_nothing(void)
 
 static void test_reflog_expire(void)
 {
-	char *dir = get_tmp_dir(__FUNCTION__);
+	char *dir = get_tmp_dir(__LINE__);
 
 	struct reftable_write_options cfg = { 0 };
 	struct reftable_stack *st = NULL;

@@ -766,7 +767,7 @@ static void test_empty_add(void)
 	struct reftable_write_options cfg = { 0 };
 	struct reftable_stack *st = NULL;
 	int err;
-	char *dir = get_tmp_dir(__FUNCTION__);
+	char *dir = get_tmp_dir(__LINE__);
 
 	struct reftable_stack *st2 = NULL;
 

@@ -788,7 +789,7 @@ static void test_reftable_stack_auto_compaction(void)
 {
 	struct reftable_write_options cfg = { 0 };
 	struct reftable_stack *st = NULL;
-	char *dir = get_tmp_dir(__FUNCTION__);
+	char *dir = get_tmp_dir(__LINE__);
 
 	int err, i;
 	int N = 100;

@@ -823,7 +824,7 @@ static void test_reftable_stack_compaction_concurrent(void)
 {
 	struct reftable_write_options cfg = { 0 };
 	struct reftable_stack *st1 = NULL, *st2 = NULL;
-	char *dir = get_tmp_dir(__FUNCTION__);
+	char *dir = get_tmp_dir(__LINE__);
 
 	int err, i;
 	int N = 3;

@@ -873,7 +874,7 @@ static void test_reftable_stack_compaction_concurrent_clean(void)
 {
 	struct reftable_write_options cfg = { 0 };
 	struct reftable_stack *st1 = NULL, *st2 = NULL, *st3 = NULL;
-	char *dir = get_tmp_dir(__FUNCTION__);
+	char *dir = get_tmp_dir(__LINE__);
 
 	int err, i;
 	int N = 3;

new file mode 100644
index 00000000000..155953d1b82
@@ -0,0 +1,107 @@
+/*
+Copyright 2020 Google LLC
+
+Use of this source code is governed by a BSD-style
+license that can be found in the LICENSE file or at
+https://developers.google.com/open-source/licenses/bsd
+*/
+
+#include "git-compat-util.h"
+#include "hash.h"
+
+#include "reftable-blocksource.h"
+#include "reftable-error.h"
+#include "reftable-merged.h"
+#include "reftable-record.h"
+#include "reftable-tests.h"
+#include "reftable-writer.h"
+#include "reftable-iterator.h"
+#include "reftable-reader.h"
+#include "reftable-stack.h"
+#include "reftable-generic.h"
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+static int compact_stack(const char *stackdir)
+{
+	struct reftable_stack *stack = NULL;
+	struct reftable_write_options cfg = { 0 };
+
+	int err = reftable_new_stack(&stack, stackdir, cfg);
+	if (err < 0)
+		goto done;
+
+	err = reftable_stack_compact_all(stack, NULL);
+	if (err < 0)
+		goto done;
+done:
+	if (stack) {
+		reftable_stack_destroy(stack);
+	}
+	return err;
+}
+
+static void print_help(void)
+{
+	printf("usage: dump [-cst] arg\n\n"
+	       "options: \n"
+	       "  -c compact\n"
+	       "  -t dump table\n"
+	       "  -s dump stack\n"
+	       "  -6 sha256 hash format\n"
+	       "  -h this help\n"
+	       "\n");
+}
+
+int reftable_dump_main(int argc, char *const *argv)
+{
+	int err = 0;
+	int opt_dump_table = 0;
+	int opt_dump_stack = 0;
+	int opt_compact = 0;
+	uint32_t opt_hash_id = GIT_SHA1_FORMAT_ID;
+	const char *arg = NULL, *argv0 = argv[0];
+
+	for (; argc > 1; argv++, argc--)
+		if (*argv[1] != '-')
+			break;
+		else if (!strcmp("-t", argv[1]))
+			opt_dump_table = 1;
+		else if (!strcmp("-6", argv[1]))
+			opt_hash_id = GIT_SHA256_FORMAT_ID;
+		else if (!strcmp("-s", argv[1]))
+			opt_dump_stack = 1;
+		else if (!strcmp("-c", argv[1]))
+			opt_compact = 1;
+		else if (!strcmp("-?", argv[1]) || !strcmp("-h", argv[1])) {
+			print_help();
+			return 2;
+		}
+
+	if (argc != 2) {
+		fprintf(stderr, "need argument\n");
+		print_help();
+		return 2;
+	}
+
+	arg = argv[1];
+
+	if (opt_dump_table) {
+		err = reftable_reader_print_file(arg);
+	} else if (opt_dump_stack) {
+		err = reftable_stack_print_directory(arg, opt_hash_id);
+	} else if (opt_compact) {
+		err = compact_stack(arg);
+	}
+
+	if (err < 0) {
+		fprintf(stderr, "%s: %s: %s\n", argv0, arg,
+			reftable_error_str(err));
+		return 1;
+	}
+	return 0;
+}

index 66fe66679c8..baa1ff4fc60 100644
@@ -1148,7 +1148,7 @@ int cmd_clone(int argc, const char **argv, const char *prefix)
 	}
 
 	init_db(git_dir, real_git_dir, option_template, GIT_HASH_UNKNOWN, NULL,
-		INIT_DB_QUIET);
+		default_ref_storage(), INIT_DB_QUIET);
 
 	if (real_git_dir)
 		git_dir = real_git_dir;

@@ -1299,7 +1299,8 @@ int cmd_clone(int argc, const char **argv, const char *prefix)
 		 * Now that we know what algorithm the remote side is using,
 		 * let's set ours to the same thing.
 		 */
-		initialize_repository_version(hash_algo, 1);
+		initialize_repository_version(hash_algo, 1,
+					      default_ref_storage());
 		repo_set_hash_algo(the_repository, hash_algo);
 
 		mapped_refs = wanted_peer_refs(refs, &remote->fetch);

index c2f03f6018e..22b07d2b2fb 100644
@@ -167,12 +167,14 @@ static int needs_work_tree_config(const char *git_dir, const char *work_tree)
 	return 1;
 }
 
-void initialize_repository_version(int hash_algo, int reinit)
+void initialize_repository_version(int hash_algo, int reinit,
+				   const char *ref_storage_format)
 {
 	char repo_version_string[10];
 	int repo_version = GIT_REPO_VERSION;
 
-	if (hash_algo != GIT_HASH_SHA1)
+	if (hash_algo != GIT_HASH_SHA1 ||
+	    !strcmp(ref_storage_format, "reftable"))
 		repo_version = GIT_REPO_VERSION_READ;
 
 	/* This forces creation of new config file */

@@ -226,6 +228,7 @@ static int create_default_files(const char *template_path,
 	is_bare_repository_cfg = init_is_bare_repository || !work_tree;
 	if (init_shared_repository != -1)
 		set_shared_repository(init_shared_repository);
+	the_repository->ref_storage_format = xstrdup(fmt->ref_storage);
 
 	/*
 	 * We would have created the above under user's umask -- under

@@ -235,6 +238,24 @@ static int create_default_files(const char *template_path,
 		adjust_shared_perm(get_git_dir());
 	}
 
+	/*
+	 * Check to see if .git/HEAD exists; this must happen before
+	 * initializing the ref db, because we want to see if there is an
+	 * existing HEAD.
+	 */
+	path = git_path_buf(&buf, "HEAD");
+	reinit = (!access(path, R_OK) ||
+		  readlink(path, junk, sizeof(junk) - 1) != -1);
+
+	/*
+	 * refs/heads is a file when using reftable. We can't reinitialize with
+	 * a reftable because it will overwrite HEAD
+	 */
+	if (reinit && (!strcmp(fmt->ref_storage, "reftable")) ==
+			      is_directory(git_path_buf(&buf, "refs/heads"))) {
+		die("cannot switch ref storage format.");
+	}
+
 	/*
 	 * We need to create a "refs" dir in any case so that older
 	 * versions of git can tell that this is a repository.

@@ -249,9 +270,6 @@ static int create_default_files(const char *template_path,
 	 * Point the HEAD symref to the initial branch with if HEAD does
 	 * not yet exist.
 	 */
-	path = git_path_buf(&buf, "HEAD");
-	reinit = (!access(path, R_OK)
-		  || readlink(path, junk, sizeof(junk)-1) != -1);
 	if (!reinit) {
 		char *ref;
 

@@ -268,7 +286,7 @@ static int create_default_files(const char *template_path,
 		free(ref);
 	}
 
-	initialize_repository_version(fmt->hash_algo, 0);
+	initialize_repository_version(fmt->hash_algo, 0, fmt->ref_storage);
 
 	/* Check filemode trustability */
 	path = git_path_buf(&buf, "config");

@@ -383,7 +401,7 @@ static void validate_hash_algorithm(struct repository_format *repo_fmt, int hash
 
 int init_db(const char *git_dir, const char *real_git_dir,
 	    const char *template_dir, int hash, const char *initial_branch,
-	    unsigned int flags)
+	    const char *ref_storage_format, unsigned int flags)
 {
 	int reinit;
 	int exist_ok = flags & INIT_DB_EXIST_OK;

@@ -422,6 +440,7 @@ int init_db(const char *git_dir, const char *real_git_dir,
 	 * is an attempt to reinitialize new repository with an old tool.
 	 */
 	check_repository_format(&repo_fmt);
+	repo_fmt.ref_storage = xstrdup(ref_storage_format);
 
 	validate_hash_algorithm(&repo_fmt, hash);
 

@@ -476,6 +495,9 @@ int init_db(const char *git_dir, const char *real_git_dir,
 		git_config_set("receive.denyNonFastforwards", "true");
 	}
 
+	if (!strcmp(ref_storage_format, "reftable"))
+		git_config_set("extensions.refStorage", ref_storage_format);
+
 	if (!(flags & INIT_DB_QUIET)) {
 		int len = strlen(git_dir);
 

@@ -549,6 +571,7 @@ static const char *const init_db_usage[] = {
 int cmd_init_db(int argc, const char **argv, const char *prefix)
 {
 	const char *git_dir;
+	const char *ref_storage_format = default_ref_storage();
 	const char *real_git_dir = NULL;
 	const char *work_tree;
 	const char *template_dir = NULL;

@@ -713,5 +736,5 @@ int cmd_init_db(int argc, const char **argv, const char *prefix)
 
 	flags |= INIT_DB_EXIST_OK;
 	return init_db(git_dir, real_git_dir, template_dir, hash_algo,
-		       initial_branch, flags);
+		       initial_branch, ref_storage_format, flags);
 }

index 8f42360ca91..d43d6898039 100644
@@ -207,10 +207,16 @@ static int get_stash_info(struct stash_info *info, int argc, const char **argv)
 static int do_clear_stash(void)
 {
 	struct object_id obj;
+	int result;
 	if (get_oid(ref_stash, &obj))
 		return 0;
 
-	return delete_ref(NULL, ref_stash, &obj, 0);
+	result = delete_ref(NULL, ref_stash, &obj, 0);
+
+	/* Ignore error; this is necessary for reftable, which keeps reflogs
+	 * even when refs are deleted. */
+	delete_reflog(ref_stash);
+	return result;
 }
 
 static int clear_stash(int argc, const char **argv, const char *prefix)

index 0d0a80da61f..6f4facebc61 100644
@@ -13,6 +13,7 @@
 #include "utf8.h"
 #include "worktree.h"
 #include "quote.h"
+#include "../refs/refs-internal.h"
 
 static const char * const worktree_usage[] = {
 	N_("git worktree add [<options>] <path> [<commit-ish>]"),

@@ -328,9 +329,29 @@ static int add_worktree(const char *path, const char *refname,
 	 * worktree.
 	 */
 	strbuf_reset(&sb);
-	strbuf_addf(&sb, "%s/HEAD", sb_repo.buf);
-	write_file(sb.buf, "%s", oid_to_hex(null_oid()));
-	strbuf_reset(&sb);
+	if (get_main_ref_store(the_repository)->be == &refs_be_reftable) {
+		/* XXX this is cut & paste from reftable_init_db. */
+		strbuf_addf(&sb, "%s/HEAD", sb_repo.buf);
+		write_file(sb.buf, "%s", "ref: refs/heads/.invalid\n");
+		strbuf_reset(&sb);
+
+		strbuf_addf(&sb, "%s/refs", sb_repo.buf);
+		safe_create_dir(sb.buf, 1);
+		strbuf_reset(&sb);
+
+		strbuf_addf(&sb, "%s/refs/heads", sb_repo.buf);
+		write_file(sb.buf, "this repository uses the reftable format");
+		strbuf_reset(&sb);
+
+		strbuf_addf(&sb, "%s/reftable", sb_repo.buf);
+		safe_create_dir(sb.buf, 1);
+		strbuf_reset(&sb);
+	} else {
+		strbuf_addf(&sb, "%s/HEAD", sb_repo.buf);
+		write_file(sb.buf, "%s", oid_to_hex(null_oid()));
+		strbuf_reset(&sb);
+	}
+
 	strbuf_addf(&sb, "%s/commondir", sb_repo.buf);
 	write_file(sb.buf, "../..");
 

index 1e838303654..02d525ab9e0 100644
@@ -656,9 +656,10 @@ int path_inside_repo(const char *prefix, const char *path);
 #define INIT_DB_EXIST_OK 0x0002
 
 int init_db(const char *git_dir, const char *real_git_dir,
-	    const char *template_dir, int hash_algo,
-	    const char *initial_branch, unsigned int flags);
-void initialize_repository_version(int hash_algo, int reinit);
+	    const char *template_dir, int hash_algo, const char *initial_branch,
+	    const char *ref_storage_format, unsigned int flags);
+void initialize_repository_version(int hash_algo, int reinit,
+				   const char *ref_storage_format);
 
 void sanitize_stdfds(void);
 int daemonize(void);

@@ -1076,6 +1077,7 @@ struct repository_format {
 	int hash_algo;
 	int sparse_index;
 	char *work_tree;
+	char *ref_storage;
 	struct string_list unknown_extensions;
 	struct string_list v1_only_extensions;
 };

index e3b6d8f8dc0..4345c176a42 100644
@@ -19,10 +19,15 @@
 #include "repository.h"
 #include "sigchain.h"
 
+const char *default_ref_storage(void)
+{
+	return git_env_bool("GIT_TEST_REFTABLE", 0) ? "reftable" : "files";
+}
+
 /*
  * List of all available backends
  */
-static struct ref_storage_be *refs_backends = &refs_be_files;
+static struct ref_storage_be *refs_backends = &refs_be_reftable;
 
 static struct ref_storage_be *find_ref_storage_backend(const char *name)
 {

@@ -1895,13 +1900,13 @@ static struct ref_store *lookup_ref_store_map(struct hashmap *map,
  * Create, record, and return a ref_store instance for the specified
  * gitdir.
  */
-static struct ref_store *ref_store_init(const char *gitdir,
+static struct ref_store *ref_store_init(const char *gitdir, const char *be_name,
 					unsigned int flags)
 {
-	const char *be_name = "files";
-	struct ref_storage_be *be = find_ref_storage_backend(be_name);
+	struct ref_storage_be *be;
 	struct ref_store *refs;
 
+	be = find_ref_storage_backend(be_name);
 	if (!be)
 		BUG("reference backend %s is unknown", be_name);
 

@@ -1917,7 +1922,11 @@ struct ref_store *get_main_ref_store(struct repository *r)
 	if (!r->gitdir)
 		BUG("attempting to get main_ref_store outside of repository");
 
-	r->refs_private = ref_store_init(r->gitdir, REF_STORE_ALL_CAPS);
+	r->refs_private = ref_store_init(r->gitdir,
+					 r->ref_storage_format ?
+						 r->ref_storage_format :
+						       default_ref_storage(),
+					 REF_STORE_ALL_CAPS);
 	r->refs_private = maybe_debug_wrap_ref_store(r->gitdir, r->refs_private);
 	return r->refs_private;
 }

@@ -1973,7 +1982,7 @@ struct ref_store *get_submodule_ref_store(const char *submodule)
 		goto done;
 
 	/* assume that add_submodule_odb() has been called */
-	refs = ref_store_init(submodule_sb.buf,
+	refs = ref_store_init(submodule_sb.buf, default_ref_storage(),
 			      REF_STORE_READ | REF_STORE_ODB);
 	register_ref_store_map(&submodule_ref_stores, "submodule",
 			       refs, submodule);

@@ -1987,6 +1996,7 @@ struct ref_store *get_submodule_ref_store(const char *submodule)
 
 struct ref_store *get_worktree_ref_store(const struct worktree *wt)
 {
+	const char *format = default_ref_storage();
 	struct ref_store *refs;
 	const char *id;
 

@@ -2000,9 +2010,9 @@ struct ref_store *get_worktree_ref_store(const struct worktree *wt)
 
 	if (wt->id)
 		refs = ref_store_init(git_common_path("worktrees/%s", wt->id),
-				      REF_STORE_ALL_CAPS);
+				      format, REF_STORE_ALL_CAPS);
 	else
-		refs = ref_store_init(get_git_common_dir(),
+		refs = ref_store_init(get_git_common_dir(), format,
 				      REF_STORE_ALL_CAPS);
 
 	if (refs)

index a5685c891a9..c83ae18c692 100644
@@ -11,6 +11,9 @@ struct string_list;
 struct string_list_item;
 struct worktree;
 
+/* Returns the ref storage backend to use by default. */
+const char *default_ref_storage(void);
+
 /*
  * Resolve a reference, recursively following symbolic refererences.
  *

index 7a3a61ac22f..8ec1047a0e0 100644
@@ -676,6 +676,7 @@ struct ref_storage_be {
 };
 
 extern struct ref_storage_be refs_be_files;
+extern struct ref_storage_be refs_be_reftable;
 extern struct ref_storage_be refs_be_packed;
 
 /*

1,691 lines not on this page · raw message

index b2bf44c6faf..f1cc8df47c4 100644
@@ -180,6 +180,8 @@ int repo_init(struct repository *repo,
 	if (worktree)
 		repo_set_worktree(repo, worktree);
 
+	repo->ref_storage_format = xstrdup_or_null(format.ref_storage);
+
 	clear_repository_format(&format);
 	return 0;
 

index 3740c93bc0f..1bd9b4d09c8 100644
@@ -82,6 +82,9 @@ struct repository {
 	 */
 	struct ref_store *refs_private;
 
+	/* The format to use for the ref database. */
+	char *ref_storage_format;
+
 	/*
 	 * Contains path to often used file names.
 	 */

index eb9367ca5cb..58504dfeb68 100644
@@ -498,6 +498,9 @@ static enum extension_result handle_extension(const char *var,
 			return error("invalid value for 'extensions.objectformat'");
 		data->hash_algo = format;
 		return EXTENSION_OK;
+	} else if (!strcmp(ext, "refstorage")) {
+		data->ref_storage = xstrdup(value);
+		return EXTENSION_OK;
 	}
 	return EXTENSION_UNKNOWN;
 }

@@ -648,6 +651,7 @@ void clear_repository_format(struct repository_format *format)
 	string_list_clear(&format->v1_only_extensions, 0);
 	free(format->work_tree);
 	free(format->partial_clone);
+	free(format->ref_storage);
 	init_repository_format(format);
 }
 

@@ -1312,6 +1316,8 @@ const char *setup_git_directory_gently(int *nongit_ok)
 			the_repository->repository_format_partial_clone =
 				repo_fmt.partial_clone;
 			repo_fmt.partial_clone = NULL;
+			the_repository->ref_storage_format =
+				xstrdup_or_null(repo_fmt.ref_storage);
 		}
 	}
 	/*

@@ -1399,6 +1405,8 @@ void check_repository_format(struct repository_format *fmt)
 	repo_set_hash_algo(the_repository, fmt->hash_algo);
 	the_repository->repository_format_partial_clone =
 		xstrdup_or_null(fmt->partial_clone);
+	/* XXX why is repo->ref_storage_format set in multiple places?! */
+	the_repository->ref_storage_format = xstrdup_or_null(fmt->ref_storage);
 	clear_repository_format(&repo_fmt);
 }
 

index 996da85f7b5..26b03d7b789 100644
@@ -14,3 +14,8 @@ int cmd__reftable(int argc, const char **argv)
 	tree_test_main(argc, argv);
 	return 0;
 }
+
+int cmd__dump_reftable(int argc, const char **argv)
+{
+	return reftable_dump_main(argc, (char *const *)argv);
+}

index f7c888ffda7..338a57b104d 100644
@@ -61,6 +61,7 @@ static struct test_cmd cmds[] = {
 	{ "read-midx", cmd__read_midx },
 	{ "ref-store", cmd__ref_store },
 	{ "reftable", cmd__reftable },
+	{ "dump-reftable", cmd__dump_reftable },
 	{ "regex", cmd__regex },
 	{ "repository", cmd__repository },
 	{ "revision-walking", cmd__revision_walking },

index 25f77469146..48cee1f4a2d 100644
@@ -19,6 +19,7 @@ int cmd__dump_cache_tree(int argc, const char **argv);
 int cmd__dump_fsmonitor(int argc, const char **argv);
 int cmd__dump_split_index(int argc, const char **argv);
 int cmd__dump_untracked_cache(int argc, const char **argv);
+int cmd__dump_reftable(int argc, const char **argv);
 int cmd__example_decorate(int argc, const char **argv);
 int cmd__fast_rebase(int argc, const char **argv);
 int cmd__genrandom(int argc, const char **argv);

index d972910bf21..dcc792e5e87 100644
@@ -108,7 +108,7 @@ static const char *bare_ref_name(const char *ref)
 static int git_reftable_read_raw_ref(struct ref_store *ref_store,
 				     const char *refname, struct object_id *oid,
 				     struct strbuf *referent,
-				     unsigned int *type);
+				     unsigned int *type, int *failure_errno);
 
 static void clear_reftable_log_record(struct reftable_log_record *log)
 {

@@ -424,6 +424,7 @@ static int fixup_symrefs(struct ref_store *ref_store,
 	struct strbuf referent = STRBUF_INIT;
 	int i = 0;
 	int err = 0;
+	int failure_errno;
 
 	for (i = 0; i < transaction->nr; i++) {
 		struct ref_update *update = transaction->updates[i];

@@ -433,8 +434,8 @@ static int fixup_symrefs(struct ref_store *ref_store,
 						&old_oid, &referent,
 						/* mutate input, like
 						   files-backend.c */
-						&update->type);
-		if (err < 0 && errno == ENOENT &&
+						&update->type, &failure_errno);
+		if (err < 0 && failure_errno == ENOENT &&
 		    is_null_oid(&update->old_oid)) {
 			err = 0;
 		}

@@ -1587,30 +1588,10 @@ git_reftable_reflog_expire(struct ref_store *ref_store, const char *refname,
 	return err;
 }
 
-static int reftable_error_to_errno(int err)
-{
-	switch (err) {
-	case REFTABLE_IO_ERROR:
-		return EIO;
-	case REFTABLE_FORMAT_ERROR:
-		return EFAULT;
-	case REFTABLE_NOT_EXIST_ERROR:
-		return ENOENT;
-	case REFTABLE_LOCK_ERROR:
-		return EBUSY;
-	case REFTABLE_API_ERROR:
-		return EINVAL;
-	case REFTABLE_ZLIB_ERROR:
-		return EDOM;
-	default:
-		return ERANGE;
-	}
-}
-
 static int git_reftable_read_raw_ref(struct ref_store *ref_store,
 				     const char *refname, struct object_id *oid,
 				     struct strbuf *referent,
-				     unsigned int *type)
+				     unsigned int *type, int *failure_errno)
 {
 	struct git_reftable_ref_store *refs =
 		(struct git_reftable_ref_store *)ref_store;

@@ -1633,13 +1614,10 @@ static int git_reftable_read_raw_ref(struct ref_store *ref_store,
 	}
 
 	err = reftable_stack_read_ref(stack, refname, &ref);
-	if (err > 0) {
-		errno = ENOENT;
-		err = -1;
-		goto done;
-	}
 	if (err < 0) {
-		errno = reftable_error_to_errno(err);
+		goto done;
+	} else if (err) {
+		*failure_errno = ENOENT;
 		err = -1;
 		goto done;
 	}

index dcc792e5e87..94917c85cf7 100644
@@ -1463,7 +1463,7 @@ static int write_reflog_expiry_table(struct reftable_writer *writer, void *argv)
 
 static int
 git_reftable_reflog_expire(struct ref_store *ref_store, const char *refname,
-			   const struct object_id *oid, unsigned int flags,
+			   unsigned int flags,
 			   reflog_expiry_prepare_fn prepare_fn,
 			   reflog_expiry_should_prune_fn should_prune_fn,
 			   reflog_expiry_cleanup_fn cleanup_fn,

@@ -1497,6 +1497,9 @@ git_reftable_reflog_expire(struct ref_store *ref_store, const char *refname,
 	struct reftable_iterator it = { NULL };
 	struct reftable_addition *add = NULL;
 	int err = 0;
+	int ignore_errno;
+	struct object_id oid;
+
 	if (refs->err < 0) {
 		return refs->err;
 	}

@@ -1515,7 +1518,14 @@ git_reftable_reflog_expire(struct ref_store *ref_store, const char *refname,
 	if (err) {
 		goto done;
 	}
-	prepare_fn(refname, oid, policy_cb_data);
+	if (!refs_resolve_ref_unsafe_with_errno(ref_store, refname,
+					       RESOLVE_REF_READING, &oid,
+					       NULL, &ignore_errno)) {
+		err = -1;
+		goto done;
+	}
+	prepare_fn(refname, &oid, policy_cb_data);
+
 	while (1) {
 		struct reftable_log_record log = { NULL };
 		int err = reftable_iterator_next_log(&it, &log);

index 94917c85cf7..61ee144e19e 100644
@@ -315,9 +315,11 @@ static int reftable_ref_iterator_advance(struct ref_iterator *ref_iterator)
 			break;
 		case REFTABLE_REF_SYMREF: {
 			int out_flags = 0;
-			const char *resolved = refs_resolve_ref_unsafe(
+			int ignore_errno;
+			const char *resolved = refs_resolve_ref_unsafe_with_errno(
 				ri->ref_store, ri->ref.refname,
-				RESOLVE_REF_READING, &ri->oid, &out_flags);
+				RESOLVE_REF_READING, &ri->oid, &out_flags,
+				&ignore_errno);
 			ri->base.flags = out_flags;
 			if (resolved == NULL &&
 			    !(ri->flags & DO_FOR_EACH_INCLUDE_BROKEN) &&

@@ -543,8 +545,10 @@ static int reftable_check_old_oid(struct ref_store *refs, const char *refname,
 {
 	struct object_id out_oid;
 	int out_flags = 0;
-	const char *resolved = refs_resolve_ref_unsafe(
-		refs, refname, RESOLVE_REF_READING, &out_oid, &out_flags);
+	int ignore_errno;
+	const char *resolved = refs_resolve_ref_unsafe_with_errno(
+		refs, refname, RESOLVE_REF_READING, &out_oid, &out_flags,
+		&ignore_errno);
 	if (is_null_oid(want_oid) != (resolved == NULL)) {
 		return REFTABLE_LOCK_ERROR;
 	}

@@ -845,20 +849,24 @@ static int write_create_symref_table(struct reftable_writer *writer, void *arg)
 		struct reftable_log_record log = { NULL };
 		struct object_id new_oid;
 		struct object_id old_oid;
+		int ignore_errno;
 
 		fill_reftable_log_record(&log);
 		log.refname = (char *)create->refname;
 		log.update_index = ts;
 		log.value.update.message = (char *)create->logmsg;
-		if (refs_resolve_ref_unsafe(
+		if (refs_resolve_ref_unsafe_with_errno(
 			    (struct ref_store *)create->refs, create->refname,
-			    RESOLVE_REF_READING, &old_oid, NULL) != NULL) {
+			    RESOLVE_REF_READING, &old_oid, NULL,
+			    &ignore_errno)) {
 			log.value.update.old_hash = old_oid.hash;
 		}
 
-		if (refs_resolve_ref_unsafe((struct ref_store *)create->refs,
-					    create->target, RESOLVE_REF_READING,
-					    &new_oid, NULL) != NULL) {
+		if (refs_resolve_ref_unsafe_with_errno((struct ref_store *)create->refs,
+						       create->target,
+						       RESOLVE_REF_READING,
+						       &new_oid, NULL,
+						       &ignore_errno)) {
 			log.value.update.new_hash = new_oid.hash;
 		}