1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2014 Intel Corporation
3 */
4
5 #include "test.h"
6
7 #include <stdio.h>
8 #include <unistd.h>
9 #include <string.h>
10
11 #include <rte_cycles.h>
12 #include <rte_errno.h>
13 #include <rte_mbuf.h>
14 #include <rte_reorder.h>
15 #include <rte_lcore.h>
16 #include <rte_malloc.h>
17
18 #define BURST 32
19 #define REORDER_BUFFER_SIZE 16384
20 #define NUM_MBUFS (2*REORDER_BUFFER_SIZE)
21 #define REORDER_BUFFER_SIZE_INVALID 2049
22
23 struct reorder_unittest_params {
24 struct rte_mempool *p;
25 struct rte_reorder_buffer *b;
26 };
27
28 static struct reorder_unittest_params default_params = {
29 .p = NULL,
30 .b = NULL
31 };
32
33 static struct reorder_unittest_params *test_params = &default_params;
34
35 static int
test_reorder_create(void)36 test_reorder_create(void)
37 {
38 struct rte_reorder_buffer *b = NULL;
39
40 b = rte_reorder_create(NULL, rte_socket_id(), REORDER_BUFFER_SIZE);
41 TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
42 "No error on create() with NULL name");
43
44 b = rte_reorder_create("PKT", rte_socket_id(), REORDER_BUFFER_SIZE_INVALID);
45 TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
46 "No error on create() with invalid buffer size param.");
47
48 b = rte_reorder_create("PKT_RO1", rte_socket_id(), REORDER_BUFFER_SIZE);
49 TEST_ASSERT_EQUAL(b, test_params->b,
50 "New reorder instance created with already existing name");
51
52 return 0;
53 }
54
55 static int
test_reorder_init(void)56 test_reorder_init(void)
57 {
58 struct rte_reorder_buffer *b = NULL;
59 unsigned int size;
60 /*
61 * The minimum memory area size that should be passed to library determined
62 * by rte_reorder_memory_footprint_get().
63 * Otherwise error will be thrown
64 */
65
66 size = rte_reorder_memory_footprint_get(REORDER_BUFFER_SIZE) - 1;
67 b = rte_reorder_init(b, size, "PKT1", REORDER_BUFFER_SIZE);
68 TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
69 "No error on init with NULL buffer.");
70
71 b = rte_malloc(NULL, size, 0);
72 b = rte_reorder_init(b, size, "PKT1", REORDER_BUFFER_SIZE);
73 TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
74 "No error on init with invalid mem zone size.");
75 rte_free(b);
76
77 size = rte_reorder_memory_footprint_get(REORDER_BUFFER_SIZE);
78 b = rte_malloc(NULL, size, 0);
79 b = rte_reorder_init(b, size, "PKT1", REORDER_BUFFER_SIZE_INVALID);
80 TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
81 "No error on init with invalid buffer size param.");
82
83 b = rte_reorder_init(b, size, NULL, REORDER_BUFFER_SIZE);
84 TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
85 "No error on init with invalid name.");
86 rte_free(b);
87
88 return 0;
89 }
90
91 static int
test_reorder_find_existing(void)92 test_reorder_find_existing(void)
93 {
94 struct rte_reorder_buffer *b = NULL;
95
96 /* Try to find existing reorder buffer instance */
97 b = rte_reorder_find_existing("PKT_RO1");
98 TEST_ASSERT_EQUAL(b, test_params->b,
99 "existing reorder buffer instance not found");
100
101 /* Try to find non existing reorder buffer instance */
102 b = rte_reorder_find_existing("ro_find_non_existing");
103 TEST_ASSERT((b == NULL) && (rte_errno == ENOENT),
104 "non existing reorder buffer instance found");
105
106 return 0;
107 }
108
109 static int
test_reorder_free(void)110 test_reorder_free(void)
111 {
112 struct rte_reorder_buffer *b1 = NULL, *b2 = NULL;
113 const char *name = "test_free";
114
115 b1 = rte_reorder_create(name, rte_socket_id(), 8);
116 TEST_ASSERT_NOT_NULL(b1, "Failed to create reorder buffer.");
117
118 b2 = rte_reorder_find_existing(name);
119 TEST_ASSERT_EQUAL(b1, b2, "Failed to find existing reorder buffer");
120
121 rte_reorder_free(b1);
122
123 b2 = rte_reorder_find_existing(name);
124 TEST_ASSERT((b2 == NULL) && (rte_errno == ENOENT),
125 "Found previously freed reorder buffer");
126
127 return 0;
128 }
129
130 static int
test_reorder_insert(void)131 test_reorder_insert(void)
132 {
133 struct rte_reorder_buffer *b = NULL;
134 struct rte_mempool *p = test_params->p;
135 const unsigned int size = 4;
136 const unsigned int num_bufs = 7;
137 struct rte_mbuf *bufs[num_bufs];
138 int ret = 0;
139 unsigned i;
140
141 /* This would create a reorder buffer instance consisting of:
142 * reorder_seq = 0
143 * ready_buf: RB[size] = {NULL, NULL, NULL, NULL}
144 * order_buf: OB[size] = {NULL, NULL, NULL, NULL}
145 */
146 b = rte_reorder_create("test_insert", rte_socket_id(), size);
147 TEST_ASSERT_NOT_NULL(b, "Failed to create reorder buffer");
148
149 for (i = 0; i < num_bufs; i++) {
150 bufs[i] = rte_pktmbuf_alloc(p);
151 TEST_ASSERT_NOT_NULL(bufs[i], "Packet allocation failed\n");
152 *rte_reorder_seqn(bufs[i]) = i;
153 }
154
155 /* This should fill up order buffer:
156 * reorder_seq = 0
157 * RB[] = {NULL, NULL, NULL, NULL}
158 * OB[] = {0, 1, 2, 3}
159 */
160 for (i = 0; i < size; i++) {
161 ret = rte_reorder_insert(b, bufs[i]);
162 if (ret != 0) {
163 printf("%s:%d: Error inserting packet with seqn less than size\n",
164 __func__, __LINE__);
165 ret = -1;
166 goto exit;
167 }
168 bufs[i] = NULL;
169 }
170
171 /* early packet - should move mbufs to ready buf and move sequence window
172 * reorder_seq = 4
173 * RB[] = {0, 1, 2, 3}
174 * OB[] = {4, NULL, NULL, NULL}
175 */
176 ret = rte_reorder_insert(b, bufs[4]);
177 if (ret != 0) {
178 printf("%s:%d: Error inserting early packet with seqn: size\n",
179 __func__, __LINE__);
180 ret = -1;
181 goto exit;
182 }
183 bufs[4] = NULL;
184
185 /* early packet from current sequence window - full ready buffer */
186 *rte_reorder_seqn(bufs[5]) = 2 * size;
187 ret = rte_reorder_insert(b, bufs[5]);
188 if (!((ret == -1) && (rte_errno == ENOSPC))) {
189 printf("%s:%d: No error inserting early packet with full ready buffer\n",
190 __func__, __LINE__);
191 ret = -1;
192 goto exit;
193 }
194 bufs[5] = NULL;
195
196 /* late packet */
197 *rte_reorder_seqn(bufs[6]) = 3 * size;
198 ret = rte_reorder_insert(b, bufs[6]);
199 if (!((ret == -1) && (rte_errno == ERANGE))) {
200 printf("%s:%d: No error inserting late packet with seqn:"
201 " 3 * size\n", __func__, __LINE__);
202 ret = -1;
203 goto exit;
204 }
205 bufs[6] = NULL;
206
207 ret = 0;
208 exit:
209 rte_reorder_free(b);
210 for (i = 0; i < num_bufs; i++) {
211 rte_pktmbuf_free(bufs[i]);
212 }
213 return ret;
214 }
215
216 static int
test_reorder_drain(void)217 test_reorder_drain(void)
218 {
219 struct rte_reorder_buffer *b = NULL;
220 struct rte_mempool *p = test_params->p;
221 const unsigned int size = 4;
222 const unsigned int num_bufs = 8;
223 struct rte_mbuf *bufs[num_bufs];
224 struct rte_mbuf *robufs[num_bufs];
225 int ret = 0;
226 unsigned i, cnt;
227
228 /* initialize all robufs to NULL */
229 for (i = 0; i < num_bufs; i++)
230 robufs[i] = NULL;
231
232 /* This would create a reorder buffer instance consisting of:
233 * reorder_seq = 0
234 * ready_buf: RB[size] = {NULL, NULL, NULL, NULL}
235 * order_buf: OB[size] = {NULL, NULL, NULL, NULL}
236 */
237 b = rte_reorder_create("test_drain", rte_socket_id(), size);
238 TEST_ASSERT_NOT_NULL(b, "Failed to create reorder buffer");
239
240 /* Check no drained packets if reorder is empty */
241 cnt = rte_reorder_drain(b, robufs, 1);
242 if (cnt != 0) {
243 printf("%s:%d: drained packets from empty reorder buffer\n",
244 __func__, __LINE__);
245 ret = -1;
246 goto exit;
247 }
248
249 for (i = 0; i < num_bufs; i++) {
250 bufs[i] = rte_pktmbuf_alloc(p);
251 TEST_ASSERT_NOT_NULL(bufs[i], "Packet allocation failed\n");
252 *rte_reorder_seqn(bufs[i]) = i;
253 }
254
255 /* Insert packet with seqn 1:
256 * reorder_seq = 0
257 * RB[] = {NULL, NULL, NULL, NULL}
258 * OB[] = {1, NULL, NULL, NULL}
259 */
260 rte_reorder_insert(b, bufs[1]);
261 bufs[1] = NULL;
262
263 cnt = rte_reorder_drain(b, robufs, 1);
264 if (cnt != 1) {
265 printf("%s:%d:%d: number of expected packets not drained\n",
266 __func__, __LINE__, cnt);
267 ret = -1;
268 goto exit;
269 }
270 rte_pktmbuf_free(robufs[0]);
271 memset(robufs, 0, sizeof(robufs));
272
273 /* Insert more packets
274 * RB[] = {NULL, NULL, NULL, NULL}
275 * OB[] = {NULL, 2, 3, NULL}
276 */
277 rte_reorder_insert(b, bufs[2]);
278 rte_reorder_insert(b, bufs[3]);
279 bufs[2] = NULL;
280 bufs[3] = NULL;
281
282 /* Insert more packets
283 * RB[] = {NULL, NULL, NULL, NULL}
284 * OB[] = {NULL, 2, 3, 4}
285 */
286 rte_reorder_insert(b, bufs[4]);
287 bufs[4] = NULL;
288
289 /* Insert more packets
290 * RB[] = {2, 3, 4, NULL}
291 * OB[] = {NULL, NULL, 7, NULL}
292 */
293 rte_reorder_insert(b, bufs[7]);
294 bufs[7] = NULL;
295
296 /* drained expected packets */
297 cnt = rte_reorder_drain(b, robufs, 4);
298 if (cnt != 3) {
299 printf("%s:%d:%d: number of expected packets not drained\n",
300 __func__, __LINE__, cnt);
301 ret = -1;
302 goto exit;
303 }
304 for (i = 0; i < 3; i++) {
305 rte_pktmbuf_free(robufs[i]);
306 }
307 memset(robufs, 0, sizeof(robufs));
308
309 /*
310 * RB[] = {NULL, NULL, NULL, NULL}
311 * OB[] = {NULL, NULL, 7, NULL}
312 */
313 cnt = rte_reorder_drain(b, robufs, 1);
314 if (cnt != 0) {
315 printf("%s:%d:%d: number of expected packets not drained\n",
316 __func__, __LINE__, cnt);
317 ret = -1;
318 goto exit;
319 }
320 ret = 0;
321 exit:
322 rte_reorder_free(b);
323 for (i = 0; i < num_bufs; i++) {
324 rte_pktmbuf_free(bufs[i]);
325 rte_pktmbuf_free(robufs[i]);
326 }
327 return ret;
328 }
329
330 static void
buffer_to_reorder_move(struct rte_mbuf ** mbuf,struct rte_reorder_buffer * b)331 buffer_to_reorder_move(struct rte_mbuf **mbuf, struct rte_reorder_buffer *b)
332 {
333 rte_reorder_insert(b, *mbuf);
334 *mbuf = NULL;
335 }
336
337 static int
test_reorder_drain_up_to_seqn(void)338 test_reorder_drain_up_to_seqn(void)
339 {
340 struct rte_mempool *p = test_params->p;
341 struct rte_reorder_buffer *b = NULL;
342 const unsigned int num_bufs = 10;
343 const unsigned int size = 4;
344 unsigned int i, cnt;
345 int ret = 0;
346
347 struct rte_mbuf *bufs[num_bufs];
348 struct rte_mbuf *robufs[num_bufs];
349
350 /* initialize all robufs to NULL */
351 memset(robufs, 0, sizeof(robufs));
352
353 /* This would create a reorder buffer instance consisting of:
354 * reorder_seq = 0
355 * ready_buf: RB[size] = {NULL, NULL, NULL, NULL}
356 * order_buf: OB[size] = {NULL, NULL, NULL, NULL}
357 */
358 b = rte_reorder_create("test_drain_up_to_seqn", rte_socket_id(), size);
359 TEST_ASSERT_NOT_NULL(b, "Failed to create reorder buffer");
360
361 for (i = 0; i < num_bufs; i++) {
362 bufs[i] = rte_pktmbuf_alloc(p);
363 TEST_ASSERT_NOT_NULL(bufs[i], "Packet allocation failed\n");
364 *rte_reorder_seqn(bufs[i]) = i;
365 }
366
367 /* Insert packet with seqn 1 and 3:
368 * RB[] = {NULL, NULL, NULL, NULL}
369 * OB[] = {1, 2, 3, NULL}
370 */
371 buffer_to_reorder_move(&bufs[1], b);
372 buffer_to_reorder_move(&bufs[2], b);
373 buffer_to_reorder_move(&bufs[3], b);
374 /* Draining 1, 2 */
375 cnt = rte_reorder_drain_up_to_seqn(b, robufs, num_bufs, 3);
376 if (cnt != 2) {
377 printf("%s:%d:%d: number of expected packets not drained\n",
378 __func__, __LINE__, cnt);
379 ret = -1;
380 goto exit;
381 }
382 for (i = 0; i < 2; i++)
383 rte_pktmbuf_free(robufs[i]);
384 memset(robufs, 0, sizeof(robufs));
385
386 /* Insert more packets
387 * RB[] = {NULL, NULL, NULL, NULL}
388 * OB[] = {3, 4, NULL, 6}
389 */
390 buffer_to_reorder_move(&bufs[4], b);
391 buffer_to_reorder_move(&bufs[6], b);
392 /* Insert more packets to utilize Ready buffer
393 * RB[] = {3, NULL, 5, 6}
394 * OB[] = {NULL, NULL, 8, NULL}
395 */
396 buffer_to_reorder_move(&bufs[8], b);
397
398 /* Drain 3 and 5 */
399 cnt = rte_reorder_drain_up_to_seqn(b, robufs, num_bufs, 6);
400 if (cnt != 2) {
401 printf("%s:%d:%d: number of expected packets not drained\n",
402 __func__, __LINE__, cnt);
403 ret = -1;
404 goto exit;
405 }
406 for (i = 0; i < 2; i++)
407 rte_pktmbuf_free(robufs[i]);
408 memset(robufs, 0, sizeof(robufs));
409
410 ret = 0;
411 exit:
412 rte_reorder_free(b);
413 for (i = 0; i < num_bufs; i++) {
414 rte_pktmbuf_free(bufs[i]);
415 rte_pktmbuf_free(robufs[i]);
416 }
417 return ret;
418 }
419
420 static int
test_reorder_set_seqn(void)421 test_reorder_set_seqn(void)
422 {
423 struct rte_mempool *p = test_params->p;
424 struct rte_reorder_buffer *b = NULL;
425 const unsigned int num_bufs = 7;
426 const unsigned int size = 4;
427 unsigned int i;
428 int ret = 0;
429
430 struct rte_mbuf *bufs[num_bufs];
431
432 /* This would create a reorder buffer instance consisting of:
433 * reorder_seq = 0
434 * ready_buf: RB[size] = {NULL, NULL, NULL, NULL}
435 * order_buf: OB[size] = {NULL, NULL, NULL, NULL}
436 */
437 b = rte_reorder_create("test_min_seqn_set", rte_socket_id(), size);
438 TEST_ASSERT_NOT_NULL(b, "Failed to create reorder buffer");
439
440 for (i = 0; i < num_bufs; i++) {
441 bufs[i] = rte_pktmbuf_alloc(p);
442 if (bufs[i] == NULL) {
443 printf("Packet allocation failed\n");
444 goto exit;
445 }
446 *rte_reorder_seqn(bufs[i]) = i;
447 }
448
449 ret = rte_reorder_min_seqn_set(b, 5);
450 if (ret != 0) {
451 printf("%s:%d: Error in setting min sequence number\n", __func__, __LINE__);
452 ret = -1;
453 goto exit;
454 }
455
456 ret = rte_reorder_insert(b, bufs[0]);
457 if (ret >= 0) {
458 printf("%s:%d: Insertion with value less the min seq number\n", __func__, __LINE__);
459 ret = -1;
460 goto exit;
461 }
462
463 ret = rte_reorder_insert(b, bufs[5]);
464 if (ret != 0) {
465 printf("%s:%d: Error inserting packet with valid seqn\n", __func__, __LINE__);
466 ret = -1;
467 goto exit;
468 }
469 bufs[5] = NULL;
470
471 ret = rte_reorder_min_seqn_set(b, 0);
472 if (ret >= 0) {
473 printf("%s:%d: Error in setting min sequence number with non-empty buffer\n",
474 __func__, __LINE__);
475 ret = -1;
476 goto exit;
477 }
478
479 ret = 0;
480 exit:
481 rte_reorder_free(b);
482 for (i = 0; i < num_bufs; i++)
483 rte_pktmbuf_free(bufs[i]);
484
485 return ret;
486 }
487
488 static int
test_setup(void)489 test_setup(void)
490 {
491 /* reorder buffer instance creation */
492 if (test_params->b == NULL) {
493 test_params->b = rte_reorder_create("PKT_RO1", rte_socket_id(),
494 REORDER_BUFFER_SIZE);
495 if (test_params->b == NULL) {
496 printf("%s: Error creating reorder buffer instance b\n",
497 __func__);
498 return -1;
499 }
500 } else
501 rte_reorder_reset(test_params->b);
502
503 /* mempool creation */
504 if (test_params->p == NULL) {
505 test_params->p = rte_pktmbuf_pool_create("RO_MBUF_POOL",
506 NUM_MBUFS, BURST, 0, RTE_MBUF_DEFAULT_BUF_SIZE,
507 rte_socket_id());
508 if (test_params->p == NULL) {
509 printf("%s: Error creating mempool\n", __func__);
510 return -1;
511 }
512 }
513 return 0;
514 }
515
516 static void
test_teardown(void)517 test_teardown(void)
518 {
519 rte_reorder_free(test_params->b);
520 test_params->b = NULL;
521 rte_mempool_free(test_params->p);
522 test_params->p = NULL;
523 }
524
525
526 static struct unit_test_suite reorder_test_suite = {
527
528 .setup = test_setup,
529 .teardown = test_teardown,
530 .suite_name = "Reorder Unit Test Suite",
531 .unit_test_cases = {
532 TEST_CASE(test_reorder_create),
533 TEST_CASE(test_reorder_init),
534 TEST_CASE(test_reorder_find_existing),
535 TEST_CASE(test_reorder_free),
536 TEST_CASE(test_reorder_insert),
537 TEST_CASE(test_reorder_drain),
538 TEST_CASE(test_reorder_drain_up_to_seqn),
539 TEST_CASE(test_reorder_set_seqn),
540 TEST_CASES_END()
541 }
542 };
543
544 static int
test_reorder(void)545 test_reorder(void)
546 {
547 return unit_test_suite_runner(&reorder_test_suite);
548 }
549
550
551 REGISTER_FAST_TEST(reorder_autotest, true, true, test_reorder);
552