MEDIUM: list: Separate "locked" list from regular list.

Instead of using the same type for regular linked lists and "autolocked"
linked lists, use a separate type, "struct mt_list", for the autolocked one,
and introduce a set of macros, similar to the LIST_* macros, with the
MT_ prefix.
When we use the same entry for both regular list and autolocked list, as
is done for the "list" field in struct connection, we know have to explicitely
cast it to struct mt_list when using MT_ macros.

diff --git a/include/common/mini-clist.h b/include/common/mini-clist.h
index 0cdddce04f79b9ca4c191e5e232233b23b024027..e530c43cc146b4e2bd68ae6e517ce25f89ab4974 100644 (file)
--- a/include/common/mini-clist.h
+++ b/include/common/mini-clist.h
@@ -34,6 +34,16 @@ struct list {
     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 @@ struct cond_wordlist {
             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 @@ struct cond_wordlist {
  * 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 @@ struct cond_wordlist {
 
 
 /* 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 b1d8638e967dccbe4cc413dde59984e6c4e02587..a7647bd8fe5a2716c9a2205a0b09883beb8df12d 100644 (file)
--- a/include/proto/connection.h
+++ b/include/proto/connection.h
@@ -625,7 +625,7 @@ static inline void conn_free(struct connection *conn)
 
        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 24a01b2ed4e710b7d93d48525c8c66bd5895f0a0..b245d6e128aa229941cdcbe43e8593a1541e8369 100644 (file)
--- a/include/proto/listener.h
+++ b/include/proto/listener.h
@@ -58,7 +58,7 @@ int enable_all_listeners(struct protocol *proto);
 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 f52b38e511b323b63b5f87f8c98567ce00079345..5a2fcc919290af6548c62dc2704e6c719f8cb703 100644 (file)
--- a/include/proto/server.h
+++ b/include/proto/server.h
@@ -41,7 +41,7 @@ __decl_hathreads(extern HA_SPINLOCK_T idle_conn_srv_lock);
 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 @@ static inline int srv_add_to_idle_list(struct server *srv, struct connection *co
                        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 4044bd459c0c7b579061dc2221572f9d428d5cd3..f213f47d058591ec731e892a34a552779b75a62a 100644 (file)
--- a/include/proto/task.h
+++ b/include/proto/task.h
@@ -542,9 +542,9 @@ static inline int thread_has_tasks(void)
 }
 
 /* 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 bd08db142bc8d6151f68011b4e314579883005b0..e9cbf3fca4480f84782594a7913eff22c24d4bdf 100644 (file)
--- a/include/types/global.h
+++ b/include/types/global.h
@@ -240,7 +240,7 @@ extern int stopping;        /* non zero means stopping in progress */
 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 def48b0db459007d00f605e8b4845d6678064da4..e60d91c4c2a1d1a0992fd2fe78188d5264e6e7c3 100644 (file)
--- a/include/types/listener.h
+++ b/include/types/listener.h
@@ -202,7 +202,7 @@ struct listener {
        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 87b85ad106aa6cc35f9bd889cba534e67a33b720..6ea96b3ad35a9b0ba4564b6fca3f6f8158b01fa1 100644 (file)
--- a/include/types/proxy.h
+++ b/include/types/proxy.h
@@ -415,7 +415,7 @@ struct proxy {
        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 a71f806df7c7f9cffbd4f1c7b6960021619995d2..842e033adc16b0a59b0ce504b778cfa6d7e06a06 100644 (file)
--- a/include/types/server.h
+++ b/include/types/server.h
@@ -223,7 +223,7 @@ struct server {
        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 3421cd3bd9d55711ea878664f20b7cee92a11a41..481d5633136b410a1ea82a5002de414dbd0fa71b 100644 (file)
--- a/include/types/task.h
+++ b/include/types/task.h
@@ -118,7 +118,7 @@ struct tasklet {
  * 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;
 };

diff --git a/src/backend.c b/src/backend.c
index f03b1ab65957bcf5c0588572c1365cf6ec499de8..e7e0e77232c607e60b65971f6d7da5110e0d2d5a 100644 (file)
--- a/src/backend.c
+++ b/src/backend.c
@@ -1227,11 +1227,11 @@ int connect_server(struct stream *s)
                else if (srv->idle_conns && !LIST_ISEMPTY(&srv->idle_conns[tid]) &&
                         (s->be->options & PR_O_REUSE_MASK) == PR_O_REUSE_ALWS) {
                        srv_conn = LIST_ELEM(srv->idle_conns[tid].n, struct connection *, list);
-               } else if (srv->idle_orphan_conns && !LIST_ISEMPTY(&srv->idle_orphan_conns[tid]) &&
+               } else if (srv->idle_orphan_conns && !MT_LIST_ISEMPTY(&srv->idle_orphan_conns[tid]) &&
                    (((s->be->options & PR_O_REUSE_MASK) == PR_O_REUSE_ALWS) ||
                    (((s->be->options & PR_O_REUSE_MASK) != PR_O_REUSE_NEVR) &&
                     s->txn && (s->txn->flags & TX_NOT_FIRST)))) {
-                       srv_conn = LIST_POP_LOCKED(&srv->idle_orphan_conns[tid],
+                       srv_conn = MT_LIST_POP(&srv->idle_orphan_conns[tid],
                                                   struct connection *, list);
                        if (srv_conn)
                                reuse_orphan = 1;
@@ -1275,7 +1275,7 @@ int connect_server(struct stream *s)
                 * acceptable, attempt to kill an idling connection
                 */
                /* First, try from our own idle list */
-               tokill_conn = LIST_POP_LOCKED(&srv->idle_orphan_conns[tid],
+               tokill_conn = MT_LIST_POP(&srv->idle_orphan_conns[tid],
                    struct connection *, list);
                if (tokill_conn)
                        tokill_conn->mux->destroy(tokill_conn->ctx);
@@ -1293,13 +1293,13 @@ int connect_server(struct stream *s)
                                // see it possibly larger.
                                ALREADY_CHECKED(i);
 
-                               tokill_conn = LIST_POP_LOCKED(&srv->idle_orphan_conns[i],
+                               tokill_conn = MT_LIST_POP(&srv->idle_orphan_conns[i],
                                    struct connection *, list);
                                if (tokill_conn) {
                                        /* We got one, put it into the concerned thread's to kill list, and wake it's kill task */
 
-                                       LIST_ADDQ_LOCKED(&toremove_connections[i],
-                                           &tokill_conn->list);
+                                       MT_LIST_ADDQ(&toremove_connections[i],
+                                           (struct mt_list *)&tokill_conn->list);
                                        task_wakeup(idle_conn_cleanup[i], TASK_WOKEN_OTHER);
                                        break;
                                }

diff --git a/src/cfgparse.c b/src/cfgparse.c
index 9c2ac141baaf33fbddd43b3bb780ad00d7fe812d..6cbcac4f41d09fde67d31ecb575e3ecb26158f03 100644 (file)
--- a/src/cfgparse.c
+++ b/src/cfgparse.c
@@ -3640,14 +3640,14 @@ out_uri_auth_compat:
                                                        goto err;
                                                idle_conn_cleanup[i]->process = srv_cleanup_toremove_connections;
                                                idle_conn_cleanup[i]->context = NULL;
-                                               LIST_INIT(&toremove_connections[i]);
+                                               MT_LIST_INIT(&toremove_connections[i]);
                                        }
                                }
                                newsrv->idle_orphan_conns = calloc((unsigned int)global.nbthread, sizeof(*newsrv->idle_orphan_conns));
                                if (!newsrv->idle_orphan_conns)
                                        goto err;
                                for (i = 0; i < global.nbthread; i++)
-                                       LIST_INIT(&newsrv->idle_orphan_conns[i]);
+                                       MT_LIST_INIT(&newsrv->idle_orphan_conns[i]);
                                newsrv->curr_idle_thr = calloc(global.nbthread, sizeof(int));
                                if (!newsrv->curr_idle_thr)
                                        goto err;

diff --git a/src/cli.c b/src/cli.c
index 231b6123ae5ff638e610c7a136854b991741eb43..6b0b5e761690723c3bb0c0dfbb4841239e48422c 100644 (file)
--- a/src/cli.c
+++ b/src/cli.c
@@ -1374,7 +1374,7 @@ static int cli_parse_set_maxconn_global(char **args, char *payload, struct appct
        global.maxconn = v;
 
        /* Dequeues all of the listeners waiting for a resource */
-       if (!LIST_ISEMPTY(&global_listener_queue))
+       if (!MT_LIST_ISEMPTY(&global_listener_queue))
                dequeue_all_listeners(&global_listener_queue);
 
        return 1;
@@ -1493,7 +1493,7 @@ static int cli_parse_set_ratelimit(char **args, char *payload, struct appctx *ap
        *res = v * mul;
 
        /* Dequeues all of the listeners waiting for a resource */
-       if (!LIST_ISEMPTY(&global_listener_queue))
+       if (!MT_LIST_ISEMPTY(&global_listener_queue))
                dequeue_all_listeners(&global_listener_queue);
 
        return 1;

diff --git a/src/haproxy.c b/src/haproxy.c
index cc3da92af6aaf45fc6526118ae27b1bff040c064..ee6dd27ebf088d0c6c7eea32b239aec8d53f1ba0 100644 (file)
--- a/src/haproxy.c
+++ b/src/haproxy.c
@@ -231,7 +231,7 @@ unsigned int rlim_fd_max_at_boot = 0;
 struct mworker_proc *proc_self = NULL;
 
 /* list of the temporarily limited listeners because of lack of resource */
-struct list global_listener_queue = LIST_HEAD_INIT(global_listener_queue);
+struct mt_list global_listener_queue = MT_LIST_HEAD_INIT(global_listener_queue);
 struct task *global_listener_queue_task;
 static struct task *manage_global_listener_queue(struct task *t, void *context, unsigned short state);
 
@@ -2747,7 +2747,7 @@ static struct task *manage_global_listener_queue(struct task *t, void *context,
 {
        int next = TICK_ETERNITY;
        /* queue is empty, nothing to do */
-       if (LIST_ISEMPTY(&global_listener_queue))
+       if (MT_LIST_ISEMPTY(&global_listener_queue))
                goto out;
 
        /* If there are still too many concurrent connections, let's wait for

diff --git a/src/listener.c b/src/listener.c
index 33ac6ce1194a5018709cb0f61052ab248d888982..949f98821d54d0e29d0e171f3e0a8c3296955b44 100644 (file)
--- a/src/listener.c
+++ b/src/listener.c
@@ -273,7 +273,7 @@ static void disable_listener(struct listener *listener)
                goto end;
        if (listener->state == LI_READY)
                fd_stop_recv(listener->fd);
-       LIST_DEL_LOCKED(&listener->wait_queue);
+       MT_LIST_DEL(&listener->wait_queue);
        listener->state = LI_LISTEN;
   end:
        HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
@@ -309,7 +309,7 @@ int pause_listener(struct listener *l)
                        goto end;
        }
 
-       LIST_DEL_LOCKED(&l->wait_queue);
+       MT_LIST_DEL(&l->wait_queue);
 
        fd_stop_recv(l->fd);
        l->state = LI_PAUSED;
@@ -337,7 +337,7 @@ int resume_listener(struct listener *l)
        /* check that another thread didn't to the job in parallel (e.g. at the
         * end of listen_accept() while we'd come from dequeue_all_listeners().
         */
-       if (LIST_ADDED(&l->wait_queue))
+       if (MT_LIST_ADDED(&l->wait_queue))
                goto end;
 
        if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) &&
@@ -375,7 +375,7 @@ int resume_listener(struct listener *l)
        if (l->state == LI_READY)
                goto end;
 
-       LIST_DEL_LOCKED(&l->wait_queue);
+       MT_LIST_DEL(&l->wait_queue);
 
        if (l->maxconn && l->nbconn >= l->maxconn) {
                l->state = LI_FULL;
@@ -405,7 +405,7 @@ static void listener_full(struct listener *l)
 {
        HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
        if (l->state >= LI_READY) {
-               LIST_DEL_LOCKED(&l->wait_queue);
+               MT_LIST_DEL(&l->wait_queue);
                if (l->state != LI_FULL) {
                        fd_stop_recv(l->fd);
                        l->state = LI_FULL;
@@ -417,11 +417,11 @@ static void listener_full(struct listener *l)
 /* Marks a ready listener as limited so that we only try to re-enable it when
  * resources are free again. It will be queued into the specified queue.
  */
-static void limit_listener(struct listener *l, struct list *list)
+static void limit_listener(struct listener *l, struct mt_list *list)
 {
        HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
        if (l->state == LI_READY) {
-               LIST_ADDQ_LOCKED(list, &l->wait_queue);
+               MT_LIST_ADDQ(list, &l->wait_queue);
                fd_stop_recv(l->fd);
                l->state = LI_LIMITED;
        }
@@ -464,11 +464,11 @@ 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)
 {
        struct listener *listener;
 
-       while ((listener = LIST_POP_LOCKED(list, struct listener *, wait_queue))) {
+       while ((listener = MT_LIST_POP(list, struct listener *, wait_queue))) {
                /* This cannot fail because the listeners are by definition in
                 * the LI_LIMITED state.
                 */
@@ -484,7 +484,7 @@ void do_unbind_listener(struct listener *listener, int do_close)
        if (listener->state == LI_READY && fd_updt)
                fd_stop_recv(listener->fd);
 
-       LIST_DEL_LOCKED(&listener->wait_queue);
+       MT_LIST_DEL(&listener->wait_queue);
 
        if (listener->state >= LI_PAUSED) {
                if (do_close) {
@@ -569,7 +569,7 @@ int create_listeners(struct bind_conf *bc, const struct sockaddr_storage *ss,
 
                l->fd = fd;
                memcpy(&l->addr, ss, sizeof(*ss));
-               LIST_INIT(&l->wait_queue);
+               MT_LIST_INIT(&l->wait_queue);
                l->state = LI_INIT;
 
                proto->add(l, port);
@@ -1062,10 +1062,10 @@ void listener_accept(int fd)
                resume_listener(l);
 
                /* Dequeues all of the listeners waiting for a resource */
-               if (!LIST_ISEMPTY(&global_listener_queue))
+               if (!MT_LIST_ISEMPTY(&global_listener_queue))
                        dequeue_all_listeners(&global_listener_queue);
 
-               if (p && !LIST_ISEMPTY(&p->listener_queue) &&
+               if (p && !MT_LIST_ISEMPTY(&p->listener_queue) &&
                    (!p->fe_sps_lim || freq_ctr_remain(&p->fe_sess_per_sec, p->fe_sps_lim, 0) > 0))
                        dequeue_all_listeners(&p->listener_queue);
        }
@@ -1090,10 +1090,10 @@ void listener_release(struct listener *l)
                resume_listener(l);
 
        /* Dequeues all of the listeners waiting for a resource */
-       if (!LIST_ISEMPTY(&global_listener_queue))
+       if (!MT_LIST_ISEMPTY(&global_listener_queue))
                dequeue_all_listeners(&global_listener_queue);
 
-       if (!LIST_ISEMPTY(&fe->listener_queue) &&
+       if (!MT_LIST_ISEMPTY(&fe->listener_queue) &&
            (!fe->fe_sps_lim || freq_ctr_remain(&fe->fe_sess_per_sec, fe->fe_sps_lim, 0) > 0))
                dequeue_all_listeners(&fe->listener_queue);
 }
@@ -1104,7 +1104,7 @@ static struct task *listener_queue_process(struct task *t, void *context, unsign
        struct work_list *wl = context;
        struct listener *l;
 
-       while ((l = LIST_POP_LOCKED(&wl->head, struct listener *, wait_queue))) {
+       while ((l = MT_LIST_POP(&wl->head, struct listener *, wait_queue))) {
                /* The listeners are still in the LI_LIMITED state */
                resume_listener(l);
        }

diff --git a/src/proxy.c b/src/proxy.c
index 097668130734e5535f926421b7a41e54093e2db3..6386812fb3b36fb599c431829da40fae4765c95c 100644 (file)
--- a/src/proxy.c
+++ b/src/proxy.c
@@ -868,7 +868,7 @@ void init_new_proxy(struct proxy *p)
        LIST_INIT(&p->tcp_rep.inspect_rules);
        LIST_INIT(&p->tcp_req.l4_rules);
        LIST_INIT(&p->tcp_req.l5_rules);
-       LIST_INIT(&p->listener_queue);
+       MT_LIST_INIT(&p->listener_queue);
        LIST_INIT(&p->logsrvs);
        LIST_INIT(&p->logformat);
        LIST_INIT(&p->logformat_sd);
@@ -1034,7 +1034,7 @@ struct task *manage_proxy(struct task *t, void *context, unsigned short state)
        }
 
        /* The proxy is not limited so we can re-enable any waiting listener */
-       if (!LIST_ISEMPTY(&p->listener_queue))
+       if (!MT_LIST_ISEMPTY(&p->listener_queue))
                dequeue_all_listeners(&p->listener_queue);
  out:
        t->expire = next;
@@ -2033,7 +2033,7 @@ static int cli_parse_set_maxconn_frontend(char **args, char *payload, struct app
                        resume_listener(l);
        }
 
-       if (px->maxconn > px->feconn && !LIST_ISEMPTY(&px->listener_queue))
+       if (px->maxconn > px->feconn && !MT_LIST_ISEMPTY(&px->listener_queue))
                dequeue_all_listeners(&px->listener_queue);
 
        HA_SPIN_UNLOCK(PROXY_LOCK, &px->lock);

diff --git a/src/server.c b/src/server.c
index 10c4cf6de4d2224050039a71d67d8c42bc5bb9cf..df0dcbfed74c6aa18b7ee1a38458fb22a858ff9d 100644 (file)
--- a/src/server.c
+++ b/src/server.c
@@ -65,7 +65,7 @@ __decl_hathreads(HA_SPINLOCK_T idle_conn_srv_lock);
 struct eb_root idle_conn_srv = EB_ROOT;
 struct task *idle_conn_task = NULL;
 struct task *idle_conn_cleanup[MAX_THREADS] = { NULL };
-struct list toremove_connections[MAX_THREADS];
+struct mt_list toremove_connections[MAX_THREADS];
 __decl_hathreads(HA_SPINLOCK_T toremove_lock[MAX_THREADS]);
 
 /* The server names dictionary */
@@ -5550,7 +5550,7 @@ struct task *srv_cleanup_toremove_connections(struct task *task, void *context,
 {
        struct connection *conn;
 
-       while ((conn = LIST_POP_LOCKED(&toremove_connections[tid],
+       while ((conn = MT_LIST_POP(&toremove_connections[tid],
                                       struct connection *, list)) != NULL) {
                conn->mux->destroy(conn->ctx);
        }
@@ -5596,11 +5596,11 @@ struct task *srv_cleanup_idle_connections(struct task *task, void *context, unsi
 
                        HA_SPIN_LOCK(OTHER_LOCK, &toremove_lock[i]);
                        for (j = 0; j < max_conn; j++) {
-                               struct connection *conn = LIST_POP_LOCKED(&srv->idle_orphan_conns[i], struct connection *, list);
+                               struct connection *conn = MT_LIST_POP(&srv->idle_orphan_conns[i], struct connection *, list);
                                if (!conn)
                                        break;
                                did_remove = 1;
-                               LIST_ADDQ_LOCKED(&toremove_connections[i], &conn->list);
+                               MT_LIST_ADDQ(&toremove_connections[i], (struct mt_list *)&conn->list);
                        }
                        HA_SPIN_UNLOCK(OTHER_LOCK, &toremove_lock[i]);
                        if (did_remove && max_conn < srv->curr_idle_thr[i])

diff --git a/src/task.c b/src/task.c
index 9a55a604f83528e47b044d1fc380893060610808..dfec419f669efa26f7e499ca5a3ea0a2aa62b128 100644 (file)
--- a/src/task.c
+++ b/src/task.c
@@ -465,7 +465,7 @@ struct work_list *work_list_create(int nbthread,
                goto fail;
 
        for (i = 0; i < nbthread; i++) {
-               LIST_INIT(&wl[i].head);
+               MT_LIST_INIT(&wl[i].head);
                wl[i].task = task_new(1UL << i);
                if (!wl[i].task)
                        goto fail;