xfr: async free zone

This patch is a proposal for speeding up AXFR of a lot of zones. Same implementation is used for IXFR, but the speeding up is not significant due to flushing zone to journal.

• valgrind reports tiny memory-leak (< 500 bytes), not solvable, mostly an issue for our integration tests
  • the "leaked" sructures are just pseudo-static objects for further call_rcu() invocations queue processing, see https://bugs.lttng.org/issues/991
  • leak is suppressed in integration tests

Origin: It has been observed with bootstrapping many (>= thousands) zones via AXFR that there is a significant delay in "consume" phase (~ 30 ms in our case). It can be workarounded by increasing the number of background-workers (raised from 1 to 10, caused doubling the delay, put the parallelism speeded it up anyway). The delay was tracked down to synchronize_rcu() in axfr_answer_finalize().

TODO: Open question is which rcu_read_lock actually makes the synchronize_rcu() routines wait and if it couldn't be removed/speed-uped/solved instead.

Suspecting the synchronize_rcu() barrier is there just for safe freeing old zone contents, this patch removes it and with the help of call_rcu (wrapped for cleaner code) makes the freeing asynchronously wait for grace period.

Zone transfer is also slowed down on flushing zone to journal. It is important to disable immediate flushing to journal (don't set zone-file-sync: -1) for speeding up AXFR transfer.

src/knot/events/handlers/refresh.c

@@ -206,6 +206,35 @@ static void axfr_cleanup(struct refresh_data *data)
 	zone_contents_deep_free(&data->axfr.zone);
 }
 
+
+/*! \brief Routine for calling call_rcu() easier way.
+ *
+ * TODO: move elsewhere, as it has no direct relation to AXFR
+ */
+typedef struct {
+	struct rcu_head rcuhead;
+	void (*ptr_free_fun)(void **);
+	void *ptr;
+} callrcu_wrapper_t;
+
+static void callrcu_wrapper_cb(struct rcu_head *param)
+{
+	callrcu_wrapper_t * wrap = (callrcu_wrapper_t *)param;
+	wrap->ptr_free_fun(&wrap->ptr);
+	free(wrap);
+}
+
+/* note: does nothing if not-enough-memory */
+static void callrcu_wrapper(void *ptr, void (*ptr_free_fun)(void **))
+{
+	callrcu_wrapper_t * wrap = malloc(sizeof(callrcu_wrapper_t));
+	if (wrap != NULL) {
+		wrap->ptr = ptr;
+		wrap->ptr_free_fun = ptr_free_fun;
+		call_rcu((struct rcu_head *)wrap, callrcu_wrapper_cb);
+	}
+}
+
 static int axfr_finalize(struct refresh_data *data)
 {
 	zone_contents_t *new_zone = data->axfr.zone;
@@ -229,11 +258,9 @@ static int axfr_finalize(struct refresh_data *data)
 
 	zone_contents_t *old_zone = zone_switch_contents(data->zone, new_zone);
 	xfr_log_publish(data->zone->name, data->remote, old_zone, new_zone);
-
-	synchronize_rcu();
-
 	data->axfr.zone = NULL; // seized
-	zone_contents_deep_free(&old_zone);
+	callrcu_wrapper(old_zone, (void (*)(void **))zone_contents_deep_free);
+
 
 	return KNOT_EOK;
 }
@@ -369,18 +396,30 @@ static void ixfr_cleanup(struct refresh_data *data)
 	changesets_free(&data->ixfr.changesets);
 }
 
+static void ixfr_finalize_cleanup(void **ptr)
+{
+	apply_ctx_t *ctx = *ptr;
+	update_free_zone(&ctx->contents);
+	update_cleanup(ctx);
+	free(ctx);
+}
+
 static int ixfr_finalize(struct refresh_data *data)
 {
 	zone_contents_t *new_zone = NULL;
-	apply_ctx_t ctx = { 0 };
+	apply_ctx_t *ctx = calloc(1, sizeof(apply_ctx_t));
+	if (ctx == NULL) {
+		return KNOT_ENOMEM;
+	}
 
-	apply_init_ctx(&ctx, NULL, APPLY_STRICT);
-	int ret = apply_changesets(&ctx, data->zone->contents,
+	apply_init_ctx(ctx, NULL, APPLY_STRICT);
+	int ret = apply_changesets(ctx, data->zone->contents,
 	                           &data->ixfr.changesets, &new_zone);
 	if (ret != KNOT_EOK) {
 		IXFRIN_LOG(LOG_WARNING, data->zone->name, data->remote,
 		           "failed to apply changes to zone (%s)",
 		           knot_strerror(ret));
+		free(ctx);
 		return ret;
 	}
 
@@ -388,8 +427,9 @@ static int ixfr_finalize(struct refresh_data *data)
 
 	ret = xfr_validate(new_zone, data);
 	if (ret != KNOT_EOK) {
-		update_rollback(&ctx);
+		update_rollback(ctx);
 		update_free_zone(&new_zone);
+		free(ctx);
 		return ret;
 	}
 
@@ -399,18 +439,17 @@ static int ixfr_finalize(struct refresh_data *data)
 		IXFRIN_LOG(LOG_WARNING, data->zone->name, data->remote,
 		           "failed to write changes to journal (%s)",
 		           knot_strerror(ret));
-		update_rollback(&ctx);
+		update_rollback(ctx);
 		update_free_zone(&new_zone);
+		free(ctx);
 		return ret;
 	}
 
 	zone_contents_t *old_zone = zone_switch_contents(data->zone, new_zone);
 	xfr_log_publish(data->zone->name, data->remote, old_zone, new_zone);
 
-	synchronize_rcu();
-
-	update_free_zone(&old_zone);
-	update_cleanup(&ctx);
+	ctx->contents = old_zone;
+	callrcu_wrapper(ctx, ixfr_finalize_cleanup);	
 
 	return KNOT_EOK;
 }