| // SPDX-License-Identifier: GPL-2.0-only | |
| /* | |
| * POWER Data Stream Control Register (DSCR) explicit test | |
| * | |
| * This test modifies the DSCR value using mtspr instruction and | |
| * verifies the change with mfspr instruction. It uses both the | |
| * privilege state SPR and the problem state SPR for this purpose. | |
| * | |
| * When using the privilege state SPR, the instructions such as | |
| * mfspr or mtspr are privileged and the kernel emulates them | |
| * for us. Instructions using problem state SPR can be executed | |
| * directly without any emulation if the HW supports them. Else | |
| * they also get emulated by the kernel. | |
| * | |
| * Copyright 2012, Anton Blanchard, IBM Corporation. | |
| * Copyright 2015, Anshuman Khandual, IBM Corporation. | |
| */ | |
| #define _GNU_SOURCE | |
| #include "dscr.h" | |
| #include "utils.h" | |
| #include <pthread.h> | |
| #include <sched.h> | |
| #include <semaphore.h> | |
| void *dscr_explicit_lockstep_thread(void *args) | |
| { | |
| sem_t *prev = (sem_t *)args; | |
| sem_t *next = (sem_t *)args + 1; | |
| unsigned long expected_dscr = 0; | |
| set_dscr(expected_dscr); | |
| srand(gettid()); | |
| for (int i = 0; i < COUNT; i++) { | |
| FAIL_IF_EXIT(sem_wait(prev)); | |
| FAIL_IF_EXIT(expected_dscr != get_dscr()); | |
| FAIL_IF_EXIT(expected_dscr != get_dscr_usr()); | |
| expected_dscr = (expected_dscr + 1) % DSCR_MAX; | |
| set_dscr(expected_dscr); | |
| FAIL_IF_EXIT(sem_post(next)); | |
| } | |
| return NULL; | |
| } | |
| int dscr_explicit_lockstep_test(void) | |
| { | |
| pthread_t thread; | |
| sem_t semaphores[2]; | |
| sem_t *prev = &semaphores[1]; /* reversed prev/next than for the other thread */ | |
| sem_t *next = &semaphores[0]; | |
| unsigned long expected_dscr = 0; | |
| SKIP_IF(!have_hwcap2(PPC_FEATURE2_DSCR)); | |
| srand(gettid()); | |
| set_dscr(expected_dscr); | |
| FAIL_IF(sem_init(prev, 0, 0)); | |
| FAIL_IF(sem_init(next, 0, 1)); /* other thread starts first */ | |
| FAIL_IF(bind_to_cpu(BIND_CPU_ANY) < 0); | |
| FAIL_IF(pthread_create(&thread, NULL, dscr_explicit_lockstep_thread, (void *)semaphores)); | |
| for (int i = 0; i < COUNT; i++) { | |
| FAIL_IF(sem_wait(prev)); | |
| FAIL_IF(expected_dscr != get_dscr()); | |
| FAIL_IF(expected_dscr != get_dscr_usr()); | |
| expected_dscr = (expected_dscr - 1) % DSCR_MAX; | |
| set_dscr(expected_dscr); | |
| FAIL_IF(sem_post(next)); | |
| } | |
| FAIL_IF(pthread_join(thread, NULL)); | |
| FAIL_IF(sem_destroy(prev)); | |
| FAIL_IF(sem_destroy(next)); | |
| return 0; | |
| } | |
| struct random_thread_args { | |
| pthread_t thread_id; | |
| bool do_yields; | |
| pthread_barrier_t *barrier; | |
| }; | |
| void *dscr_explicit_random_thread(void *in) | |
| { | |
| struct random_thread_args *args = (struct random_thread_args *)in; | |
| unsigned long expected_dscr = 0; | |
| int err; | |
| srand(gettid()); | |
| err = pthread_barrier_wait(args->barrier); | |
| FAIL_IF_EXIT(err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD); | |
| for (int i = 0; i < COUNT; i++) { | |
| expected_dscr = rand() % DSCR_MAX; | |
| set_dscr(expected_dscr); | |
| for (int j = rand() % 5; j > 0; --j) { | |
| FAIL_IF_EXIT(get_dscr() != expected_dscr); | |
| FAIL_IF_EXIT(get_dscr_usr() != expected_dscr); | |
| if (args->do_yields && rand() % 2) | |
| sched_yield(); | |
| } | |
| expected_dscr = rand() % DSCR_MAX; | |
| set_dscr_usr(expected_dscr); | |
| for (int j = rand() % 5; j > 0; --j) { | |
| FAIL_IF_EXIT(get_dscr() != expected_dscr); | |
| FAIL_IF_EXIT(get_dscr_usr() != expected_dscr); | |
| if (args->do_yields && rand() % 2) | |
| sched_yield(); | |
| } | |
| } | |
| return NULL; | |
| } | |
| int dscr_explicit_random_test(void) | |
| { | |
| struct random_thread_args threads[THREADS]; | |
| pthread_barrier_t barrier; | |
| SKIP_IF(!have_hwcap2(PPC_FEATURE2_DSCR)); | |
| FAIL_IF(pthread_barrier_init(&barrier, NULL, THREADS)); | |
| for (int i = 0; i < THREADS; i++) { | |
| threads[i].do_yields = i % 2 == 0; | |
| threads[i].barrier = &barrier; | |
| FAIL_IF(pthread_create(&threads[i].thread_id, NULL, | |
| dscr_explicit_random_thread, (void *)&threads[i])); | |
| } | |
| for (int i = 0; i < THREADS; i++) | |
| FAIL_IF(pthread_join(threads[i].thread_id, NULL)); | |
| FAIL_IF(pthread_barrier_destroy(&barrier)); | |
| return 0; | |
| } | |
| int main(int argc, char *argv[]) | |
| { | |
| unsigned long orig_dscr_default = 0; | |
| int err = 0; | |
| if (have_hwcap2(PPC_FEATURE2_DSCR)) | |
| orig_dscr_default = get_default_dscr(); | |
| err |= test_harness(dscr_explicit_lockstep_test, "dscr_explicit_lockstep_test"); | |
| err |= test_harness(dscr_explicit_random_test, "dscr_explicit_random_test"); | |
| if (have_hwcap2(PPC_FEATURE2_DSCR)) | |
| set_default_dscr(orig_dscr_default); | |
| return err; | |
| } |