test/service: fix race condition on stopping lcore
[dpdk.git] / app / test / test_fib.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2018 Vladimir Medvedkin <medvedkinv@gmail.com>
3  * Copyright(c) 2019 Intel Corporation
4  */
5
6 #include <stdio.h>
7 #include <stdint.h>
8 #include <stdlib.h>
9
10 #include <rte_ip.h>
11 #include <rte_log.h>
12 #include <rte_fib.h>
13
14 #include "test.h"
15
16 typedef int32_t (*rte_fib_test)(void);
17
18 static int32_t test_create_invalid(void);
19 static int32_t test_multiple_create(void);
20 static int32_t test_free_null(void);
21 static int32_t test_add_del_invalid(void);
22 static int32_t test_get_invalid(void);
23 static int32_t test_lookup(void);
24
25 #define MAX_ROUTES      (1 << 16)
26 #define MAX_TBL8        (1 << 15)
27
28 /*
29  * Check that rte_fib_create fails gracefully for incorrect user input
30  * arguments
31  */
32 int32_t
33 test_create_invalid(void)
34 {
35         struct rte_fib *fib = NULL;
36         struct rte_fib_conf config;
37
38         config.max_routes = MAX_ROUTES;
39         config.default_nh = 0;
40         config.type = RTE_FIB_DUMMY;
41
42         /* rte_fib_create: fib name == NULL */
43         fib = rte_fib_create(NULL, SOCKET_ID_ANY, &config);
44         RTE_TEST_ASSERT(fib == NULL,
45                 "Call succeeded with invalid parameters\n");
46
47         /* rte_fib_create: config == NULL */
48         fib = rte_fib_create(__func__, SOCKET_ID_ANY, NULL);
49         RTE_TEST_ASSERT(fib == NULL,
50                 "Call succeeded with invalid parameters\n");
51
52         /* socket_id < -1 is invalid */
53         fib = rte_fib_create(__func__, -2, &config);
54         RTE_TEST_ASSERT(fib == NULL,
55                 "Call succeeded with invalid parameters\n");
56
57         /* rte_fib_create: max_routes = 0 */
58         config.max_routes = 0;
59         fib = rte_fib_create(__func__, SOCKET_ID_ANY, &config);
60         RTE_TEST_ASSERT(fib == NULL,
61                 "Call succeeded with invalid parameters\n");
62         config.max_routes = MAX_ROUTES;
63
64         config.type = RTE_FIB_TYPE_MAX;
65         fib = rte_fib_create(__func__, SOCKET_ID_ANY, &config);
66         RTE_TEST_ASSERT(fib == NULL,
67                 "Call succeeded with invalid parameters\n");
68
69         config.type = RTE_FIB_DIR24_8;
70         config.dir24_8.num_tbl8 = MAX_TBL8;
71
72         config.dir24_8.nh_sz = RTE_FIB_DIR24_8_8B + 1;
73         fib = rte_fib_create(__func__, SOCKET_ID_ANY, &config);
74         RTE_TEST_ASSERT(fib == NULL,
75                 "Call succeeded with invalid parameters\n");
76         config.dir24_8.nh_sz = RTE_FIB_DIR24_8_8B;
77
78         config.dir24_8.num_tbl8 = 0;
79         fib = rte_fib_create(__func__, SOCKET_ID_ANY, &config);
80         RTE_TEST_ASSERT(fib == NULL,
81                 "Call succeeded with invalid parameters\n");
82
83         return TEST_SUCCESS;
84 }
85
86 /*
87  * Create fib table then delete fib table 10 times
88  * Use a slightly different rules size each time
89  */
90 int32_t
91 test_multiple_create(void)
92 {
93         struct rte_fib *fib = NULL;
94         struct rte_fib_conf config;
95         int32_t i;
96
97         config.default_nh = 0;
98         config.type = RTE_FIB_DUMMY;
99
100         for (i = 0; i < 100; i++) {
101                 config.max_routes = MAX_ROUTES - i;
102                 fib = rte_fib_create(__func__, SOCKET_ID_ANY, &config);
103                 RTE_TEST_ASSERT(fib != NULL, "Failed to create FIB\n");
104                 rte_fib_free(fib);
105         }
106         /* Can not test free so return success */
107         return TEST_SUCCESS;
108 }
109
110 /*
111  * Call rte_fib_free for NULL pointer user input. Note: free has no return and
112  * therefore it is impossible to check for failure but this test is added to
113  * increase function coverage metrics and to validate that freeing null does
114  * not crash.
115  */
116 int32_t
117 test_free_null(void)
118 {
119         struct rte_fib *fib = NULL;
120         struct rte_fib_conf config;
121
122         config.max_routes = MAX_ROUTES;
123         config.default_nh = 0;
124         config.type = RTE_FIB_DUMMY;
125
126         fib = rte_fib_create(__func__, SOCKET_ID_ANY, &config);
127         RTE_TEST_ASSERT(fib != NULL, "Failed to create FIB\n");
128
129         rte_fib_free(fib);
130         rte_fib_free(NULL);
131         return TEST_SUCCESS;
132 }
133
134 /*
135  * Check that rte_fib_add and rte_fib_delete fails gracefully
136  * for incorrect user input arguments
137  */
138 int32_t
139 test_add_del_invalid(void)
140 {
141         struct rte_fib *fib = NULL;
142         struct rte_fib_conf config;
143         uint64_t nh = 100;
144         uint32_t ip = RTE_IPV4(0, 0, 0, 0);
145         int ret;
146         uint8_t depth = 24;
147
148         config.max_routes = MAX_ROUTES;
149         config.default_nh = 0;
150         config.type = RTE_FIB_DUMMY;
151
152         /* rte_fib_add: fib == NULL */
153         ret = rte_fib_add(NULL, ip, depth, nh);
154         RTE_TEST_ASSERT(ret < 0,
155                 "Call succeeded with invalid parameters\n");
156
157         /* rte_fib_delete: fib == NULL */
158         ret = rte_fib_delete(NULL, ip, depth);
159         RTE_TEST_ASSERT(ret < 0,
160                 "Call succeeded with invalid parameters\n");
161
162         /*Create valid fib to use in rest of test. */
163         fib = rte_fib_create(__func__, SOCKET_ID_ANY, &config);
164         RTE_TEST_ASSERT(fib != NULL, "Failed to create FIB\n");
165
166         /* rte_fib_add: depth > RTE_FIB_MAXDEPTH */
167         ret = rte_fib_add(fib, ip, RTE_FIB_MAXDEPTH + 1, nh);
168         RTE_TEST_ASSERT(ret < 0,
169                 "Call succeeded with invalid parameters\n");
170
171         /* rte_fib_delete: depth > RTE_FIB_MAXDEPTH */
172         ret = rte_fib_delete(fib, ip, RTE_FIB_MAXDEPTH + 1);
173         RTE_TEST_ASSERT(ret < 0,
174                 "Call succeeded with invalid parameters\n");
175
176         rte_fib_free(fib);
177
178         return TEST_SUCCESS;
179 }
180
181 /*
182  * Check that rte_fib_get_dp and rte_fib_get_rib fails gracefully
183  * for incorrect user input arguments
184  */
185 int32_t
186 test_get_invalid(void)
187 {
188         void *p;
189
190         p = rte_fib_get_dp(NULL);
191         RTE_TEST_ASSERT(p == NULL,
192                 "Call succeeded with invalid parameters\n");
193
194         p = rte_fib_get_rib(NULL);
195         RTE_TEST_ASSERT(p == NULL,
196                 "Call succeeded with invalid parameters\n");
197
198         return TEST_SUCCESS;
199 }
200
201 /*
202  * Add routes for one supernet with all possible depths and do lookup
203  * on each step
204  * After delete routes with doing lookup on each step
205  */
206 static int
207 lookup_and_check_asc(struct rte_fib *fib, uint32_t ip_arr[RTE_FIB_MAXDEPTH],
208         uint32_t ip_missing, uint64_t def_nh, uint32_t n)
209 {
210         uint64_t nh_arr[RTE_FIB_MAXDEPTH];
211         int ret;
212         uint32_t i = 0;
213
214         ret = rte_fib_lookup_bulk(fib, ip_arr, nh_arr, RTE_FIB_MAXDEPTH);
215         RTE_TEST_ASSERT(ret == 0, "Failed to lookup\n");
216
217         for (; i <= RTE_FIB_MAXDEPTH - n; i++)
218                 RTE_TEST_ASSERT(nh_arr[i] == n,
219                         "Failed to get proper nexthop\n");
220
221         for (; i < RTE_FIB_MAXDEPTH; i++)
222                 RTE_TEST_ASSERT(nh_arr[i] == --n,
223                         "Failed to get proper nexthop\n");
224
225         ret = rte_fib_lookup_bulk(fib, &ip_missing, nh_arr, 1);
226         RTE_TEST_ASSERT((ret == 0) && (nh_arr[0] == def_nh),
227                 "Failed to get proper nexthop\n");
228
229         return TEST_SUCCESS;
230 }
231
232 static int
233 lookup_and_check_desc(struct rte_fib *fib, uint32_t ip_arr[RTE_FIB_MAXDEPTH],
234         uint32_t ip_missing, uint64_t def_nh, uint32_t n)
235 {
236         uint64_t nh_arr[RTE_FIB_MAXDEPTH];
237         int ret;
238         uint32_t i = 0;
239
240         ret = rte_fib_lookup_bulk(fib, ip_arr, nh_arr, RTE_FIB_MAXDEPTH);
241         RTE_TEST_ASSERT(ret == 0, "Failed to lookup\n");
242
243         for (; i < n; i++)
244                 RTE_TEST_ASSERT(nh_arr[i] == RTE_FIB_MAXDEPTH - i,
245                         "Failed to get proper nexthop\n");
246
247         for (; i < RTE_FIB_MAXDEPTH; i++)
248                 RTE_TEST_ASSERT(nh_arr[i] == def_nh,
249                         "Failed to get proper nexthop\n");
250
251         ret = rte_fib_lookup_bulk(fib, &ip_missing, nh_arr, 1);
252         RTE_TEST_ASSERT((ret == 0) && (nh_arr[0] == def_nh),
253                 "Failed to get proper nexthop\n");
254
255         return TEST_SUCCESS;
256 }
257
258 static int
259 check_fib(struct rte_fib *fib)
260 {
261         uint64_t def_nh = 100;
262         uint32_t ip_arr[RTE_FIB_MAXDEPTH];
263         uint32_t ip_add = RTE_IPV4(128, 0, 0, 0);
264         uint32_t i, ip_missing = RTE_IPV4(127, 255, 255, 255);
265         int ret;
266
267         for (i = 0; i < RTE_FIB_MAXDEPTH; i++)
268                 ip_arr[i] = ip_add + (1ULL << i) - 1;
269
270         ret = lookup_and_check_desc(fib, ip_arr, ip_missing, def_nh, 0);
271         RTE_TEST_ASSERT(ret == TEST_SUCCESS, "Lookup and check fails\n");
272
273         for (i = 1; i <= RTE_FIB_MAXDEPTH; i++) {
274                 ret = rte_fib_add(fib, ip_add, i, i);
275                 RTE_TEST_ASSERT(ret == 0, "Failed to add a route\n");
276                 ret = lookup_and_check_asc(fib, ip_arr, ip_missing,
277                                 def_nh, i);
278                 RTE_TEST_ASSERT(ret == TEST_SUCCESS, "Lookup and check fails\n");
279         }
280
281         for (i = RTE_FIB_MAXDEPTH; i > 1; i--) {
282                 ret = rte_fib_delete(fib, ip_add, i);
283                 RTE_TEST_ASSERT(ret == 0, "Failed to delete a route\n");
284                 ret = lookup_and_check_asc(fib, ip_arr, ip_missing,
285                         def_nh, i - 1);
286
287                 RTE_TEST_ASSERT(ret == TEST_SUCCESS, "Lookup and check fails\n");
288         }
289         ret = rte_fib_delete(fib, ip_add, i);
290         RTE_TEST_ASSERT(ret == 0, "Failed to delete a route\n");
291         ret = lookup_and_check_desc(fib, ip_arr, ip_missing, def_nh, 0);
292         RTE_TEST_ASSERT(ret == TEST_SUCCESS, "Lookup and check fails\n");
293
294         for (i = 0; i < RTE_FIB_MAXDEPTH; i++) {
295                 ret = rte_fib_add(fib, ip_add, RTE_FIB_MAXDEPTH - i,
296                         RTE_FIB_MAXDEPTH - i);
297                 RTE_TEST_ASSERT(ret == 0, "Failed to add a route\n");
298                 ret = lookup_and_check_desc(fib, ip_arr, ip_missing,
299                         def_nh, i + 1);
300                 RTE_TEST_ASSERT(ret == TEST_SUCCESS, "Lookup and check fails\n");
301         }
302
303         for (i = 1; i <= RTE_FIB_MAXDEPTH; i++) {
304                 ret = rte_fib_delete(fib, ip_add, i);
305                 RTE_TEST_ASSERT(ret == 0, "Failed to delete a route\n");
306                 ret = lookup_and_check_desc(fib, ip_arr, ip_missing, def_nh,
307                         RTE_FIB_MAXDEPTH - i);
308                 RTE_TEST_ASSERT(ret == TEST_SUCCESS, "Lookup and check fails\n");
309         }
310
311         return TEST_SUCCESS;
312 }
313
314 int32_t
315 test_lookup(void)
316 {
317         struct rte_fib *fib = NULL;
318         struct rte_fib_conf config;
319         uint64_t def_nh = 100;
320         int ret;
321
322         config.max_routes = MAX_ROUTES;
323         config.default_nh = def_nh;
324         config.type = RTE_FIB_DUMMY;
325
326         fib = rte_fib_create(__func__, SOCKET_ID_ANY, &config);
327         RTE_TEST_ASSERT(fib != NULL, "Failed to create FIB\n");
328         ret = check_fib(fib);
329         RTE_TEST_ASSERT(ret == TEST_SUCCESS,
330                 "Check_fib fails for DUMMY type\n");
331         rte_fib_free(fib);
332
333         config.type = RTE_FIB_DIR24_8;
334
335         config.dir24_8.nh_sz = RTE_FIB_DIR24_8_1B;
336         config.dir24_8.num_tbl8 = 127;
337         fib = rte_fib_create(__func__, SOCKET_ID_ANY, &config);
338         RTE_TEST_ASSERT(fib != NULL, "Failed to create FIB\n");
339         ret = check_fib(fib);
340         RTE_TEST_ASSERT(ret == TEST_SUCCESS,
341                 "Check_fib fails for DIR24_8_1B type\n");
342         rte_fib_free(fib);
343
344         config.dir24_8.nh_sz = RTE_FIB_DIR24_8_2B;
345         config.dir24_8.num_tbl8 = MAX_TBL8 - 1;
346         fib = rte_fib_create(__func__, SOCKET_ID_ANY, &config);
347         RTE_TEST_ASSERT(fib != NULL, "Failed to create FIB\n");
348         ret = check_fib(fib);
349         RTE_TEST_ASSERT(ret == TEST_SUCCESS,
350                 "Check_fib fails for DIR24_8_2B type\n");
351         rte_fib_free(fib);
352
353         config.dir24_8.nh_sz = RTE_FIB_DIR24_8_4B;
354         config.dir24_8.num_tbl8 = MAX_TBL8;
355         fib = rte_fib_create(__func__, SOCKET_ID_ANY, &config);
356         RTE_TEST_ASSERT(fib != NULL, "Failed to create FIB\n");
357         ret = check_fib(fib);
358         RTE_TEST_ASSERT(ret == TEST_SUCCESS,
359                 "Check_fib fails for DIR24_8_4B type\n");
360         rte_fib_free(fib);
361
362         config.dir24_8.nh_sz = RTE_FIB_DIR24_8_8B;
363         config.dir24_8.num_tbl8 = MAX_TBL8;
364         fib = rte_fib_create(__func__, SOCKET_ID_ANY, &config);
365         RTE_TEST_ASSERT(fib != NULL, "Failed to create FIB\n");
366         ret = check_fib(fib);
367         RTE_TEST_ASSERT(ret == TEST_SUCCESS,
368                 "Check_fib fails for DIR24_8_8B type\n");
369         rte_fib_free(fib);
370
371         return TEST_SUCCESS;
372 }
373
374 static struct unit_test_suite fib_fast_tests = {
375         .suite_name = "fib autotest",
376         .setup = NULL,
377         .teardown = NULL,
378         .unit_test_cases = {
379         TEST_CASE(test_create_invalid),
380         TEST_CASE(test_free_null),
381         TEST_CASE(test_add_del_invalid),
382         TEST_CASE(test_get_invalid),
383         TEST_CASE(test_lookup),
384         TEST_CASES_END()
385         }
386 };
387
388 static struct unit_test_suite fib_slow_tests = {
389         .suite_name = "fib slow autotest",
390         .setup = NULL,
391         .teardown = NULL,
392         .unit_test_cases = {
393         TEST_CASE(test_multiple_create),
394         TEST_CASES_END()
395         }
396 };
397
398 /*
399  * Do all unit tests.
400  */
401 static int
402 test_fib(void)
403 {
404         return unit_test_suite_runner(&fib_fast_tests);
405 }
406
407 static int
408 test_slow_fib(void)
409 {
410         return unit_test_suite_runner(&fib_slow_tests);
411 }
412
413 REGISTER_TEST_COMMAND(fib_autotest, test_fib);
414 REGISTER_TEST_COMMAND(fib_slow_autotest, test_slow_fib);