mbuf: add function to read packet data

Introduce a new function to read the packet data from an mbuf chain. It
linearizes the data if required, and also ensures that the mbuf is large
enough.

This function is used in next commits that add a software parser to
retrieve the packet type.

Signed-off-by: Olivier Matz <olivier.matz@6wind.com>

diff --git a/doc/guides/rel_notes/release_16_11.rst b/doc/guides/rel_notes/release_16_11.rst
index 905186a93d8f934d34bfaf690c361928fb5fdf45..8e14a1bc623f31074ea4eb4dfbf321d4cc5a7c11 100644 (file)
--- a/doc/guides/rel_notes/release_16_11.rst
+++ b/doc/guides/rel_notes/release_16_11.rst
@@ -36,6 +36,12 @@ New Features
 
      This section is a comment. Make sure to start the actual text at the margin.
 
+
+* **Added software parser for packet type.**
+
+  * Added a new function ``rte_pktmbuf_read()`` to read the packet data from an
+    mbuf chain, linearizing if required.
+
 * **Added vhost-user indirect descriptors support.**
 
   If indirect descriptor feature is negotiated, each packet sent by the guest

diff --git a/lib/librte_mbuf/rte_mbuf.c b/lib/librte_mbuf/rte_mbuf.c
index 05ae648e0712c14aa1e2c83a143f73bfbbac669b..04f9ed30247e790367f91a791659f331977a7de4 100644 (file)
--- a/lib/librte_mbuf/rte_mbuf.c
+++ b/lib/librte_mbuf/rte_mbuf.c
@@ -58,6 +58,7 @@
 #include <rte_string_fns.h>
 #include <rte_hexdump.h>
 #include <rte_errno.h>
+#include <rte_memcpy.h>
 
 /*
  * ctrlmbuf constructor, given as a callback function to
@@ -263,6 +264,40 @@ rte_pktmbuf_dump(FILE *f, const struct rte_mbuf *m, unsigned dump_len)
        }
 }
 
+/* read len data bytes in a mbuf at specified offset (internal) */
+const void *__rte_pktmbuf_read(const struct rte_mbuf *m, uint32_t off,
+       uint32_t len, void *buf)
+{
+       const struct rte_mbuf *seg = m;
+       uint32_t buf_off = 0, copy_len;
+
+       if (off + len > rte_pktmbuf_pkt_len(m))
+               return NULL;
+
+       while (off >= rte_pktmbuf_data_len(seg)) {
+               off -= rte_pktmbuf_data_len(seg);
+               seg = seg->next;
+       }
+
+       if (off + len <= rte_pktmbuf_data_len(seg))
+               return rte_pktmbuf_mtod_offset(seg, char *, off);
+
+       /* rare case: header is split among several segments */
+       while (len > 0) {
+               copy_len = rte_pktmbuf_data_len(seg) - off;
+               if (copy_len > len)
+                       copy_len = len;
+               rte_memcpy((char *)buf + buf_off,
+                       rte_pktmbuf_mtod_offset(seg, char *, off), copy_len);
+               off = 0;
+               buf_off += copy_len;
+               len -= copy_len;
+               seg = seg->next;
+       }
+
+       return buf;
+}
+
 /*
  * Get the name of a RX offload flag. Must be kept synchronized with flag
  * definitions in rte_mbuf.h.

diff --git a/lib/librte_mbuf/rte_mbuf.h b/lib/librte_mbuf/rte_mbuf.h
index 002e86bc8a65870afd6c794ea462dee01fb70b20..dc8070b1e68037ca7a9bd9cd496bb436b54e3f0c 100644 (file)
--- a/lib/librte_mbuf/rte_mbuf.h
+++ b/lib/librte_mbuf/rte_mbuf.h
@@ -1986,6 +1986,41 @@ static inline int rte_pktmbuf_is_contiguous(const struct rte_mbuf *m)
        return !!(m->nb_segs == 1);
 }
 
+/**
+ * @internal used by rte_pktmbuf_read().
+ */
+const void *__rte_pktmbuf_read(const struct rte_mbuf *m, uint32_t off,
+       uint32_t len, void *buf);
+
+/**
+ * Read len data bytes in a mbuf at specified offset.
+ *
+ * If the data is contiguous, return the pointer in the mbuf data, else
+ * copy the data in the buffer provided by the user and return its
+ * pointer.
+ *
+ * @param m
+ *   The pointer to the mbuf.
+ * @param off
+ *   The offset of the data in the mbuf.
+ * @param len
+ *   The amount of bytes to read.
+ * @param buf
+ *   The buffer where data is copied if it is not contigous in mbuf
+ *   data. Its length should be at least equal to the len parameter.
+ * @return
+ *   The pointer to the data, either in the mbuf if it is contiguous,
+ *   or in the user buffer. If mbuf is too small, NULL is returned.
+ */
+static inline const void *rte_pktmbuf_read(const struct rte_mbuf *m,
+       uint32_t off, uint32_t len, void *buf)
+{
+       if (likely(off + len <= rte_pktmbuf_data_len(m)))
+               return rte_pktmbuf_mtod_offset(m, char *, off);
+       else
+               return __rte_pktmbuf_read(m, off, len, buf);
+}
+
 /**
  * Chain an mbuf to another, thereby creating a segmented packet.
  *

diff --git a/lib/librte_mbuf/rte_mbuf_version.map b/lib/librte_mbuf/rte_mbuf_version.map
index e10f6bdc888bc60a0d6997a9d3c02fac7ea4a0b6..79e4dd87261414de35fb7ae08ca1abe6de53f7f3 100644 (file)
--- a/lib/librte_mbuf/rte_mbuf_version.map
+++ b/lib/librte_mbuf/rte_mbuf_version.map
@@ -18,3 +18,10 @@ DPDK_2.1 {
        rte_pktmbuf_pool_create;
 
 } DPDK_2.0;
+
+DPDK_16.11 {
+       global:
+
+       __rte_pktmbuf_read;
+
+} DPDK_2.1;