diff --git a/include/common/mini-clist.h b/include/common/mini-clist.h
index 0cdddce..e530c43 100644
--- a/include/common/mini-clist.h
+++ b/include/common/mini-clist.h
@@ -34,6 +34,16 @@
     struct list *p;	/* prev */
 };
 
+/* This is similar to struct list, but we want to be sure the compiler will
+ * yell at you if you use macroes for one when you're using the other. You have
+ * to expicitely cast if that's really what you want to do.
+ */
+struct mt_list {
+    struct mt_list *next;
+    struct mt_list *prev;
+};
+
+
 /* a back-ref is a pointer to a target list entry. It is used to detect when an
  * element being deleted is currently being tracked by another user. The best
  * example is a user dumping the session table. The table does not fit in the
@@ -189,7 +199,7 @@
 	     item = back, back = LIST_ELEM(back->member.n, typeof(back), member))
 
 #include <common/hathreads.h>
-#define LLIST_BUSY ((struct list *)1)
+#define MT_LIST_BUSY ((struct mt_list *)1)
 
 /*
  * Locked version of list manipulation macros.
@@ -197,95 +207,95 @@
  * list is only used with the locked variants. The only "unlocked" macro you
  * can use with a locked list is LIST_INIT.
  */
-#define LIST_ADD_LOCKED(lh, el)                                            \
+#define MT_LIST_ADD(lh, el)                                                \
 	do {                                                               \
 		while (1) {                                                \
-			struct list *n;                                    \
-			struct list *p;                                    \
-			n = _HA_ATOMIC_XCHG(&(lh)->n, LLIST_BUSY);         \
-			if (n == LLIST_BUSY)                               \
+			struct mt_list *n;                                 \
+			struct mt_list *p;                                 \
+			n = _HA_ATOMIC_XCHG(&(lh)->next, MT_LIST_BUSY);      \
+			if (n == MT_LIST_BUSY)                               \
 			        continue;                                  \
-			p = _HA_ATOMIC_XCHG(&n->p, LLIST_BUSY);            \
-			if (p == LLIST_BUSY) {                             \
-				(lh)->n = n;                               \
+			p = _HA_ATOMIC_XCHG(&n->prev, MT_LIST_BUSY);         \
+			if (p == MT_LIST_BUSY) {                             \
+				(lh)->next = n;                            \
 				__ha_barrier_store();                      \
 				continue;                                  \
 			}                                                  \
-			(el)->n = n;                                       \
-			(el)->p = p;                                       \
+			(el)->next = n;                                    \
+			(el)->prev = p;                                    \
 			__ha_barrier_store();                              \
-			n->p = (el);                                       \
+			n->prev = (el);                                    \
 			__ha_barrier_store();                              \
-			p->n = (el);                                       \
+			p->next = (el);                                    \
 			__ha_barrier_store();                              \
 			break;                                             \
 		}                                                          \
 	} while (0)
 
-#define LIST_ADDQ_LOCKED(lh, el)                                           \
+#define MT_LIST_ADDQ(lh, el)                                               \
 	do {                                                               \
 		while (1) {                                                \
-			struct list *n;                                    \
-			struct list *p;                                    \
-			p = _HA_ATOMIC_XCHG(&(lh)->p, LLIST_BUSY);         \
-			if (p == LLIST_BUSY)                               \
+			struct mt_list *n;                                 \
+			struct mt_list *p;                                 \
+			p = _HA_ATOMIC_XCHG(&(lh)->prev, MT_LIST_BUSY);      \
+			if (p == MT_LIST_BUSY)                               \
 			        continue;                                  \
-			n = _HA_ATOMIC_XCHG(&p->n, LLIST_BUSY);            \
-			if (n == LLIST_BUSY) {                             \
-				(lh)->p = p;                               \
+			n = _HA_ATOMIC_XCHG(&p->next, MT_LIST_BUSY);         \
+			if (n == MT_LIST_BUSY) {                             \
+				(lh)->prev = p;                            \
 				__ha_barrier_store();                      \
 				continue;                                  \
 			}                                                  \
-			(el)->n = n;                                       \
-			(el)->p = p;                                       \
+			(el)->next = n;                                    \
+			(el)->prev = p;                                    \
 			__ha_barrier_store();                              \
-			p->n = (el);                                       \
+			p->next = (el);                                    \
 			__ha_barrier_store();                              \
-			n->p = (el);                                       \
+			n->prev = (el);                                    \
 			__ha_barrier_store();                              \
 			break;                                             \
 		}                                                          \
 	} while (0)
 
-#define LIST_DEL_LOCKED(el)                                                \
+#define MT_LIST_DEL(el)                                                    \
 	do {                                                               \
 		while (1) {                                                \
-			struct list *n, *n2;                               \
-			struct list *p, *p2 = NULL;                        \
-			n = _HA_ATOMIC_XCHG(&(el)->n, LLIST_BUSY);         \
-			if (n == LLIST_BUSY)                               \
+			struct mt_list *n, *n2;                            \
+			struct mt_list *p, *p2 = NULL;                     \
+			n = _HA_ATOMIC_XCHG(&(el)->next, MT_LIST_BUSY);      \
+			if (n == MT_LIST_BUSY)                               \
 			        continue;                                  \
-			p = _HA_ATOMIC_XCHG(&(el)->p, LLIST_BUSY);         \
-			if (p == LLIST_BUSY) {                             \
-				(el)->n = n;                               \
+			p = _HA_ATOMIC_XCHG(&(el)->prev, MT_LIST_BUSY);      \
+			if (p == MT_LIST_BUSY) {                             \
+				(el)->next = n;                            \
 				__ha_barrier_store();                      \
 				continue;                                  \
 			}                                                  \
 			if (p != (el)) {                                   \
-			        p2 = _HA_ATOMIC_XCHG(&p->n, LLIST_BUSY);   \
-			        if (p2 == LLIST_BUSY) {                    \
-			                (el)->p = p;                       \
-					(el)->n = n;                       \
+			        p2 = _HA_ATOMIC_XCHG(&p->next, MT_LIST_BUSY);\
+			        if (p2 == MT_LIST_BUSY) {                    \
+			                (el)->prev = p;                    \
+					(el)->next = n;                    \
 					__ha_barrier_store();              \
 					continue;                          \
 				}                                          \
 			}                                                  \
 			if (n != (el)) {                                   \
-			        n2 = _HA_ATOMIC_XCHG(&n->p, LLIST_BUSY);   \
-				if (n2 == LLIST_BUSY) {                    \
+			        n2 = _HA_ATOMIC_XCHG(&n->prev, MT_LIST_BUSY);\
+				if (n2 == MT_LIST_BUSY) {                    \
 					if (p2 != NULL)                    \
-						p->n = p2;                 \
-					(el)->p = p;                       \
-					(el)->n = n;                       \
+						p->next = p2;              \
+					(el)->prev = p;                    \
+					(el)->next = n;                    \
 					__ha_barrier_store();              \
 					continue;                          \
 				}                                          \
 			}                                                  \
-			n->p = p;                                          \
-			p->n = n;                                          \
+			n->prev = p;                                       \
+			p->next = n;                                       \
 			__ha_barrier_store();                              \
-			(el)->p = (el);                                    \
-			(el)->n = (el);	                                   \
+			(el)->prev = (el);                                 \
+			(el)->next = (el);                                 \
 			__ha_barrier_store();                              \
 			break;                                             \
 		}                                                          \
@@ -293,54 +303,89 @@
 
 
 /* Remove the first element from the list, and return it */
-#define LIST_POP_LOCKED(lh, pt, el)                                        \
+#define MT_LIST_POP(lh, pt, el)                                            \
 	({                                                                 \
 		 void *_ret;                                               \
 		 while (1) {                                               \
-			 struct list *n, *n2;                              \
-			 struct list *p, *p2;                              \
-			 n = _HA_ATOMIC_XCHG(&(lh)->n, LLIST_BUSY);        \
-			 if (n == LLIST_BUSY)                              \
+			 struct mt_list *n, *n2;                           \
+			 struct mt_list *p, *p2;                           \
+			 n = _HA_ATOMIC_XCHG(&(lh)->next, MT_LIST_BUSY);     \
+			 if (n == MT_LIST_BUSY)                              \
 			         continue;                                 \
 			 if (n == (lh)) {                                  \
-				 (lh)->n = lh;                             \
+				 (lh)->next = lh;                          \
 				 __ha_barrier_store();                     \
 				 _ret = NULL;                              \
 				 break;                                    \
 			 }                                                 \
-			 p = _HA_ATOMIC_XCHG(&n->p, LLIST_BUSY);           \
-			 if (p == LLIST_BUSY) {                            \
-				 (lh)->n = n;                              \
+			 p = _HA_ATOMIC_XCHG(&n->prev, MT_LIST_BUSY);        \
+			 if (p == MT_LIST_BUSY) {                            \
+				 (lh)->next = n;                           \
 				 __ha_barrier_store();                     \
 				 continue;                                 \
 			 }                                                 \
-			 n2 = _HA_ATOMIC_XCHG(&n->n, LLIST_BUSY);          \
-			 if (n2 == LLIST_BUSY) {                           \
-				 n->p = p;                                 \
+			 n2 = _HA_ATOMIC_XCHG(&n->next, MT_LIST_BUSY);       \
+			 if (n2 == MT_LIST_BUSY) {                           \
+				 n->prev = p;                              \
 				 __ha_barrier_store();                     \
-				 (lh)->n = n;                              \
+				 (lh)->next = n;                           \
 				 __ha_barrier_store();                     \
 				 continue;                                 \
 			 }                                                 \
-			 p2 = _HA_ATOMIC_XCHG(&n2->p, LLIST_BUSY);         \
-			 if (p2 == LLIST_BUSY) {                           \
-				 n->n = n2;                                \
-				 n->p = p;                                 \
+			 p2 = _HA_ATOMIC_XCHG(&n2->prev, MT_LIST_BUSY);      \
+			 if (p2 == MT_LIST_BUSY) {                           \
+				 n->next = n2;                             \
+				 n->prev = p;                              \
 				 __ha_barrier_store();                     \
-				 (lh)->n = n;                              \
+				 (lh)->next = n;                           \
 				 __ha_barrier_store();                     \
 				 continue;                                 \
 			 }                                                 \
-			 (lh)->n = n2;                                     \
-			 (n2)->p = (lh);                                   \
+			 (lh)->next = n2;                                  \
+			 (n2)->prev = (lh);                                \
 			 __ha_barrier_store();                             \
-			 (n)->p = (n);                                     \
-			 (n)->n = (n);	                                   \
+			 (n)->prev = (n);                                  \
+			 (n)->next = (n);	                           \
 			 __ha_barrier_store();                             \
-			 _ret = LIST_ELEM(n, pt, el);                      \
+			 _ret = MT_LIST_ELEM(n, pt, el);                   \
 			 break;                                            \
 		 }                                                         \
 		 (_ret);                                                   \
 	 })
 
+#define MT_LIST_HEAD(a)	((void *)(&(a)))
+
+#define MT_LIST_INIT(l) ((l)->next = (l)->prev = (l))
+
+#define MT_LIST_HEAD_INIT(l) { &l, &l }
+/* returns a pointer of type <pt> to a structure containing a list head called
+ * <el> at address <lh>. Note that <lh> can be the result of a function or macro
+ * since it's used only once.
+ * Example: MT_LIST_ELEM(cur_node->args.next, struct node *, args)
+ */
+#define MT_LIST_ELEM(lh, pt, el) ((pt)(((void *)(lh)) - ((void *)&((pt)NULL)->el)))
+
+/* checks if the list head <lh> is empty or not */
+#define MT_LIST_ISEMPTY(lh) ((lh)->next == (lh))
+
+/* returns a pointer of type <pt> to a structure following the element
+ * which contains list head <lh>, which is known as element <el> in
+ * struct pt.
+ * Example: MT_LIST_NEXT(args, struct node *, list)
+ */
+#define MT_LIST_NEXT(lh, pt, el) (MT_LIST_ELEM((lh)->next, pt, el))
+
+
+/* returns a pointer of type <pt> to a structure preceding the element
+ * which contains list head <lh>, which is known as element <el> in
+ * struct pt.
+ */
+#undef MT_LIST_PREV
+#define MT_LIST_PREV(lh, pt, el) (MT_LIST_ELEM((lh)->prev, pt, el))
+
+/* checks if the list element <el> was added to a list or not. This only
+ * works when detached elements are reinitialized (using LIST_DEL_INIT)
+ */
+#define MT_LIST_ADDED(el) ((el)->next != (el))
+
 #endif /* _COMMON_MINI_CLIST_H */
diff --git a/include/proto/connection.h b/include/proto/connection.h
index b1d8638..a7647bd 100644
--- a/include/proto/connection.h
+++ b/include/proto/connection.h
@@ -625,7 +625,7 @@
 
 	conn_force_unsubscribe(conn);
 	HA_SPIN_LOCK(OTHER_LOCK, &toremove_lock[tid]);
-	LIST_DEL_LOCKED(&conn->list);
+	MT_LIST_DEL((struct mt_list *)&conn->list);
 	HA_SPIN_UNLOCK(OTHER_LOCK, &toremove_lock[tid]);
 	pool_free(pool_head_connection, conn);
 }
diff --git a/include/proto/listener.h b/include/proto/listener.h
index 24a01b2..b245d6e 100644
--- a/include/proto/listener.h
+++ b/include/proto/listener.h
@@ -58,7 +58,7 @@
 int disable_all_listeners(struct protocol *proto);
 
 /* Dequeues all of the listeners waiting for a resource in wait queue <queue>. */
-void dequeue_all_listeners(struct list *list);
+void dequeue_all_listeners(struct mt_list *list);
 
 /* Must be called with the lock held. Depending on <do_close> value, it does
  * what unbind_listener or unbind_listener_no_close should do.
diff --git a/include/proto/server.h b/include/proto/server.h
index f52b38e..5a2fcc9 100644
--- a/include/proto/server.h
+++ b/include/proto/server.h
@@ -41,7 +41,7 @@
 extern struct eb_root idle_conn_srv;
 extern struct task *idle_conn_task;
 extern struct task *idle_conn_cleanup[MAX_THREADS];
-extern struct list toremove_connections[MAX_THREADS];
+extern struct mt_list toremove_connections[MAX_THREADS];
 
 int srv_downtime(const struct server *s);
 int srv_lastsession(const struct server *s);
@@ -262,7 +262,7 @@
 			return 0;
 		}
 		LIST_DEL(&conn->list);
-		LIST_ADDQ_LOCKED(&srv->idle_orphan_conns[tid], &conn->list);
+		MT_LIST_ADDQ(&srv->idle_orphan_conns[tid], (struct mt_list *)&conn->list);
 		srv->curr_idle_thr[tid]++;
 
 		conn->idle_time = now_ms;
diff --git a/include/proto/task.h b/include/proto/task.h
index 4044bd4..f213f47 100644
--- a/include/proto/task.h
+++ b/include/proto/task.h
@@ -542,9 +542,9 @@
 }
 
 /* adds list item <item> to work list <work> and wake up the associated task */
-static inline void work_list_add(struct work_list *work, struct list *item)
+static inline void work_list_add(struct work_list *work, struct mt_list *item)
 {
-	LIST_ADDQ_LOCKED(&work->head, item);
+	MT_LIST_ADDQ(&work->head, item);
 	task_wakeup(work->task, TASK_WOKEN_OTHER);
 }
 
diff --git a/include/types/global.h b/include/types/global.h
index bd08db1..e9cbf3f 100644
--- a/include/types/global.h
+++ b/include/types/global.h
@@ -240,7 +240,7 @@
 extern int killed;	/* >0 means a hard-stop is triggered, >1 means hard-stop immediately */
 extern char hostname[MAX_HOSTNAME_LEN];
 extern char localpeer[MAX_HOSTNAME_LEN];
-extern struct list global_listener_queue; /* list of the temporarily limited listeners */
+extern struct mt_list global_listener_queue; /* list of the temporarily limited listeners */
 extern struct task *global_listener_queue_task;
 extern unsigned int warned;     /* bitfield of a few warnings to emit just once */
 extern volatile unsigned long sleeping_thread_mask;
diff --git a/include/types/listener.h b/include/types/listener.h
index def48b0..e60d91c 100644
--- a/include/types/listener.h
+++ b/include/types/listener.h
@@ -202,7 +202,7 @@
 	int (*accept)(struct listener *l, int fd, struct sockaddr_storage *addr); /* upper layer's accept() */
 	enum obj_type *default_target;  /* default target to use for accepted sessions or NULL */
 	/* cache line boundary */
-	struct list wait_queue;		/* link element to make the listener wait for something (LI_LIMITED)  */
+	struct mt_list wait_queue;	/* link element to make the listener wait for something (LI_LIMITED)  */
 	unsigned int thr_idx;           /* thread indexes for queue distribution : (t2<<16)+t1 */
 	unsigned int analysers;		/* bitmap of required protocol analysers */
 	int maxseg;			/* for TCP, advertised MSS */
diff --git a/include/types/proxy.h b/include/types/proxy.h
index 87b85ad..6ea96b3 100644
--- a/include/types/proxy.h
+++ b/include/types/proxy.h
@@ -415,7 +415,7 @@
 	struct be_counters be_counters;		/* backend statistics counters */
 	struct fe_counters fe_counters;		/* frontend statistics counters */
 
-	struct list listener_queue;		/* list of the temporarily limited listeners because of lack of a proxy resource */
+	struct mt_list listener_queue;		/* list of the temporarily limited listeners because of lack of a proxy resource */
 	struct stktable *table;			/* table for storing sticking streams */
 
 	struct task *task;			/* the associated task, mandatory to manage rate limiting, stopping and resource shortage, NULL if disabled */
diff --git a/include/types/server.h b/include/types/server.h
index a71f806..842e033 100644
--- a/include/types/server.h
+++ b/include/types/server.h
@@ -223,7 +223,7 @@
 	struct list *priv_conns;		/* private idle connections attached to stream interfaces */
 	struct list *idle_conns;		/* sharable idle connections attached or not to a stream interface */
 	struct list *safe_conns;		/* safe idle connections attached to stream interfaces, shared */
-	struct list *idle_orphan_conns;         /* Orphan connections idling */
+	struct mt_list *idle_orphan_conns;         /* Orphan connections idling */
 	unsigned int pool_purge_delay;          /* Delay before starting to purge the idle conns pool */
 	unsigned int max_idle_conns;            /* Max number of connection allowed in the orphan connections list */
 	unsigned int curr_idle_conns;           /* Current number of orphan idling connections */
diff --git a/include/types/task.h b/include/types/task.h
index 3421cd3..481d563 100644
--- a/include/types/task.h
+++ b/include/types/task.h
@@ -118,7 +118,7 @@
  * TASK_WOKEN_OTHER and a context pointing to the work_list entry.
  */
 struct work_list {
-	struct list head;
+	struct mt_list head;
 	struct task *task;
 	void *arg;
 };