X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest%2Ftest_mbuf.c;h=b9c2b2500e01d61f84a192a3295b6f85d8e7ed1f;hb=c3a90c381daa68a0ea65906ad15bc96c247ac5cd;hp=a2e9bc6cfb3edec0070df581d0320fb578693595;hpb=1feda4d8fc422ceb1700d32175501f4f691eb844;p=dpdk.git diff --git a/app/test/test_mbuf.c b/app/test/test_mbuf.c index a2e9bc6cfb..b9c2b2500e 100644 --- a/app/test/test_mbuf.c +++ b/app/test/test_mbuf.c @@ -1,34 +1,5 @@ -/*- - * BSD LICENSE - * - * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the - * distribution. - * * Neither the name of Intel Corporation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2010-2014 Intel Corporation */ #include @@ -43,10 +14,8 @@ #include #include #include -#include #include #include -#include #include #include #include @@ -58,6 +27,7 @@ #include #include #include +#include #include "test.h" @@ -82,13 +52,8 @@ #define MAKE_STRING(x) # x -static struct rte_mempool *pktmbuf_pool = NULL; -static struct rte_mempool *pktmbuf_pool2 = NULL; - #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]; @@ -144,7 +109,7 @@ static unsigned refcnt_lcore[RTE_MAX_LCORE]; * 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; @@ -182,7 +147,7 @@ fail: * 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; @@ -328,7 +293,7 @@ fail: } static int -testclone_testupdate_testdetach(void) +testclone_testupdate_testdetach(struct rte_mempool *pktmbuf_pool) { struct rte_mbuf *m = NULL; struct rte_mbuf *clone = NULL; @@ -367,8 +332,11 @@ testclone_testupdate_testdetach(void) m->next = rte_pktmbuf_alloc(pktmbuf_pool); if (m->next == NULL) GOTO_FAIL("Next Pkt Null\n"); + m->nb_segs = 2; rte_pktmbuf_append(m->next, sizeof(uint32_t)); + m->pkt_len = 2 * sizeof(uint32_t); + data = rte_pktmbuf_mtod(m->next, unaligned_uint32_t *); *data = MAGIC_DATA; @@ -432,7 +400,160 @@ fail: } static int -test_attach_from_different_pool(void) +test_pktmbuf_copy(struct rte_mempool *pktmbuf_pool) +{ + struct rte_mbuf *m = NULL; + struct rte_mbuf *copy = NULL; + struct rte_mbuf *copy2 = NULL; + struct rte_mbuf *clone = NULL; + unaligned_uint32_t *data; + + /* alloc a mbuf */ + m = rte_pktmbuf_alloc(pktmbuf_pool); + if (m == NULL) + GOTO_FAIL("ooops not allocating mbuf"); + + if (rte_pktmbuf_pkt_len(m) != 0) + GOTO_FAIL("Bad length"); + + rte_pktmbuf_append(m, sizeof(uint32_t)); + data = rte_pktmbuf_mtod(m, unaligned_uint32_t *); + *data = MAGIC_DATA; + + /* copy the allocated mbuf */ + copy = rte_pktmbuf_copy(m, pktmbuf_pool, 0, UINT32_MAX); + if (copy == NULL) + GOTO_FAIL("cannot copy data\n"); + + if (rte_pktmbuf_pkt_len(copy) != sizeof(uint32_t)) + GOTO_FAIL("copy length incorrect\n"); + + if (rte_pktmbuf_data_len(copy) != sizeof(uint32_t)) + GOTO_FAIL("copy data length incorrect\n"); + + data = rte_pktmbuf_mtod(copy, unaligned_uint32_t *); + if (*data != MAGIC_DATA) + GOTO_FAIL("invalid data in copy\n"); + + /* free the copy */ + rte_pktmbuf_free(copy); + copy = NULL; + + /* same test with a cloned mbuf */ + clone = rte_pktmbuf_clone(m, pktmbuf_pool); + if (clone == NULL) + GOTO_FAIL("cannot clone data\n"); + + if (!RTE_MBUF_CLONED(clone)) + GOTO_FAIL("clone did not give a cloned mbuf\n"); + + copy = rte_pktmbuf_copy(clone, pktmbuf_pool, 0, UINT32_MAX); + if (copy == NULL) + GOTO_FAIL("cannot copy cloned mbuf\n"); + + if (RTE_MBUF_CLONED(copy)) + GOTO_FAIL("copy of clone is cloned?\n"); + + if (rte_pktmbuf_pkt_len(copy) != sizeof(uint32_t)) + GOTO_FAIL("copy clone length incorrect\n"); + + if (rte_pktmbuf_data_len(copy) != sizeof(uint32_t)) + GOTO_FAIL("copy clone data length incorrect\n"); + + data = rte_pktmbuf_mtod(copy, unaligned_uint32_t *); + if (*data != MAGIC_DATA) + GOTO_FAIL("invalid data in clone copy\n"); + rte_pktmbuf_free(clone); + rte_pktmbuf_free(copy); + copy = NULL; + clone = NULL; + + + /* same test with a chained mbuf */ + m->next = rte_pktmbuf_alloc(pktmbuf_pool); + if (m->next == NULL) + GOTO_FAIL("Next Pkt Null\n"); + m->nb_segs = 2; + + rte_pktmbuf_append(m->next, sizeof(uint32_t)); + m->pkt_len = 2 * sizeof(uint32_t); + data = rte_pktmbuf_mtod(m->next, unaligned_uint32_t *); + *data = MAGIC_DATA + 1; + + copy = rte_pktmbuf_copy(m, pktmbuf_pool, 0, UINT32_MAX); + if (copy == NULL) + GOTO_FAIL("cannot copy data\n"); + + if (rte_pktmbuf_pkt_len(copy) != 2 * sizeof(uint32_t)) + GOTO_FAIL("chain copy length incorrect\n"); + + if (rte_pktmbuf_data_len(copy) != 2 * sizeof(uint32_t)) + GOTO_FAIL("chain copy data length incorrect\n"); + + data = rte_pktmbuf_mtod(copy, unaligned_uint32_t *); + if (data[0] != MAGIC_DATA || data[1] != MAGIC_DATA + 1) + GOTO_FAIL("invalid data in copy\n"); + + rte_pktmbuf_free(copy2); + + /* test offset copy */ + copy2 = rte_pktmbuf_copy(copy, pktmbuf_pool, + sizeof(uint32_t), UINT32_MAX); + if (copy2 == NULL) + GOTO_FAIL("cannot copy the copy\n"); + + if (rte_pktmbuf_pkt_len(copy2) != sizeof(uint32_t)) + GOTO_FAIL("copy with offset, length incorrect\n"); + + if (rte_pktmbuf_data_len(copy2) != sizeof(uint32_t)) + GOTO_FAIL("copy with offset, data length incorrect\n"); + + data = rte_pktmbuf_mtod(copy2, unaligned_uint32_t *); + if (data[0] != MAGIC_DATA + 1) + GOTO_FAIL("copy with offset, invalid data\n"); + + rte_pktmbuf_free(copy2); + + /* test truncation copy */ + copy2 = rte_pktmbuf_copy(copy, pktmbuf_pool, + 0, sizeof(uint32_t)); + if (copy2 == NULL) + GOTO_FAIL("cannot copy the copy\n"); + + if (rte_pktmbuf_pkt_len(copy2) != sizeof(uint32_t)) + GOTO_FAIL("copy with truncate, length incorrect\n"); + + if (rte_pktmbuf_data_len(copy2) != sizeof(uint32_t)) + GOTO_FAIL("copy with truncate, data length incorrect\n"); + + data = rte_pktmbuf_mtod(copy2, unaligned_uint32_t *); + if (data[0] != MAGIC_DATA) + GOTO_FAIL("copy with truncate, invalid data\n"); + + /* free mbuf */ + rte_pktmbuf_free(m); + rte_pktmbuf_free(copy); + rte_pktmbuf_free(copy2); + + m = NULL; + copy = NULL; + copy2 = NULL; + printf("%s ok\n", __func__); + return 0; + +fail: + if (m) + rte_pktmbuf_free(m); + if (copy) + rte_pktmbuf_free(copy); + if (copy2) + rte_pktmbuf_free(copy2); + return -1; +} + +static int +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; @@ -542,7 +663,7 @@ fail: * 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]; @@ -583,7 +704,7 @@ test_pktmbuf_pool(void) * 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]; @@ -636,7 +757,7 @@ test_pktmbuf_pool_ptr(void) } static int -test_pktmbuf_free_segment(void) +test_pktmbuf_free_segment(struct rte_mempool *pktmbuf_pool) { unsigned i; struct rte_mbuf *m[NB_MBUF]; @@ -674,16 +795,17 @@ test_pktmbuf_free_segment(void) /* * Stress test for rte_mbuf atomic refcnt. * Implies that RTE_MBUF_REFCNT_ATOMIC is defined. - * For more efficency, recomended to run with RTE_LIBRTE_MBUF_DEBUG defined. + * For more efficiency, recommended to run with RTE_LIBRTE_MBUF_DEBUG defined. */ #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; + struct rte_ring *refcnt_mbuf_ring = arg; lcore = rte_lcore_id(); printf("%s started at lcore %u\n", __func__, lcore); @@ -692,7 +814,7 @@ test_refcnt_slave(__attribute__((unused)) void *arg) while (refcnt_stop_slaves == 0) { if (rte_ring_dequeue(refcnt_mbuf_ring, &mp) == 0) { free++; - rte_pktmbuf_free((struct rte_mbuf *)mp); + rte_pktmbuf_free(mp); } } @@ -704,7 +826,9 @@ test_refcnt_slave(__attribute__((unused)) void *arg) } 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; @@ -760,7 +884,8 @@ test_refcnt_iter(unsigned lcore, unsigned iter) } static int -test_refcnt_master(void) +test_refcnt_master(struct rte_mempool *refcnt_pool, + struct rte_ring *refcnt_mbuf_ring) { unsigned i, lcore; @@ -768,7 +893,7 @@ test_refcnt_master(void) 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(); @@ -783,45 +908,45 @@ static int test_refcnt_mbuf(void) { #ifdef RTE_MBUF_REFCNT_ATOMIC - - unsigned lnum, master, slave, tref; - - - if ((lnum = rte_lcore_count()) == 1) { - printf("skipping %s, number of lcores: %u is not enough\n", - __func__, lnum); - return 0; + unsigned int master, slave, tref; + int ret = -1; + struct rte_mempool *refcnt_pool = NULL; + struct rte_ring *refcnt_mbuf_ring = NULL; + + if (rte_lcore_count() < 2) { + printf("Not enough cores for test_refcnt_mbuf, expecting at least 2\n"); + return TEST_SKIPPED; } - printf("starting %s, at %u lcores\n", __func__, lnum); + printf("starting %s, at %u lcores\n", __func__, rte_lcore_count()); /* 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; } - 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, - 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__); - return -1; + goto err; } 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(); @@ -839,8 +964,15 @@ test_refcnt_mbuf(void) 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; +#endif } #include @@ -870,7 +1002,7 @@ verify_mbuf_check_panics(struct rte_mbuf *buf) } 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; @@ -900,7 +1032,7 @@ test_failing_mbuf_sanity_check(void) } badbuf = *buf; - badbuf.buf_physaddr = 0; + badbuf.buf_iova = 0; if (verify_mbuf_check_panics(&badbuf)) { printf("Error with bad-physaddr mbuf test\n"); return -1; @@ -931,7 +1063,9 @@ test_failing_mbuf_sanity_check(void) } 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; @@ -1022,7 +1156,7 @@ fail: } static int -test_mbuf_linearize_check(void) +test_mbuf_linearize_check(struct rte_mempool *pktmbuf_pool) { struct test_mbuf_array { int size; @@ -1039,7 +1173,7 @@ test_mbuf_linearize_check(void) 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); @@ -1049,56 +1183,150 @@ test_mbuf_linearize_check(void) return 0; } +/* + * Helper function for test_tx_ofload + */ +static inline void +set_tx_offload(struct rte_mbuf *mb, uint64_t il2, uint64_t il3, uint64_t il4, + uint64_t tso, uint64_t ol3, uint64_t ol2) +{ + mb->l2_len = il2; + mb->l3_len = il3; + mb->l4_len = il4; + mb->tso_segsz = tso; + mb->outer_l3_len = ol3; + mb->outer_l2_len = ol2; +} + +static int +test_tx_offload(void) +{ + struct rte_mbuf *mb; + uint64_t tm, v1, v2; + size_t sz; + uint32_t i; + + static volatile struct { + uint16_t l2; + uint16_t l3; + uint16_t l4; + uint16_t tso; + } txof; + + const uint32_t num = 0x10000; + + txof.l2 = rte_rand() % (1 << RTE_MBUF_L2_LEN_BITS); + txof.l3 = rte_rand() % (1 << RTE_MBUF_L3_LEN_BITS); + txof.l4 = rte_rand() % (1 << RTE_MBUF_L4_LEN_BITS); + txof.tso = rte_rand() % (1 << RTE_MBUF_TSO_SEGSZ_BITS); + + printf("%s started, tx_offload = {\n" + "\tl2_len=%#hx,\n" + "\tl3_len=%#hx,\n" + "\tl4_len=%#hx,\n" + "\ttso_segsz=%#hx,\n" + "\touter_l3_len=%#x,\n" + "\touter_l2_len=%#x,\n" + "};\n", + __func__, + txof.l2, txof.l3, txof.l4, txof.tso, txof.l3, txof.l2); + + sz = sizeof(*mb) * num; + mb = rte_zmalloc(NULL, sz, RTE_CACHE_LINE_SIZE); + if (mb == NULL) { + printf("%s failed, out of memory\n", __func__); + return -ENOMEM; + } + + memset(mb, 0, sz); + tm = rte_rdtsc_precise(); + + for (i = 0; i != num; i++) + set_tx_offload(mb + i, txof.l2, txof.l3, txof.l4, + txof.tso, txof.l3, txof.l2); + + tm = rte_rdtsc_precise() - tm; + printf("%s set tx_offload by bit-fields: %u iterations, %" + PRIu64 " cycles, %#Lf cycles/iter\n", + __func__, num, tm, (long double)tm / num); + + v1 = mb[rte_rand() % num].tx_offload; + + memset(mb, 0, sz); + tm = rte_rdtsc_precise(); + + for (i = 0; i != num; i++) + mb[i].tx_offload = rte_mbuf_tx_offload(txof.l2, txof.l3, + txof.l4, txof.tso, txof.l3, txof.l2, 0); + + tm = rte_rdtsc_precise() - tm; + printf("%s set raw tx_offload: %u iterations, %" + PRIu64 " cycles, %#Lf cycles/iter\n", + __func__, num, tm, (long double)tm / num); + + v2 = mb[rte_rand() % num].tx_offload; + + rte_free(mb); + + printf("%s finished\n" + "expected tx_offload value: 0x%" PRIx64 ";\n" + "rte_mbuf_tx_offload value: 0x%" PRIx64 ";\n", + __func__, v1, v2); + + return (v1 == v2) ? 0 : -EINVAL; +} + 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 */ - 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); - } 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 */ - 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); - } if (pktmbuf_pool2 == NULL) { printf("cannot allocate mbuf pool\n"); - return -1; + goto err; } /* test multiple mbuf alloc */ - if (test_pktmbuf_pool() < 0) { + if (test_pktmbuf_pool(pktmbuf_pool) < 0) { printf("test_mbuf_pool() failed\n"); - return -1; + goto err; } /* 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"); - return -1; + goto err; } /* 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"); - return -1; + goto err; } /* test data manipulation in mbuf */ - if (test_one_pktmbuf() < 0) { + if (test_one_pktmbuf(pktmbuf_pool) < 0) { printf("test_one_mbuf() failed\n"); - return -1; + goto err; } @@ -1106,47 +1334,62 @@ test_mbuf(void) * 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"); - 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"); - return -1; + goto err; } /* 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"); - return -1; + goto err; } - if (testclone_testupdate_testdetach()<0){ + if (testclone_testupdate_testdetach(pktmbuf_pool) < 0) { printf("testclone_and_testupdate() failed \n"); - return -1; + goto err; + } + + if (test_pktmbuf_copy(pktmbuf_pool) < 0) { + printf("test_pktmbuf_copy() failed\n"); + 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"); - return -1; + goto err; } - if (test_refcnt_mbuf()<0){ + 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"); - 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"); - return -1; + goto err; } - return 0; + + if (test_tx_offload() < 0) { + printf("test_tx_offload() failed\n"); + goto err; + } + + ret = 0; +err: + rte_mempool_free(pktmbuf_pool); + rte_mempool_free(pktmbuf_pool2); + return ret; } REGISTER_TEST_COMMAND(mbuf_autotest, test_mbuf);