1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017 Intel Corporation
5 #include <rte_common.h>
6 #include <rte_hexdump.h>
8 #include <rte_malloc.h>
9 #include <rte_memcpy.h>
10 #include <rte_cycles.h>
12 #include <rte_service.h>
13 #include <rte_service_component.h>
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;
24 #define SERVICE_DELAY 1
26 #define DUMMY_SERVICE_NAME "dummy_service"
27 #define MT_SAFE_SERVICE_NAME "mt_safe_service"
32 slcore_id = rte_get_next_lcore(/* start core */ -1,
40 testsuite_teardown(void)
42 /* release service cores? */
45 static int32_t dummy_cb(void *args)
49 rte_delay_ms(SERVICE_DELAY);
53 static int32_t dummy_mt_unsafe_cb(void *args)
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.
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);
65 /* delay with the lock held */
67 rte_atomic32_clear((rte_atomic32_t *)atomic_lock);
69 /* 2nd thread will fail to take lock, so set pass flag */
77 static int32_t dummy_mt_safe_cb(void *args)
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
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);
90 /* delay with the lock held */
92 rte_atomic32_clear((rte_atomic32_t *)atomic_lock);
94 /* 2nd thread will fail to take lock, so set pass flag */
101 /* unregister all services */
107 TEST_ASSERT_EQUAL(-EINVAL, rte_service_component_unregister(1000),
108 "Unregistered invalid service id");
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");
116 rte_service_lcore_reset_all();
121 /* register a single dummy service */
125 /* make sure there are no remains from previous tests */
128 struct rte_service_spec service;
129 memset(&service, 0, sizeof(struct rte_service_spec));
131 TEST_ASSERT_EQUAL(-EINVAL,
132 rte_service_component_register(&service, NULL),
134 service.callback = dummy_cb;
136 TEST_ASSERT_EQUAL(-EINVAL,
137 rte_service_component_register(&service, NULL),
139 snprintf(service.name, sizeof(service.name), DUMMY_SERVICE_NAME);
142 TEST_ASSERT_EQUAL(0, rte_service_component_register(&service, &id),
143 "Failed to register valid service");
145 rte_service_component_runstate_set(id, 1);
150 /* verify get_by_name() service lookup */
152 service_get_by_name(void)
157 TEST_ASSERT_EQUAL(-ENODEV,
158 rte_service_get_by_name(DUMMY_SERVICE_NAME, &sid),
159 "get by name with invalid name should return -ENODEV");
160 TEST_ASSERT_EQUAL(-EINVAL,
161 rte_service_get_by_name(DUMMY_SERVICE_NAME, 0x0),
162 "get by name with NULL ptr should return -ENODEV");
164 /* register service */
165 struct rte_service_spec service;
166 memset(&service, 0, sizeof(struct rte_service_spec));
167 TEST_ASSERT_EQUAL(-EINVAL,
168 rte_service_component_register(&service, NULL),
170 service.callback = dummy_cb;
171 TEST_ASSERT_EQUAL(-EINVAL,
172 rte_service_component_register(&service, NULL),
174 snprintf(service.name, sizeof(service.name), DUMMY_SERVICE_NAME);
175 TEST_ASSERT_EQUAL(0, rte_service_component_register(&service, NULL),
176 "Failed to register valid service");
178 /* we unregistered all service, now registering 1, should be id 0 */
179 uint32_t service_id_as_expected = 0;
180 TEST_ASSERT_EQUAL(0, rte_service_get_by_name(DUMMY_SERVICE_NAME, &sid),
181 "Service get_by_name should return 0 on valid inputs");
182 TEST_ASSERT_EQUAL(service_id_as_expected, sid,
183 "Service get_by_name should equal expected id");
187 /* ensure after unregister, get_by_name returns NULL */
188 TEST_ASSERT_EQUAL(-ENODEV,
189 rte_service_get_by_name(DUMMY_SERVICE_NAME, &sid),
190 "get by name should return -ENODEV after unregister");
195 /* verify probe of capabilities */
197 service_probe_capability(void)
201 struct rte_service_spec service;
202 memset(&service, 0, sizeof(struct rte_service_spec));
203 service.callback = dummy_cb;
204 snprintf(service.name, sizeof(service.name), DUMMY_SERVICE_NAME);
205 service.capabilities |= RTE_SERVICE_CAP_MT_SAFE;
206 TEST_ASSERT_EQUAL(0, rte_service_component_register(&service, NULL),
207 "Register of MT SAFE service failed");
209 /* verify flag is enabled */
210 const uint32_t sid = 0;
211 int32_t mt = rte_service_probe_capability(sid, RTE_SERVICE_CAP_MT_SAFE);
212 TEST_ASSERT_EQUAL(1, mt, "MT SAFE capability flag not set.");
217 memset(&service, 0, sizeof(struct rte_service_spec));
218 service.callback = dummy_cb;
219 snprintf(service.name, sizeof(service.name), DUMMY_SERVICE_NAME);
220 TEST_ASSERT_EQUAL(0, rte_service_component_register(&service, NULL),
221 "Register of non-MT safe service failed");
223 /* verify flag is enabled */
224 mt = rte_service_probe_capability(sid, RTE_SERVICE_CAP_MT_SAFE);
225 TEST_ASSERT_EQUAL(0, mt, "MT SAFE cap flag set on non MT SAFE service");
227 return unregister_all();
230 /* verify the service name */
234 const char *name = rte_service_get_name(0);
235 int equal = strcmp(name, DUMMY_SERVICE_NAME);
236 TEST_ASSERT_EQUAL(0, equal, "Error: Service name not correct");
238 return unregister_all();
241 /* verify service attr get */
243 service_attr_get(void)
245 /* ensure all services unregistered so cycle counts are zero */
248 struct rte_service_spec service;
249 memset(&service, 0, sizeof(struct rte_service_spec));
250 service.callback = dummy_cb;
251 snprintf(service.name, sizeof(service.name), DUMMY_SERVICE_NAME);
252 service.capabilities |= RTE_SERVICE_CAP_MT_SAFE;
254 TEST_ASSERT_EQUAL(0, rte_service_component_register(&service, &id),
255 "Register of service failed");
256 rte_service_component_runstate_set(id, 1);
257 TEST_ASSERT_EQUAL(0, rte_service_runstate_set(id, 1),
258 "Error: Service start returned non-zero");
259 rte_service_set_stats_enable(id, 1);
261 uint32_t attr_id = UINT32_MAX;
262 uint32_t attr_value = 0xdead;
263 /* check error return values */
264 TEST_ASSERT_EQUAL(-EINVAL, rte_service_attr_get(id, attr_id,
266 "Invalid attr_id didn't return -EINVAL");
268 attr_id = RTE_SERVICE_ATTR_CYCLES;
269 TEST_ASSERT_EQUAL(-EINVAL, rte_service_attr_get(UINT32_MAX, attr_id,
271 "Invalid service id didn't return -EINVAL");
273 TEST_ASSERT_EQUAL(-EINVAL, rte_service_attr_get(id, attr_id, NULL),
274 "Invalid attr_value pointer id didn't return -EINVAL");
276 /* check correct (zero) return value and correct value (zero) */
277 TEST_ASSERT_EQUAL(0, rte_service_attr_get(id, attr_id, &attr_value),
278 "Valid attr_get() call didn't return success");
279 TEST_ASSERT_EQUAL(0, attr_value,
280 "attr_get() call didn't set correct cycles (zero)");
281 /* check correct call count */
282 const int attr_calls = RTE_SERVICE_ATTR_CALL_COUNT;
283 TEST_ASSERT_EQUAL(0, rte_service_attr_get(id, attr_calls, &attr_value),
284 "Valid attr_get() call didn't return success");
285 TEST_ASSERT_EQUAL(0, attr_value,
286 "attr_get() call didn't get call count (zero)");
288 /* Call service to increment cycle count */
289 TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_id),
290 "Service core add did not return zero");
291 TEST_ASSERT_EQUAL(0, rte_service_map_lcore_set(id, slcore_id, 1),
292 "Enabling valid service and core failed");
293 TEST_ASSERT_EQUAL(0, rte_service_lcore_start(slcore_id),
294 "Starting service core failed");
296 /* wait for the service lcore to run */
299 TEST_ASSERT_EQUAL(0, rte_service_attr_get(id, attr_id, &attr_value),
300 "Valid attr_get() call didn't return success");
301 int cycles_gt_zero = attr_value > 0;
302 TEST_ASSERT_EQUAL(1, cycles_gt_zero,
303 "attr_get() failed to get cycles (expected > zero)");
305 rte_service_lcore_stop(slcore_id);
307 TEST_ASSERT_EQUAL(0, rte_service_attr_get(id, attr_calls, &attr_value),
308 "Valid attr_get() call didn't return success");
309 TEST_ASSERT_EQUAL(1, (attr_value > 0),
310 "attr_get() call didn't get call count (zero)");
312 TEST_ASSERT_EQUAL(0, rte_service_attr_reset_all(id),
313 "Valid attr_reset_all() return success");
315 TEST_ASSERT_EQUAL(0, rte_service_attr_get(id, attr_id, &attr_value),
316 "Valid attr_get() call didn't return success");
317 TEST_ASSERT_EQUAL(0, attr_value,
318 "attr_get() call didn't set correct cycles (zero)");
319 /* ensure call count > zero */
320 TEST_ASSERT_EQUAL(0, rte_service_attr_get(id, attr_calls, &attr_value),
321 "Valid attr_get() call didn't return success");
322 TEST_ASSERT_EQUAL(0, (attr_value > 0),
323 "attr_get() call didn't get call count (zero)");
325 return unregister_all();
328 /* verify service dump */
332 const uint32_t sid = 0;
333 rte_service_set_stats_enable(sid, 1);
334 rte_service_dump(stdout, 0);
335 rte_service_set_stats_enable(sid, 0);
336 rte_service_dump(stdout, 0);
337 return unregister_all();
340 /* start and stop a service */
342 service_start_stop(void)
344 const uint32_t sid = 0;
346 /* runstate_get() returns if service is running and slcore is mapped */
347 TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_id),
348 "Service core add did not return zero");
349 int ret = rte_service_map_lcore_set(sid, slcore_id, 1);
350 TEST_ASSERT_EQUAL(0, ret,
351 "Enabling service core, expected 0 got %d", ret);
353 TEST_ASSERT_EQUAL(0, rte_service_runstate_get(sid),
354 "Error: Service should be stopped");
356 TEST_ASSERT_EQUAL(0, rte_service_runstate_set(sid, 0),
357 "Error: Service stopped returned non-zero");
359 TEST_ASSERT_EQUAL(0, rte_service_runstate_get(sid),
360 "Error: Service is running - should be stopped");
362 TEST_ASSERT_EQUAL(0, rte_service_runstate_set(sid, 1),
363 "Error: Service start returned non-zero");
365 TEST_ASSERT_EQUAL(1, rte_service_runstate_get(sid),
366 "Error: Service is not running");
368 return unregister_all();
373 service_remote_launch_func(void *arg)
376 service_remote_launch_flag = 1;
380 /* enable and disable a lcore for a service */
382 service_lcore_en_dis_able(void)
384 const uint32_t sid = 0;
386 /* expected failure cases */
387 TEST_ASSERT_EQUAL(-EINVAL, rte_service_map_lcore_set(sid, 100000, 1),
388 "Enable on invalid core did not fail");
389 TEST_ASSERT_EQUAL(-EINVAL, rte_service_map_lcore_set(sid, 100000, 0),
390 "Disable on invalid core did not fail");
392 /* add service core to allow enabling */
393 TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_id),
394 "Add service core failed when not in use before");
397 TEST_ASSERT_EQUAL(0, rte_service_map_lcore_set(sid, slcore_id, 1),
398 "Enabling valid service and core failed");
399 TEST_ASSERT_EQUAL(1, rte_service_map_lcore_get(sid, slcore_id),
400 "Enabled core returned not-enabled");
403 TEST_ASSERT_EQUAL(0, rte_service_map_lcore_set(sid, slcore_id, 0),
404 "Disabling valid service and lcore failed");
405 TEST_ASSERT_EQUAL(0, rte_service_map_lcore_get(sid, slcore_id),
406 "Disabled core returned enabled");
408 /* call remote_launch to verify that app can launch ex-service lcore */
409 service_remote_launch_flag = 0;
410 rte_eal_wait_lcore(slcore_id);
411 int ret = rte_eal_remote_launch(service_remote_launch_func, NULL,
413 TEST_ASSERT_EQUAL(0, ret, "Ex-service core remote launch failed.");
414 rte_eal_mp_wait_lcore();
415 TEST_ASSERT_EQUAL(1, service_remote_launch_flag,
416 "Ex-service core function call had no effect.");
418 return unregister_all();
422 service_lcore_running_check(void)
424 uint64_t tick = service_tick;
425 rte_delay_ms(SERVICE_DELAY * 100);
426 /* if (tick != service_tick) we know the lcore as polled the service */
427 return tick != service_tick;
431 service_lcore_add_del(void)
433 /* check initial count */
434 TEST_ASSERT_EQUAL(0, rte_service_lcore_count(),
435 "Service lcore count has value before adding a lcore");
437 /* check service lcore add */
438 TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_id),
439 "Add service core failed when not in use before");
440 TEST_ASSERT_EQUAL(-EALREADY, rte_service_lcore_add(slcore_id),
441 "Add service core failed to refuse in-use lcore");
444 TEST_ASSERT_EQUAL(1, rte_service_lcore_count(),
445 "Service core count not equal to one");
447 /* retrieve core list, checking lcore ids */
448 const uint32_t size = 4;
449 uint32_t service_core_ids[size];
450 int32_t n = rte_service_lcore_list(service_core_ids, size);
451 TEST_ASSERT_EQUAL(1, n, "Service core list return should equal 1");
452 TEST_ASSERT_EQUAL(slcore_id, service_core_ids[0],
453 "Service core list lcore must equal slcore_id");
455 /* recheck count, add more cores, and check count */
456 TEST_ASSERT_EQUAL(1, rte_service_lcore_count(),
457 "Service core count not equal to one");
458 uint32_t slcore_1 = rte_get_next_lcore(/* start core */ -1,
461 TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_1),
462 "Service core add did not return zero");
463 uint32_t slcore_2 = rte_get_next_lcore(/* start core */ slcore_1,
466 TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_2),
467 "Service core add did not return zero");
469 uint32_t count = rte_service_lcore_count();
470 const uint32_t cores_at_this_point = 3;
471 TEST_ASSERT_EQUAL(cores_at_this_point, count,
472 "Service core count %d, expected %d", count,
473 cores_at_this_point);
475 /* check longer service core list */
476 n = rte_service_lcore_list(service_core_ids, size);
477 TEST_ASSERT_EQUAL(3, n, "Service core list return should equal 3");
478 TEST_ASSERT_EQUAL(slcore_id, service_core_ids[0],
479 "Service core list[0] lcore must equal 1");
480 TEST_ASSERT_EQUAL(slcore_1, service_core_ids[1],
481 "Service core list[1] lcore must equal 2");
482 TEST_ASSERT_EQUAL(slcore_2, service_core_ids[2],
483 "Service core list[2] lcore must equal 3");
485 /* recheck count, remove lcores, check remaining lcore_id is correct */
486 TEST_ASSERT_EQUAL(3, rte_service_lcore_count(),
487 "Service core count not equal to three");
488 TEST_ASSERT_EQUAL(0, rte_service_lcore_del(slcore_1),
489 "Service core add did not return zero");
490 TEST_ASSERT_EQUAL(0, rte_service_lcore_del(slcore_2),
491 "Service core add did not return zero");
492 TEST_ASSERT_EQUAL(1, rte_service_lcore_count(),
493 "Service core count not equal to one");
494 n = rte_service_lcore_list(service_core_ids, size);
495 TEST_ASSERT_EQUAL(1, n, "Service core list return should equal one");
496 TEST_ASSERT_EQUAL(slcore_id, service_core_ids[0],
497 "Service core list[0] lcore must equal %d",
500 return unregister_all();
504 service_threaded_test(int mt_safe)
508 /* add next 2 cores */
509 uint32_t slcore_1 = rte_get_next_lcore(/* start core */ -1,
512 TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_1),
513 "mt safe lcore add fail");
514 uint32_t slcore_2 = rte_get_next_lcore(/* start core */ slcore_1,
517 TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_2),
518 "mt safe lcore add fail");
520 /* Use atomic locks to verify that two threads are in the same function
521 * at the same time. These are passed to the unit tests through the
522 * callback userdata parameter
524 uint32_t test_params[2];
525 memset(test_params, 0, sizeof(uint32_t) * 2);
527 /* register MT safe service. */
528 struct rte_service_spec service;
529 memset(&service, 0, sizeof(struct rte_service_spec));
530 service.callback_userdata = test_params;
531 snprintf(service.name, sizeof(service.name), MT_SAFE_SERVICE_NAME);
534 service.callback = dummy_mt_safe_cb;
535 service.capabilities |= RTE_SERVICE_CAP_MT_SAFE;
537 service.callback = dummy_mt_unsafe_cb;
540 TEST_ASSERT_EQUAL(0, rte_service_component_register(&service, &id),
541 "Register of MT SAFE service failed");
543 const uint32_t sid = 0;
544 TEST_ASSERT_EQUAL(0, rte_service_runstate_set(sid, 1),
545 "Starting valid service failed");
546 TEST_ASSERT_EQUAL(0, rte_service_map_lcore_set(sid, slcore_1, 1),
547 "Failed to enable lcore 1 on mt safe service");
548 TEST_ASSERT_EQUAL(0, rte_service_map_lcore_set(sid, slcore_2, 1),
549 "Failed to enable lcore 2 on mt safe service");
550 rte_service_lcore_start(slcore_1);
551 rte_service_lcore_start(slcore_2);
553 /* wait for the worker threads to run */
555 rte_service_lcore_stop(slcore_1);
556 rte_service_lcore_stop(slcore_2);
558 TEST_ASSERT_EQUAL(0, test_params[1],
559 "Service run with component runstate = 0");
561 /* enable backend runstate: the service should run after this */
562 rte_service_component_runstate_set(id, 1);
564 /* initialize to pass, see callback comment for details */
568 /* wait for lcores before start() */
569 rte_eal_wait_lcore(slcore_1);
570 rte_eal_wait_lcore(slcore_2);
572 rte_service_lcore_start(slcore_1);
573 rte_service_lcore_start(slcore_2);
575 /* wait for the worker threads to run */
577 rte_service_lcore_stop(slcore_1);
578 rte_service_lcore_stop(slcore_2);
580 TEST_ASSERT_EQUAL(1, test_params[1],
581 "MT Safe service not run by two cores concurrently");
582 TEST_ASSERT_EQUAL(0, rte_service_runstate_set(sid, 0),
583 "Failed to stop MT Safe service");
585 rte_eal_wait_lcore(slcore_1);
586 rte_eal_wait_lcore(slcore_2);
589 /* return the value of the callback pass_test variable to caller */
590 return test_params[1];
593 /* tests an MT SAFE service with two cores. The callback function ensures that
594 * two threads access the callback concurrently.
597 service_mt_safe_poll(void)
600 TEST_ASSERT_EQUAL(1, service_threaded_test(mt_safe),
601 "Error: MT Safe service not run by two cores concurrently");
605 /* tests a NON mt safe service with two cores, the callback is serialized
606 * using the atomic cmpset.
609 service_mt_unsafe_poll(void)
612 TEST_ASSERT_EQUAL(1, service_threaded_test(mt_safe),
613 "Error: NON MT Safe service run by two cores concurrently");
618 delay_as_a_mt_safe_service(void *args)
621 uint32_t *params = args;
623 /* retrieve done flag and atomic lock to inc/dec */
624 uint32_t *done = ¶ms[0];
625 rte_atomic32_t *lock = (rte_atomic32_t *)¶ms[1];
628 rte_atomic32_inc(lock);
630 if (rte_atomic32_read(lock) > 1)
631 /* pass: second core has simultaneously incremented */
633 rte_atomic32_dec(lock);
640 delay_as_a_service(void *args)
642 uint32_t *done = (uint32_t *)args;
649 service_run_on_app_core_func(void *arg)
651 uint32_t *delay_service_id = (uint32_t *)arg;
652 return rte_service_run_iter_on_app_lcore(*delay_service_id, 1);
656 service_app_lcore_poll_impl(const int mt_safe)
658 uint32_t params[2] = {0};
660 struct rte_service_spec service;
661 memset(&service, 0, sizeof(struct rte_service_spec));
662 snprintf(service.name, sizeof(service.name), MT_SAFE_SERVICE_NAME);
664 service.callback = delay_as_a_mt_safe_service;
665 service.callback_userdata = params;
666 service.capabilities |= RTE_SERVICE_CAP_MT_SAFE;
668 service.callback = delay_as_a_service;
669 service.callback_userdata = ¶ms;
673 TEST_ASSERT_EQUAL(0, rte_service_component_register(&service, &id),
674 "Register of app lcore delay service failed");
676 rte_service_component_runstate_set(id, 1);
677 rte_service_runstate_set(id, 1);
679 uint32_t app_core2 = rte_get_next_lcore(slcore_id, 1, 1);
680 rte_eal_wait_lcore(app_core2);
681 int app_core2_ret = rte_eal_remote_launch(service_run_on_app_core_func,
686 int app_core1_ret = service_run_on_app_core_func(&id);
688 /* flag done, then wait for the spawned 2nd core to return */
690 rte_eal_mp_wait_lcore();
692 /* core two gets launched first - and should hold the service lock */
693 TEST_ASSERT_EQUAL(0, app_core2_ret,
694 "App core2 : run service didn't return zero");
697 /* mt safe should have both cores return 0 for success */
698 TEST_ASSERT_EQUAL(0, app_core1_ret,
699 "MT Safe: App core1 didn't return 0");
701 /* core one attempts to run later - should be blocked */
702 TEST_ASSERT_EQUAL(-EBUSY, app_core1_ret,
703 "MT Unsafe: App core1 didn't return -EBUSY");
712 service_app_lcore_mt_safe(void)
714 const int mt_safe = 1;
715 return service_app_lcore_poll_impl(mt_safe);
719 service_app_lcore_mt_unsafe(void)
721 const int mt_safe = 0;
722 return service_app_lcore_poll_impl(mt_safe);
725 /* start and stop a service core - ensuring it goes back to sleep */
727 service_lcore_start_stop(void)
729 /* start service core and service, create mapping so tick() runs */
730 const uint32_t sid = 0;
731 TEST_ASSERT_EQUAL(0, rte_service_runstate_set(sid, 1),
732 "Starting valid service failed");
733 TEST_ASSERT_EQUAL(-EINVAL, rte_service_map_lcore_set(sid, slcore_id, 1),
734 "Enabling valid service on non-service core must fail");
737 TEST_ASSERT_EQUAL(-EINVAL, rte_service_lcore_start(slcore_id),
738 "Service core start without add should return EINVAL");
739 TEST_ASSERT_EQUAL(0, rte_service_lcore_add(slcore_id),
740 "Service core add did not return zero");
741 TEST_ASSERT_EQUAL(0, rte_service_map_lcore_set(sid, slcore_id, 1),
742 "Enabling valid service on valid core failed");
743 TEST_ASSERT_EQUAL(0, rte_service_lcore_start(slcore_id),
744 "Service core start after add failed");
745 TEST_ASSERT_EQUAL(-EALREADY, rte_service_lcore_start(slcore_id),
746 "Service core expected as running but was stopped");
748 /* ensures core really is running the service function */
749 TEST_ASSERT_EQUAL(1, service_lcore_running_check(),
750 "Service core expected to poll service but it didn't");
753 TEST_ASSERT_EQUAL(-EBUSY, rte_service_lcore_stop(slcore_id),
754 "Service core running a service should return -EBUSY");
755 TEST_ASSERT_EQUAL(0, rte_service_runstate_set(sid, 0),
756 "Stopping valid service failed");
757 TEST_ASSERT_EQUAL(-EINVAL, rte_service_lcore_stop(100000),
758 "Invalid Service core stop should return -EINVAL");
759 TEST_ASSERT_EQUAL(0, rte_service_lcore_stop(slcore_id),
760 "Service core stop expected to return 0");
761 TEST_ASSERT_EQUAL(-EALREADY, rte_service_lcore_stop(slcore_id),
762 "Already stopped service core should return -EALREADY");
764 /* ensure service is not longer running */
765 TEST_ASSERT_EQUAL(0, service_lcore_running_check(),
766 "Service core expected to poll service but it didn't");
768 TEST_ASSERT_EQUAL(0, rte_service_lcore_del(slcore_id),
769 "Service core del did not return zero");
771 return unregister_all();
774 static struct unit_test_suite service_tests = {
775 .suite_name = "service core test suite",
776 .setup = testsuite_setup,
777 .teardown = testsuite_teardown,
779 TEST_CASE_ST(dummy_register, NULL, unregister_all),
780 TEST_CASE_ST(dummy_register, NULL, service_name),
781 TEST_CASE_ST(dummy_register, NULL, service_get_by_name),
782 TEST_CASE_ST(dummy_register, NULL, service_dump),
783 TEST_CASE_ST(dummy_register, NULL, service_attr_get),
784 TEST_CASE_ST(dummy_register, NULL, service_probe_capability),
785 TEST_CASE_ST(dummy_register, NULL, service_start_stop),
786 TEST_CASE_ST(dummy_register, NULL, service_lcore_add_del),
787 TEST_CASE_ST(dummy_register, NULL, service_lcore_start_stop),
788 TEST_CASE_ST(dummy_register, NULL, service_lcore_en_dis_able),
789 TEST_CASE_ST(dummy_register, NULL, service_mt_unsafe_poll),
790 TEST_CASE_ST(dummy_register, NULL, service_mt_safe_poll),
791 TEST_CASE_ST(dummy_register, NULL, service_app_lcore_mt_safe),
792 TEST_CASE_ST(dummy_register, NULL, service_app_lcore_mt_unsafe),
793 TEST_CASES_END() /**< NULL terminate unit test array */
798 test_service_common(void)
800 return unit_test_suite_runner(&service_tests);
803 REGISTER_TEST_COMMAND(service_autotest, test_service_common);