@matheusbsbs / matheus-bagliano / commits / 2b3362c10d

reftable/block: rename `block` to `block_data`

The `reftable_block` structure associates a byte slice with a block source. As such it only holds the data of a reftable block without actually encoding any of the details for how to access that data. Rename the structure to instead be called `reftable_block_data`. Besides clarifying that this really only holds data, it also allows us to rename the `reftable_block_reader` to `reftable_block` in the next commit, as this is the structure that actually encapsulates access to the reftable blocks. Rename the `struct reftable_block_reader::block` member accordingly. Signed-off-by: Patrick Steinhardt <ps@pks.im> Signed-off-by: Junio C Hamano <gitster@pobox.com>

Patrick Steinhardt committed Apr 7, 2025 at 15:16 UTC 2b3362c10d39efe09fe9ef16122df3bed5149032

8 files changed +73 -73

reftable/block.c

+23 -23

@@ -210,16 +210,16 @@ int block_writer_finish(struct block_writer *w)

210 }

211

212 static int read_block(struct reftable_block_source *source,

213 - struct reftable_block *dest, uint64_t off,

213 + struct reftable_block_data *dest, uint64_t off,

214 uint32_t sz)

215 {

216 size_t size = block_source_size(source);

217 - block_source_return_block(dest);

217 + block_source_release_data(dest);

218 if (off >= size)

219 return 0;

220 if (off + sz > size)

221 sz = size - off;

222 - return block_source_read_block(source, dest, off, sz);

222 + return block_source_read_data(source, dest, off, sz);

223 }

224

