test/mbuf: remove global mempool

Currently, pool resources are allocated statically
and are not freed. Results of that test can not run more than once.

Fix removes static dependency from test application and
now allocating and freeing resources dynamically.
Test runs for more than once.

Fixes: af75078fece3 ("first public release")

Signed-off-by: Santosh Shukla <santosh.shukla@caviumnetworks.com>
Acked-by: Olivier Matz <olivier.matz@6wind.com>

diff --git a/test/test/test_mbuf.c b/test/test/test_mbuf.c
index 758402d..2057a51 100644 (file)
--- a/test/test/test_mbuf.c
+++ b/test/test/test_mbuf.c
@@ -82,13 +82,8 @@
 
 #define MAKE_STRING(x)          # x
 
 
 #define MAKE_STRING(x)          # x
 

-static struct rte_mempool *pktmbuf_pool = NULL;
-static struct rte_mempool *pktmbuf_pool2 = NULL;
-

 #ifdef RTE_MBUF_REFCNT_ATOMIC
 
 #ifdef RTE_MBUF_REFCNT_ATOMIC
 

-static struct rte_mempool *refcnt_pool = NULL;
-static struct rte_ring *refcnt_mbuf_ring = NULL;

 static volatile uint32_t refcnt_stop_slaves;
 static unsigned refcnt_lcore[RTE_MAX_LCORE];
 
 static volatile uint32_t refcnt_stop_slaves;
 static unsigned refcnt_lcore[RTE_MAX_LCORE];
 


@@ -144,7 +139,7 @@ static unsigned refcnt_lcore[RTE_MAX_LCORE];
  * test data manipulation in mbuf with non-ascii data
  */
 static int
  * test data manipulation in mbuf with non-ascii data
  */
 static int

