1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2014 Intel Corporation 3 */ 4 5 #include <string.h> 6 #include <stdio.h> 7 #include <stdlib.h> 8 #include <stdint.h> 9 #include <inttypes.h> 10 #include <stdarg.h> 11 #include <errno.h> 12 #include <sys/queue.h> 13 14 #include <rte_common.h> 15 #include <rte_log.h> 16 #include <rte_debug.h> 17 #include <rte_memory.h> 18 #include <rte_launch.h> 19 #include <rte_cycles.h> 20 #include <rte_eal.h> 21 #include <rte_per_lcore.h> 22 #include <rte_lcore.h> 23 #include <rte_atomic.h> 24 #include <rte_branch_prediction.h> 25 #include <rte_ring.h> 26 #include <rte_mempool.h> 27 #include <rte_spinlock.h> 28 #include <rte_malloc.h> 29 30 #ifdef RTE_LIBRTE_HASH 31 #include <rte_hash.h> 32 #include <rte_fbk_hash.h> 33 #include <rte_jhash.h> 34 #endif /* RTE_LIBRTE_HASH */ 35 36 #ifdef RTE_LIBRTE_LPM 37 #include <rte_lpm.h> 38 #endif /* RTE_LIBRTE_LPM */ 39 40 #include <rte_string_fns.h> 41 42 #include "test.h" 43 44 typedef int (*case_func_t)(void* arg); 45 typedef void (*case_clean_t)(unsigned lcore_id); 46 47 #define MAX_STRING_SIZE (256) 48 #define MAX_ITER_MULTI (16) 49 #define MAX_ITER_ONCE (4) 50 #define MAX_LPM_ITER_TIMES (6) 51 52 #define MEMPOOL_ELT_SIZE (sizeof(uint32_t)) 53 #define MEMPOOL_SIZE (4) 54 55 #define MAX_LCORES (RTE_MAX_MEMZONE / (MAX_ITER_MULTI * 4U)) 56 57 static rte_atomic32_t obj_count = RTE_ATOMIC32_INIT(0); 58 static rte_atomic32_t synchro = RTE_ATOMIC32_INIT(0); 59 60 #define WAIT_SYNCHRO_FOR_SLAVES() do{ \ 61 if (lcore_self != rte_get_master_lcore()) \ 62 while (rte_atomic32_read(&synchro) == 0); \ 63 } while(0) 64 65 /* 66 * rte_eal_init only init once 67 */ 68 static int 69 test_eal_init_once(__attribute__((unused)) void *arg) 70 { 71 unsigned lcore_self = rte_lcore_id(); 72 73 WAIT_SYNCHRO_FOR_SLAVES(); 74 75 rte_atomic32_set(&obj_count, 1); /* silent the check in the caller */ 76 if (rte_eal_init(0, NULL) != -1) 77 return -1; 78 79 return 0; 80 } 81 82 /* 83 * ring create/lookup reentrancy test 84 */ 85 static void 86 ring_clean(unsigned int lcore_id) 87 { 88 struct rte_ring *rp; 89 char ring_name[MAX_STRING_SIZE]; 90 int i; 91 92 for (i = 0; i < MAX_ITER_MULTI; i++) { 93 snprintf(ring_name, sizeof(ring_name), 94 "fr_test_%d_%d", lcore_id, i); 95 rp = rte_ring_lookup(ring_name); 96 if (rp != NULL) 97 rte_ring_free(rp); 98 } 99 } 100 101 static int 102 ring_create_lookup(__attribute__((unused)) void *arg) 103 { 104 unsigned lcore_self = rte_lcore_id(); 105 struct rte_ring * rp; 106 char ring_name[MAX_STRING_SIZE]; 107 int i; 108 109 WAIT_SYNCHRO_FOR_SLAVES(); 110 111 /* create the same ring simultaneously on all threads */ 112 for (i = 0; i < MAX_ITER_ONCE; i++) { 113 rp = rte_ring_create("fr_test_once", 4096, SOCKET_ID_ANY, 0); 114 if (rp != NULL) 115 rte_atomic32_inc(&obj_count); 116 } 117 118 /* create/lookup new ring several times */ 119 for (i = 0; i < MAX_ITER_MULTI; i++) { 120 snprintf(ring_name, sizeof(ring_name), "fr_test_%d_%d", lcore_self, i); 121 rp = rte_ring_create(ring_name, 4096, SOCKET_ID_ANY, 0); 122 if (NULL == rp) 123 return -1; 124 if (rte_ring_lookup(ring_name) != rp) 125 return -1; 126 127 /* verify all ring created successful */ 128 if (rte_ring_lookup(ring_name) == NULL) 129 return -1; 130 } 131 132 return 0; 133 } 134 135 static void 136 my_obj_init(struct rte_mempool *mp, __attribute__((unused)) void *arg, 137 void *obj, unsigned i) 138 { 139 uint32_t *objnum = obj; 140 memset(obj, 0, mp->elt_size); 141 *objnum = i; 142 } 143 144 static void 145 mempool_clean(unsigned int lcore_id) 146 { 147 struct rte_mempool *mp; 148 char mempool_name[MAX_STRING_SIZE]; 149 int i; 150 151 /* verify all ring created successful */ 152 for (i = 0; i < MAX_ITER_MULTI; i++) { 153 snprintf(mempool_name, sizeof(mempool_name), "fr_test_%d_%d", 154 lcore_id, i); 155 mp = rte_mempool_lookup(mempool_name); 156 if (mp != NULL) 157 rte_mempool_free(mp); 158 } 159 } 160 161 static int 162 mempool_create_lookup(__attribute__((unused)) void *arg) 163 { 164 unsigned lcore_self = rte_lcore_id(); 165 struct rte_mempool * mp; 166 char mempool_name[MAX_STRING_SIZE]; 167 int i; 168 169 WAIT_SYNCHRO_FOR_SLAVES(); 170 171 /* create the same mempool simultaneously on all threads */ 172 for (i = 0; i < MAX_ITER_ONCE; i++) { 173 mp = rte_mempool_create("fr_test_once", MEMPOOL_SIZE, 174 MEMPOOL_ELT_SIZE, 0, 0, 175 NULL, NULL, 176 my_obj_init, NULL, 177 SOCKET_ID_ANY, 0); 178 if (mp != NULL) 179 rte_atomic32_inc(&obj_count); 180 } 181 182 /* create/lookup new ring several times */ 183 for (i = 0; i < MAX_ITER_MULTI; i++) { 184 snprintf(mempool_name, sizeof(mempool_name), "fr_test_%d_%d", lcore_self, i); 185 mp = rte_mempool_create(mempool_name, MEMPOOL_SIZE, 186 MEMPOOL_ELT_SIZE, 0, 0, 187 NULL, NULL, 188 my_obj_init, NULL, 189 SOCKET_ID_ANY, 0); 190 if (NULL == mp) 191 return -1; 192 if (rte_mempool_lookup(mempool_name) != mp) 193 return -1; 194 195 /* verify all ring created successful */ 196 if (rte_mempool_lookup(mempool_name) == NULL) 197 return -1; 198 } 199 200 return 0; 201 } 202 203 #ifdef RTE_LIBRTE_HASH 204 static void 205 hash_clean(unsigned lcore_id) 206 { 207 char hash_name[MAX_STRING_SIZE]; 208 struct rte_hash *handle; 209 int i; 210 211 for (i = 0; i < MAX_ITER_MULTI; i++) { 212 snprintf(hash_name, sizeof(hash_name), "fr_test_%d_%d", lcore_id, i); 213 214 if ((handle = rte_hash_find_existing(hash_name)) != NULL) 215 rte_hash_free(handle); 216 } 217 } 218 219 static int 220 hash_create_free(__attribute__((unused)) void *arg) 221 { 222 unsigned lcore_self = rte_lcore_id(); 223 struct rte_hash *handle; 224 char hash_name[MAX_STRING_SIZE]; 225 int i; 226 struct rte_hash_parameters hash_params = { 227 .name = NULL, 228 .entries = 16, 229 .key_len = 4, 230 .hash_func = (rte_hash_function)rte_jhash_32b, 231 .hash_func_init_val = 0, 232 .socket_id = 0, 233 }; 234 235 WAIT_SYNCHRO_FOR_SLAVES(); 236 237 /* create the same hash simultaneously on all threads */ 238 hash_params.name = "fr_test_once"; 239 for (i = 0; i < MAX_ITER_ONCE; i++) { 240 handle = rte_hash_create(&hash_params); 241 if (handle != NULL) 242 rte_atomic32_inc(&obj_count); 243 } 244 245 /* create mutiple times simultaneously */ 246 for (i = 0; i < MAX_ITER_MULTI; i++) { 247 snprintf(hash_name, sizeof(hash_name), "fr_test_%d_%d", lcore_self, i); 248 hash_params.name = hash_name; 249 250 handle = rte_hash_create(&hash_params); 251 if (NULL == handle) 252 return -1; 253 254 /* verify correct existing and then free all */ 255 if (handle != rte_hash_find_existing(hash_name)) 256 return -1; 257 258 rte_hash_free(handle); 259 260 /* verify free correct */ 261 if (NULL != rte_hash_find_existing(hash_name)) 262 return -1; 263 } 264 265 return 0; 266 } 267 268 static void 269 fbk_clean(unsigned lcore_id) 270 { 271 char fbk_name[MAX_STRING_SIZE]; 272 struct rte_fbk_hash_table *handle; 273 int i; 274 275 for (i = 0; i < MAX_ITER_MULTI; i++) { 276 snprintf(fbk_name, sizeof(fbk_name), "fr_test_%d_%d", lcore_id, i); 277 278 if ((handle = rte_fbk_hash_find_existing(fbk_name)) != NULL) 279 rte_fbk_hash_free(handle); 280 } 281 } 282 283 static int 284 fbk_create_free(__attribute__((unused)) void *arg) 285 { 286 unsigned lcore_self = rte_lcore_id(); 287 struct rte_fbk_hash_table *handle; 288 char fbk_name[MAX_STRING_SIZE]; 289 int i; 290 struct rte_fbk_hash_params fbk_params = { 291 .name = NULL, 292 .entries = 4, 293 .entries_per_bucket = 4, 294 .socket_id = 0, 295 .hash_func = rte_jhash_1word, 296 .init_val = RTE_FBK_HASH_INIT_VAL_DEFAULT, 297 }; 298 299 WAIT_SYNCHRO_FOR_SLAVES(); 300 301 /* create the same fbk hash table simultaneously on all threads */ 302 fbk_params.name = "fr_test_once"; 303 for (i = 0; i < MAX_ITER_ONCE; i++) { 304 handle = rte_fbk_hash_create(&fbk_params); 305 if (handle != NULL) 306 rte_atomic32_inc(&obj_count); 307 } 308 309 /* create mutiple fbk tables simultaneously */ 310 for (i = 0; i < MAX_ITER_MULTI; i++) { 311 snprintf(fbk_name, sizeof(fbk_name), "fr_test_%d_%d", lcore_self, i); 312 fbk_params.name = fbk_name; 313 314 handle = rte_fbk_hash_create(&fbk_params); 315 if (NULL == handle) 316 return -1; 317 318 /* verify correct existing and then free all */ 319 if (handle != rte_fbk_hash_find_existing(fbk_name)) 320 return -1; 321 322 rte_fbk_hash_free(handle); 323 324 /* verify free correct */ 325 if (NULL != rte_fbk_hash_find_existing(fbk_name)) 326 return -1; 327 } 328 329 return 0; 330 } 331 #endif /* RTE_LIBRTE_HASH */ 332 333 #ifdef RTE_LIBRTE_LPM 334 static void 335 lpm_clean(unsigned int lcore_id) 336 { 337 char lpm_name[MAX_STRING_SIZE]; 338 struct rte_lpm *lpm; 339 int i; 340 341 for (i = 0; i < MAX_LPM_ITER_TIMES; i++) { 342 snprintf(lpm_name, sizeof(lpm_name), "fr_test_%d_%d", lcore_id, i); 343 344 if ((lpm = rte_lpm_find_existing(lpm_name)) != NULL) 345 rte_lpm_free(lpm); 346 } 347 } 348 349 static int 350 lpm_create_free(__attribute__((unused)) void *arg) 351 { 352 unsigned lcore_self = rte_lcore_id(); 353 struct rte_lpm *lpm; 354 struct rte_lpm_config config; 355 356 config.max_rules = 4; 357 config.number_tbl8s = 256; 358 config.flags = 0; 359 char lpm_name[MAX_STRING_SIZE]; 360 int i; 361 362 WAIT_SYNCHRO_FOR_SLAVES(); 363 364 /* create the same lpm simultaneously on all threads */ 365 for (i = 0; i < MAX_ITER_ONCE; i++) { 366 lpm = rte_lpm_create("fr_test_once", SOCKET_ID_ANY, &config); 367 if (lpm != NULL) 368 rte_atomic32_inc(&obj_count); 369 } 370 371 /* create mutiple fbk tables simultaneously */ 372 for (i = 0; i < MAX_LPM_ITER_TIMES; i++) { 373 snprintf(lpm_name, sizeof(lpm_name), "fr_test_%d_%d", lcore_self, i); 374 lpm = rte_lpm_create(lpm_name, SOCKET_ID_ANY, &config); 375 if (NULL == lpm) 376 return -1; 377 378 /* verify correct existing and then free all */ 379 if (lpm != rte_lpm_find_existing(lpm_name)) 380 return -1; 381 382 rte_lpm_free(lpm); 383 384 /* verify free correct */ 385 if (NULL != rte_lpm_find_existing(lpm_name)) 386 return -1; 387 } 388 389 return 0; 390 } 391 #endif /* RTE_LIBRTE_LPM */ 392 393 struct test_case{ 394 case_func_t func; 395 void* arg; 396 case_clean_t clean; 397 char name[MAX_STRING_SIZE]; 398 }; 399 400 /* All test cases in the test suite */ 401 struct test_case test_cases[] = { 402 { test_eal_init_once, NULL, NULL, "eal init once" }, 403 { ring_create_lookup, NULL, ring_clean, "ring create/lookup" }, 404 { mempool_create_lookup, NULL, mempool_clean, 405 "mempool create/lookup" }, 406 #ifdef RTE_LIBRTE_HASH 407 { hash_create_free, NULL, hash_clean, "hash create/free" }, 408 { fbk_create_free, NULL, fbk_clean, "fbk create/free" }, 409 #endif /* RTE_LIBRTE_HASH */ 410 #ifdef RTE_LIBRTE_LPM 411 { lpm_create_free, NULL, lpm_clean, "lpm create/free" }, 412 #endif /* RTE_LIBRTE_LPM */ 413 }; 414 415 /** 416 * launch test case in two separate thread 417 */ 418 static int 419 launch_test(struct test_case *pt_case) 420 { 421 int ret = 0; 422 unsigned lcore_id; 423 unsigned cores_save = rte_lcore_count(); 424 unsigned cores = RTE_MIN(cores_save, MAX_LCORES); 425 unsigned count; 426 427 if (pt_case->func == NULL) 428 return -1; 429 430 rte_atomic32_set(&obj_count, 0); 431 rte_atomic32_set(&synchro, 0); 432 433 RTE_LCORE_FOREACH_SLAVE(lcore_id) { 434 if (cores == 1) 435 break; 436 cores--; 437 rte_eal_remote_launch(pt_case->func, pt_case->arg, lcore_id); 438 } 439 440 rte_atomic32_set(&synchro, 1); 441 442 if (pt_case->func(pt_case->arg) < 0) 443 ret = -1; 444 445 cores = cores_save; 446 RTE_LCORE_FOREACH_SLAVE(lcore_id) { 447 if (cores == 1) 448 break; 449 cores--; 450 if (rte_eal_wait_lcore(lcore_id) < 0) 451 ret = -1; 452 453 if (pt_case->clean != NULL) 454 pt_case->clean(lcore_id); 455 } 456 457 count = rte_atomic32_read(&obj_count); 458 if (count != 1) { 459 printf("%s: common object allocated %d times (should be 1)\n", 460 pt_case->name, count); 461 ret = -1; 462 } 463 464 return ret; 465 } 466 467 /** 468 * Main entry of func_reentrancy test 469 */ 470 static int 471 test_func_reentrancy(void) 472 { 473 uint32_t case_id; 474 struct test_case *pt_case = NULL; 475 476 if (rte_lcore_count() < 2) { 477 printf("Not enough cores for func_reentrancy_autotest, expecting at least 2\n"); 478 return TEST_SKIPPED; 479 } 480 else if (rte_lcore_count() > MAX_LCORES) 481 printf("Too many lcores, some cores will be disabled\n"); 482 483 for (case_id = 0; case_id < sizeof(test_cases)/sizeof(struct test_case); case_id ++) { 484 pt_case = &test_cases[case_id]; 485 if (pt_case->func == NULL) 486 continue; 487 488 if (launch_test(pt_case) < 0) { 489 printf("Func-ReEnt CASE %"PRIu32": %s FAIL\n", case_id, pt_case->name); 490 return -1; 491 } 492 printf("Func-ReEnt CASE %"PRIu32": %s PASS\n", case_id, pt_case->name); 493 } 494 495 return 0; 496 } 497 498 REGISTER_TEST_COMMAND(func_reentrancy_autotest, test_func_reentrancy); 499