PoC: Add support to have an dedicated work queue per transport.

Author: bas-archembedded

include/zephyr/mgmt/mcumgr/transport/smp.h

@@ -132,6 +132,12 @@ struct smp_transport {
 		uint16_t expected;		/* expected bytes to come */
 	} __reassembly;
 #endif
+#ifdef CONFIG_MCUMGR_TRANSPORT_WORKQUEUE_MODEL_DEDICATED
+	/* Work queue for processing incoming requests */
+	struct k_work_q work_queue;
+	/* Work queue stack */
+	K_KERNEL_STACK_MEMBER(work_queue_stack, CONFIG_MCUMGR_TRANSPORT_WORKQUEUE_STACK_SIZE);
+#endif
 };
 
 /**

subsys/mgmt/mcumgr/smp_client/src/client.c

@@ -49,13 +49,13 @@ static void smp_client_cmd_req_free(struct smp_client_cmd_req *cmd_req);
 /**
  * Send all SMP client request packets.
  */
-static void smp_client_handle_reqs(struct k_work *work)
+static void smp_client_handle_reqs(struct k_work *work_)
 {
 	struct smp_client_object *smp_client;
 	struct smp_transport *smpt;
 	struct net_buf *nb;
 
-	smp_client = (void *)work;
+	smp_client = CONTAINER_OF(work_, struct smp_client_object, work);
 	smpt = smp_client->smpt;
 
 	while ((nb = k_fifo_get(&smp_client->tx_fifo, K_NO_WAIT)) != NULL) {
@@ -112,7 +112,7 @@ static void smp_client_transport_work_fn(struct k_work *work)
 			entry->retry_cnt--;
 			entry->timestamp = time_stamp_ref + CONFIG_SMP_CMD_RETRY_TIME;
 			k_fifo_put(&entry->smp_client->tx_fifo, entry->nb);
-			k_work_submit_to_queue(smp_get_wq(), &entry->smp_client->work);
+			k_work_submit_to_queue(smp_get_wq(entry->smp_client->smpt), &entry->smp_client->work);
 			continue;
 		}
 
@@ -126,7 +126,7 @@ static void smp_client_transport_work_fn(struct k_work *work)
 
 	if (!sys_slist_is_empty(&smp_client_data.cmd_list)) {
 		/* Re-schedule new timeout to next */
-		k_work_reschedule_for_queue(smp_get_wq(), &smp_client_data.work_delay,
+		k_work_reschedule_for_queue(NULL, &smp_client_data.work_delay,
 					    K_MSEC(backoff_ms));
 	}
 }
@@ -161,7 +161,7 @@ static void smp_cmd_add_to_list(struct smp_client_cmd_req *cmd_req)
 {
 	if (sys_slist_is_empty(&smp_client_data.cmd_list)) {
 		/* Enable timer */
-		k_work_reschedule_for_queue(smp_get_wq(), &smp_client_data.work_delay,
+		k_work_reschedule_for_queue(smp_get_wq(cmd_req->smp_client->smpt), &smp_client_data.work_delay,
 					    K_MSEC(CONFIG_SMP_CMD_RETRY_TIME));
 	}
 	sys_slist_append(&smp_client_data.cmd_list, &cmd_req->node);
@@ -322,7 +322,7 @@ int smp_client_send_cmd(struct smp_client_object *smp_client, struct net_buf *nb
 	nb = net_buf_ref(nb);
 	smp_cmd_add_to_list(cmd_req);
 	k_fifo_put(&smp_client->tx_fifo, nb);
-	k_work_submit_to_queue(smp_get_wq(), &smp_client->work);
+	k_work_submit_to_queue(smp_get_wq(smp_client->smpt), &smp_client->work);
 	return MGMT_ERR_EOK;
 }
 

subsys/mgmt/mcumgr/transport/Kconfig

@@ -11,6 +11,29 @@
 #  MCUMGR_TRANSPORT_ -- general transport options;
 #  MCUMGR_TRANSPORT_WORKQUEUE -- for workqueue configuration;
 #  MCUMGR_TRANSPORT_NETBUF -- for Net Buf related configuration.
+choice MCUMGR_TRANSPORT_WORKQUEUE_MODEL
+	prompt "MCUmgr transport thread model"
+	default MCUMGR_TRANSPORT_WORKQUEUE_MODEL_GLOBAL
+	help
+	  Select the work queue model to be used by the MCUmgr transport
+	  subsystem.
+
+config MCUMGR_TRANSPORT_WORKQUEUE_MODEL_DEDICATED
+	bool "MCUmgr transport dedicated workqueue model"
+	help
+		The transport subsystem creates its own workqueue to handle
+		incoming requests. This model is suitable for transports
+		that require asynchronous processing of requests over
+		multiple transport instances.
+
+config MCUMGR_TRANSPORT_WORKQUEUE_MODEL_GLOBAL
+	bool "MCUmgr transport global workqueue model"
+	help
+		The transport subsystem creates a global workqueue to handle
+		incoming requests. This model is suitable for cases where a single
+		workqueue services all transport instances.
+
+endchoice
 
 config MCUMGR_TRANSPORT_WORKQUEUE_STACK_SIZE
 	int "MCUmgr transport workqueue stack size"

subsys/mgmt/mcumgr/transport/include/mgmt/mcumgr/transport/smp_internal.h

@@ -48,14 +48,12 @@ struct zephyr_smp_transport;
  */
 void smp_rx_req(struct smp_transport *smtp, struct net_buf *nb);
 
-#ifdef CONFIG_SMP_CLIENT
 /**
  * @brief Get work queue for SMP client.
  *
  * @return SMP work queue object.
  */
-struct k_work_q *smp_get_wq(void);
-#endif
+struct k_work_q *smp_get_wq(struct smp_transport *smpt);
 
 /**
  * @brief Allocates a response buffer.

subsys/mgmt/mcumgr/transport/src/smp.c

@@ -13,6 +13,7 @@
 #include <zephyr/mgmt/mcumgr/smp/smp.h>
 #include <zephyr/mgmt/mcumgr/transport/smp.h>
 
+#include <mgmt/mcumgr/transport/smp_internal.h>
 #include <mgmt/mcumgr/transport/smp_reassembly.h>
 
 #include <zephyr/logging/log.h>
@@ -27,17 +28,20 @@ LOG_MODULE_REGISTER(mcumgr_smp, CONFIG_MCUMGR_TRANSPORT_LOG_LEVEL);
 #define WEAK
 #endif
 
+#ifdef CONFIG_MCUMGR_TRANSPORT_WORKQUEUE_MODEL_GLOBAL
 K_THREAD_STACK_DEFINE(smp_work_queue_stack, CONFIG_MCUMGR_TRANSPORT_WORKQUEUE_STACK_SIZE);
 
 static struct k_work_q smp_work_queue;
+#endif /* CONFIG_MCUMGR_TRANSPORT_WORKQUEUE_MODEL_GLOBAL */
+
+static const struct k_work_queue_config smp_work_queue_config = {
+	.name = "mcumgr smp"
+};
 
 #ifdef CONFIG_SMP_CLIENT
 static sys_slist_t smp_transport_clients = SYS_SLIST_STATIC_INIT(&smp_transport_clients);
 #endif
 
-static const struct k_work_queue_config smp_work_queue_config = {
-	.name = "mcumgr smp"
-};
 
 NET_BUF_POOL_DEFINE(pkt_pool, CONFIG_MCUMGR_TRANSPORT_NETBUF_COUNT,
 		    CONFIG_MCUMGR_TRANSPORT_NETBUF_SIZE,
@@ -157,6 +161,15 @@ int smp_transport_init(struct smp_transport *smpt)
 	k_work_init(&smpt->work, smp_handle_reqs);
 	k_fifo_init(&smpt->fifo);
 
+#ifdef CONFIG_MCUMGR_TRANSPORT_WORKQUEUE_MODEL_DEDICATED
+	/* Initialize dedicated work queue */
+	k_work_queue_init(&smpt->work_queue);
+
+	k_work_queue_start(&smpt->work_queue, smpt->work_queue_stack,
+			   K_THREAD_STACK_SIZEOF(smpt->work_queue_stack),
+			   CONFIG_MCUMGR_TRANSPORT_WORKQUEUE_THREAD_PRIO, &smp_work_queue_config);
+#endif /* CONFIG_MCUMGR_TRANSPORT_WORKQUEUE_MODEL_DEDICATED */
+
 	return 0;
 }
 
@@ -200,16 +213,23 @@ WEAK void
 smp_rx_req(struct smp_transport *smpt, struct net_buf *nb)
 {
 	k_fifo_put(&smpt->fifo, nb);
-	k_work_submit_to_queue(&smp_work_queue, &smpt->work);
+	k_work_submit_to_queue(smp_get_wq(smpt), &smpt->work);
 }
 
-#ifdef CONFIG_SMP_CLIENT
-struct k_work_q *smp_get_wq(void)
+struct k_work_q *smp_get_wq(struct smp_transport *smpt)
 {
-	return &smp_work_queue;
-}
+	struct k_work_q *work_q = NULL;
+#ifdef CONFIG_MCUMGR_TRANSPORT_WORKQUEUE_MODEL_GLOBAL
+	work_q = &smp_work_queue;
+#elif defined(CONFIG_MCUMGR_TRANSPORT_WORKQUEUE_MODEL_DEDICATED)
+	work_q = &smpt->work_queue;
+#else
+#error "No workqueue model defined"
 #endif
 
+	return work_q;
+}
+
 void smp_rx_remove_invalid(struct smp_transport *zst, void *arg)
 {
 	struct net_buf *nb;
@@ -245,7 +265,7 @@ void smp_rx_remove_invalid(struct smp_transport *zst, void *arg)
 
 	/* If at least one entry remains, queue the workqueue for running */
 	if (!k_fifo_is_empty(&zst->fifo)) {
-		k_work_submit_to_queue(&smp_work_queue, &zst->work);
+		k_work_submit_to_queue(smp_get_wq(zst), &zst->work);
 	}
 }
 
@@ -266,11 +286,13 @@ void smp_rx_clear(struct smp_transport *zst)
 
 static int smp_init(void)
 {
+#ifdef CONFIG_MCUMGR_TRANSPORT_WORKQUEUE_MODEL_GLOBAL
 	k_work_queue_init(&smp_work_queue);
 
 	k_work_queue_start(&smp_work_queue, smp_work_queue_stack,
 			   K_THREAD_STACK_SIZEOF(smp_work_queue_stack),
 			   CONFIG_MCUMGR_TRANSPORT_WORKQUEUE_THREAD_PRIO, &smp_work_queue_config);
+#endif /* CONFIG_MCUMGR_TRANSPORT_WORKQUEUE_MODEL_GLOBAL */
 
 	return 0;
 }