CLEANUP: lists/tree-wide: rename some list operations to avoid some confusion

The current "ADD" vs "ADDQ" is confusing because when thinking in terms
of appending at the end of a list, "ADD" naturally comes to mind, but
here it does the opposite, it inserts. Several times already it's been
incorrectly used where ADDQ was expected, the latest of which was a
fortunate accident explained in 6fa922562 ("CLEANUP: stream: explain
why we queue the stream at the head of the server list").

Let's use more explicit (but slightly longer) names now:

   LIST_ADD        ->       LIST_INSERT
   LIST_ADDQ       ->       LIST_APPEND
   LIST_ADDED      ->       LIST_INLIST
   LIST_DEL        ->       LIST_DELETE

The same is true for MT_LISTs, including their "TRY" variant.
LIST_DEL_INIT keeps its short name to encourage to use it instead of the
lazier LIST_DELETE which is often less safe.

The change is large (~674 non-comment entries) but is mechanical enough
to remain safe. No permutation was performed, so any out-of-tree code
can easily map older names to new ones.

The list doc was updated.

Author: wtarreau

include/haproxy/list.h

@@ -44,10 +44,10 @@
 #define LIST_HEAD_INIT(l) { &l, &l }
 
 /* adds an element at the beginning of a list ; returns the element */
-#define LIST_ADD(lh, el) ({ (el)->n = (lh)->n; (el)->n->p = (lh)->n = (el); (el)->p = (lh); (el); })
+#define LIST_INSERT(lh, el) ({ (el)->n = (lh)->n; (el)->n->p = (lh)->n = (el); (el)->p = (lh); (el); })
 
 /* adds an element at the end of a list ; returns the element */
-#define LIST_ADDQ(lh, el) ({ (el)->p = (lh)->p; (el)->p->n = (lh)->p = (el); (el)->n = (lh); (el); })
+#define LIST_APPEND(lh, el) ({ (el)->p = (lh)->p; (el)->p->n = (lh)->p = (el); (el)->n = (lh); (el); })
 
 /* adds the contents of a list <old> at the beginning of another list <new>. The old list head remains untouched. */
 #define LIST_SPLICE(new, old) do {				     \
@@ -71,10 +71,10 @@
 	} while (0)
 
 /* removes an element from a list and returns it */
-#define LIST_DEL(el) ({ typeof(el) __ret = (el); (el)->n->p = (el)->p; (el)->p->n = (el)->n; (__ret); })
+#define LIST_DELETE(el) ({ typeof(el) __ret = (el); (el)->n->p = (el)->p; (el)->p->n = (el)->n; (__ret); })
 
 /* removes an element from a list, initializes it and returns it.
- * This is faster than LIST_DEL+LIST_INIT as we avoid reloading the pointers.
+ * This is faster than LIST_DELETE+LIST_INIT as we avoid reloading the pointers.
  */
 #define LIST_DEL_INIT(el) ({ \
 	typeof(el) __ret = (el);                        \
@@ -98,7 +98,7 @@
 /* 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 LIST_ADDED(el) ((el)->n != (el))
+#define LIST_INLIST(el) ((el)->n != (el))
 
 /* returns a pointer of type <pt> to a structure following the element
  * which contains list head <lh>, which is known as element <el> in
@@ -224,7 +224,7 @@
  * Returns 1 if we added the item, 0 otherwise (because it was already in a
  * list).
  */
