X-Git-Url: http://git.droids-corp.org/?p=dpdk.git;a=blobdiff_plain;f=app%2Ftest%2Ftest_mbuf.c;h=a96ba3fa11ef85d03062bb4d4c955d5566cb6165;hp=854bc26d8fd81b633212a6f5ecfcfe59deb49fc7;hb=a617494eeb01ff;hpb=4958ca3a443a33ed49b2601232349037dbb7124f diff --git a/app/test/test_mbuf.c b/app/test/test_mbuf.c index 854bc26d8f..a96ba3fa11 100644 --- a/app/test/test_mbuf.c +++ b/app/test/test_mbuf.c @@ -310,8 +310,17 @@ fail: return -1; } +static uint16_t +testclone_refcnt_read(struct rte_mbuf *m) +{ + return RTE_MBUF_HAS_PINNED_EXTBUF(m) ? + rte_mbuf_ext_refcnt_read(m->shinfo) : + rte_mbuf_refcnt_read(m); +} + static int -testclone_testupdate_testdetach(struct rte_mempool *pktmbuf_pool) +testclone_testupdate_testdetach(struct rte_mempool *pktmbuf_pool, + struct rte_mempool *clone_pool) { struct rte_mbuf *m = NULL; struct rte_mbuf *clone = NULL; @@ -331,7 +340,7 @@ testclone_testupdate_testdetach(struct rte_mempool *pktmbuf_pool) *data = MAGIC_DATA; /* clone the allocated mbuf */ - clone = rte_pktmbuf_clone(m, pktmbuf_pool); + clone = rte_pktmbuf_clone(m, clone_pool); if (clone == NULL) GOTO_FAIL("cannot clone data\n"); @@ -339,7 +348,7 @@ testclone_testupdate_testdetach(struct rte_mempool *pktmbuf_pool) if (*data != MAGIC_DATA) GOTO_FAIL("invalid data in clone\n"); - if (rte_mbuf_refcnt_read(m) != 2) + if (testclone_refcnt_read(m) != 2) GOTO_FAIL("invalid refcnt in m\n"); /* free the clone */ @@ -358,7 +367,7 @@ testclone_testupdate_testdetach(struct rte_mempool *pktmbuf_pool) data = rte_pktmbuf_mtod(m->next, unaligned_uint32_t *); *data = MAGIC_DATA; - clone = rte_pktmbuf_clone(m, pktmbuf_pool); + clone = rte_pktmbuf_clone(m, clone_pool); if (clone == NULL) GOTO_FAIL("cannot clone data\n"); @@ -370,15 +379,15 @@ testclone_testupdate_testdetach(struct rte_mempool *pktmbuf_pool) if (*data != MAGIC_DATA) GOTO_FAIL("invalid data in clone->next\n"); - if (rte_mbuf_refcnt_read(m) != 2) + if (testclone_refcnt_read(m) != 2) GOTO_FAIL("invalid refcnt in m\n"); - if (rte_mbuf_refcnt_read(m->next) != 2) + if (testclone_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); + clone2 = rte_pktmbuf_clone(clone, clone_pool); if (clone2 == NULL) GOTO_FAIL("cannot clone the clone\n"); @@ -390,10 +399,10 @@ testclone_testupdate_testdetach(struct rte_mempool *pktmbuf_pool) if (*data != MAGIC_DATA) GOTO_FAIL("invalid data in clone2->next\n"); - if (rte_mbuf_refcnt_read(m) != 3) + if (testclone_refcnt_read(m) != 3) GOTO_FAIL("invalid refcnt in m\n"); - if (rte_mbuf_refcnt_read(m->next) != 3) + if (testclone_refcnt_read(m->next) != 3) GOTO_FAIL("invalid refcnt in m->next\n"); /* free mbuf */ @@ -418,7 +427,8 @@ fail: } static int -test_pktmbuf_copy(struct rte_mempool *pktmbuf_pool) +test_pktmbuf_copy(struct rte_mempool *pktmbuf_pool, + struct rte_mempool *clone_pool) { struct rte_mbuf *m = NULL; struct rte_mbuf *copy = NULL; @@ -458,11 +468,14 @@ test_pktmbuf_copy(struct rte_mempool *pktmbuf_pool) copy = NULL; /* same test with a cloned mbuf */ - clone = rte_pktmbuf_clone(m, pktmbuf_pool); + clone = rte_pktmbuf_clone(m, clone_pool); if (clone == NULL) GOTO_FAIL("cannot clone data\n"); - if (!RTE_MBUF_CLONED(clone)) + if ((!RTE_MBUF_HAS_PINNED_EXTBUF(m) && + !RTE_MBUF_CLONED(clone)) || + (RTE_MBUF_HAS_PINNED_EXTBUF(m) && + !RTE_MBUF_HAS_EXTBUF(clone))) GOTO_FAIL("clone did not give a cloned mbuf\n"); copy = rte_pktmbuf_copy(clone, pktmbuf_pool, 0, UINT32_MAX); @@ -1144,7 +1157,7 @@ test_refcnt_mbuf(void) tref += refcnt_lcore[slave]; if (tref != refcnt_lcore[master]) - rte_panic("refernced mbufs: %u, freed mbufs: %u\n", + rte_panic("referenced mbufs: %u, freed mbufs: %u\n", tref, refcnt_lcore[master]); rte_mempool_dump(stdout, refcnt_pool); @@ -1199,6 +1212,7 @@ test_failing_mbuf_sanity_check(struct rte_mempool *pktmbuf_pool) buf = rte_pktmbuf_alloc(pktmbuf_pool); if (buf == NULL) return -1; + printf("Checking good mbuf initially\n"); if (verify_mbuf_check_panics(buf) != -1) return -1; @@ -1669,7 +1683,6 @@ test_get_tx_ol_flag_name(void) VAL_NAME(PKT_TX_SEC_OFFLOAD), VAL_NAME(PKT_TX_UDP_SEG), VAL_NAME(PKT_TX_OUTER_UDP_CKSUM), - VAL_NAME(PKT_TX_METADATA), }; /* Test case to check with valid flag */ @@ -2412,6 +2425,120 @@ fail: return -1; } +/* + * Test the mbuf pool with pinned external data buffers + * - Allocate memory zone for external buffer + * - Create the mbuf pool with pinned external buffer + * - Check the created pool with relevant mbuf pool unit tests + */ +static int +test_pktmbuf_ext_pinned_buffer(struct rte_mempool *std_pool) +{ + + struct rte_pktmbuf_extmem ext_mem; + struct rte_mempool *pinned_pool = NULL; + const struct rte_memzone *mz = NULL; + + printf("Test mbuf pool with external pinned data buffers\n"); + + /* Allocate memzone for the external data buffer */ + mz = rte_memzone_reserve("pinned_pool", + NB_MBUF * MBUF_DATA_SIZE, + SOCKET_ID_ANY, + RTE_MEMZONE_2MB | RTE_MEMZONE_SIZE_HINT_ONLY); + if (mz == NULL) + GOTO_FAIL("%s: Memzone allocation failed\n", __func__); + + /* Create the mbuf pool with pinned external data buffer */ + ext_mem.buf_ptr = mz->addr; + ext_mem.buf_iova = mz->iova; + ext_mem.buf_len = mz->len; + ext_mem.elt_size = MBUF_DATA_SIZE; + + pinned_pool = rte_pktmbuf_pool_create_extbuf("test_pinned_pool", + NB_MBUF, MEMPOOL_CACHE_SIZE, 0, + MBUF_DATA_SIZE, SOCKET_ID_ANY, + &ext_mem, 1); + if (pinned_pool == NULL) + GOTO_FAIL("%s: Mbuf pool with pinned external" + " buffer creation failed\n", __func__); + /* test multiple mbuf alloc */ + if (test_pktmbuf_pool(pinned_pool) < 0) + GOTO_FAIL("%s: test_mbuf_pool(pinned) failed\n", + __func__); + + /* do it another time to check that all mbufs were freed */ + if (test_pktmbuf_pool(pinned_pool) < 0) + GOTO_FAIL("%s: test_mbuf_pool(pinned) failed (2)\n", + __func__); + + /* test that the data pointer on a packet mbuf is set properly */ + if (test_pktmbuf_pool_ptr(pinned_pool) < 0) + GOTO_FAIL("%s: test_pktmbuf_pool_ptr(pinned) failed\n", + __func__); + + /* test data manipulation in mbuf with non-ascii data */ + if (test_pktmbuf_with_non_ascii_data(pinned_pool) < 0) + GOTO_FAIL("%s: test_pktmbuf_with_non_ascii_data(pinned)" + " failed\n", __func__); + + /* test free pktmbuf segment one by one */ + if (test_pktmbuf_free_segment(pinned_pool) < 0) + GOTO_FAIL("%s: test_pktmbuf_free_segment(pinned) failed\n", + __func__); + + if (testclone_testupdate_testdetach(pinned_pool, std_pool) < 0) + GOTO_FAIL("%s: testclone_and_testupdate(pinned) failed\n", + __func__); + + if (test_pktmbuf_copy(pinned_pool, std_pool) < 0) + GOTO_FAIL("%s: test_pktmbuf_copy(pinned) failed\n", + __func__); + + if (test_failing_mbuf_sanity_check(pinned_pool) < 0) + GOTO_FAIL("%s: test_failing_mbuf_sanity_check(pinned)" + " failed\n", __func__); + + if (test_mbuf_linearize_check(pinned_pool) < 0) + GOTO_FAIL("%s: test_mbuf_linearize_check(pinned) failed\n", + __func__); + + /* test for allocating a bulk of mbufs with various sizes */ + if (test_pktmbuf_alloc_bulk(pinned_pool) < 0) + GOTO_FAIL("%s: test_rte_pktmbuf_alloc_bulk(pinned) failed\n", + __func__); + + /* test for allocating a bulk of mbufs with various sizes */ + if (test_neg_pktmbuf_alloc_bulk(pinned_pool) < 0) + GOTO_FAIL("%s: test_neg_rte_pktmbuf_alloc_bulk(pinned)" + " failed\n", __func__); + + /* test to read mbuf packet */ + if (test_pktmbuf_read(pinned_pool) < 0) + GOTO_FAIL("%s: test_rte_pktmbuf_read(pinned) failed\n", + __func__); + + /* test to read mbuf packet from offset */ + if (test_pktmbuf_read_from_offset(pinned_pool) < 0) + GOTO_FAIL("%s: test_rte_pktmbuf_read_from_offset(pinned)" + " failed\n", __func__); + + /* test to read data from chain of mbufs with data segments */ + if (test_pktmbuf_read_from_chain(pinned_pool) < 0) + GOTO_FAIL("%s: test_rte_pktmbuf_read_from_chain(pinned)" + " failed\n", __func__); + + RTE_SET_USED(std_pool); + rte_mempool_free(pinned_pool); + rte_memzone_free(mz); + return 0; + +fail: + rte_mempool_free(pinned_pool); + rte_memzone_free(mz); + return -1; +} + static int test_mbuf_dyn(struct rte_mempool *pktmbuf_pool) { @@ -2520,7 +2647,7 @@ test_mbuf_dyn(struct rte_mempool *pktmbuf_pool) flag3 = rte_mbuf_dynflag_register_bitnum(&dynflag3, rte_bsf64(PKT_LAST_FREE)); if (flag3 != rte_bsf64(PKT_LAST_FREE)) - GOTO_FAIL("failed to register dynamic flag 3, flag2=%d: %s", + GOTO_FAIL("failed to register dynamic flag 3, flag3=%d: %s", flag3, strerror(errno)); printf("dynflag: flag=%d, flag2=%d, flag3=%d\n", flag, flag2, flag3); @@ -2548,6 +2675,82 @@ fail: return -1; } +static void +my_free_cb(void *addr, void *opaque __rte_unused) +{ + rte_free(addr); +} + +static int +test_shinfo_in_mbuf(struct rte_mempool *pktmbuf_pool) +{ + struct rte_mbuf_ext_shared_info *shinfo = NULL; + struct rte_mbuf *m2 = NULL; + struct rte_mbuf *m = NULL; + size_t buf_len = 256; + rte_iova_t iova; + char *buf = NULL; + + m = rte_pktmbuf_alloc(pktmbuf_pool); + printf("%s() m=%p\n", __func__, m); + if (m == NULL) + GOTO_FAIL("cannot allocate mbuf m"); + rte_pktmbuf_dump(stdout, m, 0); + + if (rte_pktmbuf_tailroom(m) < sizeof(*shinfo)) + GOTO_FAIL("tailroom too small"); + + buf = rte_malloc(NULL, buf_len, RTE_CACHE_LINE_SIZE); + if (buf == NULL) + GOTO_FAIL("cannot allocate buffer"); + + shinfo = rte_pktmbuf_mtod(m, struct rte_mbuf_ext_shared_info *); + shinfo->free_cb = my_free_cb; + shinfo->fcb_opaque = NULL; + rte_mbuf_ext_refcnt_set(shinfo, 1); + iova = rte_malloc_virt2iova(buf); + rte_pktmbuf_attach_extbuf(m, buf, iova, buf_len, shinfo); + printf("%s() m is attached to the ext buf\n", __func__); + rte_pktmbuf_dump(stdout, m, 0); + + m2 = rte_pktmbuf_alloc(pktmbuf_pool); + printf("%s() m2=%p\n", __func__, m2); + if (m2 == NULL) + GOTO_FAIL("cannot allocate mbuf m2"); + rte_pktmbuf_dump(stdout, m2, 0); + + rte_pktmbuf_attach(m2, m); + rte_pktmbuf_dump(stdout, m2, 0); + rte_pktmbuf_dump(stdout, m, 0); + rte_pktmbuf_free(m); + m = NULL; + + m = rte_pktmbuf_alloc(pktmbuf_pool); + printf("%s() m=%p\n", __func__, m); + if (m == NULL) + GOTO_FAIL("cannot allocate mbuf m"); + + /* clobber data in the mbuf we just allocated */ + shinfo = rte_pktmbuf_mtod(m, struct rte_mbuf_ext_shared_info *); + shinfo->free_cb = NULL; + + rte_pktmbuf_free(m); + m = NULL; + + rte_pktmbuf_free(m2); + m2 = NULL; + + printf("done\n"); + return 0; + + +fail: + rte_pktmbuf_free(m2); + rte_pktmbuf_free(m); + rte_free(buf); + return -1; +} + static int test_mbuf(void) { @@ -2568,6 +2771,16 @@ test_mbuf(void) goto err; } + if (test_shinfo_in_mbuf(pktmbuf_pool) < 0) { + printf("mbuf shinfo in mbuf failed\n"); + goto err; + } + + if (1) { + ret = 0; + goto err; + } + /* test registration of dynamic fields and flags */ if (test_mbuf_dyn(pktmbuf_pool) < 0) { printf("mbuf dynflag test failed\n"); @@ -2636,12 +2849,12 @@ test_mbuf(void) goto err; } - if (testclone_testupdate_testdetach(pktmbuf_pool) < 0) { + if (testclone_testupdate_testdetach(pktmbuf_pool, pktmbuf_pool) < 0) { printf("testclone_and_testupdate() failed \n"); goto err; } - if (test_pktmbuf_copy(pktmbuf_pool) < 0) { + if (test_pktmbuf_copy(pktmbuf_pool, pktmbuf_pool) < 0) { printf("test_pktmbuf_copy() failed\n"); goto err; } @@ -2732,6 +2945,13 @@ test_mbuf(void) goto err; } + /* test the mbuf pool with pinned external data buffers */ + if (test_pktmbuf_ext_pinned_buffer(pktmbuf_pool) < 0) { + printf("test_pktmbuf_ext_pinned_buffer() failed\n"); + goto err; + } + + ret = 0; err: rte_mempool_free(pktmbuf_pool);