reftable: introduce `REFTABLE_FREE_AND_NULL()`

We have several calls to `FREE_AND_NULL()` in the reftable library,
which of course uses free(3P). As the reftable allocators are pluggable
we should rather call the reftable specific function, which is
`reftable_free()`.

Introduce a new macro `REFTABLE_FREE_AND_NULL()` and adapt the callsites
accordingly.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/reftable/basics.h b/reftable/basics.h
index 69adeab2e4b6b74e46c7f5ed436f755ac9ccc925..7f0f20e50c7715032255424f3280394377c6829f 100644 (file)
--- a/reftable/basics.h
+++ b/reftable/basics.h
@@ -71,6 +71,7 @@ char *reftable_strdup(const char *str);
                        REFTABLE_REALLOC_ARRAY(x, alloc); \
                } \
        } while (0)
+#define REFTABLE_FREE_AND_NULL(p) do { reftable_free(p); (p) = NULL; } while (0)
 
 /* Find the longest shared prefix size of `a` and `b` */
 struct strbuf;

diff --git a/reftable/block.c b/reftable/block.c
index bfa7dc61bf549280952027e553f6f259cc0409ca..8d41a2f99eda76ecdc65819eab6fdf473edc8244 100644 (file)
--- a/reftable/block.c
+++ b/reftable/block.c
@@ -551,9 +551,9 @@ done:
 void block_writer_release(struct block_writer *bw)
 {
        deflateEnd(bw->zstream);
-       FREE_AND_NULL(bw->zstream);
-       FREE_AND_NULL(bw->restarts);
-       FREE_AND_NULL(bw->compressed);
+       REFTABLE_FREE_AND_NULL(bw->zstream);
+       REFTABLE_FREE_AND_NULL(bw->restarts);
+       REFTABLE_FREE_AND_NULL(bw->compressed);
        strbuf_release(&bw->last_key);
        /* the block is not owned. */
 }

diff --git a/reftable/iter.c b/reftable/iter.c
index d319538f80486c6f7568d9eb8729248b78b9abc1..d926db653b101084faf1616bf3448b022b04bb1e 100644 (file)
--- a/reftable/iter.c
+++ b/reftable/iter.c
@@ -237,7 +237,7 @@ void reftable_iterator_destroy(struct reftable_iterator *it)
                return;
        it->ops->close(it->iter_arg);
        it->ops = NULL;
