diff --git a/src/checks.c b/src/checks.c
index d07a82f..3f4c0e1 100644
--- a/src/checks.c
+++ b/src/checks.c
@@ -1434,9 +1434,9 @@
  * reached, the task automatically stops. Note that any server status change
  * must have updated s->last_change accordingly.
  */
-static struct task *server_warmup(struct task *t)
+static struct task *server_warmup(struct task *t, void *context, unsigned short state)
 {
-	struct server *s = t->context;
+	struct server *s = context;
 
 	/* by default, plan on stopping the task */
 	t->expire = TICK_ETERNITY;
@@ -1967,9 +1967,9 @@
  * Please do NOT place any return statement in this function and only leave
  * via the out_unlock label.
  */
-static struct task *process_chk_proc(struct task *t)
+static struct task *process_chk_proc(struct task *t, void *context, unsigned short state)
 {
-	struct check *check = t->context;
+	struct check *check = context;
 	struct server *s = check->server;
 	int rv;
 	int ret;
@@ -2099,9 +2099,9 @@
  * Please do NOT place any return statement in this function and only leave
  * via the out_unlock label.
  */
-static struct task *process_chk_conn(struct task *t)
+static struct task *process_chk_conn(struct task *t, void *context, unsigned short state)
 {
-	struct check *check = t->context;
+	struct check *check = context;
 	struct server *s = check->server;
 	struct conn_stream *cs = check->cs;
 	struct connection *conn = cs_conn(cs);
@@ -2272,13 +2272,13 @@
  * manages a server health-check. Returns
  * the time the task accepts to wait, or TIME_ETERNITY for infinity.
  */
-static struct task *process_chk(struct task *t)
+static struct task *process_chk(struct task *t, void *context, unsigned short state)
 {
-	struct check *check = t->context;
+	struct check *check = context;
 
 	if (check->type == PR_O2_EXT_CHK)
-		return process_chk_proc(t);
-	return process_chk_conn(t);
+		return process_chk_proc(t, context, state);
+	return process_chk_conn(t, context, state);
 
 }
 
@@ -3126,9 +3126,9 @@
 	pool_free(pool_head_email_alert, alert);
 }
 
-static struct task *process_email_alert(struct task *t)
+static struct task *process_email_alert(struct task *t, void *context, unsigned short state)
 {
-	struct check        *check = t->context;
+	struct check        *check = context;
 	struct email_alertq *q;
 	struct email_alert  *alert;
 
@@ -3153,7 +3153,7 @@
 			check->state         |= CHK_ST_ENABLED;
 		}
 
-		process_chk(t);
+		process_chk(t, context, state);
 		if (check->state & CHK_ST_INPROGRESS)
 			break;
 
diff --git a/src/dns.c b/src/dns.c
index 9984e2c..8d6a6d6 100644
--- a/src/dns.c
+++ b/src/dns.c
@@ -1698,9 +1698,9 @@
  * resolutions and retry them if possible. Else a timeout is reported. Then, it
  * checks the wait list to trigger new resolutions.
  */
-static struct task *dns_process_resolvers(struct task *t)
+static struct task *dns_process_resolvers(struct task *t, void *context, unsigned short state)
 {
-	struct dns_resolvers  *resolvers = t->context;
+	struct dns_resolvers  *resolvers = context;
 	struct dns_resolution *res, *resback;
 	int exp;
 
diff --git a/src/flt_spoe.c b/src/flt_spoe.c
index f96a94f..856050d 100644
--- a/src/flt_spoe.c
+++ b/src/flt_spoe.c
@@ -1205,9 +1205,9 @@
 /* Callback function that catches applet timeouts. If a timeout occurred, we set
  * <appctx->st1> flag and the SPOE applet is woken up. */
 static struct task *
-spoe_process_appctx(struct task * task)
+spoe_process_appctx(struct task * task, void *context, unsigned short state)
 {
-	struct appctx *appctx = task->context;
+	struct appctx *appctx = context;
 
 	appctx->st1 = SPOE_APPCTX_ERR_NONE;
 	if (tick_is_expired(task->expire, now_ms)) {
diff --git a/src/haproxy.c b/src/haproxy.c
index 48a77e8..6fd2e83 100644
--- a/src/haproxy.c
+++ b/src/haproxy.c
@@ -211,7 +211,7 @@
 /* list of the temporarily limited listeners because of lack of resource */
 struct list global_listener_queue = LIST_HEAD_INIT(global_listener_queue);
 struct task *global_listener_queue_task;
-static struct task *manage_global_listener_queue(struct task *t);
+static struct task *manage_global_listener_queue(struct task *t, void *context, unsigned short state);
 
 /* bitfield of a few warnings to emit just once (WARN_*) */
 unsigned int warned = 0;
@@ -2476,7 +2476,7 @@
  * for global resources when there are enough free resource, or at least once in
  * a while. It is designed to be called as a task.
  */
-static struct task *manage_global_listener_queue(struct task *t)
+static struct task *manage_global_listener_queue(struct task *t, void *context, unsigned short state)
 {
 	int next = TICK_ETERNITY;
 	/* queue is empty, nothing to do */
diff --git a/src/hlua.c b/src/hlua.c
index 78d9cad..4de5db5 100644
--- a/src/hlua.c
+++ b/src/hlua.c
@@ -5517,9 +5517,9 @@
  * Task wrapper are longjmp safe because the only one Lua code
  * executed is the safe hlua_ctx_resume();
  */
-static struct task *hlua_process_task(struct task *task)
+static struct task *hlua_process_task(struct task *task, void *context, unsigned short state)
 {
-	struct hlua *hlua = task->context;
+	struct hlua *hlua = context;
 	enum hlua_exec status;
 
 	if (task->thread_mask == MAX_THREADS_MASK)
@@ -6216,9 +6216,9 @@
 	}
 }
 
-struct task *hlua_applet_wakeup(struct task *t)
+struct task *hlua_applet_wakeup(struct task *t, void *context, unsigned short state)
 {
-	struct appctx *ctx = t->context;
+	struct appctx *ctx = context;
 	struct stream_interface *si = ctx->owner;
 
 	/* If the applet is wake up without any expected work, the sheduler
diff --git a/src/mux_h2.c b/src/mux_h2.c
index 62a9f04..9c7b828 100644
--- a/src/mux_h2.c
+++ b/src/mux_h2.c
@@ -215,7 +215,7 @@
 	.id        = 0,
 };
 
-static struct task *h2_timeout_task(struct task *t);
+static struct task *h2_timeout_task(struct task *t, void *context, unsigned short state);
 
 /*****************************************************/
 /* functions below are for dynamic buffer management */
@@ -2324,9 +2324,9 @@
  * immediately killed. If it's allocatable and empty, we attempt to send a
  * GOAWAY frame.
  */
-static struct task *h2_timeout_task(struct task *t)
+static struct task *h2_timeout_task(struct task *t, void *context, unsigned short state)
 {
-	struct h2c *h2c = t->context;
+	struct h2c *h2c = context;
 	int expired = tick_is_expired(t->expire, now_ms);
 
 	if (!expired && h2c)
diff --git a/src/peers.c b/src/peers.c
index c56ed3a..6d5a556 100644
--- a/src/peers.c
+++ b/src/peers.c
@@ -1958,9 +1958,9 @@
  * Task processing function to manage re-connect and peer session
  * tasks wakeup on local update.
  */
-static struct task *process_peer_sync(struct task * task)
+static struct task *process_peer_sync(struct task * task, void *context, unsigned short state)
 {
-	struct peers *peers = task->context;
+	struct peers *peers = context;
 	struct peer *ps;
 	struct shared_table *st;
 
diff --git a/src/proxy.c b/src/proxy.c
index 6f71b4b..c262966 100644
--- a/src/proxy.c
+++ b/src/proxy.c
@@ -834,9 +834,9 @@
  * called as a task which is woken up upon stopping or when rate limiting must
  * be enforced.
  */
-struct task *manage_proxy(struct task *t)
+struct task *manage_proxy(struct task *t, void *context, unsigned short state)
 {
-	struct proxy *p = t->context;
+	struct proxy *p = context;
 	int next = TICK_ETERNITY;
 	unsigned int wait;
 
@@ -934,7 +934,7 @@
 	return 0;
 }
 
-struct task *hard_stop(struct task *t)
+struct task *hard_stop(struct task *t, void *context, unsigned short state)
 {
 	struct proxy *p;
 	struct stream *s;
diff --git a/src/session.c b/src/session.c
index 318c171..c1bd2d6 100644
--- a/src/session.c
+++ b/src/session.c
@@ -31,7 +31,7 @@
 struct pool_head *pool_head_session;
 
 static int conn_complete_session(struct connection *conn);
-static struct task *session_expire_embryonic(struct task *t);
+static struct task *session_expire_embryonic(struct task *t, void *context, unsigned short state);
 
 /* Create a a new session and assign it to frontend <fe>, listener <li>,
  * origin <origin>, set the current date and clear the stick counters pointers.
@@ -381,9 +381,9 @@
 /* Manages the embryonic session timeout. It is only called when the timeout
  * strikes and performs the required cleanup.
  */
-static struct task *session_expire_embryonic(struct task *t)
+static struct task *session_expire_embryonic(struct task *t, void *context, unsigned short state)
 {
-	struct session *sess = t->context;
+	struct session *sess = context;
 
 	if (!(t->state & TASK_WOKEN_TIMER))
 		return t;
diff --git a/src/stick_table.c b/src/stick_table.c
index 3e44747..fcc6fe6 100644
--- a/src/stick_table.c
+++ b/src/stick_table.c
@@ -578,9 +578,9 @@
  * Task processing function to trash expired sticky sessions. A pointer to the
  * task itself is returned since it never dies.
  */
-static struct task *process_table_expire(struct task *task)
+static struct task *process_table_expire(struct task *task, void *context, unsigned short state)
 {
-	struct stktable *t = task->context;
+	struct stktable *t = context;
 
 	task->expire = stktable_trash_expired(t);
 	return task;
diff --git a/src/stream.c b/src/stream.c
index 1d0b22c..3ea8953 100644
--- a/src/stream.c
+++ b/src/stream.c
@@ -1615,10 +1615,10 @@
  * and each function is called only if at least another function has changed at
  * least one flag it is interested in.
  */
-struct task *process_stream(struct task *t)
+struct task *process_stream(struct task *t, void *context, unsigned short state)
 {
 	struct server *srv;
-	struct stream *s = t->context;
+	struct stream *s = context;
 	struct session *sess = s->sess;
 	unsigned int rqf_last, rpf_last;
 	unsigned int rq_prod_last, rq_cons_last;
@@ -1655,7 +1655,7 @@
 	si_b->flags |= SI_FL_DONT_WAKE;
 
 	/* update pending events */
-	s->pending_events |= (t->state & TASK_WOKEN_ANY);
+	s->pending_events |= (state & TASK_WOKEN_ANY);
 
 	/* 1a: Check for low level timeouts if needed. We just set a flag on
 	 * stream interfaces when their timeouts have expired.
diff --git a/src/task.c b/src/task.c
index 3d021bb..23e310b 100644
--- a/src/task.c
+++ b/src/task.c
@@ -226,10 +226,10 @@
 			 * predictor take this most common call.
 			 */
 			if (likely(t->process == process_stream))
-				t = process_stream(t);
+				t = process_stream(t, t->context, t->state);
 			else {
 				if (t->process != NULL)
-					t = t->process(t);
+					t = t->process(t, t->context, t->state);
 				else {
 					__task_free(t);
 					t = NULL;
@@ -314,10 +314,10 @@
 			 */
 			curr_task = t;
 			if (likely(t->process == process_stream))
-				t = process_stream(t);
+				t = process_stream(t, t->context, t->state);
 			else {
 				if (t->process != NULL)
-					t = t->process(t);
+					t = t->process(t, t->context, t->state);
 				else {
 					__task_free(t);
 					t = NULL;