-test_pktmbuf_with_non_ascii_data(void)
+test_pktmbuf_with_non_ascii_data(struct rte_mempool *pktmbuf_pool)

 {
        struct rte_mbuf *m = NULL;
        char *data;
 {
        struct rte_mbuf *m = NULL;
        char *data;


@@ -182,7 +177,7 @@ fail:
  * test data manipulation in mbuf
  */
 static int
  * test data manipulation in mbuf
  */
 static int

-test_one_pktmbuf(void)
+test_one_pktmbuf(struct rte_mempool *pktmbuf_pool)

 {
        struct rte_mbuf *m = NULL;
        char *data, *data2, *hdr;
 {
        struct rte_mbuf *m = NULL;
        char *data, *data2, *hdr;


@@ -328,7 +323,7 @@ fail:
 }
 
 static int
 }
 
 static int

-testclone_testupdate_testdetach(void)
+testclone_testupdate_testdetach(struct rte_mempool *pktmbuf_pool)

 {
        struct rte_mbuf *m = NULL;
        struct rte_mbuf *clone = NULL;
 {
        struct rte_mbuf *m = NULL;
        struct rte_mbuf *clone = NULL;


@@ -432,7 +427,8 @@ fail:
 }
 
 static int
 }
 
 static int

-test_attach_from_different_pool(void)
+test_attach_from_different_pool(struct rte_mempool *pktmbuf_pool,
+                               struct rte_mempool *pktmbuf_pool2)

 {
        struct rte_mbuf *m = NULL;
        struct rte_mbuf *clone = NULL;
 {
        struct rte_mbuf *m = NULL;
        struct rte_mbuf *clone = NULL;


@@ -542,7 +538,7 @@ fail:
  * test allocation and free of mbufs
  */
 static int
  * test allocation and free of mbufs
  */
 static int

-test_pktmbuf_pool(void)
+test_pktmbuf_pool(struct rte_mempool *pktmbuf_pool)

 {
        unsigned i;
        struct rte_mbuf *m[NB_MBUF];
 {
        unsigned i;
        struct rte_mbuf *m[NB_MBUF];


@@ -583,7 +579,7 @@ test_pktmbuf_pool(void)
  * test that the pointer to the data on a packet mbuf is set properly
  */
 static int
  * test that the pointer to the data on a packet mbuf is set properly
  */
 static int

-test_pktmbuf_pool_ptr(void)
+test_pktmbuf_pool_ptr(struct rte_mempool *pktmbuf_pool)

 {
        unsigned i;
        struct rte_mbuf *m[NB_MBUF];
 {
        unsigned i;
        struct rte_mbuf *m[NB_MBUF];


@@ -636,7 +632,7 @@ test_pktmbuf_pool_ptr(void)
 }
 
 static int
 }
 
 static int

-test_pktmbuf_free_segment(void)
+test_pktmbuf_free_segment(struct rte_mempool *pktmbuf_pool)

 {
        unsigned i;
        struct rte_mbuf *m[NB_MBUF];
 {
        unsigned i;
        struct rte_mbuf *m[NB_MBUF];


@@ -680,10 +676,11 @@ test_pktmbuf_free_segment(void)
 #ifdef RTE_MBUF_REFCNT_ATOMIC
 
 static int
 #ifdef RTE_MBUF_REFCNT_ATOMIC
 
 static int

-test_refcnt_slave(__attribute__((unused)) void *arg)
+test_refcnt_slave(void *arg)

 {
        unsigned lcore, free;
        void *mp = 0;
 {
        unsigned lcore, free;
        void *mp = 0;

+       struct rte_ring *refcnt_mbuf_ring = arg;

 
        lcore = rte_lcore_id();
        printf("%s started at lcore %u\n", __func__, lcore);
 
        lcore = rte_lcore_id();
        printf("%s started at lcore %u\n", __func__, lcore);


@@ -704,7 +701,9 @@ test_refcnt_slave(__attribute__((unused)) void *arg)
 }
 
 static void
 }
 
 static void

-test_refcnt_iter(unsigned lcore, unsigned iter)
+test_refcnt_iter(unsigned int lcore, unsigned int iter,
+                struct rte_mempool *refcnt_pool,
+                struct rte_ring *refcnt_mbuf_ring)

 {
        uint16_t ref;
        unsigned i, n, tref, wn;
 {
        uint16_t ref;
        unsigned i, n, tref, wn;


@@ -760,7 +759,8 @@ test_refcnt_iter(unsigned lcore, unsigned iter)
 }
 
 static int
 }
 
 static int

-test_refcnt_master(void)
+test_refcnt_master(struct rte_mempool *refcnt_pool,
+                  struct rte_ring *refcnt_mbuf_ring)

 {
        unsigned i, lcore;
 
 {
        unsigned i, lcore;
 


@@ -768,7 +768,7 @@ test_refcnt_master(void)
        printf("%s started at lcore %u\n", __func__, lcore);
 
        for (i = 0; i != REFCNT_MAX_ITER; i++)
        printf("%s started at lcore %u\n", __func__, lcore);
 
        for (i = 0; i != REFCNT_MAX_ITER; i++)

-               test_refcnt_iter(lcore, i);
+               test_refcnt_iter(lcore, i, refcnt_pool, refcnt_mbuf_ring);

 
        refcnt_stop_slaves = 1;
        rte_wmb();
 
        refcnt_stop_slaves = 1;
        rte_wmb();


@@ -783,9 +783,10 @@ static int
 test_refcnt_mbuf(void)
 {
 #ifdef RTE_MBUF_REFCNT_ATOMIC
 test_refcnt_mbuf(void)
 {
 #ifdef RTE_MBUF_REFCNT_ATOMIC

-

        unsigned lnum, master, slave, tref;
        unsigned lnum, master, slave, tref;

-
+       int ret = -1;
+       struct rte_mempool *refcnt_pool = NULL;
+       struct rte_ring *refcnt_mbuf_ring = NULL;

 
        if ((lnum = rte_lcore_count()) == 1) {
                printf("skipping %s, number of lcores: %u is not enough\n",
 
        if ((lnum = rte_lcore_count()) == 1) {
                printf("skipping %s, number of lcores: %u is not enough\n",


@@ -797,31 +798,31 @@ test_refcnt_mbuf(void)
 
        /* create refcnt pool & ring if they don't exist */
 
 
        /* create refcnt pool & ring if they don't exist */
 

-       if (refcnt_pool == NULL &&
-                       (refcnt_pool = rte_pktmbuf_pool_create(
-                               MAKE_STRING(refcnt_pool),
-                               REFCNT_MBUF_NUM, 0, 0, 0,
-                               SOCKET_ID_ANY)) == NULL) {
+       refcnt_pool = rte_pktmbuf_pool_create(MAKE_STRING(refcnt_pool),
+                                             REFCNT_MBUF_NUM, 0, 0, 0,
+                                             SOCKET_ID_ANY);
+       if (refcnt_pool == NULL) {

                printf("%s: cannot allocate " MAKE_STRING(refcnt_pool) "\n",
                    __func__);
                return -1;
        }
 
                printf("%s: cannot allocate " MAKE_STRING(refcnt_pool) "\n",
                    __func__);
                return -1;
        }
 

-       if (refcnt_mbuf_ring == NULL &&
-                       (refcnt_mbuf_ring = rte_ring_create("refcnt_mbuf_ring",
+       refcnt_mbuf_ring = rte_ring_create("refcnt_mbuf_ring",

                        rte_align32pow2(REFCNT_RING_SIZE), SOCKET_ID_ANY,
                        rte_align32pow2(REFCNT_RING_SIZE), SOCKET_ID_ANY,

-                       RING_F_SP_ENQ)) == NULL) {
+                                       RING_F_SP_ENQ);
+       if (refcnt_mbuf_ring == NULL) {

                printf("%s: cannot allocate " MAKE_STRING(refcnt_mbuf_ring)
                    "\n", __func__);
                printf("%s: cannot allocate " MAKE_STRING(refcnt_mbuf_ring)
                    "\n", __func__);

-               return -1;
+               goto err;

        }
 
        refcnt_stop_slaves = 0;
        memset(refcnt_lcore, 0, sizeof (refcnt_lcore));
 
        }
 
        refcnt_stop_slaves = 0;
        memset(refcnt_lcore, 0, sizeof (refcnt_lcore));
 

-       rte_eal_mp_remote_launch(test_refcnt_slave, NULL, SKIP_MASTER);
+       rte_eal_mp_remote_launch(test_refcnt_slave, refcnt_mbuf_ring,
+                                SKIP_MASTER);

 
 

-       test_refcnt_master();
+       test_refcnt_master(refcnt_pool, refcnt_mbuf_ring);

 
        rte_eal_mp_wait_lcore();
 
 
        rte_eal_mp_wait_lcore();
 


@@ -839,8 +840,15 @@ test_refcnt_mbuf(void)
        rte_mempool_dump(stdout, refcnt_pool);
        rte_ring_dump(stdout, refcnt_mbuf_ring);
 
        rte_mempool_dump(stdout, refcnt_pool);
        rte_ring_dump(stdout, refcnt_mbuf_ring);
 

-#endif
+       ret = 0;
+
+err:
+       rte_mempool_free(refcnt_pool);
+       rte_ring_free(refcnt_mbuf_ring);
+       return ret;
+#else

        return 0;
        return 0;

+#endif

 }
 
 #include <unistd.h>
 }
 
 #include <unistd.h>


@@ -870,7 +878,7 @@ verify_mbuf_check_panics(struct rte_mbuf *buf)
 }
 
 static int
 }
 
 static int

-test_failing_mbuf_sanity_check(void)
+test_failing_mbuf_sanity_check(struct rte_mempool *pktmbuf_pool)

 {
        struct rte_mbuf *buf;
        struct rte_mbuf badbuf;
 {
        struct rte_mbuf *buf;
        struct rte_mbuf badbuf;


@@ -931,7 +939,9 @@ test_failing_mbuf_sanity_check(void)
 }
 
 static int
 }
 
 static int

-test_mbuf_linearize(int pkt_len, int nb_segs) {
+test_mbuf_linearize(struct rte_mempool *pktmbuf_pool, int pkt_len,
+                   int nb_segs)
+{

 
        struct rte_mbuf *m = NULL, *mbuf = NULL;
        uint8_t *data;
 
        struct rte_mbuf *m = NULL, *mbuf = NULL;
        uint8_t *data;


@@ -1022,7 +1032,7 @@ fail:
 }
 
 static int
 }
 
 static int

-test_mbuf_linearize_check(void)
+test_mbuf_linearize_check(struct rte_mempool *pktmbuf_pool)

 {
        struct test_mbuf_array {
                int size;
 {
        struct test_mbuf_array {
                int size;


@@ -1039,7 +1049,7 @@ test_mbuf_linearize_check(void)
        printf("Test mbuf linearize API\n");
 
        for (i = 0; i < RTE_DIM(mbuf_array); i++)
        printf("Test mbuf linearize API\n");
 
        for (i = 0; i < RTE_DIM(mbuf_array); i++)

-               if (test_mbuf_linearize(mbuf_array[i].size,
+               if (test_mbuf_linearize(pktmbuf_pool, mbuf_array[i].size,

                                mbuf_array[i].nb_segs)) {
                        printf("Test failed for %d, %d\n", mbuf_array[i].size,
                                        mbuf_array[i].nb_segs);
                                mbuf_array[i].nb_segs)) {
                        printf("Test failed for %d, %d\n", mbuf_array[i].size,
                                        mbuf_array[i].nb_segs);


@@ -1052,53 +1062,54 @@ test_mbuf_linearize_check(void)
 static int
 test_mbuf(void)
 {
 static int
 test_mbuf(void)
 {

+       int ret = -1;
+       struct rte_mempool *pktmbuf_pool = NULL;
+       struct rte_mempool *pktmbuf_pool2 = NULL;
+
+

        RTE_BUILD_BUG_ON(sizeof(struct rte_mbuf) != RTE_CACHE_LINE_MIN_SIZE * 2);
 
        /* create pktmbuf pool if it does not exist */
        RTE_BUILD_BUG_ON(sizeof(struct rte_mbuf) != RTE_CACHE_LINE_MIN_SIZE * 2);
 
        /* create pktmbuf pool if it does not exist */

-       if (pktmbuf_pool == NULL) {
-               pktmbuf_pool = rte_pktmbuf_pool_create("test_pktmbuf_pool",
+       pktmbuf_pool = rte_pktmbuf_pool_create("test_pktmbuf_pool",

                        NB_MBUF, 32, 0, MBUF_DATA_SIZE, SOCKET_ID_ANY);
                        NB_MBUF, 32, 0, MBUF_DATA_SIZE, SOCKET_ID_ANY);

-       }

 
        if (pktmbuf_pool == NULL) {
                printf("cannot allocate mbuf pool\n");
 
        if (pktmbuf_pool == NULL) {
                printf("cannot allocate mbuf pool\n");

-               return -1;
+               goto err;

        }
 
        /* create a specific pktmbuf pool with a priv_size != 0 and no data
         * room size */
        }
 
        /* create a specific pktmbuf pool with a priv_size != 0 and no data
         * room size */

-       if (pktmbuf_pool2 == NULL) {
-               pktmbuf_pool2 = rte_pktmbuf_pool_create("test_pktmbuf_pool2",
+       pktmbuf_pool2 = rte_pktmbuf_pool_create("test_pktmbuf_pool2",

                        NB_MBUF, 32, MBUF2_PRIV_SIZE, 0, SOCKET_ID_ANY);
                        NB_MBUF, 32, MBUF2_PRIV_SIZE, 0, SOCKET_ID_ANY);

-       }

 
        if (pktmbuf_pool2 == NULL) {
                printf("cannot allocate mbuf pool\n");
 
        if (pktmbuf_pool2 == NULL) {
                printf("cannot allocate mbuf pool\n");

-               return -1;
+               goto err;

        }
 
        /* test multiple mbuf alloc */
        }
 
        /* test multiple mbuf alloc */

-       if (test_pktmbuf_pool() < 0) {
+       if (test_pktmbuf_pool(pktmbuf_pool) < 0) {

                printf("test_mbuf_pool() failed\n");
                printf("test_mbuf_pool() failed\n");

-               return -1;
+               goto err;

        }
 
        /* do it another time to check that all mbufs were freed */
        }
 
        /* do it another time to check that all mbufs were freed */

-       if (test_pktmbuf_pool() < 0) {
+       if (test_pktmbuf_pool(pktmbuf_pool) < 0) {

                printf("test_mbuf_pool() failed (2)\n");
                printf("test_mbuf_pool() failed (2)\n");

-               return -1;
+               goto err;

        }
 
        /* test that the pointer to the data on a packet mbuf is set properly */
        }
 
        /* test that the pointer to the data on a packet mbuf is set properly */

-       if (test_pktmbuf_pool_ptr() < 0) {
+       if (test_pktmbuf_pool_ptr(pktmbuf_pool) < 0) {

                printf("test_pktmbuf_pool_ptr() failed\n");
                printf("test_pktmbuf_pool_ptr() failed\n");

-               return -1;
+               goto err;

        }
 
        /* test data manipulation in mbuf */
        }
 
        /* test data manipulation in mbuf */

-       if (test_one_pktmbuf() < 0) {
+       if (test_one_pktmbuf(pktmbuf_pool) < 0) {

                printf("test_one_mbuf() failed\n");
                printf("test_one_mbuf() failed\n");

-               return -1;
+               goto err;

        }
 
 
        }
 
 


@@ -1106,47 +1117,52 @@ test_mbuf(void)
         * do it another time, to check that allocation reinitialize
         * the mbuf correctly
         */
         * do it another time, to check that allocation reinitialize
         * the mbuf correctly
         */

-       if (test_one_pktmbuf() < 0) {
+       if (test_one_pktmbuf(pktmbuf_pool) < 0) {

                printf("test_one_mbuf() failed (2)\n");
                printf("test_one_mbuf() failed (2)\n");

-               return -1;
+               goto err;

        }
 
        }
 

-       if (test_pktmbuf_with_non_ascii_data() < 0) {
+       if (test_pktmbuf_with_non_ascii_data(pktmbuf_pool) < 0) {

                printf("test_pktmbuf_with_non_ascii_data() failed\n");
                printf("test_pktmbuf_with_non_ascii_data() failed\n");

-               return -1;
+               goto err;

        }
 
        /* test free pktmbuf segment one by one */
        }
 
        /* test free pktmbuf segment one by one */

-       if (test_pktmbuf_free_segment() < 0) {
+       if (test_pktmbuf_free_segment(pktmbuf_pool) < 0) {

                printf("test_pktmbuf_free_segment() failed.\n");
                printf("test_pktmbuf_free_segment() failed.\n");

-               return -1;
+               goto err;

        }
 
        }
 

-       if (testclone_testupdate_testdetach()<0){
+       if (testclone_testupdate_testdetach(pktmbuf_pool) < 0) {

                printf("testclone_and_testupdate() failed \n");
                printf("testclone_and_testupdate() failed \n");

-               return -1;
+               goto err;

        }
 
        }
 

-       if (test_attach_from_different_pool() < 0) {
+       if (test_attach_from_different_pool(pktmbuf_pool, pktmbuf_pool2) < 0) {

                printf("test_attach_from_different_pool() failed\n");
                printf("test_attach_from_different_pool() failed\n");

-               return -1;
+               goto err;

        }
 
        if (test_refcnt_mbuf()<0){
                printf("test_refcnt_mbuf() failed \n");
        }
 
        if (test_refcnt_mbuf()<0){
                printf("test_refcnt_mbuf() failed \n");

-               return -1;
+               goto err;

        }
 
        }
 

-       if (test_failing_mbuf_sanity_check() < 0) {
+       if (test_failing_mbuf_sanity_check(pktmbuf_pool) < 0) {

                printf("test_failing_mbuf_sanity_check() failed\n");
                printf("test_failing_mbuf_sanity_check() failed\n");

-               return -1;
+               goto err;

        }
 
        }
 

-       if (test_mbuf_linearize_check() < 0) {
+       if (test_mbuf_linearize_check(pktmbuf_pool) < 0) {

                printf("test_mbuf_linearize_check() failed\n");
                printf("test_mbuf_linearize_check() failed\n");

-               return -1;
+               goto err;

        }
        }

-       return 0;
+       ret = 0;
+
+err:
+       rte_mempool_free(pktmbuf_pool);
+       rte_mempool_free(pktmbuf_pool2);
+       return ret;

 }
 
 REGISTER_TEST_COMMAND(mbuf_autotest, test_mbuf);
 }
 
 REGISTER_TEST_COMMAND(mbuf_autotest, test_mbuf);