app/test: check cloning a clone

[dpdk.git] / app / test / test_mbuf.c

diff --git a/app/test/test_mbuf.c b/app/test/test_mbuf.c
index 1ff66cb..68564ee 100644 (file)
--- a/app/test/test_mbuf.c
+++ b/app/test/test_mbuf.c
@@ -61,7 +61,7 @@
 
 #include "test.h"
 
-#define MBUF_SIZE               2048
+#define MBUF_DATA_SIZE          2048
 #define NB_MBUF                 128
 #define MBUF_TEST_DATA_LEN      1464
 #define MBUF_TEST_DATA_LEN2     50
@@ -73,9 +73,10 @@
 #define REFCNT_MAX_TIMEOUT      10
 #define REFCNT_MAX_REF          (RTE_MAX_LCORE)
 #define REFCNT_MBUF_NUM         64
-#define REFCNT_MBUF_SIZE        (sizeof (struct rte_mbuf) + RTE_PKTMBUF_HEADROOM)
 #define REFCNT_RING_SIZE        (REFCNT_MBUF_NUM * REFCNT_MAX_REF)
 
+#define MAGIC_DATA              0x42424242
+
 #define MAKE_STRING(x)          # x
 
 static struct rte_mempool *pktmbuf_pool = NULL;
@@ -123,6 +124,9 @@ static unsigned refcnt_lcore[RTE_MAX_LCORE];
  *    - Repeat the test to check that allocation operations
  *      reinitialize the mbuf correctly.
  *
+ * #. Test packet cloning
+ *    - Clone a mbuf and verify the data
+ *    - Clone the cloned mbuf and verify the data
  */
 
 #define GOTO_FAIL(str, ...) do {                                       \
@@ -321,43 +325,104 @@ fail:
 static int
 testclone_testupdate_testdetach(void)
 {
-       struct rte_mbuf *mc = NULL;
+       struct rte_mbuf *m = NULL;
        struct rte_mbuf *clone = NULL;
+       struct rte_mbuf *clone2 = NULL;
+       uint32_t *data;
 
        /* alloc a mbuf */
-
-       mc = rte_pktmbuf_alloc(pktmbuf_pool);
-       if (mc == NULL)
+       m = rte_pktmbuf_alloc(pktmbuf_pool);
+       if (m == NULL)
                GOTO_FAIL("ooops not allocating mbuf");
 
-       if (rte_pktmbuf_pkt_len(mc) != 0)
+       if (rte_pktmbuf_pkt_len(m) != 0)
                GOTO_FAIL("Bad length");
 
+       rte_pktmbuf_append(m, sizeof(uint32_t));
+       data = rte_pktmbuf_mtod(m, uint32_t *);
+       *data = MAGIC_DATA;
 
        /* clone the allocated mbuf */
-       clone = rte_pktmbuf_clone(mc, pktmbuf_pool);
+       clone = rte_pktmbuf_clone(m, pktmbuf_pool);
        if (clone == NULL)
                GOTO_FAIL("cannot clone data\n");
+
+       data = rte_pktmbuf_mtod(clone, uint32_t *);
+       if (*data != MAGIC_DATA)
+               GOTO_FAIL("invalid data in clone\n");
+
+       if (rte_mbuf_refcnt_read(m) != 2)
+               GOTO_FAIL("invalid refcnt in m\n");
+
+       /* free the clone */
        rte_pktmbuf_free(clone);
+       clone = NULL;
 
-       mc->next = rte_pktmbuf_alloc(pktmbuf_pool);
-       if(mc->next == NULL)
+       /* same test with a chained mbuf */
+       m->next = rte_pktmbuf_alloc(pktmbuf_pool);
+       if (m->next == NULL)
                GOTO_FAIL("Next Pkt Null\n");
 
-       clone = rte_pktmbuf_clone(mc, pktmbuf_pool);
+       rte_pktmbuf_append(m->next, sizeof(uint32_t));
+       data = rte_pktmbuf_mtod(m->next, uint32_t *);
+       *data = MAGIC_DATA;
+
+       clone = rte_pktmbuf_clone(m, pktmbuf_pool);
        if (clone == NULL)
                GOTO_FAIL("cannot clone data\n");
 
+       data = rte_pktmbuf_mtod(clone, uint32_t *);
+       if (*data != MAGIC_DATA)
+               GOTO_FAIL("invalid data in clone\n");
+
+       data = rte_pktmbuf_mtod(clone->next, uint32_t *);
+       if (*data != MAGIC_DATA)
+               GOTO_FAIL("invalid data in clone->next\n");
+
+       if (rte_mbuf_refcnt_read(m) != 2)
+               GOTO_FAIL("invalid refcnt in m\n");
+
+       if (rte_mbuf_refcnt_read(m->next) != 2)
+               GOTO_FAIL("invalid refcnt in m->next\n");
+
+       /* try to clone the clone */
+
+       clone2 = rte_pktmbuf_clone(clone, pktmbuf_pool);
+       if (clone2 == NULL)
+               GOTO_FAIL("cannot clone the clone\n");
+
+       data = rte_pktmbuf_mtod(clone2, uint32_t *);
+       if (*data != MAGIC_DATA)
+               GOTO_FAIL("invalid data in clone2\n");
+
+       data = rte_pktmbuf_mtod(clone2->next, uint32_t *);
+       if (*data != MAGIC_DATA)
+               GOTO_FAIL("invalid data in clone2->next\n");
+
+       if (rte_mbuf_refcnt_read(m) != 3)
+               GOTO_FAIL("invalid refcnt in m\n");
+
+       if (rte_mbuf_refcnt_read(m->next) != 3)
+               GOTO_FAIL("invalid refcnt in m->next\n");
+
        /* free mbuf */
-       rte_pktmbuf_free(mc);
+       rte_pktmbuf_free(m);
        rte_pktmbuf_free(clone);
-       mc = NULL;
+       rte_pktmbuf_free(clone2);
+
+       m = NULL;
        clone = NULL;
+       clone2 = NULL;
+       printf("%s ok\n", __func__);
        return 0;
 
 fail:
-       if (mc)
-               rte_pktmbuf_free(mc);
+       if (m)
+               rte_pktmbuf_free(m);
+       if (clone)
+               rte_pktmbuf_free(clone);
+       if (clone2)
+               rte_pktmbuf_free(clone2);
        return -1;
 }
 #undef GOTO_FAIL
