d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

test/ipfrag: check fragment offsets

Browse Source 
Add the test content of the fragment_offset(offset and MF)
to the test_ip_frag function. Add test data for a fragment
that is not the last fragment.

Signed-off-by: Huichao Cai <chcchc88@163.com>
Acked-by: Konstantin Ananyev <konstantin.ananyev@intel.com>
This commit is contained in:
Huichao Cai 2021-10-25 15:58:59 +08:00 committed by David Marchand
parent f4801fdb78
commit e3999afd6e
1 changed files with 78 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
app/test/test_ipfrag.c
View File

@ -89,12 +89,14 @@ static void ut_teardown(void)
} }
static void static void
v4_allocate_packet_of(struct rte_mbuf *b, int fill, size_t s, int df, v4_allocate_packet_of(struct rte_mbuf *b, int fill,
size_t s, int df, uint8_t mf, uint16_t off,
uint8_t ttl, uint8_t proto, uint16_t pktid) uint8_t ttl, uint8_t proto, uint16_t pktid)
{ {
/* Create a packet, 2k bytes long */ /* Create a packet, 2k bytes long */
b->data_off = 0; b->data_off = 0;
char *data = rte_pktmbuf_mtod(b, char *); char *data = rte_pktmbuf_mtod(b, char *);
rte_be16_t fragment_offset = 0; /**< fragmentation offset */
memset(data, fill, sizeof(struct rte_ipv4_hdr) + s); memset(data, fill, sizeof(struct rte_ipv4_hdr) + s);
@ -106,9 +108,17 @@ v4_allocate_packet_of(struct rte_mbuf *b, int fill, size_t s, int df,
b->data_len = b->pkt_len; b->data_len = b->pkt_len;
hdr->total_length = rte_cpu_to_be_16(b->pkt_len); hdr->total_length = rte_cpu_to_be_16(b->pkt_len);
hdr->packet_id = rte_cpu_to_be_16(pktid); hdr->packet_id = rte_cpu_to_be_16(pktid);
hdr->fragment_offset = 0;
if (df) if (df)
hdr->fragment_offset = rte_cpu_to_be_16(0x4000); fragment_offset |= 0x4000;
if (mf)
fragment_offset |= 0x2000;
if (off)
fragment_offset |= off;
hdr->fragment_offset = rte_cpu_to_be_16(fragment_offset);
if (!ttl) if (!ttl)
ttl = 64; /* default to 64 */ ttl = 64; /* default to 64 */
@ -155,38 +165,73 @@ test_free_fragments(struct rte_mbuf *mb[], uint32_t num)
rte_pktmbuf_free(mb[i]); rte_pktmbuf_free(mb[i]);
} }
static inline void
test_get_offset(struct rte_mbuf **mb, int32_t len,
uint16_t *offset, int ipv)
{
int32_t i;
for (i = 0; i < len; i++) {
if (ipv == 4) {
struct rte_ipv4_hdr *iph =
rte_pktmbuf_mtod(mb[i], struct rte_ipv4_hdr *);
offset[i] = iph->fragment_offset;
} else if (ipv == 6) {
struct ipv6_extension_fragment *fh =
rte_pktmbuf_mtod_offset(
mb[i],
struct ipv6_extension_fragment *,
sizeof(struct rte_ipv6_hdr));
offset[i] = fh->frag_data;
}
}
}
static int static int
test_ip_frag(void) test_ip_frag(void)
{ {
static const uint16_t RND_ID = UINT16_MAX; static const uint16_t RND_ID = UINT16_MAX;
int result = TEST_SUCCESS; int result = TEST_SUCCESS;
size_t i; size_t i, j;
struct test_ip_frags { struct test_ip_frags {
int ipv; int ipv;
size_t mtu_size; size_t mtu_size;
size_t pkt_size; size_t pkt_size;
int set_df; int set_df;
uint8_t set_mf;
uint16_t set_of;
uint8_t ttl; uint8_t ttl;
uint8_t proto; uint8_t proto;
uint16_t pkt_id; uint16_t pkt_id;
int expected_frags; int expected_frags;
uint16_t expected_fragment_offset[BURST];
} tests[] = { } tests[] = {
{4, 1280, 1400, 0, 64, IPPROTO_ICMP, RND_ID, 2}, {4, 1280, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID, 2,
{4, 1280, 1400, 0, 64, IPPROTO_ICMP, 0, 2}, {0x2000, 0x009D}},
{4, 600, 1400, 0, 64, IPPROTO_ICMP, RND_ID, 3}, {4, 1280, 1400, 0, 0, 0, 64, IPPROTO_ICMP, 0, 2,
{4, 4, 1400, 0, 64, IPPROTO_ICMP, RND_ID, -EINVAL}, {0x2000, 0x009D}},
{4, 600, 1400, 1, 64, IPPROTO_ICMP, RND_ID, -ENOTSUP}, {4, 600, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID, 3,
{4, 600, 1400, 0, 0, IPPROTO_ICMP, RND_ID, 3}, {0x2000, 0x2048, 0x0090}},
{4, 4, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID, -EINVAL},
{4, 600, 1400, 1, 0, 0, 64, IPPROTO_ICMP, RND_ID, -ENOTSUP},
{4, 600, 1400, 0, 0, 0, 0, IPPROTO_ICMP, RND_ID, 3,
{0x2000, 0x2048, 0x0090}},
{4, 68, 104, 0, 1, 13, 0, IPPROTO_ICMP, RND_ID, 3,
{0x200D, 0x2013, 0x2019}},
{6, 1280, 1400, 0, 64, IPPROTO_ICMP, RND_ID, 2}, {6, 1280, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID, 2,
{6, 1300, 1400, 0, 64, IPPROTO_ICMP, RND_ID, 2}, {0x0001, 0x04D0}},
{6, 4, 1400, 0, 64, IPPROTO_ICMP, RND_ID, -EINVAL}, {6, 1300, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID, 2,
{6, 1300, 1400, 0, 0, IPPROTO_ICMP, RND_ID, 2}, {0x0001, 0x04E0}},
{6, 4, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID, -EINVAL},
{6, 1300, 1400, 0, 0, 0, 0, IPPROTO_ICMP, RND_ID, 2,
{0x0001, 0x04E0}},
}; };
for (i = 0; i < RTE_DIM(tests); i++) { for (i = 0; i < RTE_DIM(tests); i++) {
int32_t len = 0; int32_t len = 0;
uint16_t fragment_offset[BURST];
uint16_t pktid = tests[i].pkt_id; uint16_t pktid = tests[i].pkt_id;
struct rte_mbuf *pkts_out[BURST]; struct rte_mbuf *pkts_out[BURST];
struct rte_mbuf *b = rte_pktmbuf_alloc(pkt_pool); struct rte_mbuf *b = rte_pktmbuf_alloc(pkt_pool);
@ -201,6 +246,8 @@ test_ip_frag(void)
v4_allocate_packet_of(b, 0x41414141, v4_allocate_packet_of(b, 0x41414141,
tests[i].pkt_size, tests[i].pkt_size,
tests[i].set_df, tests[i].set_df,
tests[i].set_mf,
tests[i].set_of,
tests[i].ttl, tests[i].ttl,
tests[i].proto, tests[i].proto,
pktid); pktid);
@ -225,14 +272,30 @@ test_ip_frag(void)
rte_pktmbuf_free(b); rte_pktmbuf_free(b);
if (len > 0) if (len > 0) {
test_get_offset(pkts_out, len,
fragment_offset, tests[i].ipv);
test_free_fragments(pkts_out, len); test_free_fragments(pkts_out, len);
}
printf("%zd: checking %d with %d\n", i, len, printf("%zd: checking %d with %d\n", i, len,
tests[i].expected_frags); tests[i].expected_frags);
RTE_TEST_ASSERT_EQUAL(len, tests[i].expected_frags, RTE_TEST_ASSERT_EQUAL(len, tests[i].expected_frags,
"Failed case %zd.\n", i); "Failed case %zd.\n", i);
if (len > 0) {
for (j = 0; j < (size_t)len; j++) {
printf("%zd-%zd: checking %d with %d\n",
i, j, fragment_offset[j],
rte_cpu_to_be_16(
tests[i].expected_fragment_offset[j]));
RTE_TEST_ASSERT_EQUAL(fragment_offset[j],
rte_cpu_to_be_16(
tests[i].expected_fragment_offset[j]),
"Failed case %zd.\n", i);
}
}
} }
return result; return result;