1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2020 Red Hat, Inc.
3 */
4
5 #include <time.h>
6
7 #include <rte_common.h>
8 #include <rte_cycles.h>
9 #include <rte_hexdump.h>
10 #include <rte_ip.h>
11 #include <rte_ip_frag.h>
12 #include <rte_mbuf.h>
13 #include <rte_memcpy.h>
14 #include <rte_random.h>
15
16 #include "test.h"
17
18 #define NUM_MBUFS 128
19 #define BURST 32
20
21 static struct rte_mempool *pkt_pool,
22 *direct_pool,
23 *indirect_pool;
24
25 static int
setup_buf_pool(void)26 setup_buf_pool(void)
27 {
28 pkt_pool = rte_pktmbuf_pool_create("FRAG_MBUF_POOL",
29 NUM_MBUFS, BURST, 0,
30 RTE_MBUF_DEFAULT_BUF_SIZE,
31 SOCKET_ID_ANY);
32 if (pkt_pool == NULL) {
33 printf("%s: Error creating pkt mempool\n", __func__);
34 goto bad_setup;
35 }
36
37 direct_pool = rte_pktmbuf_pool_create("FRAG_D_MBUF_POOL",
38 NUM_MBUFS, BURST, 0,
39 RTE_MBUF_DEFAULT_BUF_SIZE,
40 SOCKET_ID_ANY);
41 if (direct_pool == NULL) {
42 printf("%s: Error creating direct mempool\n", __func__);
43 goto bad_setup;
44 }
45
46 indirect_pool = rte_pktmbuf_pool_create("FRAG_I_MBUF_POOL",
47 NUM_MBUFS, BURST, 0,
48 0, SOCKET_ID_ANY);
49 if (indirect_pool == NULL) {
50 printf("%s: Error creating indirect mempool\n", __func__);
51 goto bad_setup;
52 }
53
54 return TEST_SUCCESS;
55
56 bad_setup:
57 rte_mempool_free(pkt_pool);
58 pkt_pool = NULL;
59
60 rte_mempool_free(direct_pool);
61 direct_pool = NULL;
62
63 return TEST_FAILED;
64 }
65
testsuite_setup(void)66 static int testsuite_setup(void)
67 {
68 return setup_buf_pool();
69 }
70
testsuite_teardown(void)71 static void testsuite_teardown(void)
72 {
73 rte_mempool_free(pkt_pool);
74 rte_mempool_free(direct_pool);
75 rte_mempool_free(indirect_pool);
76
77 pkt_pool = NULL;
78 direct_pool = NULL;
79 indirect_pool = NULL;
80 }
81
ut_setup(void)82 static int ut_setup(void)
83 {
84 return TEST_SUCCESS;
85 }
86
ut_teardown(void)87 static void ut_teardown(void)
88 {
89 }
90
91 static void
v4_allocate_packet_of(struct rte_mbuf * b,int fill,size_t s,int df,uint8_t ttl,uint8_t proto,uint16_t pktid)92 v4_allocate_packet_of(struct rte_mbuf *b, int fill, size_t s, int df,
93 uint8_t ttl, uint8_t proto, uint16_t pktid)
94 {
95 /* Create a packet, 2k bytes long */
96 b->data_off = 0;
97 char *data = rte_pktmbuf_mtod(b, char *);
98
99 memset(data, fill, sizeof(struct rte_ipv4_hdr) + s);
100
101 struct rte_ipv4_hdr *hdr = (struct rte_ipv4_hdr *)data;
102
103 hdr->version_ihl = 0x45; /* standard IP header... */
104 hdr->type_of_service = 0;
105 b->pkt_len = s + sizeof(struct rte_ipv4_hdr);
106 b->data_len = b->pkt_len;
107 hdr->total_length = rte_cpu_to_be_16(b->pkt_len);
108 hdr->packet_id = rte_cpu_to_be_16(pktid);
109 hdr->fragment_offset = 0;
110 if (df)
111 hdr->fragment_offset = rte_cpu_to_be_16(0x4000);
112
113 if (!ttl)
114 ttl = 64; /* default to 64 */
115
116 if (!proto)
117 proto = 1; /* icmp */
118
119 hdr->time_to_live = ttl;
120 hdr->next_proto_id = proto;
121 hdr->hdr_checksum = 0;
122 hdr->src_addr = rte_cpu_to_be_32(0x8080808);
123 hdr->dst_addr = rte_cpu_to_be_32(0x8080404);
124 }
125
126 static void
v6_allocate_packet_of(struct rte_mbuf * b,int fill,size_t s,uint8_t ttl,uint8_t proto,uint16_t pktid)127 v6_allocate_packet_of(struct rte_mbuf *b, int fill, size_t s, uint8_t ttl,
128 uint8_t proto, uint16_t pktid)
129 {
130 /* Create a packet, 2k bytes long */
131 b->data_off = 0;
132 char *data = rte_pktmbuf_mtod(b, char *);
133
134 memset(data, fill, sizeof(struct rte_ipv6_hdr) + s);
135
136 struct rte_ipv6_hdr *hdr = (struct rte_ipv6_hdr *)data;
137 b->pkt_len = s + sizeof(struct rte_ipv6_hdr);
138 b->data_len = b->pkt_len;
139
140 /* basic v6 header */
141 hdr->vtc_flow = rte_cpu_to_be_32(0x60 << 24 | pktid);
142 hdr->payload_len = rte_cpu_to_be_16(b->pkt_len);
143 hdr->proto = proto;
144 hdr->hop_limits = ttl;
145
146 memset(hdr->src_addr, 0x08, sizeof(hdr->src_addr));
147 memset(hdr->dst_addr, 0x04, sizeof(hdr->src_addr));
148 }
149
150 static inline void
test_free_fragments(struct rte_mbuf * mb[],uint32_t num)151 test_free_fragments(struct rte_mbuf *mb[], uint32_t num)
152 {
153 uint32_t i;
154 for (i = 0; i < num; i++)
155 rte_pktmbuf_free(mb[i]);
156 }
157
158 static int
test_ip_frag(void)159 test_ip_frag(void)
160 {
161 static const uint16_t RND_ID = UINT16_MAX;
162 int result = TEST_SUCCESS;
163 size_t i;
164
165 struct test_ip_frags {
166 int ipv;
167 size_t mtu_size;
168 size_t pkt_size;
169 int set_df;
170 uint8_t ttl;
171 uint8_t proto;
172 uint16_t pkt_id;
173 int expected_frags;
174 } tests[] = {
175 {4, 1280, 1400, 0, 64, IPPROTO_ICMP, RND_ID, 2},
176 {4, 1280, 1400, 0, 64, IPPROTO_ICMP, 0, 2},
177 {4, 600, 1400, 0, 64, IPPROTO_ICMP, RND_ID, 3},
178 {4, 4, 1400, 0, 64, IPPROTO_ICMP, RND_ID, -EINVAL},
179 {4, 600, 1400, 1, 64, IPPROTO_ICMP, RND_ID, -ENOTSUP},
180 {4, 600, 1400, 0, 0, IPPROTO_ICMP, RND_ID, 3},
181
182 {6, 1280, 1400, 0, 64, IPPROTO_ICMP, RND_ID, 2},
183 {6, 1300, 1400, 0, 64, IPPROTO_ICMP, RND_ID, 2},
184 {6, 4, 1400, 0, 64, IPPROTO_ICMP, RND_ID, -EINVAL},
185 {6, 1300, 1400, 0, 0, IPPROTO_ICMP, RND_ID, 2},
186 };
187
188 for (i = 0; i < RTE_DIM(tests); i++) {
189 int32_t len = 0;
190 uint16_t pktid = tests[i].pkt_id;
191 struct rte_mbuf *pkts_out[BURST];
192 struct rte_mbuf *b = rte_pktmbuf_alloc(pkt_pool);
193
194 RTE_TEST_ASSERT_NOT_EQUAL(b, NULL,
195 "Failed to allocate pkt.");
196
197 if (tests[i].pkt_id == RND_ID)
198 pktid = rte_rand_max(UINT16_MAX);
199
200 if (tests[i].ipv == 4) {
201 v4_allocate_packet_of(b, 0x41414141,
202 tests[i].pkt_size,
203 tests[i].set_df,
204 tests[i].ttl,
205 tests[i].proto,
206 pktid);
207 } else if (tests[i].ipv == 6) {
208 v6_allocate_packet_of(b, 0x41414141,
209 tests[i].pkt_size,
210 tests[i].ttl,
211 tests[i].proto,
212 pktid);
213 }
214
215 if (tests[i].ipv == 4)
216 len = rte_ipv4_fragment_packet(b, pkts_out, BURST,
217 tests[i].mtu_size,
218 direct_pool,
219 indirect_pool);
220 else if (tests[i].ipv == 6)
221 len = rte_ipv6_fragment_packet(b, pkts_out, BURST,
222 tests[i].mtu_size,
223 direct_pool,
224 indirect_pool);
225
226 rte_pktmbuf_free(b);
227
228 if (len > 0)
229 test_free_fragments(pkts_out, len);
230
231 printf("%zd: checking %d with %d\n", i, len,
232 tests[i].expected_frags);
233 RTE_TEST_ASSERT_EQUAL(len, tests[i].expected_frags,
234 "Failed case %zd.\n", i);
235
236 }
237
238 return result;
239 }
240
241 static struct unit_test_suite ipfrag_testsuite = {
242 .suite_name = "IP Frag Unit Test Suite",
243 .setup = testsuite_setup,
244 .teardown = testsuite_teardown,
245 .unit_test_cases = {
246 TEST_CASE_ST(ut_setup, ut_teardown,
247 test_ip_frag),
248
249 TEST_CASES_END() /**< NULL terminate unit test array */
250 }
251 };
252
253 static int
test_ipfrag(void)254 test_ipfrag(void)
255 {
256 rte_log_set_global_level(RTE_LOG_DEBUG);
257 rte_log_set_level(RTE_LOGTYPE_EAL, RTE_LOG_DEBUG);
258
259 return unit_test_suite_runner(&ipfrag_testsuite);
260 }
261
262 REGISTER_TEST_COMMAND(ipfrag_autotest, test_ipfrag);
263