225 int block_reader_init(struct block_reader *br,

@@ -236,19 +236,19 @@ int block_reader_init(struct block_reader *br,

236 uint8_t block_type;

237 int err;

238

239 - err = read_block(source, &br->block, offset, guess_block_size);

239 + err = read_block(source, &br->block_data, offset, guess_block_size);

240 if (err < 0)

241 goto done;

242

243 - block_type = br->block.data[header_size];

243 + block_type = br->block_data.data[header_size];

244 if (!reftable_is_block_type(block_type)) {

245 err = REFTABLE_FORMAT_ERROR;

246 goto done;

247 }

248

249 - block_size = reftable_get_be24(br->block.data + header_size + 1);

249 + block_size = reftable_get_be24(br->block_data.data + header_size + 1);

250 if (block_size > guess_block_size) {

251 - err = read_block(source, &br->block, offset, block_size);

251 + err = read_block(source, &br->block_data, offset, block_size);

252 if (err < 0)

253 goto done;

254 }

@@ -256,7 +256,7 @@ int block_reader_init(struct block_reader *br,

256 if (block_type == BLOCK_TYPE_LOG) {

257 uint32_t block_header_skip = 4 + header_size;

258 uLong dst_len = block_size - block_header_skip;

259 - uLong src_len = br->block.len - block_header_skip;

259 + uLong src_len = br->block_data.len - block_header_skip;

260

261 /* Log blocks specify the *uncompressed* size in their header. */

262 REFTABLE_ALLOC_GROW_OR_NULL(br->uncompressed_data, block_size,

@@ -267,7 +267,7 @@ int block_reader_init(struct block_reader *br,

267 }

268

269 /* Copy over the block header verbatim. It's not compressed. */

270 - memcpy(br->uncompressed_data, br->block.data, block_header_skip);

270 + memcpy(br->uncompressed_data, br->block_data.data, block_header_skip);

271

272 if (!br->zstream) {

273 REFTABLE_CALLOC_ARRAY(br->zstream, 1);

@@ -285,7 +285,7 @@ int block_reader_init(struct block_reader *br,

285 goto done;

286 }

287

288 - br->zstream->next_in = br->block.data + block_header_skip;

288 + br->zstream->next_in = br->block_data.data + block_header_skip;

289 br->zstream->avail_in = src_len;

290 br->zstream->next_out = br->uncompressed_data + block_header_skip;

291 br->zstream->avail_out = dst_len;

@@ -310,21 +310,21 @@ int block_reader_init(struct block_reader *br,

310 }

311

312 /* We're done with the input data. */

313 - block_source_return_block(&br->block);

314 - br->block.data = br->uncompressed_data;

315 - br->block.len = block_size;

313 + block_source_release_data(&br->block_data);

314 + br->block_data.data = br->uncompressed_data;

315 + br->block_data.len = block_size;

316 full_block_size = src_len + block_header_skip - br->zstream->avail_in;

317 } else if (full_block_size == 0) {

318 full_block_size = block_size;

319 - } else if (block_size < full_block_size && block_size < br->block.len &&

320 - br->block.data[block_size] != 0) {

319 + } else if (block_size < full_block_size && block_size < br->block_data.len &&

320 + br->block_data.data[block_size] != 0) {

321 /* If the block is smaller than the full block size, it is

322 padded (data followed by '\0') or the next block is

323 unaligned. */

324 full_block_size = block_size;

325 }

326

327 - restart_count = reftable_get_be16(br->block.data + block_size - 2);

327 + restart_count = reftable_get_be16(br->block_data.data + block_size - 2);

328 restart_off = block_size - 2 - 3 * restart_count;

329

330 br->block_type = block_type;

@@ -347,20 +347,20 @@ void block_reader_release(struct block_reader *br)

347 inflateEnd(br->zstream);

348 reftable_free(br->zstream);

349 reftable_free(br->uncompressed_data);

350 - block_source_return_block(&br->block);

350 + block_source_release_data(&br->block_data);

351 memset(br, 0, sizeof(*br));

352 }

353

354 uint8_t block_reader_type(const struct block_reader *r)

355 {

356 - return r->block.data[r->header_off];

356 + return r->block_data.data[r->header_off];

357 }

358

359 int block_reader_first_key(const struct block_reader *br, struct reftable_buf *key)

360 {

361 int off = br->header_off + 4, n;

362 struct string_view in = {

363 - .buf = br->block.data + off,

363 + .buf = br->block_data.data + off,

364 .len = br->restart_off - off,

365 };

366 uint8_t extra = 0;

@@ -378,12 +378,12 @@ int block_reader_first_key(const struct block_reader *br, struct reftable_buf *k

378

379 static uint32_t block_reader_restart_offset(const struct block_reader *br, size_t idx)

380 {

381 - return reftable_get_be24(br->block.data + br->restart_off + 3 * idx);

381 + return reftable_get_be24(br->block_data.data + br->restart_off + 3 * idx);

382 }

383

384 void block_iter_seek_start(struct block_iter *it, const struct block_reader *br)

385 {

386 - it->block = br->block.data;

386 + it->block = br->block_data.data;

387 it->block_len = br->restart_off;

388 it->hash_size = br->hash_size;

389 reftable_buf_reset(&it->last_key);

@@ -401,7 +401,7 @@ static int restart_needle_less(size_t idx, void *_args)

401 struct restart_needle_less_args *args = _args;

402 uint32_t off = block_reader_restart_offset(args->reader, idx);

403 struct string_view in = {

404 - .buf = args->reader->block.data + off,

404 + .buf = args->reader->block_data.data + off,

405 .len = args->reader->restart_off - off,

406 };

407 uint64_t prefix_len, suffix_len;

@@ -528,7 +528,7 @@ int block_iter_seek_key(struct block_iter *it, const struct block_reader *br,

528 it->next_off = block_reader_restart_offset(br, i - 1);

529 else

530 it->next_off = br->header_off + 4;

531 - it->block = br->block.data;

531 + it->block = br->block_data.data;

532 it->block_len = br->restart_off;

533 it->hash_size = br->hash_size;

534

reftable/block.h

+1 -1

@@ -71,7 +71,7 @@ struct block_reader {

71 uint32_t header_off;

73 /* the memory block */

74 - struct reftable_block block;

74 + struct reftable_block_data block_data;

75 uint32_t hash_size;

77 /* Uncompressed data for log entries. */

reftable/blocksource.c

+22 -22

@@ -13,15 +13,15 @@

13 #include "reftable-blocksource.h"

14 #include "reftable-error.h"

16 -void block_source_return_block(struct reftable_block *block)

16 +void block_source_release_data(struct reftable_block_data *data)

17 {

18 - struct reftable_block_source source = block->source;

19 - if (block && source.ops)

20 - source.ops->return_block(source.arg, block);

21 - block->data = NULL;

22 - block->len = 0;

23 - block->source.ops = NULL;

24 - block->source.arg = NULL;

18 + struct reftable_block_source source = data->source;

19 + if (data && source.ops)

20 + source.ops->release_data(source.arg, data);

21 + data->data = NULL;

22 + data->len = 0;

23 + data->source.ops = NULL;

24 + data->source.arg = NULL;

25 }

27 void block_source_close(struct reftable_block_source *source)

@@ -34,11 +34,11 @@ void block_source_close(struct reftable_block_source *source)

34 source->ops = NULL;

35 }

37 -ssize_t block_source_read_block(struct reftable_block_source *source,

38 - struct reftable_block *dest, uint64_t off,

39 - uint32_t size)

37 +ssize_t block_source_read_data(struct reftable_block_source *source,

38 + struct reftable_block_data *dest, uint64_t off,

39 + uint32_t size)

40 {

41 - ssize_t result = source->ops->read_block(source->arg, dest, off, size);

41 + ssize_t result = source->ops->read_data(source->arg, dest, off, size);

42 dest->source = *source;

43 return result;

44 }

@@ -48,7 +48,7 @@ uint64_t block_source_size(struct reftable_block_source *source)

48 return source->ops->size(source->arg);

49 }

51 -static void reftable_buf_return_block(void *b REFTABLE_UNUSED, struct reftable_block *dest)

51 +static void reftable_buf_release_data(void *b REFTABLE_UNUSED, struct reftable_block_data *dest)

52 {

53 if (dest->len)

54 memset(dest->data, 0xff, dest->len);

@@ -59,8 +59,8 @@ static void reftable_buf_close(void *b REFTABLE_UNUSED)

59 {

60 }

62 -static ssize_t reftable_buf_read_block(void *v, struct reftable_block *dest,

63 - uint64_t off, uint32_t size)

62 +static ssize_t reftable_buf_read_data(void *v, struct reftable_block_data *dest,

63 + uint64_t off, uint32_t size)

64 {

65 struct reftable_buf *b = v;

66 assert(off + size <= b->len);

@@ -79,8 +79,8 @@ static uint64_t reftable_buf_size(void *b)

80 static struct reftable_block_source_vtable reftable_buf_vtable = {

81 .size = &reftable_buf_size,

82 - .read_block = &reftable_buf_read_block,

83 - .return_block = &reftable_buf_return_block,

82 + .read_data = &reftable_buf_read_data,

83 + .release_data = &reftable_buf_release_data,

84 .close = &reftable_buf_close,

85 };

@@ -102,7 +102,7 @@ static uint64_t file_size(void *b)

102 return ((struct file_block_source *)b)->size;

103 }

104

105 -static void file_return_block(void *b REFTABLE_UNUSED, struct reftable_block *dest REFTABLE_UNUSED)

105 +static void file_release_data(void *b REFTABLE_UNUSED, struct reftable_block_data *dest REFTABLE_UNUSED)

106 {

107 }

108

@@ -113,8 +113,8 @@ static void file_close(void *v)

113 reftable_free(b);

114 }

115

116 -static ssize_t file_read_block(void *v, struct reftable_block *dest, uint64_t off,

117 - uint32_t size)

116 +static ssize_t file_read_data(void *v, struct reftable_block_data *dest, uint64_t off,

117 + uint32_t size)

118 {

119 struct file_block_source *b = v;

120 assert(off + size <= b->size);

@@ -125,8 +125,8 @@ static ssize_t file_read_block(void *v, struct reftable_block *dest, uint64_t of

125

126 static struct reftable_block_source_vtable file_vtable = {

127 .size = &file_size,

128 - .read_block = &file_read_block,

129 - .return_block = &file_return_block,

128 + .read_data = &file_read_data,

129 + .release_data = &file_release_data,

130 .close = &file_close,

131 };

132

reftable/blocksource.h

+5 -5

@@ -12,7 +12,7 @@

12 #include "system.h"

14 struct reftable_block_source;

15 -struct reftable_block;

15 +struct reftable_block_data;

16 struct reftable_buf;

18 /*

@@ -24,9 +24,9 @@ void block_source_close(struct reftable_block_source *source);

24 /*

25 * Read a block of length `size` from the source at the given `off`.

26 */

27 -ssize_t block_source_read_block(struct reftable_block_source *source,

28 - struct reftable_block *dest, uint64_t off,

29 - uint32_t size);

27 +ssize_t block_source_read_data(struct reftable_block_source *source,

28 + struct reftable_block_data *dest, uint64_t off,

29 + uint32_t size);

31 /*

32 * Return the total length of the underlying resource.

@@ -37,7 +37,7 @@ uint64_t block_source_size(struct reftable_block_source *source);

37 * Return a block to its original source, releasing any resources associated

38 * with it.

39 */

40 -void block_source_return_block(struct reftable_block *block);

40 +void block_source_release_data(struct reftable_block_data *data);

42 /* Create an in-memory block source for reading reftables. */

43 void block_source_from_buf(struct reftable_block_source *bs,

reftable/iter.c

+2 -2

@@ -114,7 +114,7 @@ static void indexed_table_ref_iter_close(void *p)

114 {

115 struct indexed_table_ref_iter *it = p;

116 block_iter_close(&it->cur);

117 - block_source_return_block(&it->block_reader.block);

117 + block_source_release_data(&it->block_reader.block_data);

118 reftable_free(it->offsets);

119 reftable_buf_release(&it->oid);

120 }

@@ -128,7 +128,7 @@ static int indexed_table_ref_iter_next_block(struct indexed_table_ref_iter *it)

128 return 1;

129 }

130

131 - block_source_return_block(&it->block_reader.block);

131 + block_source_release_data(&it->block_reader.block_data);

132

133 off = it->offsets[it->offset_idx++];

134 err = table_init_block_reader(it->table, &it->block_reader, off,

reftable/reftable-blocksource.h

+7 -7

@@ -21,7 +21,7 @@ struct reftable_block_source {

22 /* a contiguous segment of bytes. It keeps track of its generating block_source

23 * so it can return itself into the pool. */

24 -struct reftable_block {

24 +struct reftable_block_data {

25 uint8_t *data;

26 size_t len;

27 struct reftable_block_source source;

@@ -29,20 +29,20 @@ struct reftable_block {

30 /* block_source_vtable are the operations that make up block_source */

31 struct reftable_block_source_vtable {

32 - /* returns the size of a block source */

32 + /* Returns the size of a block source. */

33 uint64_t (*size)(void *source);

35 /*

36 * Reads a segment from the block source. It is an error to read beyond

37 * the end of the block.

38 */

39 - ssize_t (*read_block)(void *source, struct reftable_block *dest,

40 - uint64_t off, uint32_t size);

39 + ssize_t (*read_data)(void *source, struct reftable_block_data *dest,

40 + uint64_t off, uint32_t size);

42 - /* mark the block as read; may return the data back to malloc */

43 - void (*return_block)(void *source, struct reftable_block *blockp);

42 + /* Mark the block as read; may release the data. */

43 + void (*release_data)(void *source, struct reftable_block_data *data);

45 - /* release all resources associated with the block source */

45 + /* Release all resources associated with the block source. */

46 void (*close)(void *source);

47 };

reftable/table.c

+8 -8

@@ -320,7 +320,7 @@ static int table_iter_seek_linear(struct table_iter *ti,

320 * as we have more than three blocks we would have an index, so

321 * we would not do a linear search there anymore.

322 */

323 - memset(&next.br.block, 0, sizeof(next.br.block));

323 + memset(&next.br.block_data, 0, sizeof(next.br.block_data));

324 next.br.zstream = NULL;

325 next.br.uncompressed_data = NULL;

326 next.br.uncompressed_cap = 0;

@@ -526,8 +526,8 @@ int reftable_table_init_log_iterator(struct reftable_table *t,

526 int reftable_table_new(struct reftable_table **out,

527 struct reftable_block_source *source, char const *name)

528 {

529 - struct reftable_block footer = { 0 };

530 - struct reftable_block header = { 0 };

529 + struct reftable_block_data footer = { 0 };

530 + struct reftable_block_data header = { 0 };

531 struct reftable_table *t;

532 uint64_t file_size = block_source_size(source);

533 uint32_t read_size;

@@ -550,7 +550,7 @@ int reftable_table_new(struct reftable_table **out,

550 goto done;

551 }

552

553 - bytes_read = block_source_read_block(source, &header, 0, read_size);

553 + bytes_read = block_source_read_data(source, &header, 0, read_size);

554 if (bytes_read < 0 || (size_t)bytes_read != read_size) {

555 err = REFTABLE_IO_ERROR;

556 goto done;

@@ -576,8 +576,8 @@ int reftable_table_new(struct reftable_table **out,

576 t->hash_id = 0;

577 t->refcount = 1;

578

579 - bytes_read = block_source_read_block(source, &footer, t->size,

580 - footer_size(t->version));

579 + bytes_read = block_source_read_data(source, &footer, t->size,

580 + footer_size(t->version));

581 if (bytes_read < 0 || (size_t)bytes_read != footer_size(t->version)) {

582 err = REFTABLE_IO_ERROR;

583 goto done;

@@ -590,8 +590,8 @@ int reftable_table_new(struct reftable_table **out,

590 *out = t;

591

592 done:

593 - block_source_return_block(&footer);

594 - block_source_return_block(&header);

593 + block_source_release_data(&footer);

594 + block_source_release_data(&header);

595 if (err) {

596 if (t)

597 reftable_free(t->name);

t/unit-tests/t-reftable-readwrite.c

+5 -5

@@ -23,22 +23,22 @@ static void t_buffer(void)

23 {

24 struct reftable_buf buf = REFTABLE_BUF_INIT;

25 struct reftable_block_source source = { 0 };

26 - struct reftable_block out = { 0 };

26 + struct reftable_block_data out = { 0 };

27 int n;

28 uint8_t in[] = "hello";

29 check(!reftable_buf_add(&buf, in, sizeof(in)));

30 block_source_from_buf(&source, &buf);

31 check_int(block_source_size(&source), ==, 6);

32 - n = block_source_read_block(&source, &out, 0, sizeof(in));

32 + n = block_source_read_data(&source, &out, 0, sizeof(in));

33 check_int(n, ==, sizeof(in));

34 check(!memcmp(in, out.data, n));

35 - block_source_return_block(&out);

35 + block_source_release_data(&out);

37 - n = block_source_read_block(&source, &out, 1, 2);

37 + n = block_source_read_data(&source, &out, 1, 2);

38 check_int(n, ==, 2);

39 check(!memcmp(out.data, "el", 2));

41 - block_source_return_block(&out);

41 + block_source_release_data(&out);

42 block_source_close(&source);

43 reftable_buf_release(&buf);

44 }