lws_dll2_t: wsi: switch all handrolled

Author: lws-team

lib/core-net/close.c

@@ -1100,10 +1100,8 @@ __lws_close_free_wsi_final(struct lws *wsi)
 			wsi->h2.END_STREAM = wsi->h2.END_HEADERS = 0;
 #endif
 #if defined(LWS_ROLE_H2) || defined(LWS_ROLE_MQTT) || defined(LWS_ROLE_H3)
-		if (wsi->mux.parent_wsi) {
+		if (wsi->mux.parent_wsi)
 			lws_wsi_mux_sibling_disconnect(wsi);
-			wsi->mux.parent_wsi = NULL;
-		}
 #endif
 
 #if defined(LWS_WITH_TLS)

lib/core-net/private-lib-core-net.h

@@ -34,22 +34,26 @@
  */
 
 struct lws_muxable {
-	struct lws	*parent_wsi;
-	struct lws	*child_list;
-	struct lws	*sibling_list;
+	struct lws		*parent_wsi;
+
+	/* mux child/sibling list: parent owns child_list_owner, each child
+	 * composes a sibling_list node.  All mutation goes through the
+	 * lws_wsi_mux_* helpers + the lws_dll2 primitives; the link pointers
+	 * must not be hand-edited. */
+	lws_dll2_owner_t	 child_list_owner;
+	lws_dll2_t		 sibling_list;
 
 	/*
 	 * Q-8: was unsigned int.  H2 stream IDs are 32-bit, but QUIC stream IDs
 	 * are 62-bit; a 32-bit field silently truncated them, so streams with
 	 * ids >= 2^32 were mis-looked-up and got frames emitted with the wrong
 	 * (truncated) id.  uint64_t holds both with room to spare.
 	 */
-	uint64_t	my_sid;
-	unsigned int	child_count;
+	uint64_t		my_sid;
 
-	uint32_t	highest_sid;
+	uint32_t		highest_sid;
 
-	uint8_t		requested_POLLOUT;
+	uint8_t			requested_POLLOUT;
 };
 
 #include "private-lib-roles.h"
@@ -660,12 +664,16 @@ __lws_vhost_destroy2(struct lws_vhost *vh);
 
 #define mux_to_wsi(_m) lws_container_of(_m, struct lws, mux)
 
+/* Number of mux children on wsi (kept in child_list_owner.count). */
+#define lws_wsi_mux_child_count(_wsi) \
+	((unsigned int)(_wsi)->mux.child_list_owner.count)
+
 void
 lws_wsi_mux_insert(struct lws *wsi, struct lws *parent_wsi, uint64_t sid);
 int
 lws_wsi_mux_mark_parents_needing_writeable(struct lws *wsi);
 struct lws *
-lws_wsi_mux_move_child_to_tail(struct lws **wsi2);
+lws_wsi_mux_move_child_to_tail(struct lws *parent_wsi);
 int
 lws_wsi_mux_action_pending_writeable_reqs(struct lws *wsi);
 

lib/core-net/wsi.c

@@ -1455,76 +1455,64 @@ void lws_wsi_mux_insert(struct lws *wsi, struct lws *parent_wsi,
 	}
 #endif
 
