diff --git a/src/checks.c b/src/checks.c
index 31004dd..76bd8e3 100644
--- a/src/checks.c
+++ b/src/checks.c
@@ -3301,8 +3301,7 @@
 		struct check        *check = &q->check;
 
 		if (check->task) {
-			task_delete(check->task);
-			task_free(check->task);
+			task_destroy(check->task);
 			check->task = NULL;
 		}
 		free_check(check);
diff --git a/src/dns.c b/src/dns.c
index 1d91e43..274fa83 100644
--- a/src/dns.c
+++ b/src/dns.c
@@ -1841,8 +1841,7 @@
 
 		free(resolvers->id);
 		free((char *)resolvers->conf.file);
-		task_delete(resolvers->t);
-		task_free(resolvers->t);
+		task_destroy(resolvers->t);
 		LIST_DEL(&resolvers->list);
 		free(resolvers);
 	}
diff --git a/src/flt_spoe.c b/src/flt_spoe.c
index 1b51779..0f72de8 100644
--- a/src/flt_spoe.c
+++ b/src/flt_spoe.c
@@ -1276,8 +1276,7 @@
 
 	/* Destroy the task attached to this applet */
 	if (spoe_appctx->task) {
-		task_delete(spoe_appctx->task);
-		task_free(spoe_appctx->task);
+		task_destroy(spoe_appctx->task);
 	}
 
 	/* Notify all waiting streams */
@@ -2023,7 +2022,7 @@
  out_free_sess:
 	session_free(sess);
  out_free_spoe:
-	task_free(SPOE_APPCTX(appctx)->task);
+	task_destroy(SPOE_APPCTX(appctx)->task);
  out_free_spoe_appctx:
 	pool_free(pool_head_spoe_appctx, SPOE_APPCTX(appctx));
  out_free_appctx:
diff --git a/src/haproxy.c b/src/haproxy.c
index 1b7b70c..3477ca5 100644
--- a/src/haproxy.c
+++ b/src/haproxy.c
@@ -2278,19 +2278,13 @@
 		while (s) {
 			s_next = s->next;
 
-			if (s->check.task) {
-				task_delete(s->check.task);
-				task_free(s->check.task);
-			}
-			if (s->agent.task) {
-				task_delete(s->agent.task);
-				task_free(s->agent.task);
-			}
+			if (s->check.task)
+				task_destroy(s->check.task);
+			if (s->agent.task)
+				task_destroy(s->agent.task);
 
-			if (s->warmup) {
-				task_delete(s->warmup);
-				task_free(s->warmup);
-			}
+			if (s->warmup)
+				task_destroy(s->warmup);
 
 			free(s->id);
 			free(s->cookie);
@@ -2352,7 +2346,7 @@
 
 		free_http_req_rules(&p->http_req_rules);
 		free_http_res_rules(&p->http_res_rules);
-		task_free(p->task);
+		task_destroy(p->task);
 
 		pool_destroy(p->req_cap_pool);
 		pool_destroy(p->rsp_cap_pool);
@@ -2398,8 +2392,8 @@
 	free(global.node);    global.node = NULL;
 	free(global.desc);    global.desc = NULL;
 	free(oldpids);        oldpids = NULL;
-	task_free(global_listener_queue_task); global_listener_queue_task = NULL;
-	task_free(idle_conn_task);
+	task_destroy(global_listener_queue_task); global_listener_queue_task = NULL;
+	task_destroy(idle_conn_task);
 	idle_conn_task = NULL;
 
 	list_for_each_entry_safe(log, logb, &global.logsrvs, list) {
@@ -3080,10 +3074,9 @@
 			stop_proxy(curpeers->peers_fe);
 			/* disable this peer section so that it kills itself */
 			signal_unregister_handler(curpeers->sighandler);
-			task_delete(curpeers->sync_task);
-			task_free(curpeers->sync_task);
+			task_destroy(curpeers->sync_task);
 			curpeers->sync_task = NULL;
-			task_free(curpeers->peers_fe->task);
+			task_destroy(curpeers->peers_fe->task);
 			curpeers->peers_fe->task = NULL;
 			curpeers->peers_fe = NULL;
 		}
diff --git a/src/hlua.c b/src/hlua.c
index 98c434a..ff5ffba 100644
--- a/src/hlua.c
+++ b/src/hlua.c
@@ -6185,8 +6185,7 @@
 	/* finished or yield */
 	case HLUA_E_OK:
 		hlua_ctx_destroy(hlua);
-		task_delete(task);
-		task_free(task);
+		task_destroy(task);
 		task = NULL;
 		break;
 
@@ -6199,8 +6198,7 @@
 	case HLUA_E_ERRMSG:
 		SEND_ERR(NULL, "Lua task: %s.\n", lua_tostring(hlua->T, -1));
 		hlua_ctx_destroy(hlua);
-		task_delete(task);
-		task_free(task);
+		task_destroy(task);
 		task = NULL;
 		break;
 
@@ -6208,8 +6206,7 @@
 	default:
 		SEND_ERR(NULL, "Lua task: unknown error.\n");
 		hlua_ctx_destroy(hlua);
-		task_delete(task);
-		task_free(task);
+		task_destroy(task);
 		task = NULL;
 		break;
 	}