-#define MT_LIST_TRY_ADD(_lh, _el)                                              \
+#define MT_LIST_TRY_INSERT(_lh, _el)                                              \
      ({                                                                    \
         int _ret = 0;                                                      \
 	struct mt_list *lh = (_lh), *el = (_el);                           \
@@ -283,7 +283,7 @@
  * Returns 1 if we added the item, 0 otherwise (because it was already in a
  * list).
  */
-#define MT_LIST_TRY_ADDQ(_lh, _el)                                             \
+#define MT_LIST_TRY_APPEND(_lh, _el)                                             \
     ({                                                                     \
 	int _ret = 0;                                                      \
 	struct mt_list *lh = (_lh), *el = (_el);                           \
@@ -341,7 +341,7 @@
  * Add an item at the beginning of a list.
  * It is assumed the element can't already be in a list, so it isn't checked.
  */
-#define MT_LIST_ADD(_lh, _el)                                              \
+#define MT_LIST_INSERT(_lh, _el)                                              \
      ({                                                                    \
         int _ret = 0;                                                      \
 	struct mt_list *lh = (_lh), *el = (_el);                           \
@@ -374,7 +374,7 @@
  * Add an item at the end of a list.
  * It is assumed the element can't already be in a list, so it isn't checked
  */
-#define MT_LIST_ADDQ(_lh, _el)                                     \
+#define MT_LIST_APPEND(_lh, _el)                                     \
     ({                                                                     \
 	int _ret = 0;                                                      \
 	struct mt_list *lh = (_lh), *el = (_el);                           \
@@ -406,8 +406,8 @@
 /*
  * Detach a list from its head. A pointer to the first element is returned
  * and the list is closed. If the list was empty, NULL is returned. This may
- * exclusively be used with lists modified by MT_LIST_TRY_ADD/MT_LIST_TRY_ADDQ. This
- * is incompatible with MT_LIST_DEL run concurrently.
+ * exclusively be used with lists modified by MT_LIST_TRY_INSERT/MT_LIST_TRY_APPEND. This
+ * is incompatible with MT_LIST_DELETE run concurrently.
  * If there's at least one element, the next of the last element will always
  * be NULL.
  */
@@ -454,7 +454,7 @@
 /* Remove an item from a list.
  * Returns 1 if we removed the item, 0 otherwise (because it was in no list).
  */
-#define MT_LIST_DEL(_el)                                                   \
+#define MT_LIST_DELETE(_el)                                                   \
     ({                                                                     \
         int _ret = 0;                                                      \
 	struct mt_list *el = (_el);                                        \
@@ -589,7 +589,7 @@
 /* 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))
+#define MT_LIST_INLIST(el) ((el)->next != (el))
 
 /* Lock an element in the list, to be sure it won't be removed.
  * It needs to be synchronized somehow to be sure it's not removed
@@ -722,19 +722,19 @@
 	    p->next = n;                                                   \
     } while (0);
 
-/* Equivalent of MT_LIST_DEL(), to be used when parsing the list with mt_list_entry_for_each_safe().
+/* Equivalent of MT_LIST_DELETE(), to be used when parsing the list with mt_list_entry_for_each_safe().
  * It should be the element currently parsed (tmpelt1)
  */
-#define MT_LIST_DEL_SAFE(_el)                                              \
+#define MT_LIST_DELETE_SAFE(_el)                                              \
 	do {                                                               \
 		struct mt_list *el = (_el);                                \
 		(el)->prev = (el);                                         \
 		(el)->next = (el);                                         \
 		(_el) = NULL;                                              \
 	} while (0)
 
-/* Safe as MT_LIST_DEL_SAFE, but it won't reinit the element */
-#define MT_LIST_DEL_SAFE_NOINIT(_el)                                       \
+/* Safe as MT_LIST_DELETE_SAFE, but it won't reinit the element */
+#define MT_LIST_DELETE_SAFE_NOINIT(_el)                                       \
 	do {                                                               \
 		(_el) = NULL;                                              \
 	} while (0)
@@ -745,10 +745,10 @@
  * the list is passed in <list_head>. A temporary variable <back> of same type
  * as <item> is needed so that <item> may safely be deleted if needed.
  * tmpelt1 is a temporary struct mt_list *, and tmpelt2 is a temporary
- * struct mt_list, used internally, both are needed for MT_LIST_DEL_SAFE.
+ * struct mt_list, used internally, both are needed for MT_LIST_DELETE_SAFE.
  * Example: list_for_each_entry_safe(cur_acl, tmp, known_acl, list, elt1, elt2)
  * { ... };
- * If you want to remove the current element, please use MT_LIST_DEL_SAFE.
+ * If you want to remove the current element, please use MT_LIST_DELETE_SAFE.
  */
 #define mt_list_for_each_entry_safe(item, list_head, member, tmpelt, tmpelt2)           \
         for ((tmpelt) = NULL; (tmpelt) != MT_LIST_BUSY; ({                    \

spoa.c

@@ -972,11 +972,11 @@ release_frame(struct spoe_frame *frame)
 		event_del(&frame->process_frame_event);
 
 	worker = frame->worker;
-	LIST_DEL(&frame->list);
+	LIST_DELETE(&frame->list);
 	if (frame->frag_buf)
 		free(frame->frag_buf);
 	memset(frame, 0, sizeof(*frame)+max_frame_size+4);
-	LIST_ADDQ(&worker->frames, &frame->list);
+	LIST_APPEND(&worker->frames, &frame->list);
 }
 
 static void
@@ -989,7 +989,7 @@ release_client(struct client *c)
 
 	DEBUG(c->worker, "<%lu> Release client", c->id);
 
-	LIST_DEL(&c->by_worker);
+	LIST_DELETE(&c->by_worker);
 	c->worker->nbclients--;
 
 	unuse_spoe_engine(c);
@@ -1061,12 +1061,12 @@ use_spoe_engine(struct client *client)
 	LIST_INIT(&eng->clients);
 	LIST_INIT(&eng->processing_frames);
 	LIST_INIT(&eng->outgoing_frames);
-	LIST_ADDQ(&client->worker->engines, &eng->list);
+	LIST_APPEND(&client->worker->engines, &eng->list);
 	LOG(client->worker, "Add new SPOE engine '%s'", eng->id);
 
   end:
 	client->engine = eng;
-	LIST_ADDQ(&eng->clients, &client->by_engine);
+	LIST_APPEND(&eng->clients, &client->by_engine);
 }
 
 static void
@@ -1080,12 +1080,12 @@ unuse_spoe_engine(struct client *client)
 
 	eng = client->engine;
 	client->engine = NULL;
-	LIST_DEL(&client->by_engine);
+	LIST_DELETE(&client->by_engine);
 	if (!LIST_ISEMPTY(&eng->clients))
 		return;
 
 	LOG(client->worker, "Remove SPOE engine '%s'", eng->id);
-	LIST_DEL(&eng->list);
+	LIST_DELETE(&eng->list);
 
 	list_for_each_entry_safe(frame, back, &eng->processing_frames, list) {
 		release_frame(frame);
@@ -1115,7 +1115,7 @@ acquire_incoming_frame(struct client *client)
 	}
 	else {
 		frame = LIST_NEXT(&client->worker->frames, typeof(frame), list);
-		LIST_DEL(&frame->list);
+		LIST_DELETE(&frame->list);
 	}
 
 	reset_frame(frame);
@@ -1143,12 +1143,12 @@ acquire_outgoing_frame(struct client *client)
 		frame = client->outgoing_frame;
 	else if (!LIST_ISEMPTY(&client->outgoing_frames)) {
 		frame = LIST_NEXT(&client->outgoing_frames, typeof(frame), list);
-		LIST_DEL(&frame->list);
+		LIST_DELETE(&frame->list);
 		client->outgoing_frame = frame;
 	}
 	else if (engine!= NULL && !LIST_ISEMPTY(&engine->outgoing_frames)) {
 		frame = LIST_NEXT(&engine->outgoing_frames, typeof(frame), list);
-		LIST_DEL(&frame->list);
+		LIST_DELETE(&frame->list);
 		client->outgoing_frame = frame;
 	}
 	return frame;
@@ -1159,7 +1159,7 @@ write_frame(struct client *client, struct spoe_frame *frame)
 {
 	uint32_t netint;
 
-	LIST_DEL(&frame->list);
+	LIST_DELETE(&frame->list);
 
 	frame->buf    = (char *)(frame->data);
 	frame->offset = 0;
@@ -1175,7 +1175,7 @@ write_frame(struct client *client, struct spoe_frame *frame)
 			if (client->outgoing_frame == NULL)
 				client->outgoing_frame = frame;
 			else
-				LIST_ADD(&client->outgoing_frames, &frame->list);
+				LIST_INSERT(&client->outgoing_frames, &frame->list);
 		}
 		else {
 			client->outgoing_frame = frame;
@@ -1184,12 +1184,12 @@ write_frame(struct client *client, struct spoe_frame *frame)
 	}
 	else { /* for all other frames */
 		if (frame->client == NULL) { /* async mode ! */
-			LIST_ADDQ(&frame->engine->outgoing_frames, &frame->list);
+			LIST_APPEND(&frame->engine->outgoing_frames, &frame->list);
 			list_for_each_entry(client, &frame->engine->clients, by_engine)
 				event_add(&client->write_frame_event, NULL);
 		}
 		else if (frame->client->pipelining) {
-			LIST_ADDQ(&frame->client->outgoing_frames, &frame->list);
+			LIST_APPEND(&frame->client->outgoing_frames, &frame->list);
 			event_add(&frame->client->write_frame_event, NULL);
 		}
 		else {
@@ -1213,10 +1213,10 @@ process_incoming_frame(struct spoe_frame *frame)
 
 	if (client->async) {
 		frame->client = NULL;
-		LIST_ADDQ(&frame->engine->processing_frames, &frame->list);
+		LIST_APPEND(&frame->engine->processing_frames, &frame->list);
 	}
 	else if (client->pipelining)
-		LIST_ADDQ(&client->processing_frames, &frame->list);
+		LIST_APPEND(&client->processing_frames, &frame->list);
 	else
 		event_del(&client->read_frame_event);
 }
@@ -1632,7 +1632,7 @@ accept_cb(int listener, short event, void *arg)
 	LIST_INIT(&client->processing_frames);
 	LIST_INIT(&client->outgoing_frames);
 
-	LIST_ADDQ(&worker->clients, &client->by_worker);
+	LIST_APPEND(&worker->clients, &client->by_worker);
 
 	worker->nbclients++;
 
@@ -1662,7 +1662,7 @@ worker_function(void *data)
 	}
 
 	list_for_each_entry_safe(frame, fback, &worker->frames, list) {
-		LIST_DEL(&frame->list);
+		LIST_DELETE(&frame->list);
 		free(frame);
 	}