journal: code cleanup

diff --git a/src/knot/journal/journal.c b/src/knot/journal/journal.c
index 94d85e55fce62e445eab693f31364979f6d3760d..4c82177e3810fde181c76194562ac6c500c3891f 100644 (file)
--- a/src/knot/journal/journal.c
+++ b/src/knot/journal/journal.c
@@ -1420,10 +1420,12 @@ static int store_changesets(journal_t *j, list_t *changesets)
 
                chunk_dynarray_t dchunks = { 0 };
                chunks = 0;
-               serialize_ctx_t *sctx;
-               serialize_init(&sctx, ch);
 
-               size_t chunk_size;
+               serialize_ctx_t *sctx = serialize_init(ch);
+               if (sctx == NULL) {
+                       txn->ret = KNOT_ENOMEM;
+                       break;
+               }
 
                bool is_this_merged = (inserting_merged && ch == TAIL(*changesets));
                bool is_this_bootstrap = (ch->soa_from == NULL);
@@ -1431,6 +1433,7 @@ static int store_changesets(journal_t *j, list_t *changesets)
                uint32_t serial_to = knot_soa_serial(&ch->soa_to->rrs);
 
                while (serialize_unfinished(sctx)) {
+                       size_t chunk_size;
                        serialize_prepare(sctx, CHUNK_MAX - JOURNAL_HEADER_SIZE, &chunk_size);
                        if (chunk_size == 0) {
                                break;
@@ -1465,7 +1468,7 @@ static int store_changesets(journal_t *j, list_t *changesets)
                        serialize_chunk(sctx, txn->val.data + JOURNAL_HEADER_SIZE, chunk_size);
                }
 
-               serialize_deinit(&sctx);
+               serialize_deinit(sctx);
 
                dynarray_foreach(chunk, knot_db_val_t, val, dchunks) {
                        make_header(val, serial_to, chunks);

diff --git a/src/knot/journal/serialization.c b/src/knot/journal/serialization.c
index 018f84ec65403f0ad63a6dfbf12a58915e330193..e9500bf6aa2d087247f8df7696afc3bb5682c660 100644 (file)
--- a/src/knot/journal/serialization.c
+++ b/src/knot/journal/serialization.c
@@ -42,13 +42,19 @@ struct serialize_ctx {
        size_t rrset_buf_size;
 };
 
-void serialize_init(serialize_ctx_t **ctx, const changeset_t *ch)
+serialize_ctx_t *serialize_init(const changeset_t *ch)
 {
-       *ctx = calloc(1, sizeof(**ctx));
-       (*ctx)->ch = ch;
-       (*ctx)->changeset_phase = ch->soa_from != NULL ? PHASE_SOA_1 : PHASE_SOA_2;
-       (*ctx)->rrset_phase = SERIALIZE_RRSET_INIT;
-       (*ctx)->rrset_buf_size = 0;
+       serialize_ctx_t *ctx = calloc(1, sizeof(*ctx));
+       if (ctx == NULL) {
+               return NULL;
+       }
+
+       ctx->ch = ch;
+       ctx->changeset_phase = ch->soa_from != NULL ? PHASE_SOA_1 : PHASE_SOA_2;
+       ctx->rrset_phase = SERIALIZE_RRSET_INIT;
+       ctx->rrset_buf_size = 0;
+
+       return ctx;
 }
 
 static const knot_rrset_t get_next_rrset(serialize_ctx_t *ctx)
@@ -121,9 +127,11 @@ void serialize_prepare(serialize_ctx_t *ctx, size_t max_size, size_t *realsize)
                        tmp_phase = SERIALIZE_RRSET_INIT;
                }
                if (tmp_phase == SERIALIZE_RRSET_INIT) {
-                       candidate += 3 * sizeof(uint16_t) + knot_dname_size(ctx->rrset_buf[ctx->rrset_buf_size - 1].owner);
+                       candidate += 3 * sizeof(uint16_t) +
+                                    knot_dname_size(ctx->rrset_buf[ctx->rrset_buf_size - 1].owner);
                } else {
-                       candidate += sizeof(uint32_t) + sizeof(uint16_t) + knot_rdataset_at(&ctx->rrset_buf[ctx->rrset_buf_size - 1].rrs, tmp_phase)->len;
+                       candidate += sizeof(uint32_t) + sizeof(uint16_t) +
+                                    knot_rdataset_at(&ctx->rrset_buf[ctx->rrset_buf_size - 1].rrs, tmp_phase)->len;
                }
                if (candidate > max_size) {
                        return;
@@ -145,7 +153,8 @@ void serialize_chunk(serialize_ctx_t *ctx, uint8_t *dst_chunk, size_t chunk_size
                        ctx->rrset_phase = SERIALIZE_RRSET_INIT;
                }
                if (ctx->rrset_phase == SERIALIZE_RRSET_INIT) {
-                       int size = knot_dname_to_wire(wire.position, ctx->rrset_buf[i].owner, wire_ctx_available(&wire));
+                       int size = knot_dname_to_wire(wire.position, ctx->rrset_buf[i].owner,
+                                                     wire_ctx_available(&wire));
                        if (size < 0 || wire_ctx_available(&wire) < size + 3 * sizeof(uint16_t)) {
                                break;
                        }
@@ -154,7 +163,8 @@ void serialize_chunk(serialize_ctx_t *ctx, uint8_t *dst_chunk, size_t chunk_size
                        wire_ctx_write_u16(&wire, ctx->rrset_buf[i].rclass);
                        wire_ctx_write_u16(&wire, ctx->rrset_buf[i].rrs.rr_count);
                } else {
-                       const knot_rdata_t *rr = knot_rdataset_at(&ctx->rrset_buf[i].rrs, ctx->rrset_phase);
+                       const knot_rdata_t *rr = knot_rdataset_at(&ctx->rrset_buf[i].rrs,
+                                                                 ctx->rrset_phase);
                        assert(rr);
                        uint16_t rdlen = rr->len;
                        if (wire_ctx_available(&wire) < sizeof(uint32_t) + sizeof(uint16_t) + rdlen) {
@@ -174,12 +184,12 @@ bool serialize_unfinished(serialize_ctx_t *ctx)
        return ctx->changeset_phase < PHASE_END;
 }
 
-void serialize_deinit(serialize_ctx_t **ctx)
+void serialize_deinit(serialize_ctx_t *ctx)
 {
-       if ((*ctx)->it.node != NULL) {
-               changeset_iter_clear(&(*ctx)->it);
+       if (ctx->it.node != NULL) {
+               changeset_iter_clear(&ctx->it);
        }
-       free(*ctx);
+       free(ctx);
 }
 
 static int deserialize_rrset(wire_ctx_t *wire, knot_rrset_t *rrset, long *phase)

diff --git a/src/knot/journal/serialization.h b/src/knot/journal/serialization.h
index 4dc92336e758cc520bbf8c2d8bb9694340885658..cf1dddb6ddb4aead03f7ced29ee923aa9ab7eba7 100644 (file)
--- a/src/knot/journal/serialization.h
+++ b/src/knot/journal/serialization.h
@@ -25,10 +25,11 @@ typedef struct serialize_ctx serialize_ctx_t;
 /*!
  * \brief Init serialization context.
  *
- * \param ctx Context.
  * \param ch  Changeset to be serialized.
+ *
+ * \return Context.
  */
-void serialize_init(serialize_ctx_t **ctx, const changeset_t *ch);
+serialize_ctx_t *serialize_init(const changeset_t *ch);
 
 /*!
  * \brief Pre-check and space computation before serializing a chunk.
@@ -55,7 +56,7 @@ void serialize_chunk(serialize_ctx_t *ctx, uint8_t *chunk, size_t chunk_size);
 bool serialize_unfinished(serialize_ctx_t *ctx);
 
 /*! \brief Free serialization context. */
-void serialize_deinit(serialize_ctx_t **ctx);
+void serialize_deinit(serialize_ctx_t *ctx);
 
 /*!
  * \brief Returns size of changeset in serialized form.