mirrors/git
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

reftable: introduce macros to allocate arrays

Browse Source 
Similar to the preceding commit, let's carry over macros to allocate
arrays with `REFTABLE_ALLOC_ARRAY()` and `REFTABLE_CALLOC_ARRAY()`. This
requires us to change the signature of `reftable_calloc()`, which only
takes a single argument right now and thus puts the burden on the caller
to calculate the final array's size. This is a net improvement though as
it means that we can now provide proper overflow checks when multiplying
the array size with the member size.

Convert callsites of `reftable_calloc()` to the new signature and start
using the new macros where possible.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Patrick Steinhardt
2024-02-06 07:35:27 +01:00
committed by Junio C Hamano
parent f6b58c1be4
commit b4ff12c8ee
16 changed files with 68 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
reftable/basics.h
View File

@ -51,8 +51,10 @@ int names_length(char **names);
void *reftable_malloc(size_t sz); void *reftable_malloc(size_t sz);
void *reftable_realloc(void *p, size_t sz); void *reftable_realloc(void *p, size_t sz);
void reftable_free(void *p); void reftable_free(void *p);
void *reftable_calloc(size_t sz); void *reftable_calloc(size_t nelem, size_t elsize);
#define REFTABLE_ALLOC_ARRAY(x, alloc) (x) = reftable_malloc(st_mult(sizeof(*(x)), (alloc)))
#define REFTABLE_CALLOC_ARRAY(x, alloc) (x) = reftable_calloc((alloc), sizeof(*(x)))
#define REFTABLE_REALLOC_ARRAY(x, alloc) (x) = reftable_realloc((x), st_mult(sizeof(*(x)), (alloc))) #define REFTABLE_REALLOC_ARRAY(x, alloc) (x) = reftable_realloc((x), st_mult(sizeof(*(x)), (alloc)))
#define REFTABLE_ALLOC_GROW(x, nr, alloc) \ #define REFTABLE_ALLOC_GROW(x, nr, alloc) \
do { \ do { \

10
reftable/block.c
View File

@ -143,8 +143,10 @@ int block_writer_finish(struct block_writer *w)
int block_header_skip = 4 + w->header_off; int block_header_skip = 4 + w->header_off;
uLongf src_len = w->next - block_header_skip; uLongf src_len = w->next - block_header_skip;
uLongf dest_cap = src_len * 1.001 + 12; uLongf dest_cap = src_len * 1.001 + 12;
uint8_t *compressed;
REFTABLE_ALLOC_ARRAY(compressed, dest_cap);
uint8_t *compressed = reftable_malloc(dest_cap);
while (1) { while (1) {
uLongf out_dest_len = dest_cap; uLongf out_dest_len = dest_cap;
int zresult = compress2(compressed, &out_dest_len, int zresult = compress2(compressed, &out_dest_len,
@ -201,9 +203,9 @@ int block_reader_init(struct block_reader *br, struct reftable_block *block,
uLongf dst_len = sz - block_header_skip; /* total size of dest uLongf dst_len = sz - block_header_skip; /* total size of dest
buffer. */ buffer. */
uLongf src_len = block->len - block_header_skip; uLongf src_len = block->len - block_header_skip;
/* Log blocks specify the *uncompressed* size in their header.
*/ /* Log blocks specify the *uncompressed* size in their header. */
uncompressed = reftable_malloc(sz); REFTABLE_ALLOC_ARRAY(uncompressed, sz);
/* Copy over the block header verbatim. It's not compressed. */ /* Copy over the block header verbatim. It's not compressed. */
memcpy(uncompressed, block->data, block_header_skip); memcpy(uncompressed, block->data, block_header_skip);

2
reftable/block_test.c
View File

@ -36,7 +36,7 @@ static void test_block_read_write(void)
int j = 0; int j = 0;
struct strbuf want = STRBUF_INIT; struct strbuf want = STRBUF_INIT;
block.data = reftable_calloc(block_size); REFTABLE_CALLOC_ARRAY(block.data, block_size);
block.len = block_size; block.len = block_size;
block.source = malloc_block_source(); block.source = malloc_block_source();
block_writer_init(&bw, BLOCK_TYPE_REF, block.data, block_size, block_writer_init(&bw, BLOCK_TYPE_REF, block.data, block_size,

4
reftable/blocksource.c
View File

@ -29,7 +29,7 @@ static int strbuf_read_block(void *v, struct reftable_block *dest, uint64_t off,
{ {
struct strbuf *b = v; struct strbuf *b = v;
assert(off + size <= b->len); assert(off + size <= b->len);
dest->data = reftable_calloc(size); REFTABLE_CALLOC_ARRAY(dest->data, size);
memcpy(dest->data, b->buf + off, size); memcpy(dest->data, b->buf + off, size);
dest->len = size; dest->len = size;
return size; return size;
@ -132,7 +132,7 @@ int reftable_block_source_from_file(struct reftable_block_source *bs,
return REFTABLE_IO_ERROR; return REFTABLE_IO_ERROR;
} }
p = reftable_calloc(sizeof(*p)); REFTABLE_CALLOC_ARRAY(p, 1);
p->size = st.st_size; p->size = st.st_size;
p->data = xmmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); p->data = xmmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
close(fd); close(fd);

3
reftable/iter.c
View File

@ -160,8 +160,7 @@ int new_indexed_table_ref_iter(struct indexed_table_ref_iter **dest,
int oid_len, uint64_t *offsets, int offset_len) int oid_len, uint64_t *offsets, int offset_len)
{ {
struct indexed_table_ref_iter empty = INDEXED_TABLE_REF_ITER_INIT; struct indexed_table_ref_iter empty = INDEXED_TABLE_REF_ITER_INIT;
struct indexed_table_ref_iter *itr = struct indexed_table_ref_iter *itr = reftable_calloc(1, sizeof(*itr));
reftable_calloc(sizeof(struct indexed_table_ref_iter));
int err = 0; int err = 0;
*itr = empty; *itr = empty;

4
reftable/merged.c
View File

@ -190,7 +190,7 @@ int reftable_new_merged_table(struct reftable_merged_table **dest,
} }
} }
m = reftable_calloc(sizeof(struct reftable_merged_table)); REFTABLE_CALLOC_ARRAY(m, 1);
m->stack = stack; m->stack = stack;
m->stack_len = n; m->stack_len = n;
m->min = first_min; m->min = first_min;
@ -240,7 +240,7 @@ static int merged_table_seek_record(struct reftable_merged_table *mt,
struct reftable_record *rec) struct reftable_record *rec)
{ {
struct reftable_iterator *iters = reftable_calloc( struct reftable_iterator *iters = reftable_calloc(
sizeof(struct reftable_iterator) * mt->stack_len); mt->stack_len, sizeof(*iters));
struct merged_iter merged = { struct merged_iter merged = {
.stack = iters, .stack = iters,
.typ = reftable_record_type(rec), .typ = reftable_record_type(rec),

22
reftable/merged_test.c
View File

@ -93,10 +93,12 @@ merged_table_from_records(struct reftable_ref_record **refs,
int i = 0; int i = 0;
struct reftable_merged_table *mt = NULL; struct reftable_merged_table *mt = NULL;
int err; int err;
struct reftable_table *tabs = struct reftable_table *tabs;
reftable_calloc(n * sizeof(struct reftable_table));
*readers = reftable_calloc(n * sizeof(struct reftable_reader *)); REFTABLE_CALLOC_ARRAY(tabs, n);
*source = reftable_calloc(n * sizeof(**source)); REFTABLE_CALLOC_ARRAY(*readers, n);
REFTABLE_CALLOC_ARRAY(*source, n);
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
write_test_table(&buf[i], refs[i], sizes[i]); write_test_table(&buf[i], refs[i], sizes[i]);
block_source_from_strbuf(&(*source)[i], &buf[i]); block_source_from_strbuf(&(*source)[i], &buf[i]);
@ -266,10 +268,12 @@ merged_table_from_log_records(struct reftable_log_record **logs,
int i = 0; int i = 0;
struct reftable_merged_table *mt = NULL; struct reftable_merged_table *mt = NULL;
int err; int err;
struct reftable_table *tabs = struct reftable_table *tabs;
reftable_calloc(n * sizeof(struct reftable_table));
*readers = reftable_calloc(n * sizeof(struct reftable_reader *)); REFTABLE_CALLOC_ARRAY(tabs, n);
*source = reftable_calloc(n * sizeof(**source)); REFTABLE_CALLOC_ARRAY(*readers, n);
REFTABLE_CALLOC_ARRAY(*source, n);
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
write_test_log_table(&buf[i], logs[i], sizes[i], i + 1); write_test_log_table(&buf[i], logs[i], sizes[i], i + 1);
block_source_from_strbuf(&(*source)[i], &buf[i]); block_source_from_strbuf(&(*source)[i], &buf[i]);
@ -412,7 +416,7 @@ static void test_default_write_opts(void)
}; };
int err; int err;
struct reftable_block_source source = { NULL }; struct reftable_block_source source = { NULL };
struct reftable_table *tab = reftable_calloc(sizeof(*tab) * 1); struct reftable_table *tab = reftable_calloc(1, sizeof(*tab));
uint32_t hash_id; uint32_t hash_id;
struct reftable_reader *rd = NULL; struct reftable_reader *rd = NULL;
struct reftable_merged_table *merged = NULL; struct reftable_merged_table *merged = NULL;

3
reftable/publicbasics.c
View File

@ -37,8 +37,9 @@ void reftable_free(void *p)
free(p); free(p);
} }
void *reftable_calloc(size_t sz) void *reftable_calloc(size_t nelem, size_t elsize)
{ {
size_t sz = st_mult(nelem, elsize);
void *p = reftable_malloc(sz); void *p = reftable_malloc(sz);
memset(p, 0, sz); memset(p, 0, sz);
return p; return p;

8
reftable/reader.c
View File

@ -539,8 +539,7 @@ static int reader_seek_indexed(struct reftable_reader *r,
if (err == 0) { if (err == 0) {
struct table_iter empty = TABLE_ITER_INIT; struct table_iter empty = TABLE_ITER_INIT;
struct table_iter *malloced = struct table_iter *malloced = reftable_calloc(1, sizeof(*malloced));
reftable_calloc(sizeof(struct table_iter));
*malloced = empty; *malloced = empty;
table_iter_copy_from(malloced, &next); table_iter_copy_from(malloced, &next);
iterator_from_table_iter(it, malloced); iterator_from_table_iter(it, malloced);
@ -635,8 +634,7 @@ void reader_close(struct reftable_reader *r)
int reftable_new_reader(struct reftable_reader **p, int reftable_new_reader(struct reftable_reader **p,
struct reftable_block_source *src, char const *name) struct reftable_block_source *src, char const *name)
{ {
struct reftable_reader *rd = struct reftable_reader *rd = reftable_calloc(1, sizeof(*rd));
reftable_calloc(sizeof(struct reftable_reader));
int err = init_reader(rd, src, name); int err = init_reader(rd, src, name);
if (err == 0) { if (err == 0) {
*p = rd; *p = rd;
@ -711,7 +709,7 @@ static int reftable_reader_refs_for_unindexed(struct reftable_reader *r,
uint8_t *oid) uint8_t *oid)
{ {
struct table_iter ti_empty = TABLE_ITER_INIT; struct table_iter ti_empty = TABLE_ITER_INIT;
struct table_iter *ti = reftable_calloc(sizeof(struct table_iter)); struct table_iter *ti = reftable_calloc(1, sizeof(*ti));
struct filtering_ref_iterator *filter = NULL; struct filtering_ref_iterator *filter = NULL;
struct filtering_ref_iterator empty = FILTERING_REF_ITERATOR_INIT; struct filtering_ref_iterator empty = FILTERING_REF_ITERATOR_INIT;
int oid_len = hash_size(r->hash_id); int oid_len = hash_size(r->hash_id);

8
reftable/readwrite_test.c
View File

@ -56,7 +56,9 @@ static void write_table(char ***names, struct strbuf *buf, int N,
int i = 0, n; int i = 0, n;
struct reftable_log_record log = { NULL }; struct reftable_log_record log = { NULL };
const struct reftable_stats *stats = NULL; const struct reftable_stats *stats = NULL;
*names = reftable_calloc(sizeof(char *) * (N + 1));
REFTABLE_CALLOC_ARRAY(*names, N + 1);
reftable_writer_set_limits(w, update_index, update_index); reftable_writer_set_limits(w, update_index, update_index);
for (i = 0; i < N; i++) { for (i = 0; i < N; i++) {
char name[100]; char name[100];
@ -188,7 +190,7 @@ static void test_log_overflow(void)
static void test_log_write_read(void) static void test_log_write_read(void)
{ {
int N = 2; int N = 2;
char **names = reftable_calloc(sizeof(char *) * (N + 1)); char **names = reftable_calloc(N + 1, sizeof(*names));
int err; int err;
struct reftable_write_options opts = { struct reftable_write_options opts = {
.block_size = 256, .block_size = 256,
@ -519,7 +521,7 @@ static void test_table_read_write_seek_index(void)
static void test_table_refs_for(int indexed) static void test_table_refs_for(int indexed)
{ {
int N = 50; int N = 50;
char **want_names = reftable_calloc(sizeof(char *) * (N + 1)); char **want_names = reftable_calloc(N + 1, sizeof(*want_names));
int want_names_len = 0; int want_names_len = 0;
uint8_t want_hash[GIT_SHA1_RAWSZ]; uint8_t want_hash[GIT_SHA1_RAWSZ];

14
reftable/record.c
View File

@ -497,12 +497,13 @@ static void reftable_obj_record_copy_from(void *rec, const void *src_rec,
(const struct reftable_obj_record *)src_rec; (const struct reftable_obj_record *)src_rec;
reftable_obj_record_release(obj); reftable_obj_record_release(obj);
obj->hash_prefix = reftable_malloc(src->hash_prefix_len);
REFTABLE_ALLOC_ARRAY(obj->hash_prefix, src->hash_prefix_len);
obj->hash_prefix_len = src->hash_prefix_len; obj->hash_prefix_len = src->hash_prefix_len;
if (src->hash_prefix_len) if (src->hash_prefix_len)
memcpy(obj->hash_prefix, src->hash_prefix, obj->hash_prefix_len); memcpy(obj->hash_prefix, src->hash_prefix, obj->hash_prefix_len);
obj->offsets = reftable_malloc(src->offset_len * sizeof(uint64_t)); REFTABLE_ALLOC_ARRAY(obj->offsets, src->offset_len);
obj->offset_len = src->offset_len; obj->offset_len = src->offset_len;
COPY_ARRAY(obj->offsets, src->offsets, src->offset_len); COPY_ARRAY(obj->offsets, src->offsets, src->offset_len);
} }
@ -559,7 +560,8 @@ static int reftable_obj_record_decode(void *rec, struct strbuf key,
int n = 0; int n = 0;
uint64_t last; uint64_t last;
int j; int j;
r->hash_prefix = reftable_malloc(key.len);
REFTABLE_ALLOC_ARRAY(r->hash_prefix, key.len);
memcpy(r->hash_prefix, key.buf, key.len); memcpy(r->hash_prefix, key.buf, key.len);
r->hash_prefix_len = key.len; r->hash_prefix_len = key.len;
@ -577,7 +579,7 @@ static int reftable_obj_record_decode(void *rec, struct strbuf key,
if (count == 0) if (count == 0)
return start.len - in.len; return start.len - in.len;
r->offsets = reftable_malloc(count * sizeof(uint64_t)); REFTABLE_ALLOC_ARRAY(r->offsets, count);
r->offset_len = count; r->offset_len = count;
n = get_var_int(&r->offsets[0], &in); n = get_var_int(&r->offsets[0], &in);
@ -715,12 +717,12 @@ static void reftable_log_record_copy_from(void *rec, const void *src_rec,
} }
if (dst->value.update.new_hash) { if (dst->value.update.new_hash) {
dst->value.update.new_hash = reftable_malloc(hash_size); REFTABLE_ALLOC_ARRAY(dst->value.update.new_hash, hash_size);
memcpy(dst->value.update.new_hash, memcpy(dst->value.update.new_hash,
src->value.update.new_hash, hash_size); src->value.update.new_hash, hash_size);
} }
if (dst->value.update.old_hash) { if (dst->value.update.old_hash) {
dst->value.update.old_hash = reftable_malloc(hash_size); REFTABLE_ALLOC_ARRAY(dst->value.update.old_hash, hash_size);
memcpy(dst->value.update.old_hash, memcpy(dst->value.update.old_hash,
src->value.update.old_hash, hash_size); src->value.update.old_hash, hash_size);
} }

4
reftable/record_test.c
View File

@ -231,8 +231,8 @@ static void test_reftable_log_record_roundtrip(void)
.value_type = REFTABLE_LOG_UPDATE, .value_type = REFTABLE_LOG_UPDATE,
.value = { .value = {
.update = { .update = {
.new_hash = reftable_calloc(GIT_SHA1_RAWSZ), .new_hash = reftable_calloc(GIT_SHA1_RAWSZ, 1),
.old_hash = reftable_calloc(GIT_SHA1_RAWSZ), .old_hash = reftable_calloc(GIT_SHA1_RAWSZ, 1),
.name = xstrdup("old name"), .name = xstrdup("old name"),
.email = xstrdup("old@email"), .email = xstrdup("old@email"),
.message = xstrdup("old message"), .message = xstrdup("old message"),

4
reftable/refname.c
View File

@ -140,8 +140,8 @@ int validate_ref_record_addition(struct reftable_table tab,
{ {
struct modification mod = { struct modification mod = {
.tab = tab, .tab = tab,
.add = reftable_calloc(sizeof(char *) * sz), .add = reftable_calloc(sz, sizeof(*mod.add)),
.del = reftable_calloc(sizeof(char *) * sz), .del = reftable_calloc(sz, sizeof(*mod.del)),
}; };
int i = 0; int i = 0;
int err = 0; int err = 0;

28
reftable/stack.c
View File

@ -50,8 +50,7 @@ static ssize_t reftable_fd_write(void *arg, const void *data, size_t sz)
int reftable_new_stack(struct reftable_stack **dest, const char *dir, int reftable_new_stack(struct reftable_stack **dest, const char *dir,
struct reftable_write_options config) struct reftable_write_options config)
{ {
struct reftable_stack *p = struct reftable_stack *p = reftable_calloc(1, sizeof(*p));
reftable_calloc(sizeof(struct reftable_stack));
struct strbuf list_file_name = STRBUF_INIT; struct strbuf list_file_name = STRBUF_INIT;
int err = 0; int err = 0;
@ -94,7 +93,7 @@ static int fd_read_lines(int fd, char ***namesp)
goto done; goto done;
} }
buf = reftable_malloc(size + 1); REFTABLE_ALLOC_ARRAY(buf, size + 1);
if (read_in_full(fd, buf, size) != size) { if (read_in_full(fd, buf, size) != size) {
err = REFTABLE_IO_ERROR; err = REFTABLE_IO_ERROR;
goto done; goto done;
@ -114,7 +113,7 @@ int read_lines(const char *filename, char ***namesp)
int err = 0; int err = 0;
if (fd < 0) { if (fd < 0) {
if (errno == ENOENT) { if (errno == ENOENT) {
*namesp = reftable_calloc(sizeof(char *)); REFTABLE_CALLOC_ARRAY(*namesp, 1);
return 0; return 0;
} }
@ -191,8 +190,7 @@ void reftable_stack_destroy(struct reftable_stack *st)
static struct reftable_reader **stack_copy_readers(struct reftable_stack *st, static struct reftable_reader **stack_copy_readers(struct reftable_stack *st,
int cur_len) int cur_len)
{ {
struct reftable_reader **cur = struct reftable_reader **cur = reftable_calloc(cur_len, sizeof(*cur));
reftable_calloc(sizeof(struct reftable_reader *) * cur_len);
int i = 0; int i = 0;
for (i = 0; i < cur_len; i++) { for (i = 0; i < cur_len; i++) {
cur[i] = st->readers[i]; cur[i] = st->readers[i];
@ -208,9 +206,9 @@ static int reftable_stack_reload_once(struct reftable_stack *st, char **names,
int err = 0; int err = 0;
int names_len = names_length(names); int names_len = names_length(names);
struct reftable_reader **new_readers = struct reftable_reader **new_readers =
reftable_calloc(sizeof(struct reftable_reader *) * names_len); reftable_calloc(names_len, sizeof(*new_readers));
struct reftable_table *new_tables = struct reftable_table *new_tables =
reftable_calloc(sizeof(struct reftable_table) * names_len); reftable_calloc(names_len, sizeof(*new_tables));
int new_readers_len = 0; int new_readers_len = 0;
struct reftable_merged_table *new_merged = NULL; struct reftable_merged_table *new_merged = NULL;
struct strbuf table_path = STRBUF_INIT; struct strbuf table_path = STRBUF_INIT;
@ -344,7 +342,7 @@ static int reftable_stack_reload_maybe_reuse(struct reftable_stack *st,
goto out; goto out;
} }
names = reftable_calloc(sizeof(char *)); REFTABLE_CALLOC_ARRAY(names, 1);
} else { } else {
err = fd_read_lines(fd, &names); err = fd_read_lines(fd, &names);
if (err < 0) if (err < 0)
@ -686,7 +684,7 @@ int reftable_stack_new_addition(struct reftable_addition **dest,
{ {
int err = 0; int err = 0;
struct reftable_addition empty = REFTABLE_ADDITION_INIT; struct reftable_addition empty = REFTABLE_ADDITION_INIT;
*dest = reftable_calloc(sizeof(**dest)); REFTABLE_CALLOC_ARRAY(*dest, 1);
**dest = empty; **dest = empty;
err = reftable_stack_init_addition(*dest, st); err = reftable_stack_init_addition(*dest, st);
if (err) { if (err) {
@ -871,7 +869,7 @@ static int stack_write_compact(struct reftable_stack *st,
{ {
int subtabs_len = last - first + 1; int subtabs_len = last - first + 1;
struct reftable_table *subtabs = reftable_calloc( struct reftable_table *subtabs = reftable_calloc(
sizeof(struct reftable_table) * (last - first + 1)); last - first + 1, sizeof(*subtabs));
struct reftable_merged_table *mt = NULL; struct reftable_merged_table *mt = NULL;
int err = 0; int err = 0;
struct reftable_iterator it = { NULL }; struct reftable_iterator it = { NULL };
@ -979,9 +977,9 @@ static int stack_compact_range(struct reftable_stack *st, int first, int last,
int compact_count = last - first + 1; int compact_count = last - first + 1;
char **listp = NULL; char **listp = NULL;
char **delete_on_success = char **delete_on_success =
reftable_calloc(sizeof(char *) * (compact_count + 1)); reftable_calloc(compact_count + 1, sizeof(*delete_on_success));
char **subtable_locks = char **subtable_locks =
reftable_calloc(sizeof(char *) * (compact_count + 1)); reftable_calloc(compact_count + 1, sizeof(*subtable_locks));
int i = 0; int i = 0;
int j = 0; int j = 0;
int is_empty_table = 0; int is_empty_table = 0;
@ -1204,7 +1202,7 @@ int fastlog2(uint64_t sz)
struct segment *sizes_to_segments(int *seglen, uint64_t *sizes, int n) struct segment *sizes_to_segments(int *seglen, uint64_t *sizes, int n)
{ {
struct segment *segs = reftable_calloc(sizeof(struct segment) * n); struct segment *segs = reftable_calloc(n, sizeof(*segs));
int next = 0; int next = 0;
struct segment cur = { 0 }; struct segment cur = { 0 };
int i = 0; int i = 0;
@ -1268,7 +1266,7 @@ struct segment suggest_compaction_segment(uint64_t *sizes, int n)
static uint64_t *stack_table_sizes_for_compaction(struct reftable_stack *st) static uint64_t *stack_table_sizes_for_compaction(struct reftable_stack *st)
{ {
uint64_t *sizes = uint64_t *sizes =
reftable_calloc(sizeof(uint64_t) * st->merged->stack_len); reftable_calloc(st->merged->stack_len, sizeof(*sizes));
int version = (st->config.hash_id == GIT_SHA1_FORMAT_ID) ? 1 : 2; int version = (st->config.hash_id == GIT_SHA1_FORMAT_ID) ? 1 : 2;
int overhead = header_size(version) - 1; int overhead = header_size(version) - 1;
int i = 0; int i = 0;

4
reftable/tree.c
View File

@ -20,8 +20,8 @@ struct tree_node *tree_search(void *key, struct tree_node **rootp,
if (!insert) { if (!insert) {
return NULL; return NULL;
} else { } else {
struct tree_node *n = struct tree_node *n;
reftable_calloc(sizeof(struct tree_node)); REFTABLE_CALLOC_ARRAY(n, 1);
n->key = key; n->key = key;
*rootp = n; *rootp = n;
return *rootp; return *rootp;

7
reftable/writer.c
View File

@ -49,7 +49,7 @@ static int padded_write(struct reftable_writer *w, uint8_t *data, size_t len,
{ {
int n = 0; int n = 0;
if (w->pending_padding > 0) { if (w->pending_padding > 0) {
uint8_t *zeroed = reftable_calloc(w->pending_padding); uint8_t *zeroed = reftable_calloc(w->pending_padding, sizeof(*zeroed));
int n = w->write(w->write_arg, zeroed, w->pending_padding); int n = w->write(w->write_arg, zeroed, w->pending_padding);
if (n < 0) if (n < 0)
return n; return n;
@ -123,8 +123,7 @@ struct reftable_writer *
reftable_new_writer(ssize_t (*writer_func)(void *, const void *, size_t), reftable_new_writer(ssize_t (*writer_func)(void *, const void *, size_t),
void *writer_arg, struct reftable_write_options *opts) void *writer_arg, struct reftable_write_options *opts)
{ {
struct reftable_writer *wp = struct reftable_writer *wp = reftable_calloc(1, sizeof(*wp));
reftable_calloc(sizeof(struct reftable_writer));
strbuf_init(&wp->block_writer_data.last_key, 0); strbuf_init(&wp->block_writer_data.last_key, 0);
options_set_defaults(opts); options_set_defaults(opts);
if (opts->block_size >= (1 << 24)) { if (opts->block_size >= (1 << 24)) {
@ -132,7 +131,7 @@ reftable_new_writer(ssize_t (*writer_func)(void *, const void *, size_t),
abort(); abort();
} }
wp->last_key = reftable_empty_strbuf; wp->last_key = reftable_empty_strbuf;
wp->block = reftable_calloc(opts->block_size); REFTABLE_CALLOC_ARRAY(wp->block, opts->block_size);
wp->write = writer_func; wp->write = writer_func;
wp->write_arg = writer_arg; wp->write_arg = writer_arg;
wp->opts = *opts; wp->opts = *opts;