@@ -622,12 +687,10 @@ test_refcnt_mbuf(void)
        /* create refcnt pool & ring if they don't exist */
 
        if (refcnt_pool == NULL &&
-                       (refcnt_pool = rte_mempool_create(
-                       MAKE_STRING(refcnt_pool),
-                       REFCNT_MBUF_NUM, REFCNT_MBUF_SIZE, 0,
-                       sizeof(struct rte_pktmbuf_pool_private),
-                       rte_pktmbuf_pool_init, NULL, rte_pktmbuf_init, NULL,
-                       SOCKET_ID_ANY, 0)) == NULL) {
+                       (refcnt_pool = rte_pktmbuf_pool_create(
+                               MAKE_STRING(refcnt_pool),
+                               REFCNT_MBUF_NUM, 0, 0, 0,
+                               SOCKET_ID_ANY)) == NULL) {
                printf("%s: cannot allocate " MAKE_STRING(refcnt_pool) "\n",
                    __func__);
                return (-1);
@@ -764,13 +827,8 @@ test_mbuf(void)
 
        /* create pktmbuf pool if it does not exist */
        if (pktmbuf_pool == NULL) {
-               pktmbuf_pool =
-                       rte_mempool_create("test_pktmbuf_pool", NB_MBUF,
-                                          MBUF_SIZE, 32,
-                                          sizeof(struct rte_pktmbuf_pool_private),
-                                          rte_pktmbuf_pool_init, NULL,
-                                          rte_pktmbuf_init, NULL,
-                                          SOCKET_ID_ANY, 0);
+               pktmbuf_pool = rte_pktmbuf_pool_create("test_pktmbuf_pool",
+                       NB_MBUF, 32, 0, MBUF_DATA_SIZE, SOCKET_ID_ANY);
        }
 
        if (pktmbuf_pool == NULL) {