mgmt/mcumgr: Rename zst pointers to smp_transport to smpt

Cosmetic change: the zst was short for zephyr_smp_transport,
now it is just smp_transport so smpt makes more sense.

Signed-off-by: Dominik Ermel <[email protected]>

Author: de-nordic

include/zephyr/mgmt/mcumgr/smp.h

@@ -128,13 +128,13 @@ struct zephyr_smp_transport {
 /**
  * @brief Initializes a Zephyr SMP transport object.
  *
- * @param zst                   The transport to construct.
+ * @param smpt                  The transport to construct.
  * @param output_func           The transport's send function.
  * @param get_mtu_func          The transport's get-MTU function.
  * @param ud_copy_func          The transport buffer user_data copy function.
  * @param ud_free_func          The transport buffer user_data free function.
  */
-void smp_transport_init(struct smp_transport *zst,
+void smp_transport_init(struct smp_transport *smpt,
 			smp_transport_out_fn output_func,
 			smp_transport_get_mtu_fn get_mtu_func,
 			smp_transport_ud_copy_fn ud_copy_func,

subsys/mgmt/mcumgr/smp.c

@@ -49,7 +49,7 @@ void *smp_alloc_rsp(const void *req, void *arg)
 {
 	const struct net_buf *req_nb;
 	struct net_buf *rsp_nb;
-	struct smp_transport *zst = arg;
+	struct smp_transport *smpt = arg;
 
 	req_nb = req;
 
@@ -58,8 +58,8 @@ void *smp_alloc_rsp(const void *req, void *arg)
 		return NULL;
 	}
 
-	if (zst->zst_ud_copy) {
-		zst->zst_ud_copy(rsp_nb, req_nb);
+	if (smpt->zst_ud_copy) {
+		smpt->zst_ud_copy(rsp_nb, req_nb);
 	} else {
 		memcpy(net_buf_user_data(rsp_nb),
 		       net_buf_user_data((void *)req_nb),
@@ -71,14 +71,14 @@ void *smp_alloc_rsp(const void *req, void *arg)
 
 void smp_free_buf(void *buf, void *arg)
 {
-	struct smp_transport *zst = arg;
+	struct smp_transport *smpt = arg;
 
 	if (!buf) {
 		return;
 	}
 
-	if (zst->zst_ud_free) {
-		zst->zst_ud_free(net_buf_user_data((struct net_buf *)buf));
+	if (smpt->zst_ud_free) {
+		smpt->zst_ud_free(net_buf_user_data((struct net_buf *)buf));
 	}
 
 	mcumgr_buf_free(buf);
@@ -88,8 +88,7 @@ void smp_free_buf(void *buf, void *arg)
  * Processes a single SMP packet and sends the corresponding response(s).
  */
 static int
-smp_process_packet(struct smp_transport *zst,
-			  struct net_buf *nb)
+smp_process_packet(struct smp_transport *smpt, struct net_buf *nb)
 {
 	struct cbor_nb_reader reader;
 	struct cbor_nb_writer writer;
@@ -99,7 +98,7 @@ smp_process_packet(struct smp_transport *zst,
 	streamer = (struct smp_streamer) {
 		.reader = &reader,
 		.writer = &writer,
-		.smpt = zst,
+		.smpt = smpt,
 	};
 
 	rc = smp_process_request_packet(&streamer, nb);
@@ -112,52 +111,52 @@ smp_process_packet(struct smp_transport *zst,
 static void
 smp_handle_reqs(struct k_work *work)
 {
-	struct smp_transport *zst;
+	struct smp_transport *smpt;
 	struct net_buf *nb;
 
-	zst = (void *)work;
+	smpt = (void *)work;
 
-	while ((nb = net_buf_get(&zst->zst_fifo, K_NO_WAIT)) != NULL) {
-		smp_process_packet(zst, nb);
+	while ((nb = net_buf_get(&smpt->zst_fifo, K_NO_WAIT)) != NULL) {
+		smp_process_packet(smpt, nb);
 	}
 }
 
 void
-smp_transport_init(struct smp_transport *zst,
+smp_transport_init(struct smp_transport *smpt,
 		   smp_transport_out_fn output_func,
 		   smp_transport_get_mtu_fn get_mtu_func,
 		   smp_transport_ud_copy_fn ud_copy_func,
 		   smp_transport_ud_free_fn ud_free_func)
 {
-	*zst = (struct smp_transport) {
+	*smpt = (struct smp_transport) {
 		.zst_output = output_func,
 		.zst_get_mtu = get_mtu_func,
 		.zst_ud_copy = ud_copy_func,
 		.zst_ud_free = ud_free_func,
 	};
 
 #ifdef CONFIG_MCUMGR_SMP_REASSEMBLY
-	smp_reassembly_init(zst);
+	smp_reassembly_init(smpt);
 #endif
 
-	k_work_init(&zst->zst_work, smp_handle_reqs);
-	k_fifo_init(&zst->zst_fifo);
+	k_work_init(&smpt->zst_work, smp_handle_reqs);
+	k_fifo_init(&smpt->zst_fifo);
 }
 
 /**
  * @brief Enqueues an incoming SMP request packet for processing.
  *
  * This function always consumes the supplied net_buf.
  *
- * @param zst                   The transport to use to send the corresponding
+ * @param smpt                  The transport to use to send the corresponding
  *                                  response(s).
  * @param nb                    The request packet to process.
  */
 WEAK void
-smp_rx_req(struct smp_transport *zst, struct net_buf *nb)
+smp_rx_req(struct smp_transport *smpt, struct net_buf *nb)
 {
-	net_buf_put(&zst->zst_fifo, nb);
-	k_work_submit_to_queue(&smp_work_queue, &zst->zst_work);
+	net_buf_put(&smpt->zst_fifo, nb);
+	k_work_submit_to_queue(&smp_work_queue, &smpt->zst_work);
 }
 
 static int smp_init(const struct device *dev)

subsys/mgmt/mcumgr/smp_internal.h

@@ -21,11 +21,11 @@ struct net_buf;
  *
  * This function always consumes the supplied net_buf.
  *
- * @param zst                   The transport to use to send the corresponding
+ * @param smtp                  The transport to use to send the corresponding
  *                                  response(s).
  * @param nb                    The request packet to process.
  */
-void smp_rx_req(struct smp_transport *zst, struct net_buf *nb);
+void smp_rx_req(struct smp_transport *smtp, struct net_buf *nb);
 
 static inline
 void zephyr_smp_rx_req(struct zephyr_smp_transport *smpt, struct net_buf *nb)

subsys/mgmt/mcumgr/smp_reassembly.c

@@ -13,24 +13,24 @@
 #include <smp/smp.h>
 #include "smp_internal.h"
 
-void smp_reassembly_init(struct smp_transport *zst)
+void smp_reassembly_init(struct smp_transport *smpt)
 {
-	zst->__reassembly.current = NULL;
-	zst->__reassembly.expected = 0;
+	smpt->__reassembly.current = NULL;
+	smpt->__reassembly.expected = 0;
 }
 
-int smp_reassembly_expected(const struct smp_transport *zst)
+int smp_reassembly_expected(const struct smp_transport *smpt)
 {
-	if (zst->__reassembly.current == NULL) {
+	if (smpt->__reassembly.current == NULL) {
 		return -EINVAL;
 	}
 
-	return zst->__reassembly.expected;
+	return smpt->__reassembly.expected;
 }
 
-int smp_reassembly_collect(struct smp_transport *zst, const void *buf, uint16_t len)
+int smp_reassembly_collect(struct smp_transport *smpt, const void *buf, uint16_t len)
 {
-	if (zst->__reassembly.current == NULL) {
+	if (smpt->__reassembly.current == NULL) {
 		/*
 		 * Collecting the first fragment: need to allocate buffer for it and prepare
 		 * the reassembly context.
@@ -54,9 +54,9 @@ int smp_reassembly_collect(struct smp_transport *zst, const void *buf, uint16_t
 				return -EOVERFLOW;
 			}
 
-			zst->__reassembly.current = mcumgr_buf_alloc();
-			if (zst->__reassembly.current != NULL) {
-				zst->__reassembly.expected = expected;
+			smpt->__reassembly.current = mcumgr_buf_alloc();
+			if (smpt->__reassembly.current != NULL) {
+				smpt->__reassembly.expected = expected;
 			} else {
 				return -ENOMEM;
 			}
@@ -67,53 +67,53 @@ int smp_reassembly_collect(struct smp_transport *zst, const void *buf, uint16_t
 	}
 
 	/* len is expected to be > 0 */
-	if (zst->__reassembly.expected >= len) {
-		net_buf_add_mem(zst->__reassembly.current, buf, len);
-		zst->__reassembly.expected -= len;
+	if (smpt->__reassembly.expected >= len) {
+		net_buf_add_mem(smpt->__reassembly.current, buf, len);
+		smpt->__reassembly.expected -= len;
 	} else {
 		/*
 		 * A fragment is longer than the expected size and will not fit into the buffer.
 		 */
 		return -EOVERFLOW;
 	}
 
-	return zst->__reassembly.expected;
+	return smpt->__reassembly.expected;
 }
 
-int smp_reassembly_complete(struct smp_transport *zst, bool force)
+int smp_reassembly_complete(struct smp_transport *smpt, bool force)
 {
-	if (zst->__reassembly.current == NULL) {
+	if (smpt->__reassembly.current == NULL) {
 		return -EINVAL;
 	}
 
-	if (zst->__reassembly.expected == 0 || force) {
-		int expected = zst->__reassembly.expected;
+	if (smpt->__reassembly.expected == 0 || force) {
+		int expected = smpt->__reassembly.expected;
 
-		smp_rx_req(zst, zst->__reassembly.current);
-		zst->__reassembly.expected = 0;
-		zst->__reassembly.current = NULL;
+		smp_rx_req(smpt, smpt->__reassembly.current);
+		smpt->__reassembly.expected = 0;
+		smpt->__reassembly.current = NULL;
 		return expected;
 	}
 	return -ENODATA;
 }
 
-int smp_reassembly_drop(struct smp_transport *zst)
+int smp_reassembly_drop(struct smp_transport *smpt)
 {
-	if (zst->__reassembly.current == NULL) {
+	if (smpt->__reassembly.current == NULL) {
 		return -EINVAL;
 	}
 
-	mcumgr_buf_free(zst->__reassembly.current);
-	zst->__reassembly.expected = 0;
-	zst->__reassembly.current = NULL;
+	mcumgr_buf_free(smpt->__reassembly.current);
+	smpt->__reassembly.expected = 0;
+	smpt->__reassembly.current = NULL;
 
 	return 0;
 }
 
-void *smp_reassembly_get_ud(const struct smp_transport *zst)
+void *smp_reassembly_get_ud(const struct smp_transport *smpt)
 {
-	if (zst->__reassembly.current != NULL) {
-		return net_buf_user_data(zst->__reassembly.current);
+	if (smpt->__reassembly.current != NULL) {
+		return net_buf_user_data(smpt->__reassembly.current);
 	}
 
 	return NULL;

subsys/mgmt/mcumgr/smp_reassembly.h

@@ -16,12 +16,12 @@ struct smp_transport;
 /**
  * Initialize re-assembly context within smp_transport
  *
- * @param zst	the SMP transport.
+ * @param smpt	the SMP transport.
  *
- * Note: for efficiency there is no NULL check on @p zst pointer and it is caller's responsibility
+ * Note: for efficiency there is no NULL check on @p smpt pointer and it is caller's responsibility
  * to validate the pointer before passing it to this function.
  */
-void smp_reassembly_init(struct smp_transport *zst);
+void smp_reassembly_init(struct smp_transport *smpt);
 
 /**
  * Collect data to re-assembly buffer
@@ -32,11 +32,11 @@ void smp_reassembly_init(struct smp_transport *zst);
  * Note: Currently the function is not able to concatenate buffers so re-assembled packet needs
  * to fit into one buffer.
  *
- * @param zst	the SMP transport;
+ * @param smpt	the SMP transport;
  * @param buf	buffer with data to add;
  * @param len	length of data to add;
  *
- * Note: For efficiency there are ot NULL checks on @p zst and @p buf pointers and it is caller's
+ * Note: For efficiency there are ot NULL checks on @p smpt and @p buf pointers and it is caller's
  * responsibility to make sure these are not NULL.  Also @p len should not be 0 as there is no
  * point in passing an empty fragment for re-assembly.
  *
@@ -50,35 +50,35 @@ void smp_reassembly_init(struct smp_transport *zst);
  *		-ENODATA if the first received fragment was not big enough to figure out a size
  *		of the packet; MTU is set too low;
  */
-int smp_reassembly_collect(struct smp_transport *zst, const void *buf, uint16_t len);
+int smp_reassembly_collect(struct smp_transport *smpt, const void *buf, uint16_t len);
 
 /**
  * Return number of expected bytes to complete the packet
  *
- * @param zst	the SMP transport;
+ * @param smpt	the SMP transport;
  *
- * Note: for efficiency there is no NULL check on @p zst pointer and it is caller's responsibility
+ * Note: for efficiency there is no NULL check on @p smpt pointer and it is caller's responsibility
  * to validate the pointer before passing it to this function.
  *
  * @return	number of bytes needed to complete the packet;
  *		-EINVAL if there is no packet in re-assembly;
  */
-int smp_reassembly_expected(const struct smp_transport *zst);
+int smp_reassembly_expected(const struct smp_transport *smpt);
 
 /**
  * Pass packet for further processing
  *
  * Checks if the packet has enough data to be re-assembled and passes it for further processing.
- * If successful then the re-assembly context in @p zst will indicate that there is no
+ * If successful then the re-assembly context in @p smpt will indicate that there is no
  * re-assembly in progress.
  * The function can be forced to pass a data for processing even if the packet is not complete,
  * in which case it is users responsibility to use the user data, passed with the packet, to notify
  * receiving end of such case.
  *
- * @param zst	the SMP transport;
+ * @param smpt	the SMP transport;
  * @param force	process anyway;
  *
- * Note: for efficiency there is no NULL check on @p zst pointer and it is caller's responsibility
+ * Note: for efficiency there is no NULL check on @p smpt pointer and it is caller's responsibility
  * to validate the pointer before passing it to this function.
  *
  * @return	0 on success and not forced;
@@ -87,33 +87,33 @@ int smp_reassembly_expected(const struct smp_transport *zst);
  *		-ENODATA if there is not enough data to consider packet re-assembled, it has not
  *		been passed further.
  */
-int smp_reassembly_complete(struct smp_transport *zst, bool force);
+int smp_reassembly_complete(struct smp_transport *smpt, bool force);
 
 /**
  * Drop packet and release buffer
  *
- * @param zst	the SMP transport;
+ * @param smpt	the SMP transport;
  *
- * Note: for efficiency there is no NULL check on @p zst pointer and it is caller's responsibility
+ * Note: for efficiency there is no NULL check on @p smpt pointer and it is caller's responsibility
  * to validate the pointer before passing it to this function.
  *
  * @return	0 on success;
  *		-EINVAL if there is no re-assembly in progress.
  */
-int smp_reassembly_drop(struct smp_transport *zst);
+int smp_reassembly_drop(struct smp_transport *smpt);
 
 /**
  * Get "user data" pointer for current packet re-assembly
  *
- * @param zst	the SMP transport;
+ * @param smpt	the SMP transport;
  *
- * Note: for efficiency there is no NULL check on @p zst pointer and it is caller's responsibility
+ * Note: for efficiency there is no NULL check on @p smpt pointer and it is caller's responsibility
  * to validate the pointer before passing it to this function.
  *
  * @return	pointer to "user data" of CONFIG_MCUMGR_BUF_USER_DATA_SIZE size;
  *		NULL if no re-assembly in progress.
  */
-void *smp_reassembly_get_ud(const struct smp_transport *zst);
+void *smp_reassembly_get_ud(const struct smp_transport *smpt);
 
 #ifdef __cplusplus
 }