-       FREE_AND_NULL(it->iter_arg);
+       REFTABLE_FREE_AND_NULL(it->iter_arg);
 }
 
 int reftable_iterator_seek_ref(struct reftable_iterator *it,

diff --git a/reftable/pq.c b/reftable/pq.c
index 03b99122829f3b7eb7502b288c144050cb1f78f9..6ee1164dd3a8a7739fdb4908414e84ee2bf1f7c3 100644 (file)
--- a/reftable/pq.c
+++ b/reftable/pq.c
@@ -68,6 +68,6 @@ int merged_iter_pqueue_add(struct merged_iter_pqueue *pq, const struct pq_entry
 
 void merged_iter_pqueue_release(struct merged_iter_pqueue *pq)
 {
-       FREE_AND_NULL(pq->heap);
+       REFTABLE_FREE_AND_NULL(pq->heap);
        memset(pq, 0, sizeof(*pq));
 }

diff --git a/reftable/reader.c b/reftable/reader.c
index 98e7aa26373e1504aad3913ab52469dbced06236..8d372539220c3362f8ed87c5d54cbd874b7b6076 100644 (file)
--- a/reftable/reader.c
+++ b/reftable/reader.c
@@ -678,7 +678,7 @@ void reftable_reader_decref(struct reftable_reader *r)
        if (--r->refcount)
                return;
        block_source_close(&r->source);
-       FREE_AND_NULL(r->name);
+       REFTABLE_FREE_AND_NULL(r->name);
        reftable_free(r);
 }
 

diff --git a/reftable/record.c b/reftable/record.c
index 787e134c9a0491fffb584656f31f84494d6d10d5..30d563e16d31861a2c79d00397be8ab4ef3bffdb 100644 (file)
--- a/reftable/record.c
+++ b/reftable/record.c
@@ -476,8 +476,8 @@ static void reftable_obj_record_key(const void *r, struct strbuf *dest)
 static void reftable_obj_record_release(void *rec)
 {
        struct reftable_obj_record *obj = rec;
-       FREE_AND_NULL(obj->hash_prefix);
-       FREE_AND_NULL(obj->offsets);
+       REFTABLE_FREE_AND_NULL(obj->hash_prefix);
+       REFTABLE_FREE_AND_NULL(obj->offsets);
        memset(obj, 0, sizeof(struct reftable_obj_record));
 }
 
@@ -834,10 +834,10 @@ static int reftable_log_record_decode(void *rec, struct strbuf key,
        if (val_type != r->value_type) {
                switch (r->value_type) {
                case REFTABLE_LOG_UPDATE:
-                       FREE_AND_NULL(r->value.update.message);
+                       REFTABLE_FREE_AND_NULL(r->value.update.message);
                        r->value.update.message_cap = 0;
-                       FREE_AND_NULL(r->value.update.email);
-                       FREE_AND_NULL(r->value.update.name);
+                       REFTABLE_FREE_AND_NULL(r->value.update.email);
+                       REFTABLE_FREE_AND_NULL(r->value.update.name);
                        break;
                case REFTABLE_LOG_DELETION:
                        break;

diff --git a/reftable/stack.c b/reftable/stack.c
index b2babe8e3dc5865c7e3f7fb8b888f3111e4f2575..63976e5ceae489f194d15c72fcd6994e3173fd8c 100644 (file)
--- a/reftable/stack.c
+++ b/reftable/stack.c
@@ -203,7 +203,7 @@ void reftable_stack_destroy(struct reftable_stack *st)
 
        err = read_lines(st->list_file, &names);
        if (err < 0) {
-               FREE_AND_NULL(names);
+               REFTABLE_FREE_AND_NULL(names);
        }
 
        if (st->readers) {
@@ -224,7 +224,7 @@ void reftable_stack_destroy(struct reftable_stack *st)
                }
                strbuf_release(&filename);
                st->readers_len = 0;
-               FREE_AND_NULL(st->readers);
+               REFTABLE_FREE_AND_NULL(st->readers);
        }
 
        if (st->list_fd >= 0) {
@@ -232,8 +232,8 @@ void reftable_stack_destroy(struct reftable_stack *st)
                st->list_fd = -1;
        }
 
-       FREE_AND_NULL(st->list_file);
-       FREE_AND_NULL(st->reftable_dir);
+       REFTABLE_FREE_AND_NULL(st->list_file);
+       REFTABLE_FREE_AND_NULL(st->reftable_dir);
        reftable_free(st);
        free_names(names);
 }

diff --git a/reftable/writer.c b/reftable/writer.c
index 550172e65cdbde2435d121df8f679edac8974a80..b032a47decb8fe8e1ccd71c5cd4fbfaa30338a9a 100644 (file)
--- a/reftable/writer.c
+++ b/reftable/writer.c
@@ -593,7 +593,7 @@ static void object_record_free(void *void_arg UNUSED, void *key)
 {
        struct obj_index_tree_node *entry = key;
 
-       FREE_AND_NULL(entry->offsets);
+       REFTABLE_FREE_AND_NULL(entry->offsets);
        strbuf_release(&entry->hash);
        reftable_free(entry);
 }
@@ -709,7 +709,7 @@ static void writer_clear_index(struct reftable_writer *w)
 {
        for (size_t i = 0; w->index && i < w->index_len; i++)
                strbuf_release(&w->index[i].last_key);
-       FREE_AND_NULL(w->index);
+       REFTABLE_FREE_AND_NULL(w->index);
        w->index_len = 0;
        w->index_cap = 0;
 }

diff --git a/t/unit-tests/t-reftable-stack.c b/t/unit-tests/t-reftable-stack.c
index 6e41a4cf7e57cf647e7c6a0035a37a070c2daa93..cc2db2cdefaf6aeb0eb61e3ed4b992ed191715ef 100644 (file)
--- a/t/unit-tests/t-reftable-stack.c
+++ b/t/unit-tests/t-reftable-stack.c
@@ -1149,7 +1149,7 @@ static void unclean_stack_close(struct reftable_stack *st)
        for (size_t i = 0; i < st->readers_len; i++)
                reftable_reader_decref(st->readers[i]);
        st->readers_len = 0;
-       FREE_AND_NULL(st->readers);
+       REFTABLE_FREE_AND_NULL(st->readers);
 }
 
 static void t_reftable_stack_compaction_concurrent_clean(void)