1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2016-2017 Intel Corporation
3 */
4
5 #include <rte_memcpy.h>
6 #include <rte_malloc.h>
7 #include <rte_efd.h>
8 #include <rte_byteorder.h>
9 #include <rte_random.h>
10 #include <rte_debug.h>
11 #include <rte_ip.h>
12
13 #include "test.h"
14
15 #define EFD_TEST_KEY_LEN 8
16 #define TABLE_SIZE (1 << 21)
17 #define ITERATIONS 3
18
19 #if RTE_EFD_VALUE_NUM_BITS == 32
20 #define VALUE_BITMASK 0xffffffff
21 #else
22 #define VALUE_BITMASK ((1 << RTE_EFD_VALUE_NUM_BITS) - 1)
23 #endif
24 static unsigned int test_socket_id;
25
26 /* 5-tuple key type */
27 struct flow_key {
28 uint32_t ip_src;
29 uint32_t ip_dst;
30 uint16_t port_src;
31 uint16_t port_dst;
32 uint8_t proto;
33 } __rte_packed;
34
35 RTE_LOG_REGISTER(efd_logtype_test, test.efd, INFO);
36
37 /*
38 * Print out result of unit test efd operation.
39 */
print_key_info(const char * msg,const struct flow_key * key,efd_value_t val)40 static void print_key_info(const char *msg, const struct flow_key *key,
41 efd_value_t val)
42 {
43 const uint8_t *p = (const uint8_t *) key;
44 unsigned int i;
45
46 rte_log(RTE_LOG_DEBUG, efd_logtype_test, "%s key:0x", msg);
47 for (i = 0; i < sizeof(struct flow_key); i++)
48 rte_log(RTE_LOG_DEBUG, efd_logtype_test, "%02X", p[i]);
49
50 rte_log(RTE_LOG_DEBUG, efd_logtype_test, " @ val %d\n", val);
51 }
52
53 /* Keys used by unit test functions */
54 static struct flow_key keys[5] = {
55 {
56 .ip_src = RTE_IPV4(0x03, 0x02, 0x01, 0x00),
57 .ip_dst = RTE_IPV4(0x07, 0x06, 0x05, 0x04),
58 .port_src = 0x0908,
59 .port_dst = 0x0b0a,
60 .proto = 0x0c,
61 },
62 {
63 .ip_src = RTE_IPV4(0x13, 0x12, 0x11, 0x10),
64 .ip_dst = RTE_IPV4(0x17, 0x16, 0x15, 0x14),
65 .port_src = 0x1918,
66 .port_dst = 0x1b1a,
67 .proto = 0x1c,
68 },
69 {
70 .ip_src = RTE_IPV4(0x23, 0x22, 0x21, 0x20),
71 .ip_dst = RTE_IPV4(0x27, 0x26, 0x25, 0x24),
72 .port_src = 0x2928,
73 .port_dst = 0x2b2a,
74 .proto = 0x2c,
75 },
76 {
77 .ip_src = RTE_IPV4(0x33, 0x32, 0x31, 0x30),
78 .ip_dst = RTE_IPV4(0x37, 0x36, 0x35, 0x34),
79 .port_src = 0x3938,
80 .port_dst = 0x3b3a,
81 .proto = 0x3c,
82 },
83 {
84 .ip_src = RTE_IPV4(0x43, 0x42, 0x41, 0x40),
85 .ip_dst = RTE_IPV4(0x47, 0x46, 0x45, 0x44),
86 .port_src = 0x4948,
87 .port_dst = 0x4b4a,
88 .proto = 0x4c,
89 }
90 };
91 /* Array to store the data */
92 static efd_value_t data[5];
93
efd_get_all_sockets_bitmask(void)94 static inline uint8_t efd_get_all_sockets_bitmask(void)
95 {
96 uint8_t all_cpu_sockets_bitmask = 0;
97 unsigned int i;
98 unsigned int next_lcore = rte_get_main_lcore();
99 const int val_true = 1, val_false = 0;
100 for (i = 0; i < rte_lcore_count(); i++) {
101 all_cpu_sockets_bitmask |= 1 << rte_lcore_to_socket_id(next_lcore);
102 next_lcore = rte_get_next_lcore(next_lcore, val_false, val_true);
103 }
104
105 return all_cpu_sockets_bitmask;
106 }
107
108 /*
109 * Basic sequence of operations for a single key:
110 * - add
111 * - lookup (hit)
112 * - delete
113 * Note: lookup (miss) is not applicable since this is a filter
114 */
test_add_delete(void)115 static int test_add_delete(void)
116 {
117 struct rte_efd_table *handle;
118 /* test with standard add/lookup/delete functions */
119 efd_value_t prev_value;
120 printf("Entering %s\n", __func__);
121
122 handle = rte_efd_create("test_add_delete",
123 TABLE_SIZE, sizeof(struct flow_key),
124 efd_get_all_sockets_bitmask(), test_socket_id);
125 TEST_ASSERT_NOT_NULL(handle, "Error creating the EFD table\n");
126
127 data[0] = mrand48() & VALUE_BITMASK;
128 TEST_ASSERT_SUCCESS(rte_efd_update(handle, test_socket_id, &keys[0],
129 data[0]),
130 "Error inserting the key");
131 print_key_info("Add", &keys[0], data[0]);
132
133 TEST_ASSERT_EQUAL(rte_efd_lookup(handle, test_socket_id, &keys[0]),
134 data[0],
135 "failed to find key");
136
137 TEST_ASSERT_SUCCESS(rte_efd_delete(handle, test_socket_id, &keys[0],
138 &prev_value),
139 "failed to delete key");
140 TEST_ASSERT_EQUAL(prev_value, data[0],
141 "failed to delete the expected value, got %d, "
142 "expected %d", prev_value, data[0]);
143 print_key_info("Del", &keys[0], data[0]);
144
145 rte_efd_free(handle);
146
147 return 0;
148 }
149
150 /*
151 * Sequence of operations for a single key:
152 * - add
153 * - lookup: hit
154 * - add: update
155 * - lookup: hit (updated data)
156 * - delete: hit
157 */
test_add_update_delete(void)158 static int test_add_update_delete(void)
159 {
160 struct rte_efd_table *handle;
161 printf("Entering %s\n", __func__);
162 /* test with standard add/lookup/delete functions */
163 efd_value_t prev_value;
164 data[1] = mrand48() & VALUE_BITMASK;
165
166 handle = rte_efd_create("test_add_update_delete", TABLE_SIZE,
167 sizeof(struct flow_key),
168 efd_get_all_sockets_bitmask(), test_socket_id);
169 TEST_ASSERT_NOT_NULL(handle, "Error creating the efd table\n");
170
171 TEST_ASSERT_SUCCESS(rte_efd_update(handle, test_socket_id, &keys[1],
172 data[1]), "Error inserting the key");
173 print_key_info("Add", &keys[1], data[1]);
174
175 TEST_ASSERT_EQUAL(rte_efd_lookup(handle, test_socket_id, &keys[1]),
176 data[1], "failed to find key");
177 print_key_info("Lkp", &keys[1], data[1]);
178
179 data[1] = data[1] + 1;
180 TEST_ASSERT_SUCCESS(rte_efd_update(handle, test_socket_id, &keys[1],
181 data[1]), "Error re-inserting the key");
182 print_key_info("Add", &keys[1], data[1]);
183
184 TEST_ASSERT_EQUAL(rte_efd_lookup(handle, test_socket_id, &keys[1]),
185 data[1], "failed to find key");
186 print_key_info("Lkp", &keys[1], data[1]);
187
188 TEST_ASSERT_SUCCESS(rte_efd_delete(handle, test_socket_id, &keys[1],
189 &prev_value), "failed to delete key");
190 TEST_ASSERT_EQUAL(prev_value, data[1],
191 "failed to delete the expected value, got %d, "
192 "expected %d", prev_value, data[1]);
193 print_key_info("Del", &keys[1], data[1]);
194
195
196 rte_efd_free(handle);
197 return 0;
198 }
199
200 /*
201 * Sequence of operations for find existing EFD table
202 *
203 * - create table
204 * - find existing table: hit
205 * - find non-existing table: miss
206 *
207 */
test_efd_find_existing(void)208 static int test_efd_find_existing(void)
209 {
210 struct rte_efd_table *handle = NULL, *result = NULL;
211
212 printf("Entering %s\n", __func__);
213
214 /* Create EFD table. */
215 handle = rte_efd_create("efd_find_existing", TABLE_SIZE,
216 sizeof(struct flow_key),
217 efd_get_all_sockets_bitmask(), test_socket_id);
218 TEST_ASSERT_NOT_NULL(handle, "Error creating the efd table\n");
219
220 /* Try to find existing EFD table */
221 result = rte_efd_find_existing("efd_find_existing");
222 TEST_ASSERT_EQUAL(result, handle, "could not find existing efd table");
223
224 /* Try to find non-existing EFD table */
225 result = rte_efd_find_existing("efd_find_non_existing");
226 TEST_ASSERT_NULL(result, "found table that shouldn't exist");
227
228 /* Cleanup. */
229 rte_efd_free(handle);
230
231 return 0;
232 }
233
234 /*
235 * Sequence of operations for 5 keys
236 * - add keys
237 * - lookup keys: hit (bulk)
238 * - add keys (update)
239 * - lookup keys: hit (updated data)
240 * - delete keys : hit
241 */
test_five_keys(void)242 static int test_five_keys(void)
243 {
244 struct rte_efd_table *handle;
245 const void *key_array[5] = {0};
246 efd_value_t result[5] = {0};
247 efd_value_t prev_value;
248 unsigned int i;
249 printf("Entering %s\n", __func__);
250
251 handle = rte_efd_create("test_five_keys", TABLE_SIZE,
252 sizeof(struct flow_key),
253 efd_get_all_sockets_bitmask(), test_socket_id);
254 TEST_ASSERT_NOT_NULL(handle, "Error creating the efd table\n");
255
256 /* Setup data */
257 for (i = 0; i < 5; i++)
258 data[i] = mrand48() & VALUE_BITMASK;
259
260 /* Add */
261 for (i = 0; i < 5; i++) {
262 TEST_ASSERT_SUCCESS(rte_efd_update(handle, test_socket_id,
263 &keys[i], data[i]),
264 "Error inserting the key");
265 print_key_info("Add", &keys[i], data[i]);
266 }
267
268 /* Lookup */
269 for (i = 0; i < 5; i++)
270 key_array[i] = &keys[i];
271
272 rte_efd_lookup_bulk(handle, test_socket_id, 5,
273 (void *) &key_array, result);
274
275 for (i = 0; i < 5; i++) {
276 TEST_ASSERT_EQUAL(result[i], data[i],
277 "bulk: failed to find key. Expected %d, got %d",
278 data[i], result[i]);
279 print_key_info("Lkp", &keys[i], data[i]);
280 }
281
282 /* Modify data (bulk) */
283 for (i = 0; i < 5; i++)
284 data[i] = data[i] + 1;
285
286 /* Add - update */
287 for (i = 0; i < 5; i++) {
288 TEST_ASSERT_SUCCESS(rte_efd_update(handle, test_socket_id,
289 &keys[i], data[i]),
290 "Error inserting the key");
291 print_key_info("Add", &keys[i], data[i]);
292 }
293
294 /* Lookup */
295 for (i = 0; i < 5; i++) {
296 TEST_ASSERT_EQUAL(rte_efd_lookup(handle, test_socket_id,
297 &keys[i]), data[i],
298 "failed to find key");
299 print_key_info("Lkp", &keys[i], data[i]);
300 }
301
302 /* Delete */
303 for (i = 0; i < 5; i++) {
304 TEST_ASSERT_SUCCESS(rte_efd_delete(handle, test_socket_id,
305 &keys[i], &prev_value),
306 "failed to delete key");
307 TEST_ASSERT_EQUAL(prev_value, data[i],
308 "failed to delete the expected value, got %d, "
309 "expected %d", prev_value, data[i]);
310 print_key_info("Del", &keys[i], data[i]);
311 }
312
313
314 rte_efd_free(handle);
315
316 return 0;
317 }
318
319 /*
320 * Test to see the average table utilization (entries added/max entries)
321 * before hitting a random entry that cannot be added
322 */
test_average_table_utilization(void)323 static int test_average_table_utilization(void)
324 {
325 struct rte_efd_table *handle = NULL;
326 uint32_t num_rules_in = TABLE_SIZE;
327 uint8_t simple_key[EFD_TEST_KEY_LEN];
328 unsigned int i, j;
329 unsigned int added_keys, average_keys_added = 0;
330
331 printf("Evaluating table utilization and correctness, please wait\n");
332 fflush(stdout);
333
334 for (j = 0; j < ITERATIONS; j++) {
335 handle = rte_efd_create("test_efd", num_rules_in,
336 EFD_TEST_KEY_LEN, efd_get_all_sockets_bitmask(),
337 test_socket_id);
338 if (handle == NULL) {
339 printf("efd table creation failed\n");
340 return -1;
341 }
342
343 unsigned int succeeded = 0;
344 unsigned int lost_keys = 0;
345
346 /* Add random entries until key cannot be added */
347 for (added_keys = 0; added_keys < num_rules_in; added_keys++) {
348
349 for (i = 0; i < EFD_TEST_KEY_LEN; i++)
350 simple_key[i] = rte_rand() & 0xFF;
351
352 efd_value_t val = simple_key[0];
353
354 if (rte_efd_update(handle, test_socket_id, simple_key,
355 val))
356 break; /* continue;*/
357 if (rte_efd_lookup(handle, test_socket_id, simple_key)
358 != val)
359 lost_keys++;
360 else
361 succeeded++;
362 }
363
364 average_keys_added += succeeded;
365
366 /* Reset the table */
367 rte_efd_free(handle);
368
369 /* Print progress on operations */
370 printf("Added %10u Succeeded %10u Lost %10u\n",
371 added_keys, succeeded, lost_keys);
372 fflush(stdout);
373 }
374
375 average_keys_added /= ITERATIONS;
376
377 printf("\nAverage table utilization = %.2f%% (%u/%u)\n",
378 ((double) average_keys_added / num_rules_in * 100),
379 average_keys_added, num_rules_in);
380
381 return 0;
382 }
383
384 /*
385 * Do tests for EFD creation with bad parameters.
386 */
test_efd_creation_with_bad_parameters(void)387 static int test_efd_creation_with_bad_parameters(void)
388 {
389 struct rte_efd_table *handle, *tmp;
390 printf("Entering %s, **Errors are expected **\n", __func__);
391
392 handle = rte_efd_create("creation_with_bad_parameters_0", TABLE_SIZE, 0,
393 efd_get_all_sockets_bitmask(), test_socket_id);
394 if (handle != NULL) {
395 rte_efd_free(handle);
396 printf("Impossible creating EFD table successfully "
397 "if key_len in parameter is zero\n");
398 return -1;
399 }
400
401 handle = rte_efd_create("creation_with_bad_parameters_1", TABLE_SIZE,
402 sizeof(struct flow_key), 0, test_socket_id);
403 if (handle != NULL) {
404 rte_efd_free(handle);
405 printf("Impossible creating EFD table successfully "
406 "with invalid socket bitmask\n");
407 return -1;
408 }
409
410 handle = rte_efd_create("creation_with_bad_parameters_2", TABLE_SIZE,
411 sizeof(struct flow_key), efd_get_all_sockets_bitmask(),
412 255);
413 if (handle != NULL) {
414 rte_efd_free(handle);
415 printf("Impossible creating EFD table successfully "
416 "with invalid socket\n");
417 return -1;
418 }
419
420 /* test with same name should fail */
421 handle = rte_efd_create("same_name", TABLE_SIZE,
422 sizeof(struct flow_key),
423 efd_get_all_sockets_bitmask(), 0);
424 if (handle == NULL) {
425 printf("Cannot create first EFD table with 'same_name'\n");
426 return -1;
427 }
428 tmp = rte_efd_create("same_name", TABLE_SIZE, sizeof(struct flow_key),
429 efd_get_all_sockets_bitmask(), 0);
430 if (tmp != NULL) {
431 printf("Creation of EFD table with same name should fail\n");
432 rte_efd_free(handle);
433 rte_efd_free(tmp);
434 return -1;
435 }
436 rte_efd_free(handle);
437
438 printf("# Test successful. No more errors expected\n");
439
440 return 0;
441 }
442
443 static int
test_efd(void)444 test_efd(void)
445 {
446
447 /* Unit tests */
448 if (test_add_delete() < 0)
449 return -1;
450 if (test_efd_find_existing() < 0)
451 return -1;
452 if (test_add_update_delete() < 0)
453 return -1;
454 if (test_five_keys() < 0)
455 return -1;
456 if (test_efd_creation_with_bad_parameters() < 0)
457 return -1;
458 if (test_average_table_utilization() < 0)
459 return -1;
460
461 return 0;
462 }
463
464 REGISTER_TEST_COMMAND(efd_autotest, test_efd);
465