@@ -7052,8 +7049,7 @@
 
 static void hlua_applet_tcp_release(struct appctx *ctx)
 {
-	task_delete(ctx->ctx.hlua_apptcp.task);
-	task_free(ctx->ctx.hlua_apptcp.task);
+	task_destroy(ctx->ctx.hlua_apptcp.task);
 	ctx->ctx.hlua_apptcp.task = NULL;
 	hlua_ctx_destroy(ctx->ctx.hlua_apptcp.hlua);
 	ctx->ctx.hlua_apptcp.hlua = NULL;
@@ -7520,8 +7516,7 @@
 
 static void hlua_applet_http_release(struct appctx *ctx)
 {
-	task_delete(ctx->ctx.hlua_apphttp.task);
-	task_free(ctx->ctx.hlua_apphttp.task);
+	task_destroy(ctx->ctx.hlua_apphttp.task);
 	ctx->ctx.hlua_apphttp.task = NULL;
 	hlua_ctx_destroy(ctx->ctx.hlua_apphttp.hlua);
 	ctx->ctx.hlua_apphttp.hlua = NULL;
diff --git a/src/mux_h1.c b/src/mux_h1.c
index b854fb2..2fb2803 100644
--- a/src/mux_h1.c
+++ b/src/mux_h1.c
@@ -432,7 +432,7 @@
 
   fail:
 	if (t)
-		task_free(t);
+		task_destroy(t);
 	if (h1c->wait_event.task)
 		tasklet_free(h1c->wait_event.task);
 	pool_free(pool_head_h1c, h1c);
@@ -1953,8 +1953,7 @@
 	if (!expired && h1c)
 		return t;
 
-	task_delete(t);
-	task_free(t);
+	task_destroy(t);
 
 	if (!h1c) {
 		/* resources were already deleted */
diff --git a/src/mux_h2.c b/src/mux_h2.c
index 0a500f6..5d08472 100644
--- a/src/mux_h2.c
+++ b/src/mux_h2.c
@@ -576,7 +576,7 @@
 	hpack_dht_free(h2c->ddht);
   fail:
 	if (t)
-		task_free(t);
+		task_destroy(t);
 	if (h2c->wait_event.task)
 		tasklet_free(h2c->wait_event.task);
 	pool_free(pool_head_h2c, h2c);
@@ -2925,8 +2925,7 @@
 	if (!expired && h2c)
 		return t;
 
-	task_delete(t);
-	task_free(t);
+	task_destroy(t);
 
 	if (!h2c) {
 		/* resources were already deleted */
diff --git a/src/mworker.c b/src/mworker.c
index 6b591d4..abc67bd 100644
--- a/src/mworker.c
+++ b/src/mworker.c
@@ -379,10 +379,9 @@
 		stop_proxy(curpeers->peers_fe);
 		/* disable this peer section so that it kills itself */
 		signal_unregister_handler(curpeers->sighandler);
-		task_delete(curpeers->sync_task);
-		task_free(curpeers->sync_task);
+		task_destroy(curpeers->sync_task);
 		curpeers->sync_task = NULL;
-		task_free(curpeers->peers_fe->task);
+		task_destroy(curpeers->peers_fe->task);
 		curpeers->peers_fe->task = NULL;
 		curpeers->peers_fe = NULL;
 	}
diff --git a/src/peers.c b/src/peers.c
index ee597dc..3f59b10 100644
--- a/src/peers.c
+++ b/src/peers.c
@@ -2448,8 +2448,7 @@
 	if (!peers->peers_fe) {
 		/* this one was never started, kill it */
 		signal_unregister_handler(peers->sighandler);
-		task_delete(peers->sync_task);
-		task_free(peers->sync_task);
+		task_destroy(peers->sync_task);
 		peers->sync_task = NULL;
 		return NULL;
 	}
diff --git a/src/session.c b/src/session.c
index 9b0db46..875fae8 100644
--- a/src/session.c
+++ b/src/session.c
@@ -396,8 +396,7 @@
 	conn_free(conn);
 	sess->origin = NULL;
 
-	task_delete(task);
-	task_free(task);
+	task_destroy(task);
 	session_free(sess);
 }
 
@@ -450,8 +449,7 @@
 
 	/* the embryonic session's task is not needed anymore */
 	if (sess->task) {
-		task_delete(sess->task);
-		task_free(sess->task);
+		task_destroy(sess->task);
 		sess->task = NULL;
 	}
 
diff --git a/src/stream.c b/src/stream.c
index 551f8e2..3762f1b 100644
--- a/src/stream.c
+++ b/src/stream.c
@@ -333,7 +333,7 @@
 	/* Error unrolling */
  out_fail_accept:
 	flt_stream_release(s, 0);
-	task_free(t);
+	task_destroy(t);
 	tasklet_free(s->si[1].wait_event.task);
 	LIST_DEL(&s->list);
 out_fail_alloc_si1:
@@ -2616,8 +2616,7 @@
 
 	/* the task MUST not be in the run queue anymore */
 	stream_free(s);
-	task_delete(t);
-	task_free(t);
+	task_destroy(t);
 	return NULL;
 }
 
diff --git a/src/task.c b/src/task.c
index 52686cf..f38807c 100644
--- a/src/task.c
+++ b/src/task.c
@@ -432,16 +432,14 @@
 	while (tmp_rq) {
 		t = eb32sc_entry(tmp_rq, struct task, rq);
 		tmp_rq = eb32sc_next(tmp_rq, MAX_THREADS_MASK);
-		task_delete(t);
-		task_free(t);
+		task_destroy(t);
 	}
 	/* cleanup the timers queue */
 	tmp_wq = eb32_first(&timers);
 	while (tmp_wq) {
 		t = eb32_entry(tmp_wq, struct task, wq);
 		tmp_wq = eb32_next(tmp_wq);
-		task_delete(t);
-		task_free(t);
+		task_destroy(t);
 	}
 #endif
 	/* clean the per thread run queue */
@@ -450,16 +448,14 @@
 		while (tmp_rq) {
 			t = eb32sc_entry(tmp_rq, struct task, rq);
 			tmp_rq = eb32sc_next(tmp_rq, MAX_THREADS_MASK);
-			task_delete(t);
-			task_free(t);
+			task_destroy(t);
 		}
 		/* cleanup the per thread timers queue */
 		tmp_wq = eb32_first(&task_per_thread[i].timers);
 		while (tmp_wq) {
 			t = eb32_entry(tmp_wq, struct task, wq);
 			tmp_wq = eb32_next(tmp_wq);
-			task_delete(t);
-			task_free(t);
+			task_destroy(t);
 		}
 	}
 }
