diff --git a/include/proto/task.h b/include/proto/task.h
index 5f4940c..41227b8 100644
--- a/include/proto/task.h
+++ b/include/proto/task.h
@@ -246,21 +246,19 @@
 	LIST_ADDQ(&task_per_thread[tid].task_list, &tl->list);
 }
 
-/* remove the task from the tasklet list. The task MUST already be there. If
- * unsure, use task_remove_from_task_list() instead.
+/* remove the task from the tasklet list. The tasklet MUST already be there. If
+ * unsure, use tasklet_remove_from_tasklet_list() instead.
  */
-static inline void __task_remove_from_tasklet_list(struct task *t)
+static inline void __tasklet_remove_from_tasklet_list(struct tasklet *t)
 {
-	LIST_DEL_INIT(&((struct tasklet *)t)->list);
-	if (!TASK_IS_TASKLET(t))
-		task_per_thread[tid].task_list_size--;
+	LIST_DEL_INIT(&t->list);
 	_HA_ATOMIC_SUB(&tasks_run_queue, 1);
 }
 
-static inline void task_remove_from_tasklet_list(struct task *t)
+static inline void tasklet_remove_from_tasklet_list(struct tasklet *t)
 {
-	if (likely(!LIST_ISEMPTY(&((struct tasklet *)t)->list)))
-		__task_remove_from_tasklet_list(t);
+	if (likely(!LIST_ISEMPTY(&t->list)))
+		__tasklet_remove_from_tasklet_list(t);
 }
 
 /*
diff --git a/src/checks.c b/src/checks.c
index e1a2e68..c175a75 100644
--- a/src/checks.c
+++ b/src/checks.c
@@ -2254,7 +2254,7 @@
 			 * I/O handler expects to have a cs, so remove
 			 * the tasklet
 			 */
-			task_remove_from_tasklet_list((struct task *)check->wait_list.tasklet);
+			tasklet_remove_from_tasklet_list(check->wait_list.tasklet);
 			cs_destroy(cs);
 			cs = check->cs = NULL;
 			conn = NULL;
@@ -2315,10 +2315,10 @@
 				    check->wait_list.events,
 				    &check->wait_list);
 			/* We may have been scheduled to run, and the
-                         * I/O handler expects to have a cs, so remove
-                         * the tasklet
-                         */
-                        task_remove_from_tasklet_list((struct task *)check->wait_list.tasklet);
+			 * I/O handler expects to have a cs, so remove
+			 * the tasklet
+			 */
+			tasklet_remove_from_tasklet_list(check->wait_list.tasklet);
 			cs_destroy(cs);
 			cs = check->cs = NULL;
 			conn = NULL;
@@ -2831,13 +2831,11 @@
 					                            cs->conn->xprt_ctx,
 								    check->wait_list.events,
 								    &check->wait_list);
-			/* We may have been scheduled to run, and the
-                         * I/O handler expects to have a cs, so remove
-                         * the tasklet
-                         */
-                        task_remove_from_tasklet_list((struct task *)check->wait_list.tasklet);
-
-
+				/* We may have been scheduled to run, and the
+				 * I/O handler expects to have a cs, so remove
+				 * the tasklet
+				 */
+				tasklet_remove_from_tasklet_list(check->wait_list.tasklet);
 				cs_destroy(check->cs);
 			}
 
diff --git a/src/mux_h2.c b/src/mux_h2.c
index 9fb222e..20108bd 100644
--- a/src/mux_h2.c
+++ b/src/mux_h2.c
@@ -911,7 +911,7 @@
 	 */
 	LIST_DEL_INIT(&h2s->list);
 	if (LIST_ADDED(&h2s->sending_list)) {
-		task_remove_from_tasklet_list((struct task *)h2s->send_wait->tasklet);
+		tasklet_remove_from_tasklet_list(h2s->send_wait->tasklet);
 		LIST_DEL_INIT(&h2s->sending_list);
 	}
 	tasklet_free(h2s->wait_event.tasklet);
@@ -3144,7 +3144,7 @@
 	/* The stream is about to die, so no need to attempt to run its task */
 	if (LIST_ADDED(&h2s->sending_list) &&
 	    h2s->send_wait != &h2s->wait_event) {
-		task_remove_from_tasklet_list((struct task *)h2s->send_wait->tasklet);
+		tasklet_remove_from_tasklet_list(h2s->send_wait->tasklet);
 		LIST_DEL_INIT(&h2s->sending_list);
 		/*
 		 * At this point, the stream_interface is supposed to have called
@@ -5346,7 +5346,7 @@
 		/* We were about to send, make sure it does not happen */
 		if (LIST_ADDED(&h2s->sending_list) &&
 		    h2s->send_wait != &h2s->wait_event) {
-			task_remove_from_tasklet_list((struct task *)h2s->send_wait->tasklet);
+			tasklet_remove_from_tasklet_list(h2s->send_wait->tasklet);
 			LIST_DEL_INIT(&h2s->sending_list);
 		}
 		h2s->send_wait = NULL;
@@ -5439,7 +5439,7 @@
 
 	list_for_each_entry_safe(h2s, h2s_back, &h2c->sending_list, sending_list) {
 		LIST_DEL_INIT(&h2s->sending_list);
-		task_remove_from_tasklet_list((struct task *)h2s->send_wait->tasklet);
+		tasklet_remove_from_tasklet_list(h2s->send_wait->tasklet);
 		h2s->send_wait->events |= SUB_RETRY_SEND;
 	}
 }
diff --git a/src/task.c b/src/task.c
index d004a2c..1683208 100644
--- a/src/task.c
+++ b/src/task.c
@@ -388,7 +388,7 @@
 		t = (struct task *)LIST_ELEM(task_per_thread[tid].task_list.n, struct tasklet *, list);
 		state = _HA_ATOMIC_XCHG(&t->state, TASK_RUNNING);
 		__ha_barrier_atomic_store();
-		__task_remove_from_tasklet_list(t);
+		__tasklet_remove_from_tasklet_list((struct tasklet *)t);
 
 		ti->flags &= ~TI_FL_STUCK; // this thread is still running
 		activity[tid].ctxsw++;
