aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--reftable/block.c142
-rw-r--r--reftable/block.h29
-rw-r--r--reftable/iter.c9
-rw-r--r--reftable/iter.h2
-rw-r--r--reftable/table.c46
-rw-r--r--reftable/table.h8
-rw-r--r--t/unit-tests/t-reftable-block.c102
7 files changed, 172 insertions, 166 deletions
diff --git a/reftable/block.c b/reftable/block.c
index dca30b8527..844da39783 100644
--- a/reftable/block.c
+++ b/reftable/block.c
@@ -222,10 +222,10 @@ static int read_block(struct reftable_block_source *source,
return block_source_read_data(source, dest, off, sz);
}
-int block_reader_init(struct block_reader *br,
- struct reftable_block_source *source,
- uint32_t offset, uint32_t header_size,
- uint32_t table_block_size, uint32_t hash_size)
+int reftable_block_init(struct reftable_block *block,
+ struct reftable_block_source *source,
+ uint32_t offset, uint32_t header_size,
+ uint32_t table_block_size, uint32_t hash_size)
{
uint32_t guess_block_size = table_block_size ?
table_block_size : DEFAULT_BLOCK_SIZE;
@@ -236,19 +236,19 @@ int block_reader_init(struct block_reader *br,
uint8_t block_type;
int err;
- err = read_block(source, &br->block_data, offset, guess_block_size);
+ err = read_block(source, &block->block_data, offset, guess_block_size);
if (err < 0)
goto done;
- block_type = br->block_data.data[header_size];
+ block_type = block->block_data.data[header_size];
if (!reftable_is_block_type(block_type)) {
err = REFTABLE_FORMAT_ERROR;
goto done;
}
- block_size = reftable_get_be24(br->block_data.data + header_size + 1);
+ block_size = reftable_get_be24(block->block_data.data + header_size + 1);
if (block_size > guess_block_size) {
- err = read_block(source, &br->block_data, offset, block_size);
+ err = read_block(source, &block->block_data, offset, block_size);
if (err < 0)
goto done;
}
@@ -256,39 +256,39 @@ int block_reader_init(struct block_reader *br,
if (block_type == BLOCK_TYPE_LOG) {
uint32_t block_header_skip = 4 + header_size;
uLong dst_len = block_size - block_header_skip;
- uLong src_len = br->block_data.len - block_header_skip;
+ uLong src_len = block->block_data.len - block_header_skip;
/* Log blocks specify the *uncompressed* size in their header. */
- REFTABLE_ALLOC_GROW_OR_NULL(br->uncompressed_data, block_size,
- br->uncompressed_cap);
- if (!br->uncompressed_data) {
+ REFTABLE_ALLOC_GROW_OR_NULL(block->uncompressed_data, block_size,
+ block->uncompressed_cap);
+ if (!block->uncompressed_data) {
err = REFTABLE_OUT_OF_MEMORY_ERROR;
goto done;
}
/* Copy over the block header verbatim. It's not compressed. */
- memcpy(br->uncompressed_data, br->block_data.data, block_header_skip);
+ memcpy(block->uncompressed_data, block->block_data.data, block_header_skip);
- if (!br->zstream) {
- REFTABLE_CALLOC_ARRAY(br->zstream, 1);
- if (!br->zstream) {
+ if (!block->zstream) {
+ REFTABLE_CALLOC_ARRAY(block->zstream, 1);
+ if (!block->zstream) {
err = REFTABLE_OUT_OF_MEMORY_ERROR;
goto done;
}
- err = inflateInit(br->zstream);
+ err = inflateInit(block->zstream);
} else {
- err = inflateReset(br->zstream);
+ err = inflateReset(block->zstream);
}
if (err != Z_OK) {
err = REFTABLE_ZLIB_ERROR;
goto done;
}
- br->zstream->next_in = br->block_data.data + block_header_skip;
- br->zstream->avail_in = src_len;
- br->zstream->next_out = br->uncompressed_data + block_header_skip;
- br->zstream->avail_out = dst_len;
+ block->zstream->next_in = block->block_data.data + block_header_skip;
+ block->zstream->avail_in = src_len;
+ block->zstream->next_out = block->uncompressed_data + block_header_skip;
+ block->zstream->avail_out = dst_len;
/*
* We know both input as well as output size, and we know that
@@ -297,71 +297,71 @@ int block_reader_init(struct block_reader *br,
* here to instruct zlib to inflate the data in one go, which
* is more efficient than using `Z_NO_FLUSH`.
*/
- err = inflate(br->zstream, Z_FINISH);
+ err = inflate(block->zstream, Z_FINISH);
if (err != Z_STREAM_END) {
err = REFTABLE_ZLIB_ERROR;
goto done;
}
err = 0;
- if (br->zstream->total_out + block_header_skip != block_size) {
+ if (block->zstream->total_out + block_header_skip != block_size) {
err = REFTABLE_FORMAT_ERROR;
goto done;
}
/* We're done with the input data. */
- block_source_release_data(&br->block_data);
- br->block_data.data = br->uncompressed_data;
- br->block_data.len = block_size;
- full_block_size = src_len + block_header_skip - br->zstream->avail_in;
+ block_source_release_data(&block->block_data);
+ block->block_data.data = block->uncompressed_data;
+ block->block_data.len = block_size;
+ full_block_size = src_len + block_header_skip - block->zstream->avail_in;
} else if (full_block_size == 0) {
full_block_size = block_size;
- } else if (block_size < full_block_size && block_size < br->block_data.len &&
- br->block_data.data[block_size] != 0) {
+ } else if (block_size < full_block_size && block_size < block->block_data.len &&
+ block->block_data.data[block_size] != 0) {
/* If the block is smaller than the full block size, it is
padded (data followed by '\0') or the next block is
unaligned. */
full_block_size = block_size;
}
- restart_count = reftable_get_be16(br->block_data.data + block_size - 2);
+ restart_count = reftable_get_be16(block->block_data.data + block_size - 2);
restart_off = block_size - 2 - 3 * restart_count;
- br->block_type = block_type;
- br->hash_size = hash_size;
- br->restart_off = restart_off;
- br->full_block_size = full_block_size;
- br->header_off = header_size;
- br->restart_count = restart_count;
+ block->block_type = block_type;
+ block->hash_size = hash_size;
+ block->restart_off = restart_off;
+ block->full_block_size = full_block_size;
+ block->header_off = header_size;
+ block->restart_count = restart_count;
err = 0;
done:
if (err < 0)
- block_reader_release(br);
+ reftable_block_release(block);
return err;
}
-void block_reader_release(struct block_reader *br)
+void reftable_block_release(struct reftable_block *block)
{
- inflateEnd(br->zstream);
- reftable_free(br->zstream);
- reftable_free(br->uncompressed_data);
- block_source_release_data(&br->block_data);
- memset(br, 0, sizeof(*br));
+ inflateEnd(block->zstream);
+ reftable_free(block->zstream);
+ reftable_free(block->uncompressed_data);
+ block_source_release_data(&block->block_data);
+ memset(block, 0, sizeof(*block));
}
-uint8_t block_reader_type(const struct block_reader *r)
+uint8_t reftable_block_type(const struct reftable_block *b)
{
- return r->block_data.data[r->header_off];
+ return b->block_data.data[b->header_off];
}
-int block_reader_first_key(const struct block_reader *br, struct reftable_buf *key)
+int reftable_block_first_key(const struct reftable_block *block, struct reftable_buf *key)
{
- int off = br->header_off + 4, n;
+ int off = block->header_off + 4, n;
struct string_view in = {
- .buf = br->block_data.data + off,
- .len = br->restart_off - off,
+ .buf = block->block_data.data + off,
+ .len = block->restart_off - off,
};
uint8_t extra = 0;
@@ -376,33 +376,33 @@ int block_reader_first_key(const struct block_reader *br, struct reftable_buf *k
return 0;
}
-static uint32_t block_reader_restart_offset(const struct block_reader *br, size_t idx)
+static uint32_t block_restart_offset(const struct reftable_block *b, size_t idx)
{
- return reftable_get_be24(br->block_data.data + br->restart_off + 3 * idx);
+ return reftable_get_be24(b->block_data.data + b->restart_off + 3 * idx);
}
-void block_iter_seek_start(struct block_iter *it, const struct block_reader *br)
+void block_iter_seek_start(struct block_iter *it, const struct reftable_block *b)
{
- it->block = br->block_data.data;
- it->block_len = br->restart_off;
- it->hash_size = br->hash_size;
+ it->block = b->block_data.data;
+ it->block_len = b->restart_off;
+ it->hash_size = b->hash_size;
reftable_buf_reset(&it->last_key);
- it->next_off = br->header_off + 4;
+ it->next_off = b->header_off + 4;
}
struct restart_needle_less_args {
int error;
struct reftable_buf needle;
- const struct block_reader *reader;
+ const struct reftable_block *block;
};
static int restart_needle_less(size_t idx, void *_args)
{
struct restart_needle_less_args *args = _args;
- uint32_t off = block_reader_restart_offset(args->reader, idx);
+ uint32_t off = block_restart_offset(args->block, idx);
struct string_view in = {
- .buf = args->reader->block_data.data + off,
- .len = args->reader->restart_off - off,
+ .buf = args->block->block_data.data + off,
+ .len = args->block->restart_off - off,
};
uint64_t prefix_len, suffix_len;
uint8_t extra;
@@ -477,12 +477,12 @@ void block_iter_close(struct block_iter *it)
reftable_buf_release(&it->scratch);
}
-int block_iter_seek_key(struct block_iter *it, const struct block_reader *br,
+int block_iter_seek_key(struct block_iter *it, const struct reftable_block *block,
struct reftable_buf *want)
{
struct restart_needle_less_args args = {
.needle = *want,
- .reader = br,
+ .block = block,
};
struct reftable_record rec;
int err = 0;
@@ -500,7 +500,7 @@ int block_iter_seek_key(struct block_iter *it, const struct block_reader *br,
* restart point. While that works alright, we would end up scanning
* too many record.
*/
- i = binsearch(br->restart_count, &restart_needle_less, &args);
+ i = binsearch(block->restart_count, &restart_needle_less, &args);
if (args.error) {
err = REFTABLE_FORMAT_ERROR;
goto done;
@@ -525,21 +525,21 @@ int block_iter_seek_key(struct block_iter *it, const struct block_reader *br,
* starting from the preceding restart point.
*/
if (i > 0)
- it->next_off = block_reader_restart_offset(br, i - 1);
+ it->next_off = block_restart_offset(block, i - 1);
else
- it->next_off = br->header_off + 4;
- it->block = br->block_data.data;
- it->block_len = br->restart_off;
- it->hash_size = br->hash_size;
+ it->next_off = block->header_off + 4;
+ it->block = block->block_data.data;
+ it->block_len = block->restart_off;
+ it->hash_size = block->hash_size;
- err = reftable_record_init(&rec, block_reader_type(br));
+ err = reftable_record_init(&rec, reftable_block_type(block));
if (err < 0)
goto done;
/*
* We're looking for the last entry less than the wanted key so that
* the next call to `block_reader_next()` would yield the wanted
- * record. We thus don't want to position our reader at the sought
+ * record. We thus don't want to position our iterator at the sought
* after record, but one before. To do so, we have to go one entry too
* far and then back up.
*/
diff --git a/reftable/block.h b/reftable/block.h
index 948b79e461..3957aee429 100644
--- a/reftable/block.h
+++ b/reftable/block.h
@@ -64,8 +64,11 @@ void block_writer_release(struct block_writer *bw);
struct z_stream;
-/* Read a block. */
-struct block_reader {
+/*
+ * A block part of a reftable. Contains records as well as some metadata
+ * describing them.
+ */
+struct reftable_block {
/* offset of the block header; nonzero for the first block in a
* reftable. */
uint32_t header_off;
@@ -92,19 +95,21 @@ struct block_reader {
uint8_t block_type;
};
-/* initializes a block reader. */
-int block_reader_init(struct block_reader *br,
- struct reftable_block_source *source,
- uint32_t offset, uint32_t header_size,
- uint32_t table_block_size, uint32_t hash_size);
+/*
+ * Initialize a reftable block from the given block source.
+ */
+int reftable_block_init(struct reftable_block *b,
+ struct reftable_block_source *source,
+ uint32_t offset, uint32_t header_size,
+ uint32_t table_block_size, uint32_t hash_size);
-void block_reader_release(struct block_reader *br);
+void reftable_block_release(struct reftable_block *b);
/* Returns the block type (eg. 'r' for refs) */
-uint8_t block_reader_type(const struct block_reader *r);
+uint8_t reftable_block_type(const struct reftable_block *b);
/* Decodes the first key in the block */
-int block_reader_first_key(const struct block_reader *br, struct reftable_buf *key);
+int reftable_block_first_key(const struct reftable_block *b, struct reftable_buf *key);
/* Iterate over entries in a block */
struct block_iter {
@@ -125,10 +130,10 @@ struct block_iter {
}
/* Position `it` at start of the block */
-void block_iter_seek_start(struct block_iter *it, const struct block_reader *br);
+void block_iter_seek_start(struct block_iter *it, const struct reftable_block *block);
/* Position `it` to the `want` key in the block */
-int block_iter_seek_key(struct block_iter *it, const struct block_reader *br,
+int block_iter_seek_key(struct block_iter *it, const struct reftable_block *block,
struct reftable_buf *want);
/* return < 0 for error, 0 for OK, > 0 for EOF. */
diff --git a/reftable/iter.c b/reftable/iter.c
index c00ffc8857..9ce675510c 100644
--- a/reftable/iter.c
+++ b/reftable/iter.c
@@ -114,7 +114,7 @@ static void indexed_table_ref_iter_close(void *p)
{
struct indexed_table_ref_iter *it = p;
block_iter_close(&it->cur);
- block_source_release_data(&it->block_reader.block_data);
+ block_source_release_data(&it->block.block_data);
reftable_free(it->offsets);
reftable_buf_release(&it->oid);
}
@@ -128,11 +128,10 @@ static int indexed_table_ref_iter_next_block(struct indexed_table_ref_iter *it)
return 1;
}
- block_source_release_data(&it->block_reader.block_data);
+ block_source_release_data(&it->block.block_data);
off = it->offsets[it->offset_idx++];
- err = table_init_block_reader(it->table, &it->block_reader, off,
- BLOCK_TYPE_REF);
+ err = table_init_block(it->table, &it->block, off, BLOCK_TYPE_REF);
if (err < 0) {
return err;
}
@@ -140,7 +139,7 @@ static int indexed_table_ref_iter_next_block(struct indexed_table_ref_iter *it)
/* indexed block does not exist. */
return REFTABLE_FORMAT_ERROR;
}
- block_iter_seek_start(&it->cur, &it->block_reader);
+ block_iter_seek_start(&it->cur, &it->block);
return 0;
}
diff --git a/reftable/iter.h b/reftable/iter.h
index add5c9472f..cc920970a5 100644
--- a/reftable/iter.h
+++ b/reftable/iter.h
@@ -68,7 +68,7 @@ struct indexed_table_ref_iter {
/* Points to the next offset to read. */
int offset_idx;
int offset_len;
- struct block_reader block_reader;
+ struct reftable_block block;
struct block_iter cur;
int is_finished;
};
diff --git a/reftable/table.c b/reftable/table.c
index c86b1d4c64..ef1f33c92f 100644
--- a/reftable/table.c
+++ b/reftable/table.c
@@ -131,7 +131,7 @@ struct table_iter {
struct reftable_table *table;
uint8_t typ;
uint64_t block_off;
- struct block_reader br;
+ struct reftable_block block;
struct block_iter bi;
int is_finished;
};
@@ -159,12 +159,12 @@ static int table_iter_next_in_block(struct table_iter *ti,
static void table_iter_block_done(struct table_iter *ti)
{
- block_reader_release(&ti->br);
+ reftable_block_release(&ti->block);
block_iter_reset(&ti->bi);
}
-int table_init_block_reader(struct reftable_table *t, struct block_reader *br,
- uint64_t next_off, uint8_t want_typ)
+int table_init_block(struct reftable_table *t, struct reftable_block *block,
+ uint64_t next_off, uint8_t want_typ)
{
uint32_t header_off = next_off ? 0 : header_size(t->version);
int err;
@@ -172,19 +172,19 @@ int table_init_block_reader(struct reftable_table *t, struct block_reader *br,
if (next_off >= t->size)
return 1;
- err = block_reader_init(br, &t->source, next_off, header_off,
- t->block_size, hash_size(t->hash_id));
+ err = reftable_block_init(block, &t->source, next_off, header_off,
+ t->block_size, hash_size(t->hash_id));
if (err < 0)
goto done;
- if (want_typ != BLOCK_TYPE_ANY && br->block_type != want_typ) {
+ if (want_typ != BLOCK_TYPE_ANY && block->block_type != want_typ) {
err = 1;
goto done;
}
done:
if (err)
- block_reader_release(br);
+ reftable_block_release(block);
return err;
}
@@ -197,10 +197,10 @@ static void table_iter_close(struct table_iter *ti)
static int table_iter_next_block(struct table_iter *ti)
{
- uint64_t next_block_off = ti->block_off + ti->br.full_block_size;
+ uint64_t next_block_off = ti->block_off + ti->block.full_block_size;
int err;
- err = table_init_block_reader(ti->table, &ti->br, next_block_off, ti->typ);
+ err = table_init_block(ti->table, &ti->block, next_block_off, ti->typ);
if (err > 0)
ti->is_finished = 1;
if (err)
@@ -208,7 +208,7 @@ static int table_iter_next_block(struct table_iter *ti)
ti->block_off = next_block_off;
ti->is_finished = 0;
- block_iter_seek_start(&ti->bi, &ti->br);
+ block_iter_seek_start(&ti->bi, &ti->block);
return 0;
}
@@ -250,13 +250,13 @@ static int table_iter_seek_to(struct table_iter *ti, uint64_t off, uint8_t typ)
{
int err;
- err = table_init_block_reader(ti->table, &ti->br, off, typ);
+ err = table_init_block(ti->table, &ti->block, off, typ);
if (err != 0)
return err;
- ti->typ = block_reader_type(&ti->br);
+ ti->typ = reftable_block_type(&ti->block);
ti->block_off = off;
- block_iter_seek_start(&ti->bi, &ti->br);
+ block_iter_seek_start(&ti->bi, &ti->block);
ti->is_finished = 0;
return 0;
}
@@ -320,10 +320,10 @@ static int table_iter_seek_linear(struct table_iter *ti,
* as we have more than three blocks we would have an index, so
* we would not do a linear search there anymore.
*/
- memset(&next.br.block_data, 0, sizeof(next.br.block_data));
- next.br.zstream = NULL;
- next.br.uncompressed_data = NULL;
- next.br.uncompressed_cap = 0;
+ memset(&next.block.block_data, 0, sizeof(next.block.block_data));
+ next.block.zstream = NULL;
+ next.block.uncompressed_data = NULL;
+ next.block.uncompressed_cap = 0;
err = table_iter_next_block(&next);
if (err < 0)
@@ -331,7 +331,7 @@ static int table_iter_seek_linear(struct table_iter *ti,
if (err > 0)
break;
- err = block_reader_first_key(&next.br, &got_key);
+ err = reftable_block_first_key(&next.block, &got_key);
if (err < 0)
goto done;
@@ -349,7 +349,7 @@ static int table_iter_seek_linear(struct table_iter *ti,
* the wanted key inside of it. If the block does not contain our key
* we know that the corresponding record does not exist.
*/
- err = block_iter_seek_key(&ti->bi, &ti->br, &want_key);
+ err = block_iter_seek_key(&ti->bi, &ti->block, &want_key);
if (err < 0)
goto done;
err = 0;
@@ -417,7 +417,7 @@ static int table_iter_seek_indexed(struct table_iter *ti,
if (err != 0)
goto done;
- err = block_iter_seek_key(&ti->bi, &ti->br, &want_index.u.idx.last_key);
+ err = block_iter_seek_key(&ti->bi, &ti->block, &want_index.u.idx.last_key);
if (err < 0)
goto done;
@@ -785,8 +785,8 @@ int reftable_table_print_blocks(const char *tablename)
printf("%s:\n", sections[i].name);
while (1) {
- printf(" - length: %u\n", ti.br.restart_off);
- printf(" restarts: %u\n", ti.br.restart_count);
+ printf(" - length: %u\n", ti.block.restart_off);
+ printf(" restarts: %u\n", ti.block.restart_count);
err = table_iter_next_block(&ti);
if (err < 0)
diff --git a/reftable/table.h b/reftable/table.h
index 8d8dd2b413..e15d58d8e9 100644
--- a/reftable/table.h
+++ b/reftable/table.h
@@ -53,8 +53,10 @@ int table_init_iter(struct reftable_table *t,
struct reftable_iterator *it,
uint8_t typ);
-/* initialize a block reader to read from `t` */
-int table_init_block_reader(struct reftable_table *t, struct block_reader *br,
- uint64_t next_off, uint8_t want_typ);
+/*
+ * Initialize a block by reading from the given table and offset.
+ */
+int table_init_block(struct reftable_table *t, struct reftable_block *block,
+ uint64_t next_off, uint8_t want_typ);
#endif
diff --git a/t/unit-tests/t-reftable-block.c b/t/unit-tests/t-reftable-block.c
index dbec6a5d0d..e36ed7ac57 100644
--- a/t/unit-tests/t-reftable-block.c
+++ b/t/unit-tests/t-reftable-block.c
@@ -28,16 +28,16 @@ static void t_ref_block_read_write(void)
};
size_t i = 0;
int ret;
- struct block_reader br = { 0 };
+ struct reftable_block block = { 0 };
struct block_iter it = BLOCK_ITER_INIT;
struct reftable_buf want = REFTABLE_BUF_INIT;
- struct reftable_buf block = REFTABLE_BUF_INIT;
+ struct reftable_buf block_data = REFTABLE_BUF_INIT;
- REFTABLE_CALLOC_ARRAY(block.buf, block_size);
- check(block.buf != NULL);
- block.len = block_size;
+ REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
+ check(block_data.buf != NULL);
+ block_data.len = block_size;
- ret = block_writer_init(&bw, BLOCK_TYPE_REF, (uint8_t *) block.buf, block_size,
+ ret = block_writer_init(&bw, BLOCK_TYPE_REF, (uint8_t *) block_data.buf, block_size,
header_off, hash_size(REFTABLE_HASH_SHA1));
check(!ret);
@@ -63,10 +63,10 @@ static void t_ref_block_read_write(void)
block_writer_release(&bw);
- block_source_from_buf(&source ,&block);
- block_reader_init(&br, &source, 0, header_off, block_size, REFTABLE_HASH_SIZE_SHA1);
+ block_source_from_buf(&source ,&block_data);
+ reftable_block_init(&block, &source, 0, header_off, block_size, REFTABLE_HASH_SIZE_SHA1);
- block_iter_seek_start(&it, &br);
+ block_iter_seek_start(&it, &block);
for (i = 0; ; i++) {
ret = block_iter_next(&it, &rec);
@@ -82,7 +82,7 @@ static void t_ref_block_read_write(void)
block_iter_reset(&it);
reftable_record_key(&recs[i], &want);
- ret = block_iter_seek_key(&it, &br, &want);
+ ret = block_iter_seek_key(&it, &block, &want);
check_int(ret, ==, 0);
ret = block_iter_next(&it, &rec);
@@ -91,7 +91,7 @@ static void t_ref_block_read_write(void)
check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));
want.len--;
- ret = block_iter_seek_key(&it, &br, &want);
+ ret = block_iter_seek_key(&it, &block, &want);
check_int(ret, ==, 0);
ret = block_iter_next(&it, &rec);
@@ -99,11 +99,11 @@ static void t_ref_block_read_write(void)
check(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));
}
- block_reader_release(&br);
+ reftable_block_release(&block);
block_iter_close(&it);
reftable_record_release(&rec);
reftable_buf_release(&want);
- reftable_buf_release(&block);
+ reftable_buf_release(&block_data);
for (i = 0; i < N; i++)
reftable_record_release(&recs[i]);
}
@@ -123,16 +123,16 @@ static void t_log_block_read_write(void)
};
size_t i = 0;
int ret;
- struct block_reader br = { 0 };
+ struct reftable_block block = { 0 };
struct block_iter it = BLOCK_ITER_INIT;
struct reftable_buf want = REFTABLE_BUF_INIT;
- struct reftable_buf block = REFTABLE_BUF_INIT;
+ struct reftable_buf block_data = REFTABLE_BUF_INIT;
- REFTABLE_CALLOC_ARRAY(block.buf, block_size);
- check(block.buf != NULL);
- block.len = block_size;
+ REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
+ check(block_data.buf != NULL);
+ block_data.len = block_size;
- ret = block_writer_init(&bw, BLOCK_TYPE_LOG, (uint8_t *) block.buf, block_size,
+ ret = block_writer_init(&bw, BLOCK_TYPE_LOG, (uint8_t *) block_data.buf, block_size,
header_off, hash_size(REFTABLE_HASH_SHA1));
check(!ret);
@@ -153,10 +153,10 @@ static void t_log_block_read_write(void)
block_writer_release(&bw);
- block_source_from_buf(&source, &block);
- block_reader_init(&br, &source, 0, header_off, block_size, REFTABLE_HASH_SIZE_SHA1);
+ block_source_from_buf(&source, &block_data);
+ reftable_block_init(&block, &source, 0, header_off, block_size, REFTABLE_HASH_SIZE_SHA1);
- block_iter_seek_start(&it, &br);
+ block_iter_seek_start(&it, &block);
for (i = 0; ; i++) {
ret = block_iter_next(&it, &rec);
@@ -173,7 +173,7 @@ static void t_log_block_read_write(void)
reftable_buf_reset(&want);
check(!reftable_buf_addstr(&want, recs[i].u.log.refname));
- ret = block_iter_seek_key(&it, &br, &want);
+ ret = block_iter_seek_key(&it, &block, &want);
check_int(ret, ==, 0);
ret = block_iter_next(&it, &rec);
@@ -182,7 +182,7 @@ static void t_log_block_read_write(void)
check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));
want.len--;
- ret = block_iter_seek_key(&it, &br, &want);
+ ret = block_iter_seek_key(&it, &block, &want);
check_int(ret, ==, 0);
ret = block_iter_next(&it, &rec);
@@ -190,11 +190,11 @@ static void t_log_block_read_write(void)
check(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));
}
- block_reader_release(&br);
+ reftable_block_release(&block);
block_iter_close(&it);
reftable_record_release(&rec);
reftable_buf_release(&want);
- reftable_buf_release(&block);
+ reftable_buf_release(&block_data);
for (i = 0; i < N; i++)
reftable_record_release(&recs[i]);
}
@@ -214,16 +214,16 @@ static void t_obj_block_read_write(void)
};
size_t i = 0;
int ret;
- struct block_reader br = { 0 };
+ struct reftable_block block = { 0 };
struct block_iter it = BLOCK_ITER_INIT;
struct reftable_buf want = REFTABLE_BUF_INIT;
- struct reftable_buf block = REFTABLE_BUF_INIT;
+ struct reftable_buf block_data = REFTABLE_BUF_INIT;
- REFTABLE_CALLOC_ARRAY(block.buf, block_size);
- check(block.buf != NULL);
- block.len = block_size;
+ REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
+ check(block_data.buf != NULL);
+ block_data.len = block_size;
- ret = block_writer_init(&bw, BLOCK_TYPE_OBJ, (uint8_t *) block.buf, block_size,
+ ret = block_writer_init(&bw, BLOCK_TYPE_OBJ, (uint8_t *) block_data.buf, block_size,
header_off, hash_size(REFTABLE_HASH_SHA1));
check(!ret);
@@ -246,10 +246,10 @@ static void t_obj_block_read_write(void)
block_writer_release(&bw);
- block_source_from_buf(&source, &block);
- block_reader_init(&br, &source, 0, header_off, block_size, REFTABLE_HASH_SIZE_SHA1);
+ block_source_from_buf(&source, &block_data);
+ reftable_block_init(&block, &source, 0, header_off, block_size, REFTABLE_HASH_SIZE_SHA1);
- block_iter_seek_start(&it, &br);
+ block_iter_seek_start(&it, &block);
for (i = 0; ; i++) {
ret = block_iter_next(&it, &rec);
@@ -265,7 +265,7 @@ static void t_obj_block_read_write(void)
block_iter_reset(&it);
reftable_record_key(&recs[i], &want);
- ret = block_iter_seek_key(&it, &br, &want);
+ ret = block_iter_seek_key(&it, &block, &want);
check_int(ret, ==, 0);
ret = block_iter_next(&it, &rec);
@@ -274,11 +274,11 @@ static void t_obj_block_read_write(void)
check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));
}
- block_reader_release(&br);
+ reftable_block_release(&block);
block_iter_close(&it);
reftable_record_release(&rec);
reftable_buf_release(&want);
- reftable_buf_release(&block);
+ reftable_buf_release(&block_data);
for (i = 0; i < N; i++)
reftable_record_release(&recs[i]);
}
@@ -299,16 +299,16 @@ static void t_index_block_read_write(void)
};
size_t i = 0;
int ret;
- struct block_reader br = { 0 };
+ struct reftable_block block = { 0 };
struct block_iter it = BLOCK_ITER_INIT;
struct reftable_buf want = REFTABLE_BUF_INIT;
- struct reftable_buf block = REFTABLE_BUF_INIT;
+ struct reftable_buf block_data = REFTABLE_BUF_INIT;
- REFTABLE_CALLOC_ARRAY(block.buf, block_size);
- check(block.buf != NULL);
- block.len = block_size;
+ REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
+ check(block_data.buf != NULL);
+ block_data.len = block_size;
- ret = block_writer_init(&bw, BLOCK_TYPE_INDEX, (uint8_t *) block.buf, block_size,
+ ret = block_writer_init(&bw, BLOCK_TYPE_INDEX, (uint8_t *) block_data.buf, block_size,
header_off, hash_size(REFTABLE_HASH_SHA1));
check(!ret);
@@ -331,10 +331,10 @@ static void t_index_block_read_write(void)
block_writer_release(&bw);
- block_source_from_buf(&source, &block);
- block_reader_init(&br, &source, 0, header_off, block_size, REFTABLE_HASH_SIZE_SHA1);
+ block_source_from_buf(&source, &block_data);
+ reftable_block_init(&block, &source, 0, header_off, block_size, REFTABLE_HASH_SIZE_SHA1);
- block_iter_seek_start(&it, &br);
+ block_iter_seek_start(&it, &block);
for (i = 0; ; i++) {
ret = block_iter_next(&it, &rec);
@@ -350,7 +350,7 @@ static void t_index_block_read_write(void)
block_iter_reset(&it);
reftable_record_key(&recs[i], &want);
- ret = block_iter_seek_key(&it, &br, &want);
+ ret = block_iter_seek_key(&it, &block, &want);
check_int(ret, ==, 0);
ret = block_iter_next(&it, &rec);
@@ -359,7 +359,7 @@ static void t_index_block_read_write(void)
check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));
want.len--;
- ret = block_iter_seek_key(&it, &br, &want);
+ ret = block_iter_seek_key(&it, &block, &want);
check_int(ret, ==, 0);
ret = block_iter_next(&it, &rec);
@@ -367,11 +367,11 @@ static void t_index_block_read_write(void)
check(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));
}
- block_reader_release(&br);
+ reftable_block_release(&block);
block_iter_close(&it);
reftable_record_release(&rec);
reftable_buf_release(&want);
- reftable_buf_release(&block);
+ reftable_buf_release(&block_data);
for (i = 0; i < N; i++)
reftable_record_release(&recs[i]);
}
generated by cgit 1.2.3-korg (git 2.43.0) at 2025-12-05 06:40:40 +0000