reftable/block: rename `block_reader` to `reftable_block`

+71 -71

reftable/block.c

··· 222 222 return block_source_read_data(source, dest, off, sz); 223 223 } 224 224 225 - int block_reader_init(struct block_reader *br, 226 - struct reftable_block_source *source, 227 - uint32_t offset, uint32_t header_size, 228 - uint32_t table_block_size, uint32_t hash_size) 225 + int reftable_block_init(struct reftable_block *block, 226 + struct reftable_block_source *source, 227 + uint32_t offset, uint32_t header_size, 228 + uint32_t table_block_size, uint32_t hash_size) 229 229 { 230 230 uint32_t guess_block_size = table_block_size ? 231 231 table_block_size : DEFAULT_BLOCK_SIZE; ··· 236 236 uint8_t block_type; 237 237 int err; 238 238 239 - err = read_block(source, &br->block_data, offset, guess_block_size); 239 + err = read_block(source, &block->block_data, offset, guess_block_size); 240 240 if (err < 0) 241 241 goto done; 242 242 243 - block_type = br->block_data.data[header_size]; 243 + block_type = block->block_data.data[header_size]; 244 244 if (!reftable_is_block_type(block_type)) { 245 245 err = REFTABLE_FORMAT_ERROR; 246 246 goto done; 247 247 } 248 248 249 - block_size = reftable_get_be24(br->block_data.data + header_size + 1); 249 + block_size = reftable_get_be24(block->block_data.data + header_size + 1); 250 250 if (block_size > guess_block_size) { 251 - err = read_block(source, &br->block_data, offset, block_size); 251 + err = read_block(source, &block->block_data, offset, block_size); 252 252 if (err < 0) 253 253 goto done; 254 254 } ··· 256 256 if (block_type == BLOCK_TYPE_LOG) { 257 257 uint32_t block_header_skip = 4 + header_size; 258 258 uLong dst_len = block_size - block_header_skip; 259 - uLong src_len = br->block_data.len - block_header_skip; 259 + uLong src_len = block->block_data.len - block_header_skip; 260 260 261 261 /* Log blocks specify the *uncompressed* size in their header. */ 262 - REFTABLE_ALLOC_GROW_OR_NULL(br->uncompressed_data, block_size, 263 - br->uncompressed_cap); 264 - if (!br->uncompressed_data) { 262 + REFTABLE_ALLOC_GROW_OR_NULL(block->uncompressed_data, block_size, 263 + block->uncompressed_cap); 264 + if (!block->uncompressed_data) { 265 265 err = REFTABLE_OUT_OF_MEMORY_ERROR; 266 266 goto done; 267 267 } 268 268 269 269 /* Copy over the block header verbatim. It's not compressed. */ 270 - memcpy(br->uncompressed_data, br->block_data.data, block_header_skip); 270 + memcpy(block->uncompressed_data, block->block_data.data, block_header_skip); 271 271 272 - if (!br->zstream) { 273 - REFTABLE_CALLOC_ARRAY(br->zstream, 1); 274 - if (!br->zstream) { 272 + if (!block->zstream) { 273 + REFTABLE_CALLOC_ARRAY(block->zstream, 1); 274 + if (!block->zstream) { 275 275 err = REFTABLE_OUT_OF_MEMORY_ERROR; 276 276 goto done; 277 277 } 278 278 279 - err = inflateInit(br->zstream); 279 + err = inflateInit(block->zstream); 280 280 } else { 281 - err = inflateReset(br->zstream); 281 + err = inflateReset(block->zstream); 282 282 } 283 283 if (err != Z_OK) { 284 284 err = REFTABLE_ZLIB_ERROR; 285 285 goto done; 286 286 } 287 287 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; 288 + block->zstream->next_in = block->block_data.data + block_header_skip; 289 + block->zstream->avail_in = src_len; 290 + block->zstream->next_out = block->uncompressed_data + block_header_skip; 291 + block->zstream->avail_out = dst_len; 292 292 293 293 /* 294 294 * We know both input as well as output size, and we know that ··· 297 297 * here to instruct zlib to inflate the data in one go, which 298 298 * is more efficient than using `Z_NO_FLUSH`. 299 299 */ 300 - err = inflate(br->zstream, Z_FINISH); 300 + err = inflate(block->zstream, Z_FINISH); 301 301 if (err != Z_STREAM_END) { 302 302 err = REFTABLE_ZLIB_ERROR; 303 303 goto done; 304 304 } 305 305 err = 0; 306 306 307 - if (br->zstream->total_out + block_header_skip != block_size) { 307 + if (block->zstream->total_out + block_header_skip != block_size) { 308 308 err = REFTABLE_FORMAT_ERROR; 309 309 goto done; 310 310 } 311 311 312 312 /* We're done with the input data. */ 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; 313 + block_source_release_data(&block->block_data); 314 + block->block_data.data = block->uncompressed_data; 315 + block->block_data.len = block_size; 316 + full_block_size = src_len + block_header_skip - block->zstream->avail_in; 317 317 } else if (full_block_size == 0) { 318 318 full_block_size = block_size; 319 - } else if (block_size < full_block_size && block_size < br->block_data.len && 320 - br->block_data.data[block_size] != 0) { 319 + } else if (block_size < full_block_size && block_size < block->block_data.len && 320 + block->block_data.data[block_size] != 0) { 321 321 /* If the block is smaller than the full block size, it is 322 322 padded (data followed by '\0') or the next block is 323 323 unaligned. */ 324 324 full_block_size = block_size; 325 325 } 326 326 327 - restart_count = reftable_get_be16(br->block_data.data + block_size - 2); 327 + restart_count = reftable_get_be16(block->block_data.data + block_size - 2); 328 328 restart_off = block_size - 2 - 3 * restart_count; 329 329 330 - br->block_type = block_type; 331 - br->hash_size = hash_size; 332 - br->restart_off = restart_off; 333 - br->full_block_size = full_block_size; 334 - br->header_off = header_size; 335 - br->restart_count = restart_count; 330 + block->block_type = block_type; 331 + block->hash_size = hash_size; 332 + block->restart_off = restart_off; 333 + block->full_block_size = full_block_size; 334 + block->header_off = header_size; 335 + block->restart_count = restart_count; 336 336 337 337 err = 0; 338 338 339 339 done: 340 340 if (err < 0) 341 - block_reader_release(br); 341 + reftable_block_release(block); 342 342 return err; 343 343 } 344 344 345 - void block_reader_release(struct block_reader *br) 345 + void reftable_block_release(struct reftable_block *block) 346 346 { 347 - inflateEnd(br->zstream); 348 - reftable_free(br->zstream); 349 - reftable_free(br->uncompressed_data); 350 - block_source_release_data(&br->block_data); 351 - memset(br, 0, sizeof(*br)); 347 + inflateEnd(block->zstream); 348 + reftable_free(block->zstream); 349 + reftable_free(block->uncompressed_data); 350 + block_source_release_data(&block->block_data); 351 + memset(block, 0, sizeof(*block)); 352 352 } 353 353 354 - uint8_t block_reader_type(const struct block_reader *r) 354 + uint8_t reftable_block_type(const struct reftable_block *b) 355 355 { 356 - return r->block_data.data[r->header_off]; 356 + return b->block_data.data[b->header_off]; 357 357 } 358 358 359 - int block_reader_first_key(const struct block_reader *br, struct reftable_buf *key) 359 + int reftable_block_first_key(const struct reftable_block *block, struct reftable_buf *key) 360 360 { 361 - int off = br->header_off + 4, n; 361 + int off = block->header_off + 4, n; 362 362 struct string_view in = { 363 - .buf = br->block_data.data + off, 364 - .len = br->restart_off - off, 363 + .buf = block->block_data.data + off, 364 + .len = block->restart_off - off, 365 365 }; 366 366 uint8_t extra = 0; 367 367 ··· 376 376 return 0; 377 377 } 378 378 379 - static uint32_t block_reader_restart_offset(const struct block_reader *br, size_t idx) 379 + static uint32_t block_restart_offset(const struct reftable_block *b, size_t idx) 380 380 { 381 - return reftable_get_be24(br->block_data.data + br->restart_off + 3 * idx); 381 + return reftable_get_be24(b->block_data.data + b->restart_off + 3 * idx); 382 382 } 383 383 384 - void block_iter_seek_start(struct block_iter *it, const struct block_reader *br) 384 + void block_iter_seek_start(struct block_iter *it, const struct reftable_block *b) 385 385 { 386 - it->block = br->block_data.data; 387 - it->block_len = br->restart_off; 388 - it->hash_size = br->hash_size; 386 + it->block = b->block_data.data; 387 + it->block_len = b->restart_off; 388 + it->hash_size = b->hash_size; 389 389 reftable_buf_reset(&it->last_key); 390 - it->next_off = br->header_off + 4; 390 + it->next_off = b->header_off + 4; 391 391 } 392 392 393 393 struct restart_needle_less_args { 394 394 int error; 395 395 struct reftable_buf needle; 396 - const struct block_reader *reader; 396 + const struct reftable_block *block; 397 397 }; 398 398 399 399 static int restart_needle_less(size_t idx, void *_args) 400 400 { 401 401 struct restart_needle_less_args *args = _args; 402 - uint32_t off = block_reader_restart_offset(args->reader, idx); 402 + uint32_t off = block_restart_offset(args->block, idx); 403 403 struct string_view in = { 404 - .buf = args->reader->block_data.data + off, 405 - .len = args->reader->restart_off - off, 404 + .buf = args->block->block_data.data + off, 405 + .len = args->block->restart_off - off, 406 406 }; 407 407 uint64_t prefix_len, suffix_len; 408 408 uint8_t extra; ··· 477 477 reftable_buf_release(&it->scratch); 478 478 } 479 479 480 - int block_iter_seek_key(struct block_iter *it, const struct block_reader *br, 480 + int block_iter_seek_key(struct block_iter *it, const struct reftable_block *block, 481 481 struct reftable_buf *want) 482 482 { 483 483 struct restart_needle_less_args args = { 484 484 .needle = *want, 485 - .reader = br, 485 + .block = block, 486 486 }; 487 487 struct reftable_record rec; 488 488 int err = 0; ··· 500 500 * restart point. While that works alright, we would end up scanning 501 501 * too many record. 502 502 */ 503 - i = binsearch(br->restart_count, &restart_needle_less, &args); 503 + i = binsearch(block->restart_count, &restart_needle_less, &args); 504 504 if (args.error) { 505 505 err = REFTABLE_FORMAT_ERROR; 506 506 goto done; ··· 525 525 * starting from the preceding restart point. 526 526 */ 527 527 if (i > 0) 528 - it->next_off = block_reader_restart_offset(br, i - 1); 528 + it->next_off = block_restart_offset(block, i - 1); 529 529 else 530 - it->next_off = br->header_off + 4; 531 - it->block = br->block_data.data; 532 - it->block_len = br->restart_off; 533 - it->hash_size = br->hash_size; 530 + it->next_off = block->header_off + 4; 531 + it->block = block->block_data.data; 532 + it->block_len = block->restart_off; 533 + it->hash_size = block->hash_size; 534 534 535 - err = reftable_record_init(&rec, block_reader_type(br)); 535 + err = reftable_record_init(&rec, reftable_block_type(block)); 536 536 if (err < 0) 537 537 goto done; 538 538 539 539 /* 540 540 * We're looking for the last entry less than the wanted key so that 541 541 * the next call to `block_reader_next()` would yield the wanted 542 - * record. We thus don't want to position our reader at the sought 542 + * record. We thus don't want to position our iterator at the sought 543 543 * after record, but one before. To do so, we have to go one entry too 544 544 * far and then back up. 545 545 */

+17 -12

reftable/block.h

··· 64 64 65 65 struct z_stream; 66 66 67 - /* Read a block. */ 68 - struct block_reader { 67 + /* 68 + * A block part of a reftable. Contains records as well as some metadata 69 + * describing them. 70 + */ 71 + struct reftable_block { 69 72 /* offset of the block header; nonzero for the first block in a 70 73 * reftable. */ 71 74 uint32_t header_off; ··· 92 95 uint8_t block_type; 93 96 }; 94 97 95 - /* initializes a block reader. */ 96 - int block_reader_init(struct block_reader *br, 97 - struct reftable_block_source *source, 98 - uint32_t offset, uint32_t header_size, 99 - uint32_t table_block_size, uint32_t hash_size); 98 + /* 99 + * Initialize a reftable block from the given block source. 100 + */ 101 + int reftable_block_init(struct reftable_block *b, 102 + struct reftable_block_source *source, 103 + uint32_t offset, uint32_t header_size, 104 + uint32_t table_block_size, uint32_t hash_size); 100 105 101 - void block_reader_release(struct block_reader *br); 106 + void reftable_block_release(struct reftable_block *b); 102 107 103 108 /* Returns the block type (eg. 'r' for refs) */ 104 - uint8_t block_reader_type(const struct block_reader *r); 109 + uint8_t reftable_block_type(const struct reftable_block *b); 105 110 106 111 /* Decodes the first key in the block */ 107 - int block_reader_first_key(const struct block_reader *br, struct reftable_buf *key); 112 + int reftable_block_first_key(const struct reftable_block *b, struct reftable_buf *key); 108 113 109 114 /* Iterate over entries in a block */ 110 115 struct block_iter { ··· 125 130 } 126 131 127 132 /* Position `it` at start of the block */ 128 - void block_iter_seek_start(struct block_iter *it, const struct block_reader *br); 133 + void block_iter_seek_start(struct block_iter *it, const struct reftable_block *block); 129 134 130 135 /* Position `it` to the `want` key in the block */ 131 - int block_iter_seek_key(struct block_iter *it, const struct block_reader *br, 136 + int block_iter_seek_key(struct block_iter *it, const struct reftable_block *block, 132 137 struct reftable_buf *want); 133 138 134 139 /* return < 0 for error, 0 for OK, > 0 for EOF. */

+4 -5

reftable/iter.c

··· 114 114 { 115 115 struct indexed_table_ref_iter *it = p; 116 116 block_iter_close(&it->cur); 117 - block_source_release_data(&it->block_reader.block_data); 117 + block_source_release_data(&it->block.block_data); 118 118 reftable_free(it->offsets); 119 119 reftable_buf_release(&it->oid); 120 120 } ··· 128 128 return 1; 129 129 } 130 130 131 - block_source_release_data(&it->block_reader.block_data); 131 + block_source_release_data(&it->block.block_data); 132 132 133 133 off = it->offsets[it->offset_idx++]; 134 - err = table_init_block_reader(it->table, &it->block_reader, off, 135 - BLOCK_TYPE_REF); 134 + err = table_init_block(it->table, &it->block, off, BLOCK_TYPE_REF); 136 135 if (err < 0) { 137 136 return err; 138 137 } ··· 140 139 /* indexed block does not exist. */ 141 140 return REFTABLE_FORMAT_ERROR; 142 141 } 143 - block_iter_seek_start(&it->cur, &it->block_reader); 142 + block_iter_seek_start(&it->cur, &it->block); 144 143 return 0; 145 144 } 146 145

+1 -1

reftable/iter.h

··· 68 68 /* Points to the next offset to read. */ 69 69 int offset_idx; 70 70 int offset_len; 71 - struct block_reader block_reader; 71 + struct reftable_block block; 72 72 struct block_iter cur; 73 73 int is_finished; 74 74 };

+23 -23

reftable/table.c

··· 131 131 struct reftable_table *table; 132 132 uint8_t typ; 133 133 uint64_t block_off; 134 - struct block_reader br; 134 + struct reftable_block block; 135 135 struct block_iter bi; 136 136 int is_finished; 137 137 }; ··· 159 159 160 160 static void table_iter_block_done(struct table_iter *ti) 161 161 { 162 - block_reader_release(&ti->br); 162 + reftable_block_release(&ti->block); 163 163 block_iter_reset(&ti->bi); 164 164 } 165 165 166 - int table_init_block_reader(struct reftable_table *t, struct block_reader *br, 167 - uint64_t next_off, uint8_t want_typ) 166 + int table_init_block(struct reftable_table *t, struct reftable_block *block, 167 + uint64_t next_off, uint8_t want_typ) 168 168 { 169 169 uint32_t header_off = next_off ? 0 : header_size(t->version); 170 170 int err; ··· 172 172 if (next_off >= t->size) 173 173 return 1; 174 174 175 - err = block_reader_init(br, &t->source, next_off, header_off, 176 - t->block_size, hash_size(t->hash_id)); 175 + err = reftable_block_init(block, &t->source, next_off, header_off, 176 + t->block_size, hash_size(t->hash_id)); 177 177 if (err < 0) 178 178 goto done; 179 179 180 - if (want_typ != BLOCK_TYPE_ANY && br->block_type != want_typ) { 180 + if (want_typ != BLOCK_TYPE_ANY && block->block_type != want_typ) { 181 181 err = 1; 182 182 goto done; 183 183 } 184 184 185 185 done: 186 186 if (err) 187 - block_reader_release(br); 187 + reftable_block_release(block); 188 188 return err; 189 189 } 190 190 ··· 197 197 198 198 static int table_iter_next_block(struct table_iter *ti) 199 199 { 200 - uint64_t next_block_off = ti->block_off + ti->br.full_block_size; 200 + uint64_t next_block_off = ti->block_off + ti->block.full_block_size; 201 201 int err; 202 202 203 - err = table_init_block_reader(ti->table, &ti->br, next_block_off, ti->typ); 203 + err = table_init_block(ti->table, &ti->block, next_block_off, ti->typ); 204 204 if (err > 0) 205 205 ti->is_finished = 1; 206 206 if (err) ··· 208 208 209 209 ti->block_off = next_block_off; 210 210 ti->is_finished = 0; 211 - block_iter_seek_start(&ti->bi, &ti->br); 211 + block_iter_seek_start(&ti->bi, &ti->block); 212 212 213 213 return 0; 214 214 } ··· 250 250 { 251 251 int err; 252 252 253 - err = table_init_block_reader(ti->table, &ti->br, off, typ); 253 + err = table_init_block(ti->table, &ti->block, off, typ); 254 254 if (err != 0) 255 255 return err; 256 256 257 - ti->typ = block_reader_type(&ti->br); 257 + ti->typ = reftable_block_type(&ti->block); 258 258 ti->block_off = off; 259 - block_iter_seek_start(&ti->bi, &ti->br); 259 + block_iter_seek_start(&ti->bi, &ti->block); 260 260 ti->is_finished = 0; 261 261 return 0; 262 262 } ··· 320 320 * as we have more than three blocks we would have an index, so 321 321 * we would not do a linear search there anymore. 322 322 */ 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; 323 + memset(&next.block.block_data, 0, sizeof(next.block.block_data)); 324 + next.block.zstream = NULL; 325 + next.block.uncompressed_data = NULL; 326 + next.block.uncompressed_cap = 0; 327 327 328 328 err = table_iter_next_block(&next); 329 329 if (err < 0) ··· 331 331 if (err > 0) 332 332 break; 333 333 334 - err = block_reader_first_key(&next.br, &got_key); 334 + err = reftable_block_first_key(&next.block, &got_key); 335 335 if (err < 0) 336 336 goto done; 337 337 ··· 349 349 * the wanted key inside of it. If the block does not contain our key 350 350 * we know that the corresponding record does not exist. 351 351 */ 352 - err = block_iter_seek_key(&ti->bi, &ti->br, &want_key); 352 + err = block_iter_seek_key(&ti->bi, &ti->block, &want_key); 353 353 if (err < 0) 354 354 goto done; 355 355 err = 0; ··· 417 417 if (err != 0) 418 418 goto done; 419 419 420 - err = block_iter_seek_key(&ti->bi, &ti->br, &want_index.u.idx.last_key); 420 + err = block_iter_seek_key(&ti->bi, &ti->block, &want_index.u.idx.last_key); 421 421 if (err < 0) 422 422 goto done; 423 423 ··· 785 785 printf("%s:\n", sections[i].name); 786 786 787 787 while (1) { 788 - printf(" - length: %u\n", ti.br.restart_off); 789 - printf(" restarts: %u\n", ti.br.restart_count); 788 + printf(" - length: %u\n", ti.block.restart_off); 789 + printf(" restarts: %u\n", ti.block.restart_count); 790 790 791 791 err = table_iter_next_block(&ti); 792 792 if (err < 0)

+5 -3

reftable/table.h

··· 53 53 struct reftable_iterator *it, 54 54 uint8_t typ); 55 55 56 - /* initialize a block reader to read from `t` */ 57 - int table_init_block_reader(struct reftable_table *t, struct block_reader *br, 58 - uint64_t next_off, uint8_t want_typ); 56 + /* 57 + * Initialize a block by reading from the given table and offset. 58 + */ 59 + int table_init_block(struct reftable_table *t, struct reftable_block *block, 60 + uint64_t next_off, uint8_t want_typ); 59 61 60 62 #endif

+51 -51

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

··· 28 28 }; 29 29 size_t i = 0; 30 30 int ret; 31 - struct block_reader br = { 0 }; 31 + struct reftable_block block = { 0 }; 32 32 struct block_iter it = BLOCK_ITER_INIT; 33 33 struct reftable_buf want = REFTABLE_BUF_INIT; 34 - struct reftable_buf block = REFTABLE_BUF_INIT; 34 + struct reftable_buf block_data = REFTABLE_BUF_INIT; 35 35 36 - REFTABLE_CALLOC_ARRAY(block.buf, block_size); 37 - check(block.buf != NULL); 38 - block.len = block_size; 36 + REFTABLE_CALLOC_ARRAY(block_data.buf, block_size); 37 + check(block_data.buf != NULL); 38 + block_data.len = block_size; 39 39 40 - ret = block_writer_init(&bw, BLOCK_TYPE_REF, (uint8_t *) block.buf, block_size, 40 + ret = block_writer_init(&bw, BLOCK_TYPE_REF, (uint8_t *) block_data.buf, block_size, 41 41 header_off, hash_size(REFTABLE_HASH_SHA1)); 42 42 check(!ret); 43 43 ··· 63 63 64 64 block_writer_release(&bw); 65 65 66 - block_source_from_buf(&source ,&block); 67 - block_reader_init(&br, &source, 0, header_off, block_size, REFTABLE_HASH_SIZE_SHA1); 66 + block_source_from_buf(&source ,&block_data); 67 + reftable_block_init(&block, &source, 0, header_off, block_size, REFTABLE_HASH_SIZE_SHA1); 68 68 69 - block_iter_seek_start(&it, &br); 69 + block_iter_seek_start(&it, &block); 70 70 71 71 for (i = 0; ; i++) { 72 72 ret = block_iter_next(&it, &rec); ··· 82 82 block_iter_reset(&it); 83 83 reftable_record_key(&recs[i], &want); 84 84 85 - ret = block_iter_seek_key(&it, &br, &want); 85 + ret = block_iter_seek_key(&it, &block, &want); 86 86 check_int(ret, ==, 0); 87 87 88 88 ret = block_iter_next(&it, &rec); ··· 91 91 check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1)); 92 92 93 93 want.len--; 94 - ret = block_iter_seek_key(&it, &br, &want); 94 + ret = block_iter_seek_key(&it, &block, &want); 95 95 check_int(ret, ==, 0); 96 96 97 97 ret = block_iter_next(&it, &rec); ··· 99 99 check(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1)); 100 100 } 101 101 102 - block_reader_release(&br); 102 + reftable_block_release(&block); 103 103 block_iter_close(&it); 104 104 reftable_record_release(&rec); 105 105 reftable_buf_release(&want); 106 - reftable_buf_release(&block); 106 + reftable_buf_release(&block_data); 107 107 for (i = 0; i < N; i++) 108 108 reftable_record_release(&recs[i]); 109 109 } ··· 123 123 }; 124 124 size_t i = 0; 125 125 int ret; 126 - struct block_reader br = { 0 }; 126 + struct reftable_block block = { 0 }; 127 127 struct block_iter it = BLOCK_ITER_INIT; 128 128 struct reftable_buf want = REFTABLE_BUF_INIT; 129 - struct reftable_buf block = REFTABLE_BUF_INIT; 129 + struct reftable_buf block_data = REFTABLE_BUF_INIT; 130 130 131 - REFTABLE_CALLOC_ARRAY(block.buf, block_size); 132 - check(block.buf != NULL); 133 - block.len = block_size; 131 + REFTABLE_CALLOC_ARRAY(block_data.buf, block_size); 132 + check(block_data.buf != NULL); 133 + block_data.len = block_size; 134 134 135 - ret = block_writer_init(&bw, BLOCK_TYPE_LOG, (uint8_t *) block.buf, block_size, 135 + ret = block_writer_init(&bw, BLOCK_TYPE_LOG, (uint8_t *) block_data.buf, block_size, 136 136 header_off, hash_size(REFTABLE_HASH_SHA1)); 137 137 check(!ret); 138 138 ··· 153 153 154 154 block_writer_release(&bw); 155 155 156 - block_source_from_buf(&source, &block); 157 - block_reader_init(&br, &source, 0, header_off, block_size, REFTABLE_HASH_SIZE_SHA1); 156 + block_source_from_buf(&source, &block_data); 157 + reftable_block_init(&block, &source, 0, header_off, block_size, REFTABLE_HASH_SIZE_SHA1); 158 158 159 - block_iter_seek_start(&it, &br); 159 + block_iter_seek_start(&it, &block); 160 160 161 161 for (i = 0; ; i++) { 162 162 ret = block_iter_next(&it, &rec); ··· 173 173 reftable_buf_reset(&want); 174 174 check(!reftable_buf_addstr(&want, recs[i].u.log.refname)); 175 175 176 - ret = block_iter_seek_key(&it, &br, &want); 176 + ret = block_iter_seek_key(&it, &block, &want); 177 177 check_int(ret, ==, 0); 178 178 179 179 ret = block_iter_next(&it, &rec); ··· 182 182 check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1)); 183 183 184 184 want.len--; 185 - ret = block_iter_seek_key(&it, &br, &want); 185 + ret = block_iter_seek_key(&it, &block, &want); 186 186 check_int(ret, ==, 0); 187 187 188 188 ret = block_iter_next(&it, &rec); ··· 190 190 check(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1)); 191 191 } 192 192 193 - block_reader_release(&br); 193 + reftable_block_release(&block); 194 194 block_iter_close(&it); 195 195 reftable_record_release(&rec); 196 196 reftable_buf_release(&want); 197 - reftable_buf_release(&block); 197 + reftable_buf_release(&block_data); 198 198 for (i = 0; i < N; i++) 199 199 reftable_record_release(&recs[i]); 200 200 } ··· 214 214 }; 215 215 size_t i = 0; 216 216 int ret; 217 - struct block_reader br = { 0 }; 217 + struct reftable_block block = { 0 }; 218 218 struct block_iter it = BLOCK_ITER_INIT; 219 219 struct reftable_buf want = REFTABLE_BUF_INIT; 220 - struct reftable_buf block = REFTABLE_BUF_INIT; 220 + struct reftable_buf block_data = REFTABLE_BUF_INIT; 221 221 222 - REFTABLE_CALLOC_ARRAY(block.buf, block_size); 223 - check(block.buf != NULL); 224 - block.len = block_size; 222 + REFTABLE_CALLOC_ARRAY(block_data.buf, block_size); 223 + check(block_data.buf != NULL); 224 + block_data.len = block_size; 225 225 226 - ret = block_writer_init(&bw, BLOCK_TYPE_OBJ, (uint8_t *) block.buf, block_size, 226 + ret = block_writer_init(&bw, BLOCK_TYPE_OBJ, (uint8_t *) block_data.buf, block_size, 227 227 header_off, hash_size(REFTABLE_HASH_SHA1)); 228 228 check(!ret); 229 229 ··· 246 246 247 247 block_writer_release(&bw); 248 248 249 - block_source_from_buf(&source, &block); 250 - block_reader_init(&br, &source, 0, header_off, block_size, REFTABLE_HASH_SIZE_SHA1); 249 + block_source_from_buf(&source, &block_data); 250 + reftable_block_init(&block, &source, 0, header_off, block_size, REFTABLE_HASH_SIZE_SHA1); 251 251 252 - block_iter_seek_start(&it, &br); 252 + block_iter_seek_start(&it, &block); 253 253 254 254 for (i = 0; ; i++) { 255 255 ret = block_iter_next(&it, &rec); ··· 265 265 block_iter_reset(&it); 266 266 reftable_record_key(&recs[i], &want); 267 267 268 - ret = block_iter_seek_key(&it, &br, &want); 268 + ret = block_iter_seek_key(&it, &block, &want); 269 269 check_int(ret, ==, 0); 270 270 271 271 ret = block_iter_next(&it, &rec); ··· 274 274 check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1)); 275 275 } 276 276 277 - block_reader_release(&br); 277 + reftable_block_release(&block); 278 278 block_iter_close(&it); 279 279 reftable_record_release(&rec); 280 280 reftable_buf_release(&want); 281 - reftable_buf_release(&block); 281 + reftable_buf_release(&block_data); 282 282 for (i = 0; i < N; i++) 283 283 reftable_record_release(&recs[i]); 284 284 } ··· 299 299 }; 300 300 size_t i = 0; 301 301 int ret; 302 - struct block_reader br = { 0 }; 302 + struct reftable_block block = { 0 }; 303 303 struct block_iter it = BLOCK_ITER_INIT; 304 304 struct reftable_buf want = REFTABLE_BUF_INIT; 305 - struct reftable_buf block = REFTABLE_BUF_INIT; 305 + struct reftable_buf block_data = REFTABLE_BUF_INIT; 306 306 307 - REFTABLE_CALLOC_ARRAY(block.buf, block_size); 308 - check(block.buf != NULL); 309 - block.len = block_size; 307 + REFTABLE_CALLOC_ARRAY(block_data.buf, block_size); 308 + check(block_data.buf != NULL); 309 + block_data.len = block_size; 310 310 311 - ret = block_writer_init(&bw, BLOCK_TYPE_INDEX, (uint8_t *) block.buf, block_size, 311 + ret = block_writer_init(&bw, BLOCK_TYPE_INDEX, (uint8_t *) block_data.buf, block_size, 312 312 header_off, hash_size(REFTABLE_HASH_SHA1)); 313 313 check(!ret); 314 314 ··· 331 331 332 332 block_writer_release(&bw); 333 333 334 - block_source_from_buf(&source, &block); 335 - block_reader_init(&br, &source, 0, header_off, block_size, REFTABLE_HASH_SIZE_SHA1); 334 + block_source_from_buf(&source, &block_data); 335 + reftable_block_init(&block, &source, 0, header_off, block_size, REFTABLE_HASH_SIZE_SHA1); 336 336 337 - block_iter_seek_start(&it, &br); 337 + block_iter_seek_start(&it, &block); 338 338 339 339 for (i = 0; ; i++) { 340 340 ret = block_iter_next(&it, &rec); ··· 350 350 block_iter_reset(&it); 351 351 reftable_record_key(&recs[i], &want); 352 352 353 - ret = block_iter_seek_key(&it, &br, &want); 353 + ret = block_iter_seek_key(&it, &block, &want); 354 354 check_int(ret, ==, 0); 355 355 356 356 ret = block_iter_next(&it, &rec); ··· 359 359 check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1)); 360 360 361 361 want.len--; 362 - ret = block_iter_seek_key(&it, &br, &want); 362 + ret = block_iter_seek_key(&it, &block, &want); 363 363 check_int(ret, ==, 0); 364 364 365 365 ret = block_iter_next(&it, &rec); ··· 367 367 check(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1)); 368 368 } 369 369 370 - block_reader_release(&br); 370 + reftable_block_release(&block); 371 371 block_iter_close(&it); 372 372 reftable_record_release(&rec); 373 373 reftable_buf_release(&want); 374 - reftable_buf_release(&block); 374 + reftable_buf_release(&block_data); 375 375 for (i = 0; i < N; i++) 376 376 reftable_record_release(&recs[i]); 377 377 }