-	/* new guy's sibling is whoever was the first child before */
-	wsi->mux.sibling_list = parent_wsi->mux.child_list;
-
-	/* first child is now the new guy */
-	parent_wsi->mux.child_list = wsi;
-
-	parent_wsi->mux.child_count++;
+	/* new guy becomes the head child of the parent's mux child list */
+	lws_dll2_add_head(&wsi->mux.sibling_list, &parent_wsi->mux.child_list_owner);
 }
 
 struct lws *lws_wsi_mux_from_id(struct lws *parent_wsi, unsigned int sid) {
-	lws_start_foreach_ll(struct lws *, wsi, parent_wsi->mux.child_list) {
-		if (wsi->mux.my_sid == sid)
+	lws_start_foreach_dll(struct lws_dll2 *, d, parent_wsi->mux.child_list_owner.head) {
+		struct lws *wsi = lws_container_of(d, struct lws, mux.sibling_list);
+		if ((unsigned int)wsi->mux.my_sid == sid)
 			return wsi;
 	}
-	lws_end_foreach_ll(wsi, mux.sibling_list);
+	lws_end_foreach_dll(d);
 
 	return NULL;
 }
 
 void lws_wsi_mux_dump_children(struct lws *wsi) {
 #if defined(_DEBUG)
+	struct lws *parent;
+
 	if (!wsi->mux.parent_wsi || !lwsl_visible(LLL_INFO))
 		return;
 
-	lws_start_foreach_llp(struct lws **, w, wsi->mux.parent_wsi->mux.child_list) {
+	parent = wsi->mux.parent_wsi;
+
+	lws_start_foreach_dll(struct lws_dll2 *, d, parent->mux.child_list_owner.head) {
+		struct lws *w = lws_container_of(d, struct lws, mux.sibling_list);
 		lwsl_wsi_info(wsi, "   \\---- child %s %s\n",
-				(*w)->role_ops ? (*w)->role_ops->name : "?", lws_wsi_tag(*w));
-		assert(*w != (*w)->mux.sibling_list);
+				w->role_ops ? w->role_ops->name : "?", lws_wsi_tag(w));
 	}
-	lws_end_foreach_llp(w, mux.sibling_list);
+	lws_end_foreach_dll(d);
 #endif
 }
 
 void lws_wsi_mux_close_children(struct lws *wsi, int reason) {
-	struct lws *wsi2;
-	struct lws **w;
 
-	if (!wsi->mux.child_list)
+	if (!wsi->mux.child_list_owner.head)
 		return;
 
-	w = &wsi->mux.child_list;
-	while (*w) {
-		lwsl_wsi_info((*w), "   closing child");
-		/* disconnect from siblings */
-		wsi2 = (*w)->mux.sibling_list;
-		assert(wsi2 != *w);
-		(*w)->mux.sibling_list = NULL;
-		(*w)->socket_is_permanently_unusable = 1;
-		__lws_close_free_wsi(*w, (enum lws_close_status)reason,
+	lws_start_foreach_dll_safe(struct lws_dll2 *, d, d1,
+				   wsi->mux.child_list_owner.head) {
+		struct lws *w = lws_container_of(d, struct lws, mux.sibling_list);
+
+		lwsl_wsi_info(w, "   closing child");
+		w->socket_is_permanently_unusable = 1;
+		__lws_close_free_wsi(w, (enum lws_close_status)reason,
 				"mux child recurse");
-		*w = wsi2;
 	}
+	lws_end_foreach_dll_safe(d, d1);
 }
 
 void lws_wsi_mux_sibling_disconnect(struct lws *wsi) {
-	struct lws *wsi2;
 
-	lws_start_foreach_llp(struct lws **, w, wsi->mux.parent_wsi->mux.child_list) {
+	if (!wsi->mux.parent_wsi)
+		return;
 
-		/* disconnect from siblings */
-		if (*w == wsi) {
-			wsi2 = (*w)->mux.sibling_list;
-			(*w)->mux.sibling_list = NULL;
-			*w = wsi2;
-			lwsl_wsi_debug(wsi, " disentangled from sibling %s", lws_wsi_tag(wsi2));
-			break;
-		}
-	}
-	lws_end_foreach_llp(w, mux.sibling_list);
-	wsi->mux.parent_wsi->mux.child_count--;
+	lws_dll2_remove(&wsi->mux.sibling_list);
+	lwsl_wsi_debug(wsi, " disentangled from mux parent %s",
+		       lws_wsi_tag(wsi->mux.parent_wsi));
 
 	wsi->mux.parent_wsi = NULL;
 }
@@ -1534,16 +1522,15 @@ void lws_wsi_mux_dump_waiting_children(struct lws *wsi) {
 	lwsl_info("%s: %s: children waiting for POLLOUT service:\n", __func__,
 			lws_wsi_tag(wsi));
 
-	wsi = wsi->mux.child_list;
-	while (wsi) {
-		lwsl_wsi_info(wsi, "  %c sid %llu: 0x%x %s %s",
-				wsi->mux.requested_POLLOUT ? '*' : ' ',
-				(unsigned long long)wsi->mux.my_sid,
-				lwsi_state(wsi), wsi->role_ops->name,
-				wsi->a.protocol ? wsi->a.protocol->name : "noprotocol");
-
-		wsi = wsi->mux.sibling_list;
+	lws_start_foreach_dll(struct lws_dll2 *, d, wsi->mux.child_list_owner.head) {
+		struct lws *w = lws_container_of(d, struct lws, mux.sibling_list);
+		lwsl_wsi_info(w, "  %c sid %llu: 0x%x %s %s",
+				w->mux.requested_POLLOUT ? '*' : ' ',
+				(unsigned long long)w->mux.my_sid,
+				lwsi_state(w), w->role_ops->name,
+				w->a.protocol ? w->a.protocol->name : "noprotocol");
 	}
+	lws_end_foreach_dll(d);
 #endif
 }
 
@@ -1564,43 +1551,33 @@ int lws_wsi_mux_mark_parents_needing_writeable(struct lws *wsi) {
 	return 0; // already;
 }
 
-struct lws *lws_wsi_mux_move_child_to_tail(struct lws **wsi2) {
-	struct lws *w = *wsi2;
-
-	while (w) {
-		if (!w->mux.sibling_list) { /* w is the current last */
-			lwsl_wsi_debug(w, "*wsi2 = %s\n", lws_wsi_tag(*wsi2));
-
-			if (w == *wsi2) /* we are already last */
-				break;
-
-			/* last points to us as new last */
-			w->mux.sibling_list = *wsi2;
+/*
+ * Move the head mux child of parent_wsi to the tail of its sibling list, and
+ * clear its requested_POLLOUT.  Returns the moved child (formerly the head),
+ * or NULL if there are no children.  This implements the fair-share rotation
+ * used by the POLLOUT service loops.
+ */
+struct lws *lws_wsi_mux_move_child_to_tail(struct lws *parent_wsi) {
+	struct lws_dll2 *head;
+	struct lws *w;
 
-			/* guy pointing to us until now points to
-			 * our old next */
-			*wsi2 = (*wsi2)->mux.sibling_list;
+	head = lws_dll2_get_head(&parent_wsi->mux.child_list_owner);
+	if (!head)
+		return NULL;
 
-			/* we point to nothing because we are last */
-			w->mux.sibling_list->mux.sibling_list = NULL;
+	w = lws_container_of(head, struct lws, mux.sibling_list);
 
-			/* w becomes us */
-			w = w->mux.sibling_list;
-			break;
-		}
-		w = w->mux.sibling_list;
-	}
+	lws_dll2_remove(&w->mux.sibling_list);
+	lws_dll2_add_tail(&w->mux.sibling_list,
+			  &parent_wsi->mux.child_list_owner);
 
 	/* clear the waiting for POLLOUT on the guy that was chosen */
-
-	if (w)
-		w->mux.requested_POLLOUT = 0;
+	w->mux.requested_POLLOUT = 0;
 
 	return w;
 }
 
 int lws_wsi_mux_action_pending_writeable_reqs(struct lws *wsi) {
-	struct lws *w = wsi->mux.child_list;
 	struct lws *nwsi = lws_get_network_wsi(wsi);
 
 	if (wsi->mux.requested_POLLOUT) {
@@ -1609,14 +1586,16 @@ int lws_wsi_mux_action_pending_writeable_reqs(struct lws *wsi) {
 		return 0;
 	}
 
-	while (w) {
+	lws_start_foreach_dll(struct lws_dll2 *, d, wsi->mux.child_list_owner.head) {
+		struct lws *w = lws_container_of(d, struct lws, mux.sibling_list);
+
 		if (w->mux.requested_POLLOUT) {
 			if (lws_change_pollfd(nwsi, 0, LWS_POLLOUT))
 				return -1;
 			return 0;
 		}
-		w = w->mux.sibling_list;
 	}
+	lws_end_foreach_dll(d);
 
 	if (lws_change_pollfd(nwsi, LWS_POLLOUT, 0))
 		return -1;

lib/roles/h2/http2.c

@@ -242,7 +242,7 @@ __lws_wsi_server_new(struct lws_vhost *vh, struct lws *parent_wsi,
 	}
 
 	/* no more children allowed by parent */
-	if (parent_wsi->mux.child_count + 1 >
+	if (lws_wsi_mux_child_count(parent_wsi) + 1 >
 	    parent_wsi->h2.h2n->our_set.s[H2SET_MAX_CONCURRENT_STREAMS]) {
 		lwsl_notice("reached concurrent stream limit\n");
 		return NULL;
@@ -310,8 +310,7 @@ __lws_wsi_server_new(struct lws_vhost *vh, struct lws *parent_wsi,
 
 bail1:
 	/* undo the insert */
-	parent_wsi->mux.child_list = wsi->mux.sibling_list;
-	parent_wsi->mux.child_count--;
+	lws_wsi_mux_sibling_disconnect(wsi);
 
 	if (wsi->user_space)
 		lws_free_set_NULL(wsi->user_space);
@@ -328,7 +327,7 @@ lws_wsi_h2_adopt(struct lws *parent_wsi, struct lws *wsi)
 	struct lws *nwsi = lws_get_network_wsi(parent_wsi);
 
 	/* no more children allowed by parent */
-	if (parent_wsi->mux.child_count + 1 >
+	if (lws_wsi_mux_child_count(parent_wsi) + 1 >
 	    parent_wsi->h2.h2n->our_set.s[H2SET_MAX_CONCURRENT_STREAMS]) {
 		lwsl_notice("reached concurrent stream limit\n");
 		return NULL;
@@ -382,8 +381,7 @@ lws_wsi_h2_adopt(struct lws *parent_wsi, struct lws *wsi)
 
 bail1:
 	/* undo the insert */
-	parent_wsi->mux.child_list = wsi->mux.sibling_list;
-	parent_wsi->mux.child_count--;
+	lws_wsi_mux_sibling_disconnect(wsi);
 
 	if (wsi->user_space)
 		lws_free_set_NULL(wsi->user_space);
@@ -582,8 +580,10 @@ lws_h2_settings(struct lws *wsi, struct http2_settings *settings,
 			 * the new value and the old value.
 			 */
 
-			lws_start_foreach_ll(struct lws *, w,
-					     nwsi->mux.child_list) {
+			lws_start_foreach_dll(struct lws_dll2 *, d,
+					     nwsi->mux.child_list_owner.head) {
+				struct lws *w = lws_container_of(d, struct lws,
+								 mux.sibling_list);
 				lwsl_info("%s: adi child tc cr %d +%d -> %d",
 					  __func__, (int)w->txc.tx_cr,
 					  b - (unsigned int)settings->s[a],
@@ -595,7 +595,7 @@ lws_h2_settings(struct lws *wsi, struct http2_settings *settings,
 						  (int32_t)(b - settings->s[a]))
 
 					lws_callback_on_writable(w);
-			} lws_end_foreach_ll(w, mux.sibling_list);
+			} lws_end_foreach_dll(d);
 
 			break;
 		case H2SET_MAX_FRAME_SIZE:
@@ -1456,7 +1456,7 @@ lws_h2_parse_frame_header(struct lws *wsi)
 
 		if (!h2n->swsi) {
 			/* no more children allowed by parent */
-			if (wsi->mux.child_count + 1 >
+			if (lws_wsi_mux_child_count(wsi) + 1 >
 			    wsi->h2.h2n->our_set.s[H2SET_MAX_CONCURRENT_STREAMS]) {
 				lws_h2_goaway(wsi, H2_ERR_PROTOCOL_ERROR,
 				"Another stream not allowed");
@@ -1515,12 +1515,14 @@ lws_h2_parse_frame_header(struct lws *wsi)
 		 * transitions to the "closed" state when the first frame for
 		 * stream 7 is sent or received.
 		 */
-		lws_start_foreach_ll_safe(struct lws *, w, wsi->mux.child_list,
-					  mux.sibling_list) {
+		lws_start_foreach_dll_safe(struct lws_dll2 *, d, d1,
+				wsi->mux.child_list_owner.head) {
+			struct lws *w = lws_container_of(d, struct lws,
+							 mux.sibling_list);
 			if (w->mux.my_sid < h2n->sid &&
 			    w->h2.h2_state == LWS_H2_STATE_IDLE)
 				lws_close_free_wsi(w, 0, "h2 sid close");
-		} lws_end_foreach_ll_safe(w);
+		} lws_end_foreach_dll_safe(d, d1);
 
 		h2n->cont_exp = !(h2n->flags & LWS_H2_FLAG_END_HEADERS);
 		h2n->cont_exp_sid = h2n->sid;
@@ -2152,9 +2154,12 @@ lws_h2_parse_end_of_frame(struct lws *wsi)
 		 * too)... for us and any children waiting on us... reassess
 		 * blockage for all children first
 		 */
-		lws_start_foreach_ll(struct lws *, w, wsi->mux.child_list) {
+		lws_start_foreach_dll(struct lws_dll2 *, d,
+				wsi->mux.child_list_owner.head) {
+			struct lws *w = lws_container_of(d, struct lws,
+							 mux.sibling_list);
 			lws_callback_on_writable(w);
-		} lws_end_foreach_ll(w, mux.sibling_list);
+		} lws_end_foreach_dll(d);
 
 		if (eff_wsi->txc.skint &&
 		    !lws_wsi_txc_check_skint(&eff_wsi->txc,
@@ -2984,10 +2989,13 @@ lws_h2_client_handshake(struct lws *wsi)
 	lwsi_set_state(wsi, LRS_ESTABLISHED);
 
 	if (wsi->mux.my_sid == 1) {
-		lws_start_foreach_ll(struct lws *, w1, nwsi->mux.child_list) {
+		lws_start_foreach_dll(struct lws_dll2 *, d,
+				nwsi->mux.child_list_owner.head) {
+			struct lws *w1 = lws_container_of(d, struct lws,
+							  mux.sibling_list);
 			if (w1 != wsi && lwsi_state(w1) == LRS_H2_WAITING_TO_SEND_HEADERS)
 				lws_callback_on_writable(w1);
-		} lws_end_foreach_ll(w1, mux.sibling_list);
+		} lws_end_foreach_dll(d);
 	}
 
 	if (wsi->flags & LCCSCF_HTTP_MULTIPART_MIME)