app/test/test_service_cores.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Intel Corporation
   3  */
   4
   5 #include <rte_common.h>
   6 #include <rte_hexdump.h>
   7 #include <rte_mbuf.h>
   8 #include <rte_malloc.h>
   9 #include <rte_memcpy.h>
  10 #include <rte_cycles.h>
  11
  12 #include <rte_service.h>
  13 #include <rte_service_component.h>
  14
  15 #include "test.h"
  16
  17 /* used as the service core ID */
  18 static uint32_t slcore_id;
  19 /* used as timestamp to detect if a service core is running */
  20 static uint64_t service_tick;
  21 /* used as a flag to check if a function was run */
  22 static uint32_t service_remote_launch_flag;
  23
  24 #define SERVICE_DELAY 1
  25
  26 #define DUMMY_SERVICE_NAME "dummy_service"
  27 #define MT_SAFE_SERVICE_NAME "mt_safe_service"
  28
  29 static int
  30 testsuite_setup(void)
  31 {
  32         slcore_id = rte_get_next_lcore(/* start core */ -1,
  33                                        /* skip main */ 1,
  34                                        /* wrap */ 0);
  35
  36         return TEST_SUCCESS;
  37 }
  38
  39 static void
  40 testsuite_teardown(void)
  41 {
  42         /* release service cores? */
  43 }
  44
  45 static int32_t dummy_cb(void *args)
  46 {
  47         RTE_SET_USED(args);
  48         service_tick++;
  49         rte_delay_ms(SERVICE_DELAY);
  50         return 0;
  51 }
  52
  53 static int32_t dummy_mt_unsafe_cb(void *args)
  54 {
  55         /* before running test, the initialization has set pass_test to 1.
  56          * If the cmpset in service-cores is working correctly, the code here
  57          * should never fail to take the lock. If the lock *is* taken, fail the
  58          * test, because two threads are concurrently in a non-MT safe callback.
  59          */
  60         uint32_t *test_params = args;
  61         uint32_t *atomic_lock = &test_params[0];
  62         uint32_t *pass_test = &test_params[1];
  63         int lock_taken = rte_atomic32_cmpset(atomic_lock, 0, 1);
  64         if (lock_taken) {
  65                 /* delay with the lock held */
  66                 rte_delay_ms(250);
  67                 rte_atomic32_clear((rte_atomic32_t *)atomic_lock);
  68         } else {
  69                 /* 2nd thread will fail to take lock, so set pass flag */
  70                 *pass_test = 0;
  71         }
  72
  73         return 0;
  74 }
  75
  76
  77 static int32_t dummy_mt_safe_cb(void *args)
  78 {
  79         /* Atomic checks to ensure MT safe services allow > 1 thread to
  80          * concurrently run the callback. The concept is as follows;
  81          * 1) if lock is available, take the lock then delay
  82          * 2) if first lock is taken, and a thread arrives in the CB, we know
  83          *    that 2 threads are running the callback at the same time: MT safe
  84          */
  85         uint32_t *test_params = args;
  86         uint32_t *atomic_lock = &test_params[0];
  87         uint32_t *pass_test = &test_params[1];
  88         int lock_taken = rte_atomic32_cmpset(atomic_lock, 0, 1);
  89         if (lock_taken) {
  90                 /* delay with the lock held */
  91                 rte_delay_ms(250);
  92                 rte_atomic32_clear((rte_atomic32_t *)atomic_lock);
  93         } else {
  94                 /* 2nd thread will fail to take lock, so set pass flag */
  95                 *pass_test = 1;
  96         }
  97
  98         return 0;
  99 }
 100
 101 /* unregister all services */
 102 static int
 103 unregister_all(void)
 104 {
 105         uint32_t i;
 106
 107         TEST_ASSERT_EQUAL(-EINVAL, rte_service_component_unregister(1000),
 108                         "Unregistered invalid service id");
 109
 110         uint32_t c = rte_service_get_count();
 111         for (i = 0; i < c; i++) {
 112                 TEST_ASSERT_EQUAL(0, rte_service_component_unregister(i),
 113                                 "Error unregistering a valid service");
 114         }
 115
 116         rte_service_lcore_reset_all();
 117         rte_eal_mp_wait_lcore();
 118
 119         return TEST_SUCCESS;
 120 }
 121
 122 /* Wait until service lcore not active, or for 100x SERVICE_DELAY */
 123 static void
 124 wait_slcore_inactive(uint32_t slcore_id)
 125 {
 126         int i;
 127
 128         for (i = 0; rte_service_lcore_may_be_active(slcore_id) == 1 &&
 129                         i < 100; i++)
 130                 rte_delay_ms(SERVICE_DELAY);
 131 }
 132
 133 /* register a single dummy service */
 134 static int
 135 dummy_register(void)
 136 {
 137         /* make sure there are no remains from previous tests */
 138         unregister_all();
 139
 140         struct rte_service_spec service;
 141         memset(&service, 0, sizeof(struct rte_service_spec));
 142
 143         TEST_ASSERT_EQUAL(-EINVAL,
 144                         rte_service_component_register(&service, NULL),
 145                         "Invalid callback");
 146         service.callback = dummy_cb;
 147
 148         TEST_ASSERT_EQUAL(-EINVAL,
 149                         rte_service_component_register(&service, NULL),
 150                         "Invalid name");
 151         snprintf(service.name, sizeof(service.name), DUMMY_SERVICE_NAME);
 152
 153         uint32_t id;
 154         TEST_ASSERT_EQUAL(0, rte_service_component_register(&service, &id),
 155                         "Failed to register valid service");
 156
 157         rte_service_component_runstate_set(id, 1);
 158
 159         return TEST_SUCCESS;
 160 }
 161
 162 /* verify get_by_name() service lookup */
 163 static int
 164 service_get_by_name(void)
 165 {
 166         unregister_all();
 167
 168         uint32_t sid;
 169         TEST_ASSERT_EQUAL(-ENODEV,
 170                         rte_service_get_by_name(DUMMY_SERVICE_NAME, &sid),
 171                         "get by name with invalid name should return -ENODEV");
 172         TEST_ASSERT_EQUAL(-EINVAL,
 173                         rte_service_get_by_name(DUMMY_SERVICE_NAME, 0x0),
 174                         "get by name with NULL ptr should return -ENODEV");
 175
 176         /* register service */
 177         struct rte_service_spec service;
 178         memset(&service, 0, sizeof(struct rte_service_spec));
 179         TEST_ASSERT_EQUAL(-EINVAL,
 180                         rte_service_component_register(&service, NULL),
 181                         "Invalid callback");
 182         service.callback = dummy_cb;
 183         TEST_ASSERT_EQUAL(-EINVAL,
 184                         rte_service_component_register(&service, NULL),
 185                         "Invalid name");
 186         snprintf(service.name, sizeof(service.name), DUMMY_SERVICE_NAME);
 187         TEST_ASSERT_EQUAL(0, rte_service_component_register(&service, NULL),
 188                         "Failed to register valid service");
 189
 190         /* we unregistered all service, now registering 1, should be id 0 */
 191         uint32_t service_id_as_expected = 0;
 192         TEST_ASSERT_EQUAL(0, rte_service_get_by_name(DUMMY_SERVICE_NAME, &sid),
 193                         "Service get_by_name should return 0 on valid inputs");
 194         TEST_ASSERT_EQUAL(service_id_as_expected, sid,
 195                         "Service get_by_name should equal expected id");
 196
 197         unregister_all();
 198
 199         /* ensure after unregister, get_by_name returns NULL */
 200         TEST_ASSERT_EQUAL(-ENODEV,
 201                         rte_service_get_by_name(DUMMY_SERVICE_NAME, &sid),
 202                         "get by name should return -ENODEV after unregister");
 203
 204         return TEST_SUCCESS;
 205 }
 206
 207 /* verify probe of capabilities */
 208 static int
 209 service_probe_capability(void)
 210 {
 211         unregister_all();
 212
 213         struct rte_service_spec service;
 214         memset(&service, 0, sizeof(struct rte_service_spec));
 215         service.callback = dummy_cb;
 216         snprintf(service.name, sizeof(service.name), DUMMY_SERVICE_NAME);
 217         service.capabilities |= RTE_SERVICE_CAP_MT_SAFE;
 218         TEST_ASSERT_EQUAL(0, rte_service_component_register(&service, NULL),
 219                         "Register of MT SAFE service failed");
 220
 221         /* verify flag is enabled */
 222         const uint32_t sid = 0;
 223         int32_t mt = rte_service_probe_capability(sid, RTE_SERVICE_CAP_MT_SAFE);
 224         TEST_ASSERT_EQUAL(1, mt, "MT SAFE capability flag not set.");
 225
 226
 227         unregister_all();
 228
 229         memset(&service, 0, sizeof(struct rte_service_spec));
 230         service.callback = dummy_cb;
 231         snprintf(service.name, sizeof(service.name), DUMMY_SERVICE_NAME);
 232         TEST_ASSERT_EQUAL(0, rte_service_component_register(&service, NULL),
 233                         "Register of non-MT safe service failed");
 234
 235         /* verify flag is enabled */
 236         mt = rte_service_probe_capability(sid, RTE_SERVICE_CAP_MT_SAFE);
 237         TEST_ASSERT_EQUAL(0, mt, "MT SAFE cap flag set on non MT SAFE service");
 238
 239         return unregister_all();
 240 }
 241
 242 /* verify the service name */
 243 static int
 244 service_name(void)
 245 {
 246         const char *name = rte_service_get_name(0);
 247         int equal = strcmp(name, DUMMY_SERVICE_NAME);
 248         TEST_ASSERT_EQUAL(0, equal, "Error: Service name not correct");
 249
 250         return unregister_all();
 251 }
 252
 253 /* verify service attr get */
 254 static int
 255 service_attr_get(void)
 256 {
 257         /* ensure all services unregistered so cycle counts are zero */
 258         unregister_all();
 259
 260         struct rte_service_spec service;
 261         memset(&service, 0, sizeof(struct rte_service_spec));
 262         service.callback = dummy_cb;
 263         snprintf(service.name, sizeof(service.name), DUMMY_SERVICE_NAME);
 264         service.capabilities |= RTE_SERVICE_CAP_MT_SAFE;
 265         uint32_t id;
 266         TEST_ASSERT_EQUAL(0, rte_service_component_register(&service, &id),
 267                         "Register of  service failed");
 268         rte_service_component_runstate_set(id, 1);
 269         TEST_ASSERT_EQUAL(0, rte_service_runstate_set(id, 1),
 270                         "Error: Service start returned non-zero");
 271         rte_service_set_stats_enable(id, 1);
 272
 273         uint32_t attr_id = UINT32_MAX;
 274         uint64_t attr_value = 0xdead;
 275         /* check error return values */
 276         TEST_ASSERT_EQUAL(-EINVAL, rte_service_attr_get(id, attr_id,
 277                                                         &attr_value),
 278                         "Invalid attr_id didn't return -EINVAL");
 279
 280         attr_id = RTE_SERVICE_ATTR_CYCLES;
 281         TEST_ASSERT_EQUAL(-EINVAL, rte_service_attr_get(UINT32_MAX, attr_id,
 282                                                         &attr_value),
 283                         "Invalid service id didn't return -EINVAL");
 284
 285         TEST_ASSERT_EQUAL(-EINVAL, rte_service_attr_get(id, attr_id, NULL),
 286                         "Invalid attr_value pointer id didn't return -EINVAL");
 287
 288         /* check correct (zero) return value and correct value (zero) */
 289         TEST_ASSERT_EQUAL(0, rte_service_attr_get(id, attr_id, &attr_value),
 290                         "Valid attr_get() call didn't return success");
 291         TEST_ASSERT_EQUAL(0, attr_value,
 292                         "attr_get() call didn't set correct cycles (zero)");
 293         /* check correct call count */
 294         const int attr_calls = RTE_SERVICE_ATTR_CALL_COUNT;
 295         TEST_ASSERT_EQUAL(0, rte_service_attr_get(id, attr_calls, &attr_value),
 296                         "Valid attr_get() call didn't return success");
 297         TEST_ASSERT_EQUAL(0, attr_value,
 298                         "attr_get() call didn't get call count (zero)");
 299
 300         /* Call service to increment cycle count */
 301         TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_id),
 302                         "Service core add did not return zero");
 303         TEST_ASSERT_EQUAL(0, rte_service_map_lcore_set(id, slcore_id, 1),
 304                         "Enabling valid service and core failed");
 305         TEST_ASSERT_EQUAL(0, rte_service_lcore_start(slcore_id),
 306                         "Starting service core failed");
 307
 308         /* wait for the service lcore to run */
 309         rte_delay_ms(200);
 310
 311         TEST_ASSERT_EQUAL(0, rte_service_attr_get(id, attr_id, &attr_value),
 312                         "Valid attr_get() call didn't return success");
 313         int cycles_gt_zero = attr_value > 0;
 314         TEST_ASSERT_EQUAL(1, cycles_gt_zero,
 315                         "attr_get() failed to get cycles (expected > zero)");
 316
 317         rte_service_lcore_stop(slcore_id);
 318
 319         wait_slcore_inactive(slcore_id);
 320
 321         TEST_ASSERT_EQUAL(0, rte_service_attr_get(id, attr_calls, &attr_value),
 322                         "Valid attr_get() call didn't return success");
 323         TEST_ASSERT_EQUAL(1, (attr_value > 0),
 324                         "attr_get() call didn't get call count (zero)");
 325
 326         TEST_ASSERT_EQUAL(0, rte_service_attr_reset_all(id),
 327                         "Valid attr_reset_all() return success");
 328
 329         TEST_ASSERT_EQUAL(0, rte_service_attr_get(id, attr_id, &attr_value),
 330                         "Valid attr_get() call didn't return success");
 331         TEST_ASSERT_EQUAL(0, attr_value,
 332                         "attr_get() call didn't set correct cycles (zero)");
 333         /* ensure call count > zero */
 334         TEST_ASSERT_EQUAL(0, rte_service_attr_get(id, attr_calls, &attr_value),
 335                         "Valid attr_get() call didn't return success");
 336         TEST_ASSERT_EQUAL(0, (attr_value > 0),
 337                         "attr_get() call didn't get call count (zero)");
 338
 339         return unregister_all();
 340 }
 341
 342 /* verify service lcore attr get */
 343 static int
 344 service_lcore_attr_get(void)
 345 {
 346         /* ensure all services unregistered so cycle counts are zero */
 347         unregister_all();
 348
 349         struct rte_service_spec service;
 350         memset(&service, 0, sizeof(struct rte_service_spec));
 351         service.callback = dummy_cb;
 352         snprintf(service.name, sizeof(service.name), DUMMY_SERVICE_NAME);
 353         service.capabilities |= RTE_SERVICE_CAP_MT_SAFE;
 354         uint32_t id;
 355         TEST_ASSERT_EQUAL(0, rte_service_component_register(&service, &id),
 356                         "Register of  service failed");
 357         rte_service_component_runstate_set(id, 1);
 358         TEST_ASSERT_EQUAL(0, rte_service_runstate_set(id, 1),
 359                         "Error: Service start returned non-zero");
 360         rte_service_set_stats_enable(id, 1);
 361
 362         uint64_t lcore_attr_value = 0xdead;
 363         uint32_t lcore_attr_id = UINT32_MAX;
 364
 365         /* check error return values */
 366         TEST_ASSERT_EQUAL(-EINVAL, rte_service_lcore_attr_get(UINT32_MAX,
 367                         lcore_attr_id, &lcore_attr_value),
 368                         "Invalid lcore_id didn't return -EINVAL");
 369         TEST_ASSERT_EQUAL(-ENOTSUP, rte_service_lcore_attr_get(rte_lcore_id(),
 370                         lcore_attr_id, &lcore_attr_value),
 371                         "Non-service core didn't return -ENOTSUP");
 372
 373         /* Start service core to increment loop count */
 374         TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_id),
 375                         "Service core add did not return zero");
 376         TEST_ASSERT_EQUAL(0, rte_service_map_lcore_set(id, slcore_id, 1),
 377                         "Enabling valid service and core failed");
 378         /* Ensure service is not active before starting */
 379         TEST_ASSERT_EQUAL(0, rte_service_lcore_may_be_active(slcore_id),
 380                         "Not-active service core reported as active");
 381         TEST_ASSERT_EQUAL(0, rte_service_lcore_start(slcore_id),
 382                         "Starting service core failed");
 383
 384         /* wait for the service lcore to run */
 385         rte_delay_ms(200);
 386
 387         lcore_attr_id = RTE_SERVICE_LCORE_ATTR_LOOPS;
 388         TEST_ASSERT_EQUAL(0, rte_service_lcore_attr_get(slcore_id,
 389                         lcore_attr_id, &lcore_attr_value),
 390                         "Valid lcore_attr_get() call didn't return success");
 391         int loops_gt_zero = lcore_attr_value > 0;
 392         TEST_ASSERT_EQUAL(1, loops_gt_zero,
 393                         "lcore_attr_get() failed to get loops "
 394                         "(expected > zero)");
 395
 396         lcore_attr_id++;  // invalid lcore attr id
 397         TEST_ASSERT_EQUAL(-EINVAL, rte_service_lcore_attr_get(slcore_id,
 398                         lcore_attr_id, &lcore_attr_value),
 399                         "Invalid lcore attr didn't return -EINVAL");
 400
 401         /* Ensure service is active */
 402         TEST_ASSERT_EQUAL(1, rte_service_lcore_may_be_active(slcore_id),
 403                         "Active service core reported as not-active");
 404
 405         TEST_ASSERT_EQUAL(0, rte_service_map_lcore_set(id, slcore_id, 0),
 406                         "Disabling valid service and core failed");
 407         TEST_ASSERT_EQUAL(0, rte_service_lcore_stop(slcore_id),
 408                         "Failed to stop service lcore");
 409
 410         wait_slcore_inactive(slcore_id);
 411
 412         TEST_ASSERT_EQUAL(0, rte_service_lcore_may_be_active(slcore_id),
 413                           "Service lcore not stopped after waiting.");
 414
 415         TEST_ASSERT_EQUAL(0, rte_service_lcore_attr_reset_all(slcore_id),
 416                           "Valid lcore_attr_reset_all() didn't return success");
 417
 418         lcore_attr_id = RTE_SERVICE_LCORE_ATTR_LOOPS;
 419         TEST_ASSERT_EQUAL(0, rte_service_lcore_attr_get(slcore_id,
 420                         lcore_attr_id, &lcore_attr_value),
 421                         "Valid lcore_attr_get() call didn't return success");
 422         TEST_ASSERT_EQUAL(0, lcore_attr_value,
 423                         "lcore_attr_get() didn't get correct loop count "
 424                         "(zero)");
 425
 426         return unregister_all();
 427 }
 428
 429 /* verify service dump */
 430 static int
 431 service_dump(void)
 432 {
 433         const uint32_t sid = 0;
 434         rte_service_set_stats_enable(sid, 1);
 435         rte_service_dump(stdout, 0);
 436         rte_service_set_stats_enable(sid, 0);
 437         rte_service_dump(stdout, 0);
 438         return unregister_all();
 439 }
 440
 441 /* start and stop a service */
 442 static int
 443 service_start_stop(void)
 444 {
 445         const uint32_t sid = 0;
 446
 447         /* runstate_get() returns if service is running and slcore is mapped */
 448         TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_id),
 449                         "Service core add did not return zero");
 450         int ret = rte_service_map_lcore_set(sid, slcore_id, 1);
 451         TEST_ASSERT_EQUAL(0, ret,
 452                         "Enabling service core, expected 0 got %d", ret);
 453
 454         TEST_ASSERT_EQUAL(0, rte_service_runstate_get(sid),
 455                         "Error: Service should be stopped");
 456
 457         TEST_ASSERT_EQUAL(0, rte_service_runstate_set(sid, 0),
 458                         "Error: Service stopped returned non-zero");
 459
 460         TEST_ASSERT_EQUAL(0, rte_service_runstate_get(sid),
 461                         "Error: Service is running - should be stopped");
 462
 463         TEST_ASSERT_EQUAL(0, rte_service_runstate_set(sid, 1),
 464                         "Error: Service start returned non-zero");
 465
 466         TEST_ASSERT_EQUAL(1, rte_service_runstate_get(sid),
 467                         "Error: Service is not running");
 468
 469         return unregister_all();
 470 }
 471
 472
 473 static int
 474 service_remote_launch_func(void *arg)
 475 {
 476         RTE_SET_USED(arg);
 477         service_remote_launch_flag = 1;
 478         return 0;
 479 }
 480
 481 /* enable and disable a lcore for a service */
 482 static int
 483 service_lcore_en_dis_able(void)
 484 {
 485         const uint32_t sid = 0;
 486
 487         /* expected failure cases */
 488         TEST_ASSERT_EQUAL(-EINVAL, rte_service_map_lcore_set(sid, 100000, 1),
 489                         "Enable on invalid core did not fail");
 490         TEST_ASSERT_EQUAL(-EINVAL, rte_service_map_lcore_set(sid, 100000, 0),
 491                         "Disable on invalid core did not fail");
 492
 493         /* add service core to allow enabling */
 494         TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_id),
 495                         "Add service core failed when not in use before");
 496
 497         /* valid enable */
 498         TEST_ASSERT_EQUAL(0, rte_service_map_lcore_set(sid, slcore_id, 1),
 499                         "Enabling valid service and core failed");
 500         TEST_ASSERT_EQUAL(1, rte_service_map_lcore_get(sid, slcore_id),
 501                         "Enabled core returned not-enabled");
 502
 503         /* valid disable */
 504         TEST_ASSERT_EQUAL(0, rte_service_map_lcore_set(sid, slcore_id, 0),
 505                         "Disabling valid service and lcore failed");
 506         TEST_ASSERT_EQUAL(0, rte_service_map_lcore_get(sid, slcore_id),
 507                         "Disabled core returned enabled");
 508
 509         /* call remote_launch to verify that app can launch ex-service lcore */
 510         service_remote_launch_flag = 0;
 511         rte_eal_wait_lcore(slcore_id);
 512         int ret = rte_eal_remote_launch(service_remote_launch_func, NULL,
 513                                         slcore_id);
 514         TEST_ASSERT_EQUAL(0, ret, "Ex-service core remote launch failed.");
 515         rte_eal_wait_lcore(slcore_id);
 516         TEST_ASSERT_EQUAL(1, service_remote_launch_flag,
 517                         "Ex-service core function call had no effect.");
 518
 519         return unregister_all();
 520 }
 521
 522 static int
 523 service_lcore_running_check(void)
 524 {
 525         uint64_t tick = service_tick;
 526         rte_delay_ms(SERVICE_DELAY * 100);
 527         /* if (tick != service_tick) we know the lcore as polled the service */
 528         return tick != service_tick;
 529 }
 530
 531 static int
 532 service_lcore_add_del(void)
 533 {
 534         if (!rte_lcore_is_enabled(0) || !rte_lcore_is_enabled(1) ||
 535             !rte_lcore_is_enabled(2) || !rte_lcore_is_enabled(3))
 536                 return TEST_SKIPPED;
 537
 538         /* check initial count */
 539         TEST_ASSERT_EQUAL(0, rte_service_lcore_count(),
 540                         "Service lcore count has value before adding a lcore");
 541
 542         /* check service lcore add */
 543         TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_id),
 544                         "Add service core failed when not in use before");
 545         TEST_ASSERT_EQUAL(-EALREADY, rte_service_lcore_add(slcore_id),
 546                         "Add service core failed to refuse in-use lcore");
 547
 548         /* check count */
 549         TEST_ASSERT_EQUAL(1, rte_service_lcore_count(),
 550                         "Service core count not equal to one");
 551
 552         /* retrieve core list, checking lcore ids */
 553         const uint32_t size = 4;
 554         uint32_t service_core_ids[size];
 555         int32_t n = rte_service_lcore_list(service_core_ids, size);
 556         TEST_ASSERT_EQUAL(1, n, "Service core list return should equal 1");
 557         TEST_ASSERT_EQUAL(slcore_id, service_core_ids[0],
 558                                 "Service core list lcore must equal slcore_id");
 559
 560         /* recheck count, add more cores, and check count */
 561         TEST_ASSERT_EQUAL(1, rte_service_lcore_count(),
 562                         "Service core count not equal to one");
 563         uint32_t slcore_1 = rte_get_next_lcore(/* start core */ -1,
 564                                                /* skip main */ 1,
 565                                                /* wrap */ 0);
 566         TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_1),
 567                         "Service core add did not return zero");
 568         uint32_t slcore_2 = rte_get_next_lcore(/* start core */ slcore_1,
 569                                                /* skip main */ 1,
 570                                                /* wrap */ 0);
 571         TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_2),
 572                         "Service core add did not return zero");
 573
 574         uint32_t count = rte_service_lcore_count();
 575         const uint32_t cores_at_this_point = 3;
 576         TEST_ASSERT_EQUAL(cores_at_this_point, count,
 577                         "Service core count %d, expected %d", count,
 578                         cores_at_this_point);
 579
 580         /* check longer service core list */
 581         n = rte_service_lcore_list(service_core_ids, size);
 582         TEST_ASSERT_EQUAL(3, n, "Service core list return should equal 3");
 583         TEST_ASSERT_EQUAL(slcore_id, service_core_ids[0],
 584                                 "Service core list[0] lcore must equal 1");
 585         TEST_ASSERT_EQUAL(slcore_1, service_core_ids[1],
 586                                 "Service core list[1] lcore must equal 2");
 587         TEST_ASSERT_EQUAL(slcore_2, service_core_ids[2],
 588                                 "Service core list[2] lcore must equal 3");
 589
 590         /* recheck count, remove lcores, check remaining lcore_id is correct */
 591         TEST_ASSERT_EQUAL(3, rte_service_lcore_count(),
 592                         "Service core count not equal to three");
 593         TEST_ASSERT_EQUAL(0, rte_service_lcore_del(slcore_1),
 594                         "Service core add did not return zero");
 595         TEST_ASSERT_EQUAL(0, rte_service_lcore_del(slcore_2),
 596                         "Service core add did not return zero");
 597         TEST_ASSERT_EQUAL(1, rte_service_lcore_count(),
 598                         "Service core count not equal to one");
 599         n = rte_service_lcore_list(service_core_ids, size);
 600         TEST_ASSERT_EQUAL(1, n, "Service core list return should equal one");
 601         TEST_ASSERT_EQUAL(slcore_id, service_core_ids[0],
 602                                 "Service core list[0] lcore must equal %d",
 603                                 slcore_id);
 604
 605         return unregister_all();
 606 }
 607
 608 static int
 609 service_threaded_test(int mt_safe)
 610 {
 611         unregister_all();
 612
 613         /* add next 2 cores */
 614         uint32_t slcore_1 = rte_get_next_lcore(/* start core */ -1,
 615                                                /* skip main */ 1,
 616                                                /* wrap */ 0);
 617         TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_1),
 618                         "mt safe lcore add fail");
 619         uint32_t slcore_2 = rte_get_next_lcore(/* start core */ slcore_1,
 620                                                /* skip main */ 1,
 621                                                /* wrap */ 0);
 622         TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_2),
 623                         "mt safe lcore add fail");
 624
 625         /* Use atomic locks to verify that two threads are in the same function
 626          * at the same time. These are passed to the unit tests through the
 627          * callback userdata parameter
 628          */
 629         uint32_t test_params[2];
 630         memset(test_params, 0, sizeof(uint32_t) * 2);
 631
 632         /* register MT safe service. */
 633         struct rte_service_spec service;
 634         memset(&service, 0, sizeof(struct rte_service_spec));
 635         service.callback_userdata = test_params;
 636         snprintf(service.name, sizeof(service.name), MT_SAFE_SERVICE_NAME);
 637
 638         if (mt_safe) {
 639                 service.callback = dummy_mt_safe_cb;
 640                 service.capabilities |= RTE_SERVICE_CAP_MT_SAFE;
 641         } else
 642                 service.callback = dummy_mt_unsafe_cb;
 643
 644         uint32_t id;
 645         TEST_ASSERT_EQUAL(0, rte_service_component_register(&service, &id),
 646                         "Register of MT SAFE service failed");
 647
 648         const uint32_t sid = 0;
 649         TEST_ASSERT_EQUAL(0, rte_service_runstate_set(sid, 1),
 650                         "Starting valid service failed");
 651         TEST_ASSERT_EQUAL(0, rte_service_map_lcore_set(sid, slcore_1, 1),
 652                         "Failed to enable lcore 1 on mt safe service");
 653         TEST_ASSERT_EQUAL(0, rte_service_map_lcore_set(sid, slcore_2, 1),
 654                         "Failed to enable lcore 2 on mt safe service");
 655         rte_service_lcore_start(slcore_1);
 656         rte_service_lcore_start(slcore_2);
 657
 658         /* wait for the worker threads to run */
 659         rte_delay_ms(500);
 660         rte_service_lcore_stop(slcore_1);
 661         rte_service_lcore_stop(slcore_2);
 662
 663         TEST_ASSERT_EQUAL(0, test_params[1],
 664                         "Service run with component runstate = 0");
 665
 666         /* enable backend runstate: the service should run after this */
 667         rte_service_component_runstate_set(id, 1);
 668
 669         /* initialize to pass, see callback comment for details */
 670         if (!mt_safe)
 671                 test_params[1] = 1;
 672
 673         /* wait for lcores before start() */
 674         rte_eal_wait_lcore(slcore_1);
 675         rte_eal_wait_lcore(slcore_2);
 676
 677         rte_service_lcore_start(slcore_1);
 678         rte_service_lcore_start(slcore_2);
 679
 680         /* wait for the worker threads to run */
 681         rte_delay_ms(500);
 682         rte_service_lcore_stop(slcore_1);
 683         rte_service_lcore_stop(slcore_2);
 684
 685         TEST_ASSERT_EQUAL(1, test_params[1],
 686                         "MT Safe service not run by two cores concurrently");
 687         TEST_ASSERT_EQUAL(0, rte_service_runstate_set(sid, 0),
 688                         "Failed to stop MT Safe service");
 689
 690         rte_eal_wait_lcore(slcore_1);
 691         rte_eal_wait_lcore(slcore_2);
 692         unregister_all();
 693
 694         /* return the value of the callback pass_test variable to caller */
 695         return test_params[1];
 696 }
 697
 698 /* tests an MT SAFE service with two cores. The callback function ensures that
 699  * two threads access the callback concurrently.
 700  */
 701 static int
 702 service_mt_safe_poll(void)
 703 {
 704         int mt_safe = 1;
 705
 706         if (!rte_lcore_is_enabled(0) || !rte_lcore_is_enabled(1) ||
 707             !rte_lcore_is_enabled(2))
 708                 return TEST_SKIPPED;
 709
 710         TEST_ASSERT_EQUAL(1, service_threaded_test(mt_safe),
 711                         "Error: MT Safe service not run by two cores concurrently");
 712         return TEST_SUCCESS;
 713 }
 714
 715 /* tests a NON mt safe service with two cores, the callback is serialized
 716  * using the atomic cmpset.
 717  */
 718 static int
 719 service_mt_unsafe_poll(void)
 720 {
 721         int mt_safe = 0;
 722
 723         if (!rte_lcore_is_enabled(0) || !rte_lcore_is_enabled(1) ||
 724             !rte_lcore_is_enabled(2))
 725                 return TEST_SKIPPED;
 726
 727         TEST_ASSERT_EQUAL(1, service_threaded_test(mt_safe),
 728                         "Error: NON MT Safe service run by two cores concurrently");
 729         return TEST_SUCCESS;
 730 }
 731
 732 static int32_t
 733 delay_as_a_mt_safe_service(void *args)
 734 {
 735         RTE_SET_USED(args);
 736         uint32_t *params = args;
 737
 738         /* retrieve done flag and atomic lock to inc/dec */
 739         uint32_t *done = &params[0];
 740         rte_atomic32_t *lock = (rte_atomic32_t *)&params[1];
 741
 742         while (!*done) {
 743                 rte_atomic32_inc(lock);
 744                 rte_delay_us(500);
 745                 if (rte_atomic32_read(lock) > 1)
 746                         /* pass: second core has simultaneously incremented */
 747                         *done = 1;
 748                 rte_atomic32_dec(lock);
 749         }
 750
 751         return 0;
 752 }
 753
 754 static int32_t
 755 delay_as_a_service(void *args)
 756 {
 757         uint32_t *done = (uint32_t *)args;
 758         while (!*done)
 759                 rte_delay_ms(5);
 760         return 0;
 761 }
 762
 763 static int
 764 service_run_on_app_core_func(void *arg)
 765 {
 766         uint32_t *delay_service_id = (uint32_t *)arg;
 767         return rte_service_run_iter_on_app_lcore(*delay_service_id, 1);
 768 }
 769
 770 static int
 771 service_app_lcore_poll_impl(const int mt_safe)
 772 {
 773         uint32_t params[2] = {0};
 774
 775         struct rte_service_spec service;
 776         memset(&service, 0, sizeof(struct rte_service_spec));
 777         snprintf(service.name, sizeof(service.name), MT_SAFE_SERVICE_NAME);
 778         if (mt_safe) {
 779                 service.callback = delay_as_a_mt_safe_service;
 780                 service.callback_userdata = params;
 781                 service.capabilities |= RTE_SERVICE_CAP_MT_SAFE;
 782         } else {
 783                 service.callback = delay_as_a_service;
 784                 service.callback_userdata = &params;
 785         }
 786
 787         uint32_t id;
 788         TEST_ASSERT_EQUAL(0, rte_service_component_register(&service, &id),
 789                         "Register of app lcore delay service failed");
 790
 791         rte_service_component_runstate_set(id, 1);
 792         rte_service_runstate_set(id, 1);
 793
 794         uint32_t app_core2 = rte_get_next_lcore(slcore_id, 1, 1);
 795         rte_eal_wait_lcore(app_core2);
 796         int app_core2_ret = rte_eal_remote_launch(service_run_on_app_core_func,
 797                                                   &id, app_core2);
 798
 799         rte_delay_ms(100);
 800
 801         int app_core1_ret = service_run_on_app_core_func(&id);
 802
 803         /* flag done, then wait for the spawned 2nd core to return */
 804         params[0] = 1;
 805         rte_eal_mp_wait_lcore();
 806
 807         /* core two gets launched first - and should hold the service lock */
 808         TEST_ASSERT_EQUAL(0, app_core2_ret,
 809                         "App core2 : run service didn't return zero");
 810
 811         if (mt_safe) {
 812                 /* mt safe should have both cores return 0 for success */
 813                 TEST_ASSERT_EQUAL(0, app_core1_ret,
 814                                 "MT Safe: App core1 didn't return 0");
 815         } else {
 816                 /* core one attempts to run later - should be blocked */
 817                 TEST_ASSERT_EQUAL(-EBUSY, app_core1_ret,
 818                                 "MT Unsafe: App core1 didn't return -EBUSY");
 819         }
 820
 821         /* Performance test: call in a loop, and measure tsc() */
 822         const uint32_t perf_iters = (1 << 12);
 823         uint64_t start = rte_rdtsc();
 824         uint32_t i;
 825         for (i = 0; i < perf_iters; i++) {
 826                 int err = service_run_on_app_core_func(&id);
 827                 TEST_ASSERT_EQUAL(0, err, "perf test: returned run failure");
 828         }
 829         uint64_t end = rte_rdtsc();
 830         printf("perf test for %s: %0.1f cycles per call\n", mt_safe ?
 831                 "MT Safe" : "MT Unsafe", (end - start)/(float)perf_iters);
 832
 833         unregister_all();
 834         return TEST_SUCCESS;
 835 }
 836
 837 static int
 838 service_app_lcore_mt_safe(void)
 839 {
 840         const int mt_safe = 1;
 841         return service_app_lcore_poll_impl(mt_safe);
 842 }
 843
 844 static int
 845 service_app_lcore_mt_unsafe(void)
 846 {
 847         const int mt_safe = 0;
 848         return service_app_lcore_poll_impl(mt_safe);
 849 }
 850
 851 /* start and stop a service core - ensuring it goes back to sleep */
 852 static int
 853 service_lcore_start_stop(void)
 854 {
 855         /* start service core and service, create mapping so tick() runs */
 856         const uint32_t sid = 0;
 857         TEST_ASSERT_EQUAL(0, rte_service_runstate_set(sid, 1),
 858                         "Starting valid service failed");
 859         TEST_ASSERT_EQUAL(-EINVAL, rte_service_map_lcore_set(sid, slcore_id, 1),
 860                         "Enabling valid service on non-service core must fail");
 861
 862         /* core start */
 863         TEST_ASSERT_EQUAL(-EINVAL, rte_service_lcore_start(slcore_id),
 864                         "Service core start without add should return EINVAL");
 865         TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_id),
 866                         "Service core add did not return zero");
 867         TEST_ASSERT_EQUAL(0, rte_service_map_lcore_set(sid, slcore_id, 1),
 868                         "Enabling valid service on valid core failed");
 869         TEST_ASSERT_EQUAL(0, rte_service_lcore_start(slcore_id),
 870                         "Service core start after add failed");
 871         TEST_ASSERT_EQUAL(-EALREADY, rte_service_lcore_start(slcore_id),
 872                         "Service core expected as running but was stopped");
 873
 874         /* ensures core really is running the service function */
 875         TEST_ASSERT_EQUAL(1, service_lcore_running_check(),
 876                         "Service core expected to poll service but it didn't");
 877
 878         /* core stop */
 879         TEST_ASSERT_EQUAL(-EBUSY, rte_service_lcore_stop(slcore_id),
 880                         "Service core running a service should return -EBUSY");
 881         TEST_ASSERT_EQUAL(0, rte_service_runstate_set(sid, 0),
 882                         "Stopping valid service failed");
 883         TEST_ASSERT_EQUAL(-EINVAL, rte_service_lcore_stop(100000),
 884                         "Invalid Service core stop should return -EINVAL");
 885         TEST_ASSERT_EQUAL(0, rte_service_lcore_stop(slcore_id),
 886                         "Service core stop expected to return 0");
 887         TEST_ASSERT_EQUAL(-EALREADY, rte_service_lcore_stop(slcore_id),
 888                         "Already stopped service core should return -EALREADY");
 889
 890         /* ensure service is not longer running */
 891         TEST_ASSERT_EQUAL(0, service_lcore_running_check(),
 892                         "Service core expected to poll service but it didn't");
 893
 894         TEST_ASSERT_EQUAL(0, rte_service_lcore_del(slcore_id),
 895                         "Service core del did not return zero");
 896
 897         return unregister_all();
 898 }
 899
 900 /* stop a service and wait for it to become inactive */
 901 static int
 902 service_may_be_active(void)
 903 {
 904         const uint32_t sid = 0;
 905         int i;
 906
 907         /* expected failure cases */
 908         TEST_ASSERT_EQUAL(-EINVAL, rte_service_may_be_active(10000),
 909                         "Invalid service may be active check did not fail");
 910
 911         /* start the service */
 912         TEST_ASSERT_EQUAL(0, rte_service_runstate_set(sid, 1),
 913                         "Starting valid service failed");
 914         TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_id),
 915                         "Add service core failed when not in use before");
 916         TEST_ASSERT_EQUAL(0, rte_service_map_lcore_set(sid, slcore_id, 1),
 917                         "Enabling valid service on valid core failed");
 918         TEST_ASSERT_EQUAL(0, rte_service_lcore_start(slcore_id),
 919                         "Service core start after add failed");
 920
 921         /* ensures core really is running the service function */
 922         TEST_ASSERT_EQUAL(1, service_lcore_running_check(),
 923                         "Service core expected to poll service but it didn't");
 924
 925         /* stop the service */
 926         TEST_ASSERT_EQUAL(0, rte_service_runstate_set(sid, 0),
 927                         "Error: Service stop returned non-zero");
 928
 929         /* give the service 100ms to stop running */
 930         for (i = 0; i < 100; i++) {
 931                 if (!rte_service_may_be_active(sid))
 932                         break;
 933                 rte_delay_ms(SERVICE_DELAY);
 934         }
 935
 936         TEST_ASSERT_EQUAL(0, rte_service_may_be_active(sid),
 937                           "Error: Service not stopped after 100ms");
 938
 939         return unregister_all();
 940 }
 941
 942 /* check service may be active when service is running on a second lcore */
 943 static int
 944 service_active_two_cores(void)
 945 {
 946         if (!rte_lcore_is_enabled(0) || !rte_lcore_is_enabled(1) ||
 947             !rte_lcore_is_enabled(2))
 948                 return TEST_SKIPPED;
 949
 950         const uint32_t sid = 0;
 951         int i;
 952
 953         uint32_t lcore = rte_get_next_lcore(/* start core */ -1,
 954                                             /* skip main */ 1,
 955                                             /* wrap */ 0);
 956         uint32_t slcore = rte_get_next_lcore(/* start core */ lcore,
 957                                              /* skip main */ 1,
 958                                              /* wrap */ 0);
 959
 960         /* start the service on the second available lcore */
 961         TEST_ASSERT_EQUAL(0, rte_service_runstate_set(sid, 1),
 962                         "Starting valid service failed");
 963         TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore),
 964                         "Add service core failed when not in use before");
 965         TEST_ASSERT_EQUAL(0, rte_service_map_lcore_set(sid, slcore, 1),
 966                         "Enabling valid service on valid core failed");
 967         TEST_ASSERT_EQUAL(0, rte_service_lcore_start(slcore),
 968                         "Service core start after add failed");
 969
 970         /* ensures core really is running the service function */
 971         TEST_ASSERT_EQUAL(1, service_lcore_running_check(),
 972                         "Service core expected to poll service but it didn't");
 973
 974         /* ensures that service may be active reports running state */
 975         TEST_ASSERT_EQUAL(1, rte_service_may_be_active(sid),
 976                         "Service may be active did not report running state");
 977
 978         /* stop the service */
 979         TEST_ASSERT_EQUAL(0, rte_service_runstate_set(sid, 0),
 980                         "Error: Service stop returned non-zero");
 981
 982         /* give the service 100ms to stop running */
 983         for (i = 0; i < 100; i++) {
 984                 if (!rte_service_may_be_active(sid))
 985                         break;
 986                 rte_delay_ms(SERVICE_DELAY);
 987         }
 988
 989         TEST_ASSERT_EQUAL(0, rte_service_may_be_active(sid),
 990                           "Error: Service not stopped after 100ms");
 991
 992         return unregister_all();
 993 }
 994
 995 static struct unit_test_suite service_tests  = {
 996         .suite_name = "service core test suite",
 997         .setup = testsuite_setup,
 998         .teardown = testsuite_teardown,
 999         .unit_test_cases = {
1000                 TEST_CASE_ST(dummy_register, NULL, unregister_all),
1001                 TEST_CASE_ST(dummy_register, NULL, service_name),
1002                 TEST_CASE_ST(dummy_register, NULL, service_get_by_name),
1003                 TEST_CASE_ST(dummy_register, NULL, service_dump),
1004                 TEST_CASE_ST(dummy_register, NULL, service_attr_get),
1005                 TEST_CASE_ST(dummy_register, NULL, service_lcore_attr_get),
1006                 TEST_CASE_ST(dummy_register, NULL, service_probe_capability),
1007                 TEST_CASE_ST(dummy_register, NULL, service_start_stop),
1008                 TEST_CASE_ST(dummy_register, NULL, service_lcore_add_del),
1009                 TEST_CASE_ST(dummy_register, NULL, service_lcore_start_stop),
1010                 TEST_CASE_ST(dummy_register, NULL, service_lcore_en_dis_able),
1011                 TEST_CASE_ST(dummy_register, NULL, service_mt_unsafe_poll),
1012                 TEST_CASE_ST(dummy_register, NULL, service_mt_safe_poll),
1013                 TEST_CASE_ST(dummy_register, NULL, service_app_lcore_mt_safe),
1014                 TEST_CASE_ST(dummy_register, NULL, service_app_lcore_mt_unsafe),
1015                 TEST_CASE_ST(dummy_register, NULL, service_may_be_active),
1016                 TEST_CASE_ST(dummy_register, NULL, service_active_two_cores),
1017                 TEST_CASES_END() /**< NULL terminate unit test array */
1018         }
1019 };
1020
1021 static int
1022 test_service_common(void)
1023 {
1024         return unit_test_suite_runner(&service_tests);
1025 }
1026
1027 REGISTER_TEST_COMMAND(service_autotest, test_service_common);