- Linux-kselftest-mirror - lists.linaro.org

[Linux-kselftest-mirror] [RFC PATCH v2 for 4.15 15/24] membarrier: selftest: Test private expedited cmd

by Mathieu Desnoyers

Test the new MEMBARRIER_CMD_PRIVATE_EXPEDITED and MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED commands. Add checks expecting specific error values on system calls expected to fail. Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers(a)efficios.com> Acked-by: Shuah Khan <shuahkh(a)osg.samsung.com> Acked-by: Greg Kroah-Hartman <gregkh(a)linuxfoundation.org> CC: Peter Zijlstra <peterz(a)infradead.org> CC: Paul E. McKenney <paulmck(a)linux.vnet.ibm.com> CC: Boqun Feng <boqun.feng(a)gmail.com> CC: Andrew Hunter <ahh(a)google.com> CC: Maged Michael <maged.michael(a)gmail.com> CC: Avi Kivity <avi(a)scylladb.com> CC: Benjamin Herrenschmidt <benh(a)kernel.crashing.org> CC: Paul Mackerras <paulus(a)samba.org> CC: Michael Ellerman <mpe(a)ellerman.id.au> CC: Dave Watson <davejwatson(a)fb.com> CC: Alan Stern <stern(a)rowland.harvard.edu> CC: Will Deacon <will.deacon(a)arm.com> CC: Andy Lutomirski <luto(a)kernel.org> CC: Alice Ferrazzi <alice.ferrazzi(a)gmail.com> CC: Paul Elder <paul.elder(a)pitt.edu> CC: linux-kselftest(a)vger.kernel.org CC: linux-arch(a)vger.kernel.org --- Changes since v1: - return result of ksft_exit_pass from main(), silencing compiler warning about missing return value. --- .../testing/selftests/membarrier/membarrier_test.c | 111 ++++++++++++++++++--- 1 file changed, 95 insertions(+), 16 deletions(-) diff --git a/tools/testing/selftests/membarrier/membarrier_test.c b/tools/testing/selftests/membarrier/membarrier_test.c index 9e674d9514d1..e6ee73d01fa1 100644 --- a/tools/testing/selftests/membarrier/membarrier_test.c +++ b/tools/testing/selftests/membarrier/membarrier_test.c @@ -16,49 +16,119 @@ static int sys_membarrier(int cmd, int flags) static int test_membarrier_cmd_fail(void) { int cmd = -1, flags = 0; + const char *test_name = "sys membarrier invalid command"; if (sys_membarrier(cmd, flags) != -1) { ksft_exit_fail_msg( - "sys membarrier invalid command test: command = %d, flags = %d. Should fail, but passed\n", - cmd, flags); + "%s test: command = %d, flags = %d. Should fail, but passed\n", + test_name, cmd, flags); + } + if (errno != EINVAL) { + ksft_exit_fail_msg( + "%s test: flags = %d. Should return (%d: \"%s\"), but returned (%d: \"%s\").\n", + test_name, flags, EINVAL, strerror(EINVAL), + errno, strerror(errno)); } ksft_test_result_pass( - "sys membarrier invalid command test: command = %d, flags = %d. Failed as expected\n", - cmd, flags); + "%s test: command = %d, flags = %d, errno = %d. Failed as expected\n", + test_name, cmd, flags, errno); return 0; } static int test_membarrier_flags_fail(void) { int cmd = MEMBARRIER_CMD_QUERY, flags = 1; + const char *test_name = "sys membarrier MEMBARRIER_CMD_QUERY invalid flags"; if (sys_membarrier(cmd, flags) != -1) { ksft_exit_fail_msg( - "sys membarrier MEMBARRIER_CMD_QUERY invalid flags test: flags = %d. Should fail, but passed\n", - flags); + "%s test: flags = %d. Should fail, but passed\n", + test_name, flags); + } + if (errno != EINVAL) { + ksft_exit_fail_msg( + "%s test: flags = %d. Should return (%d: \"%s\"), but returned (%d: \"%s\").\n", + test_name, flags, EINVAL, strerror(EINVAL), + errno, strerror(errno)); } ksft_test_result_pass( - "sys membarrier MEMBARRIER_CMD_QUERY invalid flags test: flags = %d. Failed as expected\n", - flags); + "%s test: flags = %d, errno = %d. Failed as expected\n", + test_name, flags, errno); return 0; } -static int test_membarrier_success(void) +static int test_membarrier_shared_success(void) { int cmd = MEMBARRIER_CMD_SHARED, flags = 0; - const char *test_name = "sys membarrier MEMBARRIER_CMD_SHARED\n"; + const char *test_name = "sys membarrier MEMBARRIER_CMD_SHARED"; + + if (sys_membarrier(cmd, flags) != 0) { + ksft_exit_fail_msg( + "%s test: flags = %d, errno = %d\n", + test_name, flags, errno); + } + + ksft_test_result_pass( + "%s test: flags = %d\n", test_name, flags); + return 0; +} + +static int test_membarrier_private_expedited_fail(void) +{ + int cmd = MEMBARRIER_CMD_PRIVATE_EXPEDITED, flags = 0; + const char *test_name = "sys membarrier MEMBARRIER_CMD_PRIVATE_EXPEDITED not registered failure"; + + if (sys_membarrier(cmd, flags) != -1) { + ksft_exit_fail_msg( + "%s test: flags = %d. Should fail, but passed\n", + test_name, flags); + } + if (errno != EPERM) { + ksft_exit_fail_msg( + "%s test: flags = %d. Should return (%d: \"%s\"), but returned (%d: \"%s\").\n", + test_name, flags, EPERM, strerror(EPERM), + errno, strerror(errno)); + } + + ksft_test_result_pass( + "%s test: flags = %d, errno = %d\n", + test_name, flags, errno); + return 0; +} + +static int test_membarrier_register_private_expedited_success(void) +{ + int cmd = MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED, flags = 0; + const char *test_name = "sys membarrier MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED"; if (sys_membarrier(cmd, flags) != 0) { ksft_exit_fail_msg( - "sys membarrier MEMBARRIER_CMD_SHARED test: flags = %d\n", - flags); + "%s test: flags = %d, errno = %d\n", + test_name, flags, errno); } ksft_test_result_pass( - "sys membarrier MEMBARRIER_CMD_SHARED test: flags = %d\n", - flags); + "%s test: flags = %d\n", + test_name, flags); + return 0; +} + +static int test_membarrier_private_expedited_success(void) +{ + int cmd = MEMBARRIER_CMD_PRIVATE_EXPEDITED, flags = 0; + const char *test_name = "sys membarrier MEMBARRIER_CMD_PRIVATE_EXPEDITED"; + + if (sys_membarrier(cmd, flags) != 0) { + ksft_exit_fail_msg( + "%s test: flags = %d, errno = %d\n", + test_name, flags, errno); + } + + ksft_test_result_pass( + "%s test: flags = %d\n", + test_name, flags); return 0; } @@ -72,7 +142,16 @@ static int test_membarrier(void) status = test_membarrier_flags_fail(); if (status) return status; - status = test_membarrier_success(); + status = test_membarrier_shared_success(); + if (status) + return status; + status = test_membarrier_private_expedited_fail(); + if (status) + return status; + status = test_membarrier_register_private_expedited_success(); + if (status) + return status; + status = test_membarrier_private_expedited_success(); if (status) return status; return 0; @@ -108,5 +187,5 @@ int main(int argc, char **argv) test_membarrier_query(); test_membarrier(); - ksft_exit_pass(); + return ksft_exit_pass(); } -- 2.11.0 -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

7 years, 1 month

1
0
0 0

[Linux-kselftest-mirror] [RFC PATCH for 4.15 14/24] Restartable sequences selftests: arm: workaround gcc asm size guess

by Mathieu Desnoyers

Fixes assembler errors: /tmp/cceKwI9a.s: Assembler messages: /tmp/cceKwI9a.s:849: Error: co-processor offset out of range with gcc prior to gcc-7. This can trigger if multiple rseq inline asm are used within the same function. My best guess on the cause of this issue is that gcc has a hard time figuring out the actual size of the inline asm, and therefore does not compute the offsets at which literal values can be placed from the program counter accurately. Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers(a)efficios.com> CC: "Paul E. McKenney" <paulmck(a)linux.vnet.ibm.com> CC: Peter Zijlstra <peterz(a)infradead.org> CC: Paul Turner <pjt(a)google.com> CC: Thomas Gleixner <tglx(a)linutronix.de> CC: Andrew Hunter <ahh(a)google.com> CC: Andy Lutomirski <luto(a)amacapital.net> CC: Andi Kleen <andi(a)firstfloor.org> CC: Dave Watson <davejwatson(a)fb.com> CC: Chris Lameter <cl(a)linux.com> CC: Ingo Molnar <mingo(a)redhat.com> CC: "H. Peter Anvin" <hpa(a)zytor.com> CC: Ben Maurer <bmaurer(a)fb.com> CC: Steven Rostedt <rostedt(a)goodmis.org> CC: Josh Triplett <josh(a)joshtriplett.org> CC: Linus Torvalds <torvalds(a)linux-foundation.org> CC: Andrew Morton <akpm(a)linux-foundation.org> CC: Russell King <linux(a)arm.linux.org.uk> CC: Catalin Marinas <catalin.marinas(a)arm.com> CC: Will Deacon <will.deacon(a)arm.com> CC: Michael Kerrisk <mtk.manpages(a)gmail.com> CC: Boqun Feng <boqun.feng(a)gmail.com> CC: Florian Weimer <fweimer(a)redhat.com> CC: Shuah Khan <shuah(a)kernel.org> CC: linux-kselftest(a)vger.kernel.org CC: linux-api(a)vger.kernel.org --- tools/testing/selftests/rseq/rseq-arm.h | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/tools/testing/selftests/rseq/rseq-arm.h b/tools/testing/selftests/rseq/rseq-arm.h index b02489cde80b..c42db74c48ae 100644 --- a/tools/testing/selftests/rseq/rseq-arm.h +++ b/tools/testing/selftests/rseq/rseq-arm.h @@ -79,12 +79,15 @@ do { \ teardown \ "b %l[" __rseq_str(cmpfail_label) "]\n\t" +#define rseq_workaround_gcc_asm_size_guess() __asm__ __volatile__("") + static inline __attribute__((always_inline)) int rseq_cmpeqv_storev(intptr_t *v, intptr_t expect, intptr_t newv, int cpu) { RSEQ_INJECT_C(9) + rseq_workaround_gcc_asm_size_guess(); __asm__ __volatile__ goto ( RSEQ_ASM_DEFINE_TABLE(__rseq_table, 0x0, 0x0, 1f, 2f-1f, 4f) RSEQ_ASM_STORE_RSEQ_CS(1, 3f, rseq_cs) @@ -115,11 +118,14 @@ int rseq_cmpeqv_storev(intptr_t *v, intptr_t expect, intptr_t newv, RSEQ_INJECT_CLOBBER : abort, cmpfail ); + rseq_workaround_gcc_asm_size_guess(); return 0; abort: + rseq_workaround_gcc_asm_size_guess(); RSEQ_INJECT_FAILED return -1; cmpfail: + rseq_workaround_gcc_asm_size_guess(); return 1; } @@ -129,6 +135,7 @@ int rseq_cmpnev_storeoffp_load(intptr_t *v, intptr_t expectnot, { RSEQ_INJECT_C(9) + rseq_workaround_gcc_asm_size_guess(); __asm__ __volatile__ goto ( RSEQ_ASM_DEFINE_TABLE(__rseq_table, 0x0, 0x0, 1f, 2f-1f, 4f) RSEQ_ASM_STORE_RSEQ_CS(1, 3f, rseq_cs) @@ -164,11 +171,14 @@ int rseq_cmpnev_storeoffp_load(intptr_t *v, intptr_t expectnot, RSEQ_INJECT_CLOBBER : abort, cmpfail ); + rseq_workaround_gcc_asm_size_guess(); return 0; abort: + rseq_workaround_gcc_asm_size_guess(); RSEQ_INJECT_FAILED return -1; cmpfail: + rseq_workaround_gcc_asm_size_guess(); return 1; } @@ -177,6 +187,7 @@ int rseq_addv(intptr_t *v, intptr_t count, int cpu) { RSEQ_INJECT_C(9) + rseq_workaround_gcc_asm_size_guess(); __asm__ __volatile__ goto ( RSEQ_ASM_DEFINE_TABLE(__rseq_table, 0x0, 0x0, 1f, 2f-1f, 4f) RSEQ_ASM_STORE_RSEQ_CS(1, 3f, rseq_cs) @@ -203,8 +214,10 @@ int rseq_addv(intptr_t *v, intptr_t count, int cpu) RSEQ_INJECT_CLOBBER : abort ); + rseq_workaround_gcc_asm_size_guess(); return 0; abort: + rseq_workaround_gcc_asm_size_guess(); RSEQ_INJECT_FAILED return -1; } @@ -216,6 +229,7 @@ int rseq_cmpeqv_trystorev_storev(intptr_t *v, intptr_t expect, { RSEQ_INJECT_C(9) + rseq_workaround_gcc_asm_size_guess(); __asm__ __volatile__ goto ( RSEQ_ASM_DEFINE_TABLE(__rseq_table, 0x0, 0x0, 1f, 2f-1f, 4f) RSEQ_ASM_STORE_RSEQ_CS(1, 3f, rseq_cs) @@ -253,11 +267,14 @@ int rseq_cmpeqv_trystorev_storev(intptr_t *v, intptr_t expect, RSEQ_INJECT_CLOBBER : abort, cmpfail ); + rseq_workaround_gcc_asm_size_guess(); return 0; abort: + rseq_workaround_gcc_asm_size_guess(); RSEQ_INJECT_FAILED return -1; cmpfail: + rseq_workaround_gcc_asm_size_guess(); return 1; } @@ -268,6 +285,7 @@ int rseq_cmpeqv_trystorev_storev_release(intptr_t *v, intptr_t expect, { RSEQ_INJECT_C(9) + rseq_workaround_gcc_asm_size_guess(); __asm__ __volatile__ goto ( RSEQ_ASM_DEFINE_TABLE(__rseq_table, 0x0, 0x0, 1f, 2f-1f, 4f) RSEQ_ASM_STORE_RSEQ_CS(1, 3f, rseq_cs) @@ -306,11 +324,14 @@ int rseq_cmpeqv_trystorev_storev_release(intptr_t *v, intptr_t expect, RSEQ_INJECT_CLOBBER : abort, cmpfail ); + rseq_workaround_gcc_asm_size_guess(); return 0; abort: + rseq_workaround_gcc_asm_size_guess(); RSEQ_INJECT_FAILED return -1; cmpfail: + rseq_workaround_gcc_asm_size_guess(); return 1; } @@ -321,6 +342,7 @@ int rseq_cmpeqv_cmpeqv_storev(intptr_t *v, intptr_t expect, { RSEQ_INJECT_C(9) + rseq_workaround_gcc_asm_size_guess(); __asm__ __volatile__ goto ( RSEQ_ASM_DEFINE_TABLE(__rseq_table, 0x0, 0x0, 1f, 2f-1f, 4f) RSEQ_ASM_STORE_RSEQ_CS(1, 3f, rseq_cs) @@ -359,11 +381,14 @@ int rseq_cmpeqv_cmpeqv_storev(intptr_t *v, intptr_t expect, RSEQ_INJECT_CLOBBER : abort, cmpfail ); + rseq_workaround_gcc_asm_size_guess(); return 0; abort: + rseq_workaround_gcc_asm_size_guess(); RSEQ_INJECT_FAILED return -1; cmpfail: + rseq_workaround_gcc_asm_size_guess(); return 1; } @@ -376,6 +401,7 @@ int rseq_cmpeqv_trymemcpy_storev(intptr_t *v, intptr_t expect, RSEQ_INJECT_C(9) + rseq_workaround_gcc_asm_size_guess(); __asm__ __volatile__ goto ( RSEQ_ASM_DEFINE_TABLE(__rseq_table, 0x0, 0x0, 1f, 2f-1f, 4f) "str %[src], %[rseq_scratch0]\n\t" @@ -442,11 +468,14 @@ int rseq_cmpeqv_trymemcpy_storev(intptr_t *v, intptr_t expect, RSEQ_INJECT_CLOBBER : abort, cmpfail ); + rseq_workaround_gcc_asm_size_guess(); return 0; abort: + rseq_workaround_gcc_asm_size_guess(); RSEQ_INJECT_FAILED return -1; cmpfail: + rseq_workaround_gcc_asm_size_guess(); return 1; } @@ -459,6 +488,7 @@ int rseq_cmpeqv_trymemcpy_storev_release(intptr_t *v, intptr_t expect, RSEQ_INJECT_C(9) + rseq_workaround_gcc_asm_size_guess(); __asm__ __volatile__ goto ( RSEQ_ASM_DEFINE_TABLE(__rseq_table, 0x0, 0x0, 1f, 2f-1f, 4f) "str %[src], %[rseq_scratch0]\n\t" @@ -526,10 +556,13 @@ int rseq_cmpeqv_trymemcpy_storev_release(intptr_t *v, intptr_t expect, RSEQ_INJECT_CLOBBER : abort, cmpfail ); + rseq_workaround_gcc_asm_size_guess(); return 0; abort: + rseq_workaround_gcc_asm_size_guess(); RSEQ_INJECT_FAILED return -1; cmpfail: + rseq_workaround_gcc_asm_size_guess(); return 1; } -- 2.11.0 -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

7 years, 1 month

1
0
0 0

[Linux-kselftest-mirror] [RFC PATCH v2 for 4.15 12/24] cpu_opv: Implement selftests

by Mathieu Desnoyers

Implement cpu_opv selftests. It needs to express dependencies on header files and .so, which require to override the selftests lib.mk targets. Introduce a new OVERRIDE_TARGETS define for this. Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers(a)efficios.com> CC: Russell King <linux(a)arm.linux.org.uk> CC: Catalin Marinas <catalin.marinas(a)arm.com> CC: Will Deacon <will.deacon(a)arm.com> CC: Thomas Gleixner <tglx(a)linutronix.de> CC: Paul Turner <pjt(a)google.com> CC: Andrew Hunter <ahh(a)google.com> CC: Peter Zijlstra <peterz(a)infradead.org> CC: Andy Lutomirski <luto(a)amacapital.net> CC: Andi Kleen <andi(a)firstfloor.org> CC: Dave Watson <davejwatson(a)fb.com> CC: Chris Lameter <cl(a)linux.com> CC: Ingo Molnar <mingo(a)redhat.com> CC: "H. Peter Anvin" <hpa(a)zytor.com> CC: Ben Maurer <bmaurer(a)fb.com> CC: Steven Rostedt <rostedt(a)goodmis.org> CC: "Paul E. McKenney" <paulmck(a)linux.vnet.ibm.com> CC: Josh Triplett <josh(a)joshtriplett.org> CC: Linus Torvalds <torvalds(a)linux-foundation.org> CC: Andrew Morton <akpm(a)linux-foundation.org> CC: Boqun Feng <boqun.feng(a)gmail.com> CC: Shuah Khan <shuah(a)kernel.org> CC: linux-kselftest(a)vger.kernel.org CC: linux-api(a)vger.kernel.org --- Changes since v1: - Expose similar library API as rseq: Expose library API closely matching the rseq APIs, following removal of the event counter from the rseq kernel API. - Update makefile to fix make run_tests dependency on "all". - Introduce a OVERRIDE_TARGETS. --- MAINTAINERS | 1 + tools/testing/selftests/Makefile | 1 + tools/testing/selftests/cpu-opv/.gitignore | 1 + tools/testing/selftests/cpu-opv/Makefile | 17 + .../testing/selftests/cpu-opv/basic_cpu_opv_test.c | 1157 ++++++++++++++++++++ tools/testing/selftests/cpu-opv/cpu-op.c | 348 ++++++ tools/testing/selftests/cpu-opv/cpu-op.h | 68 ++ tools/testing/selftests/lib.mk | 4 + 8 files changed, 1597 insertions(+) create mode 100644 tools/testing/selftests/cpu-opv/.gitignore create mode 100644 tools/testing/selftests/cpu-opv/Makefile create mode 100644 tools/testing/selftests/cpu-opv/basic_cpu_opv_test.c create mode 100644 tools/testing/selftests/cpu-opv/cpu-op.c create mode 100644 tools/testing/selftests/cpu-opv/cpu-op.h diff --git a/MAINTAINERS b/MAINTAINERS index 45a1bbdaa287..85a1e8781f56 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -3681,6 +3681,7 @@ L: linux-kernel(a)vger.kernel.org S: Supported F: kernel/cpu_opv.c F: include/uapi/linux/cpu_opv.h +F: tools/testing/selftests/cpu-opv/ CRAMFS FILESYSTEM W: http://sourceforge.net/projects/cramfs/ diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile index 3c9c0bbe7dbb..c66e5e67cfab 100644 --- a/tools/testing/selftests/Makefile +++ b/tools/testing/selftests/Makefile @@ -4,6 +4,7 @@ TARGETS += breakpoints TARGETS += capabilities TARGETS += cpufreq TARGETS += cpu-hotplug +TARGETS += cpu-opv TARGETS += efivarfs TARGETS += exec TARGETS += firmware diff --git a/tools/testing/selftests/cpu-opv/.gitignore b/tools/testing/selftests/cpu-opv/.gitignore new file mode 100644 index 000000000000..c7186eb95cf5 --- /dev/null +++ b/tools/testing/selftests/cpu-opv/.gitignore @@ -0,0 +1 @@ +basic_cpu_opv_test diff --git a/tools/testing/selftests/cpu-opv/Makefile b/tools/testing/selftests/cpu-opv/Makefile new file mode 100644 index 000000000000..21e63545d521 --- /dev/null +++ b/tools/testing/selftests/cpu-opv/Makefile @@ -0,0 +1,17 @@ +CFLAGS += -O2 -Wall -g -I./ -I../../../../usr/include/ -L./ -Wl,-rpath=./ + +# Own dependencies because we only want to build against 1st prerequisite, but +# still track changes to header files and depend on shared object. +OVERRIDE_TARGETS = 1 + +TEST_GEN_PROGS = basic_cpu_opv_test + +TEST_GEN_PROGS_EXTENDED = libcpu-op.so + +include ../lib.mk + +$(OUTPUT)/libcpu-op.so: cpu-op.c cpu-op.h + $(CC) $(CFLAGS) -shared -fPIC $< -o $@ + +$(OUTPUT)/%: %.c $(TEST_GEN_PROGS_EXTENDED) cpu-op.h + $(CC) $(CFLAGS) $< -lcpu-op -o $@ diff --git a/tools/testing/selftests/cpu-opv/basic_cpu_opv_test.c b/tools/testing/selftests/cpu-opv/basic_cpu_opv_test.c new file mode 100644 index 000000000000..6b624f1939ea --- /dev/null +++ b/tools/testing/selftests/cpu-opv/basic_cpu_opv_test.c @@ -0,0 +1,1157 @@ +/* + * Basic test coverage for cpu_opv system call. + */ + +#define _GNU_SOURCE +#include <assert.h> +#include <sched.h> +#include <signal.h> +#include <stdio.h> +#include <string.h> +#include <sys/time.h> +#include <errno.h> +#include <stdlib.h> + +#include "cpu-op.h" + +#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) + +#define TESTBUFLEN 4096 +#define TESTBUFLEN_CMP 16 + +#define TESTBUFLEN_PAGE_MAX 65536 + +static int test_compare_eq_op(char *a, char *b, size_t len) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_COMPARE_EQ_OP, + .len = len, + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.compare_op.a, a), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.compare_op.b, b), + .u.compare_op.expect_fault_a = 0, + .u.compare_op.expect_fault_b = 0, + }, + }; + int ret, cpu; + + do { + cpu = cpu_op_get_current_cpu(); + ret = cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); + } while (ret == -1 && errno == EAGAIN); + + return ret; +} + +static int test_compare_eq_same(void) +{ + int i, ret; + char buf1[TESTBUFLEN]; + char buf2[TESTBUFLEN]; + const char *test_name = "test_compare_eq same"; + + printf("Testing %s\n", test_name); + + /* Test compare_eq */ + for (i = 0; i < TESTBUFLEN; i++) + buf1[i] = (char)i; + for (i = 0; i < TESTBUFLEN; i++) + buf2[i] = (char)i; + ret = test_compare_eq_op(buf2, buf1, TESTBUFLEN); + if (ret < 0) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + if (ret > 0) { + printf("%s returned %d, expecting %d\n", + test_name, ret, 0); + return -1; + } + return 0; +} + +static int test_compare_eq_diff(void) +{ + int i, ret; + char buf1[TESTBUFLEN]; + char buf2[TESTBUFLEN]; + const char *test_name = "test_compare_eq different"; + + printf("Testing %s\n", test_name); + + for (i = 0; i < TESTBUFLEN; i++) + buf1[i] = (char)i; + memset(buf2, 0, TESTBUFLEN); + ret = test_compare_eq_op(buf2, buf1, TESTBUFLEN); + if (ret < 0) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + if (ret == 0) { + printf("%s returned %d, expecting %d\n", + test_name, ret, 1); + return -1; + } + return 0; +} + +static int test_compare_ne_op(char *a, char *b, size_t len) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_COMPARE_NE_OP, + .len = len, + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.compare_op.a, a), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.compare_op.b, b), + .u.compare_op.expect_fault_a = 0, + .u.compare_op.expect_fault_b = 0, + }, + }; + int ret, cpu; + + do { + cpu = cpu_op_get_current_cpu(); + ret = cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); + } while (ret == -1 && errno == EAGAIN); + + return ret; +} + +static int test_compare_ne_same(void) +{ + int i, ret; + char buf1[TESTBUFLEN]; + char buf2[TESTBUFLEN]; + const char *test_name = "test_compare_ne same"; + + printf("Testing %s\n", test_name); + + /* Test compare_ne */ + for (i = 0; i < TESTBUFLEN; i++) + buf1[i] = (char)i; + for (i = 0; i < TESTBUFLEN; i++) + buf2[i] = (char)i; + ret = test_compare_ne_op(buf2, buf1, TESTBUFLEN); + if (ret < 0) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + if (ret == 0) { + printf("%s returned %d, expecting %d\n", + test_name, ret, 1); + return -1; + } + return 0; +} + +static int test_compare_ne_diff(void) +{ + int i, ret; + char buf1[TESTBUFLEN]; + char buf2[TESTBUFLEN]; + const char *test_name = "test_compare_ne different"; + + printf("Testing %s\n", test_name); + + for (i = 0; i < TESTBUFLEN; i++) + buf1[i] = (char)i; + memset(buf2, 0, TESTBUFLEN); + ret = test_compare_ne_op(buf2, buf1, TESTBUFLEN); + if (ret < 0) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + if (ret != 0) { + printf("%s returned %d, expecting %d\n", + test_name, ret, 0); + return -1; + } + return 0; +} + +static int test_2compare_eq_op(char *a, char *b, char *c, char *d, + size_t len) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_COMPARE_EQ_OP, + .len = len, + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.compare_op.a, a), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.compare_op.b, b), + .u.compare_op.expect_fault_a = 0, + .u.compare_op.expect_fault_b = 0, + }, + [1] = { + .op = CPU_COMPARE_EQ_OP, + .len = len, + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.compare_op.a, c), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.compare_op.b, d), + .u.compare_op.expect_fault_a = 0, + .u.compare_op.expect_fault_b = 0, + }, + }; + int ret, cpu; + + do { + cpu = cpu_op_get_current_cpu(); + ret = cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); + } while (ret == -1 && errno == EAGAIN); + + return ret; +} + +static int test_2compare_eq_index(void) +{ + int i, ret; + char buf1[TESTBUFLEN_CMP]; + char buf2[TESTBUFLEN_CMP]; + char buf3[TESTBUFLEN_CMP]; + char buf4[TESTBUFLEN_CMP]; + const char *test_name = "test_2compare_eq index"; + + printf("Testing %s\n", test_name); + + for (i = 0; i < TESTBUFLEN_CMP; i++) + buf1[i] = (char)i; + memset(buf2, 0, TESTBUFLEN_CMP); + memset(buf3, 0, TESTBUFLEN_CMP); + memset(buf4, 0, TESTBUFLEN_CMP); + + /* First compare failure is op[0], expect 1. */ + ret = test_2compare_eq_op(buf2, buf1, buf4, buf3, TESTBUFLEN_CMP); + if (ret < 0) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + if (ret != 1) { + printf("%s returned %d, expecting %d\n", + test_name, ret, 1); + return -1; + } + + /* All compares succeed. */ + for (i = 0; i < TESTBUFLEN_CMP; i++) + buf2[i] = (char)i; + ret = test_2compare_eq_op(buf2, buf1, buf4, buf3, TESTBUFLEN_CMP); + if (ret < 0) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + if (ret != 0) { + printf("%s returned %d, expecting %d\n", + test_name, ret, 0); + return -1; + } + + /* First compare failure is op[1], expect 2. */ + for (i = 0; i < TESTBUFLEN_CMP; i++) + buf3[i] = (char)i; + ret = test_2compare_eq_op(buf2, buf1, buf4, buf3, TESTBUFLEN_CMP); + if (ret < 0) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + if (ret != 2) { + printf("%s returned %d, expecting %d\n", + test_name, ret, 2); + return -1; + } + + return 0; +} + +static int test_2compare_ne_op(char *a, char *b, char *c, char *d, + size_t len) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_COMPARE_NE_OP, + .len = len, + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.compare_op.a, a), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.compare_op.b, b), + .u.compare_op.expect_fault_a = 0, + .u.compare_op.expect_fault_b = 0, + }, + [1] = { + .op = CPU_COMPARE_NE_OP, + .len = len, + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.compare_op.a, c), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.compare_op.b, d), + .u.compare_op.expect_fault_a = 0, + .u.compare_op.expect_fault_b = 0, + }, + }; + int ret, cpu; + + do { + cpu = cpu_op_get_current_cpu(); + ret = cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); + } while (ret == -1 && errno == EAGAIN); + + return ret; +} + +static int test_2compare_ne_index(void) +{ + int i, ret; + char buf1[TESTBUFLEN_CMP]; + char buf2[TESTBUFLEN_CMP]; + char buf3[TESTBUFLEN_CMP]; + char buf4[TESTBUFLEN_CMP]; + const char *test_name = "test_2compare_ne index"; + + printf("Testing %s\n", test_name); + + memset(buf1, 0, TESTBUFLEN_CMP); + memset(buf2, 0, TESTBUFLEN_CMP); + memset(buf3, 0, TESTBUFLEN_CMP); + memset(buf4, 0, TESTBUFLEN_CMP); + + /* First compare ne failure is op[0], expect 1. */ + ret = test_2compare_ne_op(buf2, buf1, buf4, buf3, TESTBUFLEN_CMP); + if (ret < 0) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + if (ret != 1) { + printf("%s returned %d, expecting %d\n", + test_name, ret, 1); + return -1; + } + + /* All compare ne succeed. */ + for (i = 0; i < TESTBUFLEN_CMP; i++) + buf1[i] = (char)i; + for (i = 0; i < TESTBUFLEN_CMP; i++) + buf3[i] = (char)i; + ret = test_2compare_ne_op(buf2, buf1, buf4, buf3, TESTBUFLEN_CMP); + if (ret < 0) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + if (ret != 0) { + printf("%s returned %d, expecting %d\n", + test_name, ret, 0); + return -1; + } + + /* First compare failure is op[1], expect 2. */ + for (i = 0; i < TESTBUFLEN_CMP; i++) + buf4[i] = (char)i; + ret = test_2compare_ne_op(buf2, buf1, buf4, buf3, TESTBUFLEN_CMP); + if (ret < 0) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + if (ret != 2) { + printf("%s returned %d, expecting %d\n", + test_name, ret, 2); + return -1; + } + + return 0; +} + +static int test_memcpy_op(void *dst, void *src, size_t len) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_MEMCPY_OP, + .len = len, + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.memcpy_op.dst, dst), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.memcpy_op.src, src), + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + }; + int ret, cpu; + + do { + cpu = cpu_op_get_current_cpu(); + ret = cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); + } while (ret == -1 && errno == EAGAIN); + + return ret; +} + +static int test_memcpy(void) +{ + int i, ret; + char buf1[TESTBUFLEN]; + char buf2[TESTBUFLEN]; + const char *test_name = "test_memcpy"; + + printf("Testing %s\n", test_name); + + /* Test memcpy */ + for (i = 0; i < TESTBUFLEN; i++) + buf1[i] = (char)i; + memset(buf2, 0, TESTBUFLEN); + ret = test_memcpy_op(buf2, buf1, TESTBUFLEN); + if (ret) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + for (i = 0; i < TESTBUFLEN; i++) { + if (buf2[i] != (char)i) { + printf("%s failed. Expecting '%d', found '%d' at offset %d\n", + test_name, (char)i, buf2[i], i); + return -1; + } + } + return 0; +} + +static int test_memcpy_u32(void) +{ + int ret; + uint32_t v1, v2; + const char *test_name = "test_memcpy_u32"; + + printf("Testing %s\n", test_name); + + /* Test memcpy_u32 */ + v1 = 42; + v2 = 0; + ret = test_memcpy_op(&v2, &v1, sizeof(v1)); + if (ret) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + if (v1 != v2) { + printf("%s failed. Expecting '%d', found '%d'\n", + test_name, v1, v2); + return -1; + } + return 0; +} + +static int test_memcpy_mb_memcpy_op(void *dst1, void *src1, + void *dst2, void *src2, size_t len) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_MEMCPY_OP, + .len = len, + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.memcpy_op.dst, dst1), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.memcpy_op.src, src1), + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + [1] = { + .op = CPU_MB_OP, + }, + [2] = { + .op = CPU_MEMCPY_OP, + .len = len, + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.memcpy_op.dst, dst2), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.memcpy_op.src, src2), + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + }; + int ret, cpu; + + do { + cpu = cpu_op_get_current_cpu(); + ret = cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); + } while (ret == -1 && errno == EAGAIN); + + return ret; +} + +static int test_memcpy_mb_memcpy(void) +{ + int ret; + int v1, v2, v3; + const char *test_name = "test_memcpy_mb_memcpy"; + + printf("Testing %s\n", test_name); + + /* Test memcpy */ + v1 = 42; + v2 = v3 = 0; + ret = test_memcpy_mb_memcpy_op(&v2, &v1, &v3, &v2, sizeof(int)); + if (ret) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + if (v3 != v1) { + printf("%s failed. Expecting '%d', found '%d'\n", + test_name, v1, v3); + return -1; + } + return 0; +} + +static int test_add_op(int *v, int64_t increment) +{ + int ret, cpu; + + do { + cpu = cpu_op_get_current_cpu(); + ret = cpu_op_add(v, increment, sizeof(*v), cpu); + } while (ret == -1 && errno == EAGAIN); + + return ret; +} + +static int test_add(void) +{ + int orig_v = 42, v, ret; + int increment = 1; + const char *test_name = "test_add"; + + printf("Testing %s\n", test_name); + + v = orig_v; + ret = test_add_op(&v, increment); + if (ret) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + return -1; + } + if (v != orig_v + increment) { + printf("%s unexpected value: %d. Should be %d.\n", + test_name, v, orig_v); + return -1; + } + return 0; +} + +static int test_two_add_op(int *v, int64_t *increments) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_ADD_OP, + .len = sizeof(*v), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK( + .u.arithmetic_op.p, v), + .u.arithmetic_op.count = increments[0], + .u.arithmetic_op.expect_fault_p = 0, + }, + [1] = { + .op = CPU_ADD_OP, + .len = sizeof(*v), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK( + .u.arithmetic_op.p, v), + .u.arithmetic_op.count = increments[1], + .u.arithmetic_op.expect_fault_p = 0, + }, + }; + int ret, cpu; + + do { + cpu = cpu_op_get_current_cpu(); + ret = cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); + } while (ret == -1 && errno == EAGAIN); + + return ret; +} + +static int test_two_add(void) +{ + int orig_v = 42, v, ret; + int64_t increments[2] = { 99, 123 }; + const char *test_name = "test_two_add"; + + printf("Testing %s\n", test_name); + + v = orig_v; + ret = test_two_add_op(&v, increments); + if (ret) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + return -1; + } + if (v != orig_v + increments[0] + increments[1]) { + printf("%s unexpected value: %d. Should be %d.\n", + test_name, v, orig_v); + return -1; + } + return 0; +} + +static int test_or_op(int *v, uint64_t mask) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_OR_OP, + .len = sizeof(*v), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK( + .u.bitwise_op.p, v), + .u.bitwise_op.mask = mask, + .u.bitwise_op.expect_fault_p = 0, + }, + }; + int ret, cpu; + + do { + cpu = cpu_op_get_current_cpu(); + ret = cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); + } while (ret == -1 && errno == EAGAIN); + + return ret; +} + +static int test_or(void) +{ + int orig_v = 0xFF00000, v, ret; + uint32_t mask = 0xFFF; + const char *test_name = "test_or"; + + printf("Testing %s\n", test_name); + + v = orig_v; + ret = test_or_op(&v, mask); + if (ret) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + return -1; + } + if (v != (orig_v | mask)) { + printf("%s unexpected value: %d. Should be %d.\n", + test_name, v, orig_v | mask); + return -1; + } + return 0; +} + +static int test_and_op(int *v, uint64_t mask) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_AND_OP, + .len = sizeof(*v), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK( + .u.bitwise_op.p, v), + .u.bitwise_op.mask = mask, + .u.bitwise_op.expect_fault_p = 0, + }, + }; + int ret, cpu; + + do { + cpu = cpu_op_get_current_cpu(); + ret = cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); + } while (ret == -1 && errno == EAGAIN); + + return ret; +} + +static int test_and(void) +{ + int orig_v = 0xF00, v, ret; + uint32_t mask = 0xFFF; + const char *test_name = "test_and"; + + printf("Testing %s\n", test_name); + + v = orig_v; + ret = test_and_op(&v, mask); + if (ret) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + return -1; + } + if (v != (orig_v & mask)) { + printf("%s unexpected value: %d. Should be %d.\n", + test_name, v, orig_v & mask); + return -1; + } + return 0; +} + +static int test_xor_op(int *v, uint64_t mask) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_XOR_OP, + .len = sizeof(*v), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK( + .u.bitwise_op.p, v), + .u.bitwise_op.mask = mask, + .u.bitwise_op.expect_fault_p = 0, + }, + }; + int ret, cpu; + + do { + cpu = cpu_op_get_current_cpu(); + ret = cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); + } while (ret == -1 && errno == EAGAIN); + + return ret; +} + +static int test_xor(void) +{ + int orig_v = 0xF00, v, ret; + uint32_t mask = 0xFFF; + const char *test_name = "test_xor"; + + printf("Testing %s\n", test_name); + + v = orig_v; + ret = test_xor_op(&v, mask); + if (ret) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + return -1; + } + if (v != (orig_v ^ mask)) { + printf("%s unexpected value: %d. Should be %d.\n", + test_name, v, orig_v ^ mask); + return -1; + } + return 0; +} + +static int test_lshift_op(int *v, uint32_t bits) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_LSHIFT_OP, + .len = sizeof(*v), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK( + .u.shift_op.p, v), + .u.shift_op.bits = bits, + .u.shift_op.expect_fault_p = 0, + }, + }; + int ret, cpu; + + do { + cpu = cpu_op_get_current_cpu(); + ret = cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); + } while (ret == -1 && errno == EAGAIN); + + return ret; +} + +static int test_lshift(void) +{ + int orig_v = 0xF00, v, ret; + uint32_t bits = 5; + const char *test_name = "test_lshift"; + + printf("Testing %s\n", test_name); + + v = orig_v; + ret = test_lshift_op(&v, bits); + if (ret) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + return -1; + } + if (v != (orig_v << bits)) { + printf("%s unexpected value: %d. Should be %d.\n", + test_name, v, orig_v << bits); + return -1; + } + return 0; +} + +static int test_rshift_op(int *v, uint32_t bits) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_RSHIFT_OP, + .len = sizeof(*v), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK( + .u.shift_op.p, v), + .u.shift_op.bits = bits, + .u.shift_op.expect_fault_p = 0, + }, + }; + int ret, cpu; + + do { + cpu = cpu_op_get_current_cpu(); + ret = cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); + } while (ret == -1 && errno == EAGAIN); + + return ret; +} + +static int test_rshift(void) +{ + int orig_v = 0xF00, v, ret; + uint32_t bits = 5; + const char *test_name = "test_rshift"; + + printf("Testing %s\n", test_name); + + v = orig_v; + ret = test_rshift_op(&v, bits); + if (ret) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + return -1; + } + if (v != (orig_v >> bits)) { + printf("%s unexpected value: %d. Should be %d.\n", + test_name, v, orig_v >> bits); + return -1; + } + return 0; +} + +static int test_cmpxchg_op(void *v, void *expect, void *old, void *n, + size_t len) +{ + int ret, cpu; + + do { + cpu = cpu_op_get_current_cpu(); + ret = cpu_op_cmpxchg(v, expect, old, n, len, cpu); + } while (ret == -1 && errno == EAGAIN); + + return ret; +} + + +static int test_cmpxchg_success(void) +{ + int ret; + uint64_t orig_v = 1, v, expect = 1, old = 0, n = 3; + const char *test_name = "test_cmpxchg success"; + + printf("Testing %s\n", test_name); + + v = orig_v; + ret = test_cmpxchg_op(&v, &expect, &old, &n, sizeof(uint64_t)); + if (ret < 0) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + if (ret) { + printf("%s returned %d, expecting %d\n", + test_name, ret, 0); + return -1; + } + if (v != n) { + printf("%s v is %lld, expecting %lld\n", + test_name, (long long)v, (long long)n); + return -1; + } + if (old != orig_v) { + printf("%s old is %lld, expecting %lld\n", + test_name, (long long)old, (long long)orig_v); + return -1; + } + return 0; +} + +static int test_cmpxchg_fail(void) +{ + int ret; + uint64_t orig_v = 1, v, expect = 123, old = 0, n = 3; + const char *test_name = "test_cmpxchg fail"; + + printf("Testing %s\n", test_name); + + v = orig_v; + ret = test_cmpxchg_op(&v, &expect, &old, &n, sizeof(uint64_t)); + if (ret < 0) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + if (ret == 0) { + printf("%s returned %d, expecting %d\n", + test_name, ret, 1); + return -1; + } + if (v == n) { + printf("%s v is %lld, expecting %lld\n", + test_name, (long long)v, (long long)orig_v); + return -1; + } + if (old != orig_v) { + printf("%s old is %lld, expecting %lld\n", + test_name, (long long)old, (long long)orig_v); + return -1; + } + return 0; +} + +static int test_memcpy_expect_fault_op(void *dst, void *src, size_t len) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_MEMCPY_OP, + .len = len, + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.memcpy_op.dst, dst), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.memcpy_op.src, src), + .u.memcpy_op.expect_fault_dst = 0, + /* Return EAGAIN on fault. */ + .u.memcpy_op.expect_fault_src = 1, + }, + }; + int cpu; + + cpu = cpu_op_get_current_cpu(); + return cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); +} + +static int test_memcpy_fault(void) +{ + int ret; + char buf1[TESTBUFLEN]; + const char *test_name = "test_memcpy_fault"; + + printf("Testing %s\n", test_name); + + /* Test memcpy */ + ret = test_memcpy_op(buf1, NULL, TESTBUFLEN); + if (!ret || (ret < 0 && errno != EFAULT)) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + /* Test memcpy expect fault */ + ret = test_memcpy_expect_fault_op(buf1, NULL, TESTBUFLEN); + if (!ret || (ret < 0 && errno != EAGAIN)) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + return 0; +} + +static int do_test_unknown_op(void) +{ + struct cpu_op opvec[] = { + [0] = { + .op = -1, /* Unknown */ + .len = 0, + }, + }; + int cpu; + + cpu = cpu_op_get_current_cpu(); + return cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); +} + +static int test_unknown_op(void) +{ + int ret; + const char *test_name = "test_unknown_op"; + + printf("Testing %s\n", test_name); + + ret = do_test_unknown_op(); + if (!ret || (ret < 0 && errno != EINVAL)) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + return 0; +} + +static int do_test_max_ops(void) +{ + struct cpu_op opvec[] = { + [0] = { .op = CPU_MB_OP, }, + [1] = { .op = CPU_MB_OP, }, + [2] = { .op = CPU_MB_OP, }, + [3] = { .op = CPU_MB_OP, }, + [4] = { .op = CPU_MB_OP, }, + [5] = { .op = CPU_MB_OP, }, + [6] = { .op = CPU_MB_OP, }, + [7] = { .op = CPU_MB_OP, }, + [8] = { .op = CPU_MB_OP, }, + [9] = { .op = CPU_MB_OP, }, + [10] = { .op = CPU_MB_OP, }, + [11] = { .op = CPU_MB_OP, }, + [12] = { .op = CPU_MB_OP, }, + [13] = { .op = CPU_MB_OP, }, + [14] = { .op = CPU_MB_OP, }, + [15] = { .op = CPU_MB_OP, }, + }; + int cpu; + + cpu = cpu_op_get_current_cpu(); + return cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); +} + +static int test_max_ops(void) +{ + int ret; + const char *test_name = "test_max_ops"; + + printf("Testing %s\n", test_name); + + ret = do_test_max_ops(); + if (ret < 0) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + return 0; +} + +static int do_test_too_many_ops(void) +{ + struct cpu_op opvec[] = { + [0] = { .op = CPU_MB_OP, }, + [1] = { .op = CPU_MB_OP, }, + [2] = { .op = CPU_MB_OP, }, + [3] = { .op = CPU_MB_OP, }, + [4] = { .op = CPU_MB_OP, }, + [5] = { .op = CPU_MB_OP, }, + [6] = { .op = CPU_MB_OP, }, + [7] = { .op = CPU_MB_OP, }, + [8] = { .op = CPU_MB_OP, }, + [9] = { .op = CPU_MB_OP, }, + [10] = { .op = CPU_MB_OP, }, + [11] = { .op = CPU_MB_OP, }, + [12] = { .op = CPU_MB_OP, }, + [13] = { .op = CPU_MB_OP, }, + [14] = { .op = CPU_MB_OP, }, + [15] = { .op = CPU_MB_OP, }, + [16] = { .op = CPU_MB_OP, }, + }; + int cpu; + + cpu = cpu_op_get_current_cpu(); + return cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); +} + +static int test_too_many_ops(void) +{ + int ret; + const char *test_name = "test_too_many_ops"; + + printf("Testing %s\n", test_name); + + ret = do_test_too_many_ops(); + if (!ret || (ret < 0 && errno != EINVAL)) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + return 0; +} + +/* Use 64kB len, largest page size known on Linux. */ +static int test_memcpy_single_too_large(void) +{ + int i, ret; + char buf1[TESTBUFLEN_PAGE_MAX + 1]; + char buf2[TESTBUFLEN_PAGE_MAX + 1]; + const char *test_name = "test_memcpy_single_too_large"; + + printf("Testing %s\n", test_name); + + /* Test memcpy */ + for (i = 0; i < TESTBUFLEN_PAGE_MAX + 1; i++) + buf1[i] = (char)i; + memset(buf2, 0, TESTBUFLEN_PAGE_MAX + 1); + ret = test_memcpy_op(buf2, buf1, TESTBUFLEN_PAGE_MAX + 1); + if (!ret || (ret < 0 && errno != EINVAL)) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + return 0; +} + +static int test_memcpy_single_ok_sum_too_large_op(void *dst, void *src, size_t len) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_MEMCPY_OP, + .len = len, + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.memcpy_op.dst, dst), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.memcpy_op.src, src), + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + [1] = { + .op = CPU_MEMCPY_OP, + .len = len, + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.memcpy_op.dst, dst), + CPU_OP_FIELD_u32_u64_INIT_ONSTACK(.u.memcpy_op.src, src), + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + }; + int ret, cpu; + + do { + cpu = cpu_op_get_current_cpu(); + ret = cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); + } while (ret == -1 && errno == EAGAIN); + + return ret; +} + +static int test_memcpy_single_ok_sum_too_large(void) +{ + int i, ret; + char buf1[TESTBUFLEN]; + char buf2[TESTBUFLEN]; + const char *test_name = "test_memcpy_single_ok_sum_too_large"; + + printf("Testing %s\n", test_name); + + /* Test memcpy */ + for (i = 0; i < TESTBUFLEN; i++) + buf1[i] = (char)i; + memset(buf2, 0, TESTBUFLEN); + ret = test_memcpy_single_ok_sum_too_large_op(buf2, buf1, TESTBUFLEN); + if (!ret || (ret < 0 && errno != EINVAL)) { + printf("%s returned with %d, errno: %s\n", + test_name, ret, strerror(errno)); + exit(-1); + } + return 0; +} + +int main(int argc, char **argv) +{ + int ret = 0; + + ret |= test_compare_eq_same(); + ret |= test_compare_eq_diff(); + ret |= test_compare_ne_same(); + ret |= test_compare_ne_diff(); + ret |= test_2compare_eq_index(); + ret |= test_2compare_ne_index(); + ret |= test_memcpy(); + ret |= test_memcpy_u32(); + ret |= test_memcpy_mb_memcpy(); + ret |= test_add(); + ret |= test_two_add(); + ret |= test_or(); + ret |= test_and(); + ret |= test_xor(); + ret |= test_lshift(); + ret |= test_rshift(); + ret |= test_cmpxchg_success(); + ret |= test_cmpxchg_fail(); + ret |= test_memcpy_fault(); + ret |= test_unknown_op(); + ret |= test_max_ops(); + ret |= test_too_many_ops(); + ret |= test_memcpy_single_too_large(); + ret |= test_memcpy_single_ok_sum_too_large(); + + return ret; +} diff --git a/tools/testing/selftests/cpu-opv/cpu-op.c b/tools/testing/selftests/cpu-opv/cpu-op.c new file mode 100644 index 000000000000..d7ba481cca04 --- /dev/null +++ b/tools/testing/selftests/cpu-opv/cpu-op.c @@ -0,0 +1,348 @@ +/* + * cpu-op.c + * + * Copyright (C) 2017 Mathieu Desnoyers <mathieu.desnoyers(a)efficios.com> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; only + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + */ + +#define _GNU_SOURCE +#include <errno.h> +#include <sched.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <syscall.h> +#include <assert.h> +#include <signal.h> + +#include "cpu-op.h" + +#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) + +int cpu_opv(struct cpu_op *cpu_opv, int cpuopcnt, int cpu, int flags) +{ + return syscall(__NR_cpu_opv, cpu_opv, cpuopcnt, cpu, flags); +} + +int cpu_op_get_current_cpu(void) +{ + int cpu; + + cpu = sched_getcpu(); + if (cpu < 0) { + perror("sched_getcpu()"); + abort(); + } + return cpu; +} + +int cpu_op_cmpxchg(void *v, void *expect, void *old, void *n, + size_t len, int cpu) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_MEMCPY_OP, + .len = len, + .u.memcpy_op.dst = (unsigned long)old, + .u.memcpy_op.src = (unsigned long)v, + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + [1] = { + .op = CPU_COMPARE_EQ_OP, + .len = len, + .u.compare_op.a = (unsigned long)v, + .u.compare_op.b = (unsigned long)expect, + .u.compare_op.expect_fault_a = 0, + .u.compare_op.expect_fault_b = 0, + }, + [2] = { + .op = CPU_MEMCPY_OP, + .len = len, + .u.memcpy_op.dst = (unsigned long)v, + .u.memcpy_op.src = (unsigned long)n, + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + }; + + return cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); +} + +int cpu_op_add(void *v, int64_t count, size_t len, int cpu) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_ADD_OP, + .len = len, + .u.arithmetic_op.p = (unsigned long)v, + .u.arithmetic_op.count = count, + .u.arithmetic_op.expect_fault_p = 0, + }, + }; + + return cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); +} + +int cpu_op_cmpeqv_storev(intptr_t *v, intptr_t expect, intptr_t newv, + int cpu) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_COMPARE_EQ_OP, + .len = sizeof(intptr_t), + .u.compare_op.a = (unsigned long)v, + .u.compare_op.b = (unsigned long)&expect, + .u.compare_op.expect_fault_a = 0, + .u.compare_op.expect_fault_b = 0, + }, + [1] = { + .op = CPU_MEMCPY_OP, + .len = sizeof(intptr_t), + .u.memcpy_op.dst = (unsigned long)v, + .u.memcpy_op.src = (unsigned long)&newv, + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + }; + + return cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); +} + +static int cpu_op_cmpeqv_storep_expect_fault(intptr_t *v, intptr_t expect, + intptr_t *newp, int cpu) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_COMPARE_EQ_OP, + .len = sizeof(intptr_t), + .u.compare_op.a = (unsigned long)v, + .u.compare_op.b = (unsigned long)&expect, + .u.compare_op.expect_fault_a = 0, + .u.compare_op.expect_fault_b = 0, + }, + [1] = { + .op = CPU_MEMCPY_OP, + .len = sizeof(intptr_t), + .u.memcpy_op.dst = (unsigned long)v, + .u.memcpy_op.src = (unsigned long)newp, + .u.memcpy_op.expect_fault_dst = 0, + /* Return EAGAIN on src fault. */ + .u.memcpy_op.expect_fault_src = 1, + }, + }; + + return cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); +} + +int cpu_op_cmpnev_storeoffp_load(intptr_t *v, intptr_t expectnot, + off_t voffp, intptr_t *load, int cpu) +{ + intptr_t oldv = READ_ONCE(*v); + intptr_t *newp = (intptr_t *)(oldv + voffp); + int ret; + + if (oldv == expectnot) + return 1; + ret = cpu_op_cmpeqv_storep_expect_fault(v, oldv, newp, cpu); + if (!ret) { + *load = oldv; + return 0; + } + if (ret > 0) { + errno = EAGAIN; + return -1; + } + return -1; +} + +int cpu_op_cmpeqv_storev_storev(intptr_t *v, intptr_t expect, + intptr_t *v2, intptr_t newv2, intptr_t newv, + int cpu) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_COMPARE_EQ_OP, + .len = sizeof(intptr_t), + .u.compare_op.a = (unsigned long)v, + .u.compare_op.b = (unsigned long)&expect, + .u.compare_op.expect_fault_a = 0, + .u.compare_op.expect_fault_b = 0, + }, + [1] = { + .op = CPU_MEMCPY_OP, + .len = sizeof(intptr_t), + .u.memcpy_op.dst = (unsigned long)v2, + .u.memcpy_op.src = (unsigned long)&newv2, + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + [2] = { + .op = CPU_MEMCPY_OP, + .len = sizeof(intptr_t), + .u.memcpy_op.dst = (unsigned long)v, + .u.memcpy_op.src = (unsigned long)&newv, + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + }; + + return cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); +} + +int cpu_op_cmpeqv_storev_mb_storev(intptr_t *v, intptr_t expect, + intptr_t *v2, intptr_t newv2, intptr_t newv, + int cpu) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_COMPARE_EQ_OP, + .len = sizeof(intptr_t), + .u.compare_op.a = (unsigned long)v, + .u.compare_op.b = (unsigned long)&expect, + .u.compare_op.expect_fault_a = 0, + .u.compare_op.expect_fault_b = 0, + }, + [1] = { + .op = CPU_MEMCPY_OP, + .len = sizeof(intptr_t), + .u.memcpy_op.dst = (unsigned long)v2, + .u.memcpy_op.src = (unsigned long)&newv2, + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + [2] = { + .op = CPU_MB_OP, + }, + [3] = { + .op = CPU_MEMCPY_OP, + .len = sizeof(intptr_t), + .u.memcpy_op.dst = (unsigned long)v, + .u.memcpy_op.src = (unsigned long)&newv, + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + }; + + return cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); +} + +int cpu_op_cmpeqv_cmpeqv_storev(intptr_t *v, intptr_t expect, + intptr_t *v2, intptr_t expect2, intptr_t newv, + int cpu) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_COMPARE_EQ_OP, + .len = sizeof(intptr_t), + .u.compare_op.a = (unsigned long)v, + .u.compare_op.b = (unsigned long)&expect, + .u.compare_op.expect_fault_a = 0, + .u.compare_op.expect_fault_b = 0, + }, + [1] = { + .op = CPU_COMPARE_EQ_OP, + .len = sizeof(intptr_t), + .u.compare_op.a = (unsigned long)v2, + .u.compare_op.b = (unsigned long)&expect2, + .u.compare_op.expect_fault_a = 0, + .u.compare_op.expect_fault_b = 0, + }, + [2] = { + .op = CPU_MEMCPY_OP, + .len = sizeof(intptr_t), + .u.memcpy_op.dst = (unsigned long)v, + .u.memcpy_op.src = (unsigned long)&newv, + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + }; + + return cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); +} + +int cpu_op_cmpeqv_memcpy_storev(intptr_t *v, intptr_t expect, + void *dst, void *src, size_t len, intptr_t newv, + int cpu) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_COMPARE_EQ_OP, + .len = sizeof(intptr_t), + .u.compare_op.a = (unsigned long)v, + .u.compare_op.b = (unsigned long)&expect, + .u.compare_op.expect_fault_a = 0, + .u.compare_op.expect_fault_b = 0, + }, + [1] = { + .op = CPU_MEMCPY_OP, + .len = len, + .u.memcpy_op.dst = (unsigned long)dst, + .u.memcpy_op.src = (unsigned long)src, + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + [2] = { + .op = CPU_MEMCPY_OP, + .len = sizeof(intptr_t), + .u.memcpy_op.dst = (unsigned long)v, + .u.memcpy_op.src = (unsigned long)&newv, + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + }; + + return cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); +} + +int cpu_op_cmpeqv_memcpy_mb_storev(intptr_t *v, intptr_t expect, + void *dst, void *src, size_t len, intptr_t newv, + int cpu) +{ + struct cpu_op opvec[] = { + [0] = { + .op = CPU_COMPARE_EQ_OP, + .len = sizeof(intptr_t), + .u.compare_op.a = (unsigned long)v, + .u.compare_op.b = (unsigned long)&expect, + .u.compare_op.expect_fault_a = 0, + .u.compare_op.expect_fault_b = 0, + }, + [1] = { + .op = CPU_MEMCPY_OP, + .len = len, + .u.memcpy_op.dst = (unsigned long)dst, + .u.memcpy_op.src = (unsigned long)src, + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + [2] = { + .op = CPU_MB_OP, + }, + [3] = { + .op = CPU_MEMCPY_OP, + .len = sizeof(intptr_t), + .u.memcpy_op.dst = (unsigned long)v, + .u.memcpy_op.src = (unsigned long)&newv, + .u.memcpy_op.expect_fault_dst = 0, + .u.memcpy_op.expect_fault_src = 0, + }, + }; + + return cpu_opv(opvec, ARRAY_SIZE(opvec), cpu, 0); +} + +int cpu_op_addv(intptr_t *v, int64_t count, int cpu) +{ + return cpu_op_add(v, count, sizeof(intptr_t), cpu); +} diff --git a/tools/testing/selftests/cpu-opv/cpu-op.h b/tools/testing/selftests/cpu-opv/cpu-op.h new file mode 100644 index 000000000000..ba2ec578ec50 --- /dev/null +++ b/tools/testing/selftests/cpu-opv/cpu-op.h @@ -0,0 +1,68 @@ +/* + * cpu-op.h + * + * (C) Copyright 2017 - Mathieu Desnoyers <mathieu.desnoyers(a)efficios.com> + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#ifndef CPU_OPV_H +#define CPU_OPV_H + +#include <stdlib.h> +#include <stdint.h> +#include <linux/cpu_opv.h> + +#define likely(x) __builtin_expect(!!(x), 1) +#define unlikely(x) __builtin_expect(!!(x), 0) +#define barrier() __asm__ __volatile__("" : : : "memory") + +#define ACCESS_ONCE(x) (*(__volatile__ __typeof__(x) *)&(x)) +#define WRITE_ONCE(x, v) __extension__ ({ ACCESS_ONCE(x) = (v); }) +#define READ_ONCE(x) ACCESS_ONCE(x) + +int cpu_opv(struct cpu_op *cpuopv, int cpuopcnt, int cpu, int flags); +int cpu_op_get_current_cpu(void); + +int cpu_op_cmpxchg(void *v, void *expect, void *old, void *_new, + size_t len, int cpu); +int cpu_op_add(void *v, int64_t count, size_t len, int cpu); + +int cpu_op_cmpeqv_storev(intptr_t *v, intptr_t expect, intptr_t newv, + int cpu); +int cpu_op_cmpnev_storeoffp_load(intptr_t *v, intptr_t expectnot, + off_t voffp, intptr_t *load, int cpu); +int cpu_op_cmpeqv_storev_storev(intptr_t *v, intptr_t expect, + intptr_t *v2, intptr_t newv2, intptr_t newv, + int cpu); +int cpu_op_cmpeqv_storev_mb_storev(intptr_t *v, intptr_t expect, + intptr_t *v2, intptr_t newv2, intptr_t newv, + int cpu); +int cpu_op_cmpeqv_cmpeqv_storev(intptr_t *v, intptr_t expect, + intptr_t *v2, intptr_t expect2, intptr_t newv, + int cpu); +int cpu_op_cmpeqv_memcpy_storev(intptr_t *v, intptr_t expect, + void *dst, void *src, size_t len, intptr_t newv, + int cpu); +int cpu_op_cmpeqv_memcpy_mb_storev(intptr_t *v, intptr_t expect, + void *dst, void *src, size_t len, intptr_t newv, + int cpu); +int cpu_op_addv(intptr_t *v, int64_t count, int cpu); + +#endif /* CPU_OPV_H_ */ diff --git a/tools/testing/selftests/lib.mk b/tools/testing/selftests/lib.mk index 5bef05d6ba39..441d7bc63bb7 100644 --- a/tools/testing/selftests/lib.mk +++ b/tools/testing/selftests/lib.mk @@ -105,6 +105,9 @@ COMPILE.S = $(CC) $(ASFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c LINK.S = $(CC) $(ASFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH) endif +# Selftest makefiles can override those targets by setting +# OVERRIDE_TARGETS = 1. +ifeq ($(OVERRIDE_TARGETS),) $(OUTPUT)/%:%.c $(LINK.c) $^ $(LDLIBS) -o $@ @@ -113,5 +116,6 @@ $(OUTPUT)/%.o:%.S $(OUTPUT)/%:%.S $(LINK.S) $^ $(LDLIBS) -o $@ +endif .PHONY: run_tests all clean install emit_tests -- 2.11.0 -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

7 years, 1 month

1
0
0 0

Re: [Linux-kselftest-mirror] [PATCH v9 23/51] powerpc: Enable pkey subsystem

by Ram Pai

On Mon, Nov 06, 2017 at 12:57:15AM -0800, Ram Pai wrote: > PAPR defines 'ibm,processor-storage-keys' property. It exports two > values. The first value holds the number of data-access keys and the > second holds the number of instruction-access keys. Due to a bug in > the firmware, instruction-access keys is always reported as zero. > However any key can be configured to disable data-access and/or disable > execution-access. The inavailablity of the second value is not a > big handicap, though it could have been used to determine if the > platform supported disable-execution-access. > > Non PAPR platforms do not define this property in the device tree yet. > Here, we hardcode CPUs that support pkey by consulting > PowerISA3.0 > > This patch calculates the number of keys supported by the platform. > Alsi it determines the platform support for read/write/execution access > support for pkeys. > > Signed-off-by: Ram Pai <linuxram(a)us.ibm.com> > --- > ....snip... > +static inline bool pkey_mmu_enabled(void) > +{ > + if (firmware_has_feature(FW_FEATURE_LPAR)) > + return pkeys_total; > + else > + return cpu_has_feature(CPU_FTR_PKEY); > +} > + > void __init pkey_initialize(void) > { > int os_reserved, i; > @@ -46,14 +54,9 @@ void __init pkey_initialize(void) > __builtin_popcountl(ARCH_VM_PKEY_FLAGS >> VM_PKEY_SHIFT) > != (sizeof(u64) * BITS_PER_BYTE)); > > - /* > - * Disable the pkey system till everything is in place. A subsequent > - * patch will enable it. > - */ > - static_branch_enable(&pkey_disabled); > - > - /* Lets assume 32 keys */ > - pkeys_total = 32; vvvvvvvvvvvvvvvvvvvv > + /* Let's assume 32 keys if we are not told the number of pkeys. */ > + if (!pkeys_total) > + pkeys_total = 32; ^^^^^^^^^^^^^^^^^^^^ There is a small bug here. On a KVM guest or a LPAR, if the device tree does not expose pkeys, the pkey-subsystem must be disabled. Unfortunately, the code above blindly sets the pkeys_total to 32. This confuses pkey_mmu_enabled() into returning true. Because of this bug the guest errorneously enables pkey-subsystem. The fix is to delete the code marked above. > > /* > * Adjust the upper limit, based on the number of bits supported by > @@ -62,11 +65,19 @@ void __init pkey_initialize(void) > pkeys_total = min_t(int, pkeys_total, > (ARCH_VM_PKEY_FLAGS >> VM_PKEY_SHIFT)); > > + if (!pkey_mmu_enabled() || radix_enabled() || !pkeys_total) > + static_branch_enable(&pkey_disabled); > + else > + static_branch_disable(&pkey_disabled); > + RP -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

7 years, 1 month

1
0
0 0

Re: [Linux-kselftest-mirror] [PATCH v9 00/51] powerpc, mm: Memory Protection Keys

by Christophe LEROY

Hi Le 06/11/2017 à 09:56, Ram Pai a écrit : > Memory protection keys enable applications to protect its > address space from inadvertent access from or corruption > by itself. > > These patches along with the pte-bit freeing patch series > enables the protection key feature on powerpc; 4k and 64k > hashpage kernels. It also changes the generic and x86 > code to expose memkey features through sysfs. Finally > testcases and Documentation is updated. > > All patches can be found at -- > https://github.com/rampai/memorykeys.git memkey.v9 As far as I can see you are focussing the implementation on 64 bits powerpc. This could also be implemented on 32 bits powerpc, for instance the 8xx has MMU Access Protection Registers which can be used to define 16 domains and could I think be used for implementing protection keys. Of course the challenge after that would be to find 4 spare PTE bits, I'm sure we can find them on the 8xx, at least when using 16k pages we have 2 bits already available, then by merging PAGE_SHARED and PAGE_USER and by reducing PAGE_RO to only one bit we can get the 4 spare bits. Therefore I think it would be great if you could implement a framework common to both PPC32 and PPC64. Christophe > > The overall idea: > ----------------- > A process allocates a key and associates it with > an address range within its address space. > The process then can dynamically set read/write > permissions on the key without involving the > kernel. Any code that violates the permissions > of the address space; as defined by its associated > key, will receive a segmentation fault. > > This patch series enables the feature on PPC64 HPTE > platform. > > ISA3.0 section 5.7.13 describes the detailed > specifications. > > > Highlevel view of the design: > --------------------------- > When an application associates a key with a address > address range, program the key in the Linux PTE. > When the MMU detects a page fault, allocate a hash > page and program the key into HPTE. And finally > when the MMU detects a key violation; due to > invalid application access, invoke the registered > signal handler and provide the violated key number. > > > Testing: > ------- > This patch series has passed all the protection key > tests available in the selftest directory.The > tests are updated to work on both x86 and powerpc. > The selftests have passed on x86 and powerpc hardware. > > History: > ------- > version v9: > (1) used jump-labels to optimize code > -- Balbir > (2) fixed a register initialization bug noted > by Balbir > (3) fixed inappropriate use of paca to pass > siginfo and keys to signal handler > (4) Cleanup of comment style not to be right > justified -- mpe > (5) restructured the patches to depend on the > availability of VM_PKEY_BIT4 in > include/linux/mm.h > (6) Incorporated comments from Dave Hansen > towards changes to selftest and got > them tested on x86. > > version v8: > (1) Contents of the AMR register withdrawn from > the siginfo structure. Applications can always > read the AMR register. > (2) AMR/IAMR/UAMOR are now available through > ptrace system call. -- thanks to Thiago > (3) code changes to handle legacy power cpus > that do not support execute-disable. > (4) incorporates many code improvement > suggestions. > > version v7: > (1) refers to device tree property to enable > protection keys. > (2) adds 4K PTE support. > (3) fixes a couple of bugs noticed by Thiago > (4) decouples this patch series from arch- > independent code. This patch series can > now stand by itself, with one kludge > patch(2). > version v7: > (1) refers to device tree property to enable > protection keys. > (2) adds 4K PTE support. > (3) fixes a couple of bugs noticed by Thiago > (4) decouples this patch series from arch- > independent code. This patch series can > now stand by itself, with one kludge > patch(2). > > version v6: > (1) selftest changes are broken down into 20 > incremental patches. > (2) A separate key allocation mask that > includes PKEY_DISABLE_EXECUTE is > added for powerpc > (3) pkey feature is enabled for 64K HPT case > only. RPT and 4k HPT is disabled. > (4) Documentation is updated to better > capture the semantics. > (5) introduced arch_pkeys_enabled() to find > if an arch enables pkeys. Correspond- > ing change the logic that displays > key value in smaps. > (6) code rearranged in many places based on > comments from Dave Hansen, Balbir, > Anshuman. > (7) fixed one bug where a bogus key could be > associated successfully in > pkey_mprotect(). > > version v5: > (1) reverted back to the old design -- store > the key in the pte, instead of bypassing > it. The v4 design slowed down the hash > page path. > (2) detects key violation when kernel is told > to access user pages. > (3) further refined the patches into smaller > consumable units > (4) page faults handlers captures the fault- > ing key > from the pte instead of the vma. This > closes a race between where the key > update in the vma and a key fault caused > by the key programmed in the pte. > (5) a key created with access-denied should > also set it up to deny write. Fixed it. > (6) protection-key number is displayed in > smaps the x86 way. > > version v4: > (1) patches no more depend on the pte bits > to program the hpte > -- comment by Balbir > (2) documentation updates > (3) fixed a bug in the selftest. > (4) unlike x86, powerpc lets signal handler > change key permission bits; the > change will persist across signal > handler boundaries. Earlier we > allowed the signal handler to > modify a field in the siginfo > structure which would than be used > by the kernel to program the key > protection register (AMR) > -- resolves a issue raised by Ben. > "Calls to sys_swapcontext with a > made-up context will end up with a > crap AMR if done by code who didn't > know about that register". > (5) these changes enable protection keys on > 4k-page kernel aswell. > > version v3: > (1) split the patches into smaller consumable > patches. > (2) added the ability to disable execute > permission on a key at creation. > (3) rename calc_pte_to_hpte_pkey_bits() to > pte_to_hpte_pkey_bits() > -- suggested by Anshuman > (4) some code optimization and clarity in > do_page_fault() > (5) A bug fix while invalidating a hpte slot > in __hash_page_4K() > -- noticed by Aneesh > > > version v2: > (1) documentation and selftest added. > (2) fixed a bug in 4k hpte backed 64k pte > where page invalidation was not > done correctly, and initialization > of second-part-of-the-pte was not > done correctly if the pte was not > yet Hashed with a hpte. > -- Reported by Aneesh. > (3) Fixed ABI breakage caused in siginfo > structure. > -- Reported by Anshuman. > > > version v1: Initial version > > Ram Pai (47): > mm, powerpc, x86: define VM_PKEY_BITx bits if CONFIG_ARCH_HAS_PKEYS > is enabled > mm, powerpc, x86: introduce an additional vma bit for powerpc pkey > powerpc: initial pkey plumbing > powerpc: track allocation status of all pkeys > powerpc: helper function to read,write AMR,IAMR,UAMOR registers > powerpc: helper functions to initialize AMR, IAMR and UAMOR registers > powerpc: cleanup AMR, IAMR when a key is allocated or freed > powerpc: implementation for arch_set_user_pkey_access() > powerpc: ability to create execute-disabled pkeys > powerpc: store and restore the pkey state across context switches > powerpc: introduce execute-only pkey > powerpc: ability to associate pkey to a vma > powerpc: implementation for arch_override_mprotect_pkey() > powerpc: map vma key-protection bits to pte key bits. > powerpc: Program HPTE key protection bits > powerpc: helper to validate key-access permissions of a pte > powerpc: check key protection for user page access > powerpc: implementation for arch_vma_access_permitted() > powerpc: Handle exceptions caused by pkey violation > powerpc: introduce get_mm_addr_key() helper > powerpc: Deliver SEGV signal on pkey violation > powerpc: Enable pkey subsystem > powerpc: sys_pkey_alloc() and sys_pkey_free() system calls > powerpc: sys_pkey_mprotect() system call > powerpc: add sys_pkey_modify() system call > mm, x86 : introduce arch_pkeys_enabled() > mm: display pkey in smaps if arch_pkeys_enabled() is true > Documentation/x86: Move protecton key documentation to arch neutral > directory > Documentation/vm: PowerPC specific updates to memory protection keys > selftest/x86: Move protecton key selftest to arch neutral directory > selftest/vm: rename all references to pkru to a generic name > selftest/vm: move generic definitions to header file > selftest/vm: typecast the pkey register > selftest/vm: generic function to handle shadow key register > selftest/vm: fix the wrong assert in pkey_disable_set() > selftest/vm: fixed bugs in pkey_disable_clear() > selftest/vm: clear the bits in shadow reg when a pkey is freed. > selftest/vm: fix alloc_random_pkey() to make it really random > selftest/vm: introduce two arch independent abstraction > selftest/vm: pkey register should match shadow pkey > selftest/vm: generic cleanup > selftest/vm: powerpc implementation for generic abstraction > selftest/vm: fix an assertion in test_pkey_alloc_exhaust() > selftest/vm: associate key on a mapped page and detect access > violation > selftest/vm: associate key on a mapped page and detect write > violation > selftest/vm: detect write violation on a mapped access-denied-key > page > selftest/vm: sub-page allocator > > Thiago Jung Bauermann (4): > powerpc/ptrace: Add memory protection key regset > mm/mprotect, powerpc/mm/pkeys, x86/mm/pkeys: Add sysfs interface > selftests/powerpc: Add ptrace tests for Protection Key register > selftests/powerpc: Add core file test for Protection Key register > > Documentation/vm/protection-keys.txt | 161 +++ > Documentation/x86/protection-keys.txt | 85 -- > arch/powerpc/Kconfig | 15 + > arch/powerpc/include/asm/book3s/64/mmu-hash.h | 5 + > arch/powerpc/include/asm/book3s/64/mmu.h | 10 + > arch/powerpc/include/asm/book3s/64/pgtable.h | 42 +- > arch/powerpc/include/asm/bug.h | 1 + > arch/powerpc/include/asm/cputable.h | 15 +- > arch/powerpc/include/asm/mman.h | 13 +- > arch/powerpc/include/asm/mmu.h | 9 + > arch/powerpc/include/asm/mmu_context.h | 24 + > arch/powerpc/include/asm/pkeys.h | 247 ++++ > arch/powerpc/include/asm/processor.h | 5 + > arch/powerpc/include/asm/systbl.h | 4 + > arch/powerpc/include/asm/unistd.h | 6 +- > arch/powerpc/include/uapi/asm/elf.h | 1 + > arch/powerpc/include/uapi/asm/mman.h | 6 + > arch/powerpc/include/uapi/asm/unistd.h | 4 + > arch/powerpc/kernel/entry_64.S | 9 + > arch/powerpc/kernel/process.c | 7 + > arch/powerpc/kernel/prom.c | 18 + > arch/powerpc/kernel/ptrace.c | 66 + > arch/powerpc/kernel/traps.c | 19 +- > arch/powerpc/mm/Makefile | 1 + > arch/powerpc/mm/fault.c | 49 +- > arch/powerpc/mm/hash_utils_64.c | 29 + > arch/powerpc/mm/mmu_context_book3s64.c | 2 + > arch/powerpc/mm/pkeys.c | 463 +++++++ > arch/x86/include/asm/mmu_context.h | 4 +- > arch/x86/include/asm/pkeys.h | 2 + > arch/x86/kernel/fpu/xstate.c | 5 + > arch/x86/kernel/setup.c | 8 - > arch/x86/mm/pkeys.c | 9 + > fs/proc/task_mmu.c | 16 +- > include/linux/mm.h | 12 +- > include/linux/pkeys.h | 7 +- > include/uapi/linux/elf.h | 1 + > mm/mprotect.c | 88 ++ > tools/testing/selftests/powerpc/include/reg.h | 1 + > tools/testing/selftests/powerpc/ptrace/Makefile | 5 +- > tools/testing/selftests/powerpc/ptrace/core-pkey.c | 438 ++++++ > .../testing/selftests/powerpc/ptrace/ptrace-pkey.c | 443 ++++++ > tools/testing/selftests/vm/Makefile | 1 + > tools/testing/selftests/vm/pkey-helpers.h | 405 ++++++ > tools/testing/selftests/vm/protection_keys.c | 1464 ++++++++++++++++++++ > tools/testing/selftests/x86/Makefile | 2 +- > tools/testing/selftests/x86/pkey-helpers.h | 220 --- > tools/testing/selftests/x86/protection_keys.c | 1395 ------------------- > 48 files changed, 4095 insertions(+), 1747 deletions(-) > create mode 100644 Documentation/vm/protection-keys.txt > delete mode 100644 Documentation/x86/protection-keys.txt > create mode 100644 arch/powerpc/include/asm/pkeys.h > create mode 100644 arch/powerpc/mm/pkeys.c > create mode 100644 tools/testing/selftests/powerpc/ptrace/core-pkey.c > create mode 100644 tools/testing/selftests/powerpc/ptrace/ptrace-pkey.c > create mode 100644 tools/testing/selftests/vm/pkey-helpers.h > create mode 100644 tools/testing/selftests/vm/protection_keys.c > delete mode 100644 tools/testing/selftests/x86/pkey-helpers.h > delete mode 100644 tools/testing/selftests/x86/protection_keys.c > -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

7 years, 1 month

2
1
0 0

[Linux-kselftest-mirror] [RFC PATCH for 4.15 10/10] membarrier: selftest: Test shared expedited cmd

by Mathieu Desnoyers

Test the new MEMBARRIER_CMD_SHARED_EXPEDITED and MEMBARRIER_CMD_REGISTER_SHARED_EXPEDITED commands. Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers(a)efficios.com> CC: Shuah Khan <shuahkh(a)osg.samsung.com> CC: Greg Kroah-Hartman <gregkh(a)linuxfoundation.org> CC: Peter Zijlstra <peterz(a)infradead.org> CC: Paul E. McKenney <paulmck(a)linux.vnet.ibm.com> CC: Boqun Feng <boqun.feng(a)gmail.com> CC: Andrew Hunter <ahh(a)google.com> CC: Maged Michael <maged.michael(a)gmail.com> CC: Avi Kivity <avi(a)scylladb.com> CC: Benjamin Herrenschmidt <benh(a)kernel.crashing.org> CC: Paul Mackerras <paulus(a)samba.org> CC: Michael Ellerman <mpe(a)ellerman.id.au> CC: Dave Watson <davejwatson(a)fb.com> CC: Alan Stern <stern(a)rowland.harvard.edu> CC: Will Deacon <will.deacon(a)arm.com> CC: Andy Lutomirski <luto(a)kernel.org> CC: Alice Ferrazzi <alice.ferrazzi(a)gmail.com> CC: Paul Elder <paul.elder(a)pitt.edu> CC: linux-kselftest(a)vger.kernel.org CC: linux-arch(a)vger.kernel.org --- .../testing/selftests/membarrier/membarrier_test.c | 47 ++++++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/tools/testing/selftests/membarrier/membarrier_test.c b/tools/testing/selftests/membarrier/membarrier_test.c index a0eae8d51e72..c699227f4d9a 100644 --- a/tools/testing/selftests/membarrier/membarrier_test.c +++ b/tools/testing/selftests/membarrier/membarrier_test.c @@ -189,6 +189,40 @@ static int test_membarrier_private_expedited_sync_core_success(void) return 0; } +static int test_membarrier_register_shared_expedited_success(void) +{ + int cmd = MEMBARRIER_CMD_REGISTER_SHARED_EXPEDITED, flags = 0; + const char *test_name = "sys membarrier MEMBARRIER_CMD_REGISTER_SHARED_EXPEDITED"; + + if (sys_membarrier(cmd, flags) != 0) { + ksft_exit_fail_msg( + "%s test: flags = %d, errno = %d\n", + test_name, flags, errno); + } + + ksft_test_result_pass( + "%s test: flags = %d\n", + test_name, flags); + return 0; +} + +static int test_membarrier_shared_expedited_success(void) +{ + int cmd = MEMBARRIER_CMD_SHARED_EXPEDITED, flags = 0; + const char *test_name = "sys membarrier MEMBARRIER_CMD_SHARED_EXPEDITED"; + + if (sys_membarrier(cmd, flags) != 0) { + ksft_exit_fail_msg( + "%s test: flags = %d, errno = %d\n", + test_name, flags, errno); + } + + ksft_test_result_pass( + "%s test: flags = %d\n", + test_name, flags); + return 0; +} + static int test_membarrier(void) { int status; @@ -227,6 +261,19 @@ static int test_membarrier(void) if (status) return status; } + /* + * It is valid to send a shared membarrier from a non-registered + * process. + */ + status = test_membarrier_shared_expedited_success(); + if (status) + return status; + status = test_membarrier_register_shared_expedited_success(); + if (status) + return status; + status = test_membarrier_shared_expedited_success(); + if (status) + return status; return 0; } -- 2.11.0 -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

7 years, 1 month

1
0
0 0

[Linux-kselftest-mirror] [RFC PATCH for 4.15 08/10] membarrier: selftest: Test private expedited sync core cmd

by Mathieu Desnoyers

Test the new MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE and MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE commands. Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers(a)efficios.com> CC: Shuah Khan <shuahkh(a)osg.samsung.com> CC: Greg Kroah-Hartman <gregkh(a)linuxfoundation.org> CC: Peter Zijlstra <peterz(a)infradead.org> CC: Paul E. McKenney <paulmck(a)linux.vnet.ibm.com> CC: Boqun Feng <boqun.feng(a)gmail.com> CC: Andrew Hunter <ahh(a)google.com> CC: Maged Michael <maged.michael(a)gmail.com> CC: Avi Kivity <avi(a)scylladb.com> CC: Benjamin Herrenschmidt <benh(a)kernel.crashing.org> CC: Paul Mackerras <paulus(a)samba.org> CC: Michael Ellerman <mpe(a)ellerman.id.au> CC: Dave Watson <davejwatson(a)fb.com> CC: Alan Stern <stern(a)rowland.harvard.edu> CC: Will Deacon <will.deacon(a)arm.com> CC: Andy Lutomirski <luto(a)kernel.org> CC: Alice Ferrazzi <alice.ferrazzi(a)gmail.com> CC: Paul Elder <paul.elder(a)pitt.edu> CC: linux-kselftest(a)vger.kernel.org CC: linux-arch(a)vger.kernel.org --- .../testing/selftests/membarrier/membarrier_test.c | 77 +++++++++++++++++++++- 1 file changed, 76 insertions(+), 1 deletion(-) diff --git a/tools/testing/selftests/membarrier/membarrier_test.c b/tools/testing/selftests/membarrier/membarrier_test.c index d7543a6d9030..a0eae8d51e72 100644 --- a/tools/testing/selftests/membarrier/membarrier_test.c +++ b/tools/testing/selftests/membarrier/membarrier_test.c @@ -132,6 +132,63 @@ static int test_membarrier_private_expedited_success(void) return 0; } +static int test_membarrier_private_expedited_sync_core_fail(void) +{ + int cmd = MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE, flags = 0; + const char *test_name = "sys membarrier MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE not registered failure"; + + if (sys_membarrier(cmd, flags) != -1) { + ksft_exit_fail_msg( + "%s test: flags = %d. Should fail, but passed\n", + test_name, flags); + } + if (errno != EPERM) { + ksft_exit_fail_msg( + "%s test: flags = %d. Should return (%d: \"%s\"), but returned (%d: \"%s\").\n", + test_name, flags, EPERM, strerror(EPERM), + errno, strerror(errno)); + } + + ksft_test_result_pass( + "%s test: flags = %d, errno = %d\n", + test_name, flags, errno); + return 0; +} + +static int test_membarrier_register_private_expedited_sync_core_success(void) +{ + int cmd = MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE, flags = 0; + const char *test_name = "sys membarrier MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE"; + + if (sys_membarrier(cmd, flags) != 0) { + ksft_exit_fail_msg( + "%s test: flags = %d, errno = %d\n", + test_name, flags, errno); + } + + ksft_test_result_pass( + "%s test: flags = %d\n", + test_name, flags); + return 0; +} + +static int test_membarrier_private_expedited_sync_core_success(void) +{ + int cmd = MEMBARRIER_CMD_PRIVATE_EXPEDITED, flags = 0; + const char *test_name = "sys membarrier MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE"; + + if (sys_membarrier(cmd, flags) != 0) { + ksft_exit_fail_msg( + "%s test: flags = %d, errno = %d\n", + test_name, flags, errno); + } + + ksft_test_result_pass( + "%s test: flags = %d\n", + test_name, flags); + return 0; +} + static int test_membarrier(void) { int status; @@ -154,6 +211,22 @@ static int test_membarrier(void) status = test_membarrier_private_expedited_success(); if (status) return status; + status = sys_membarrier(MEMBARRIER_CMD_QUERY, 0); + if (status < 0) { + ksft_test_result_fail("sys_membarrier() failed\n"); + return status; + } + if (status & MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE) { + status = test_membarrier_private_expedited_sync_core_fail(); + if (status) + return status; + status = test_membarrier_register_private_expedited_sync_core_success(); + if (status) + return status; + status = test_membarrier_private_expedited_sync_core_success(); + if (status) + return status; + } return 0; } @@ -173,8 +246,10 @@ static int test_membarrier_query(void) } ksft_exit_fail_msg("sys_membarrier() failed\n"); } - if (!(ret & MEMBARRIER_CMD_SHARED)) + if (!(ret & MEMBARRIER_CMD_SHARED)) { + ksft_test_result_fail("sys_membarrier() CMD_SHARED query failed\n"); ksft_exit_fail_msg("sys_membarrier is not supported.\n"); + } ksft_test_result_pass("sys_membarrier available\n"); return 0; -- 2.11.0 -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

7 years, 1 month

1
0
0 0

[Linux-kselftest-mirror] [RFC PATCH for 4.15 01/10] membarrier: selftest: Test private expedited cmd

by Mathieu Desnoyers

Test the new MEMBARRIER_CMD_PRIVATE_EXPEDITED and MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED commands. Add checks expecting specific error values on system calls expected to fail. Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers(a)efficios.com> Acked-by: Shuah Khan <shuahkh(a)osg.samsung.com> Acked-by: Greg Kroah-Hartman <gregkh(a)linuxfoundation.org> CC: Peter Zijlstra <peterz(a)infradead.org> CC: Paul E. McKenney <paulmck(a)linux.vnet.ibm.com> CC: Boqun Feng <boqun.feng(a)gmail.com> CC: Andrew Hunter <ahh(a)google.com> CC: Maged Michael <maged.michael(a)gmail.com> CC: Avi Kivity <avi(a)scylladb.com> CC: Benjamin Herrenschmidt <benh(a)kernel.crashing.org> CC: Paul Mackerras <paulus(a)samba.org> CC: Michael Ellerman <mpe(a)ellerman.id.au> CC: Dave Watson <davejwatson(a)fb.com> CC: Alan Stern <stern(a)rowland.harvard.edu> CC: Will Deacon <will.deacon(a)arm.com> CC: Andy Lutomirski <luto(a)kernel.org> CC: Alice Ferrazzi <alice.ferrazzi(a)gmail.com> CC: Paul Elder <paul.elder(a)pitt.edu> CC: linux-kselftest(a)vger.kernel.org CC: linux-arch(a)vger.kernel.org --- .../testing/selftests/membarrier/membarrier_test.c | 109 ++++++++++++++++++--- 1 file changed, 94 insertions(+), 15 deletions(-) diff --git a/tools/testing/selftests/membarrier/membarrier_test.c b/tools/testing/selftests/membarrier/membarrier_test.c index 9e674d9514d1..d7543a6d9030 100644 --- a/tools/testing/selftests/membarrier/membarrier_test.c +++ b/tools/testing/selftests/membarrier/membarrier_test.c @@ -16,49 +16,119 @@ static int sys_membarrier(int cmd, int flags) static int test_membarrier_cmd_fail(void) { int cmd = -1, flags = 0; + const char *test_name = "sys membarrier invalid command"; if (sys_membarrier(cmd, flags) != -1) { ksft_exit_fail_msg( - "sys membarrier invalid command test: command = %d, flags = %d. Should fail, but passed\n", - cmd, flags); + "%s test: command = %d, flags = %d. Should fail, but passed\n", + test_name, cmd, flags); + } + if (errno != EINVAL) { + ksft_exit_fail_msg( + "%s test: flags = %d. Should return (%d: \"%s\"), but returned (%d: \"%s\").\n", + test_name, flags, EINVAL, strerror(EINVAL), + errno, strerror(errno)); } ksft_test_result_pass( - "sys membarrier invalid command test: command = %d, flags = %d. Failed as expected\n", - cmd, flags); + "%s test: command = %d, flags = %d, errno = %d. Failed as expected\n", + test_name, cmd, flags, errno); return 0; } static int test_membarrier_flags_fail(void) { int cmd = MEMBARRIER_CMD_QUERY, flags = 1; + const char *test_name = "sys membarrier MEMBARRIER_CMD_QUERY invalid flags"; if (sys_membarrier(cmd, flags) != -1) { ksft_exit_fail_msg( - "sys membarrier MEMBARRIER_CMD_QUERY invalid flags test: flags = %d. Should fail, but passed\n", - flags); + "%s test: flags = %d. Should fail, but passed\n", + test_name, flags); + } + if (errno != EINVAL) { + ksft_exit_fail_msg( + "%s test: flags = %d. Should return (%d: \"%s\"), but returned (%d: \"%s\").\n", + test_name, flags, EINVAL, strerror(EINVAL), + errno, strerror(errno)); } ksft_test_result_pass( - "sys membarrier MEMBARRIER_CMD_QUERY invalid flags test: flags = %d. Failed as expected\n", - flags); + "%s test: flags = %d, errno = %d. Failed as expected\n", + test_name, flags, errno); return 0; } -static int test_membarrier_success(void) +static int test_membarrier_shared_success(void) { int cmd = MEMBARRIER_CMD_SHARED, flags = 0; - const char *test_name = "sys membarrier MEMBARRIER_CMD_SHARED\n"; + const char *test_name = "sys membarrier MEMBARRIER_CMD_SHARED"; + + if (sys_membarrier(cmd, flags) != 0) { + ksft_exit_fail_msg( + "%s test: flags = %d, errno = %d\n", + test_name, flags, errno); + } + + ksft_test_result_pass( + "%s test: flags = %d\n", test_name, flags); + return 0; +} + +static int test_membarrier_private_expedited_fail(void) +{ + int cmd = MEMBARRIER_CMD_PRIVATE_EXPEDITED, flags = 0; + const char *test_name = "sys membarrier MEMBARRIER_CMD_PRIVATE_EXPEDITED not registered failure"; + + if (sys_membarrier(cmd, flags) != -1) { + ksft_exit_fail_msg( + "%s test: flags = %d. Should fail, but passed\n", + test_name, flags); + } + if (errno != EPERM) { + ksft_exit_fail_msg( + "%s test: flags = %d. Should return (%d: \"%s\"), but returned (%d: \"%s\").\n", + test_name, flags, EPERM, strerror(EPERM), + errno, strerror(errno)); + } + + ksft_test_result_pass( + "%s test: flags = %d, errno = %d\n", + test_name, flags, errno); + return 0; +} + +static int test_membarrier_register_private_expedited_success(void) +{ + int cmd = MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED, flags = 0; + const char *test_name = "sys membarrier MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED"; if (sys_membarrier(cmd, flags) != 0) { ksft_exit_fail_msg( - "sys membarrier MEMBARRIER_CMD_SHARED test: flags = %d\n", - flags); + "%s test: flags = %d, errno = %d\n", + test_name, flags, errno); } ksft_test_result_pass( - "sys membarrier MEMBARRIER_CMD_SHARED test: flags = %d\n", - flags); + "%s test: flags = %d\n", + test_name, flags); + return 0; +} + +static int test_membarrier_private_expedited_success(void) +{ + int cmd = MEMBARRIER_CMD_PRIVATE_EXPEDITED, flags = 0; + const char *test_name = "sys membarrier MEMBARRIER_CMD_PRIVATE_EXPEDITED"; + + if (sys_membarrier(cmd, flags) != 0) { + ksft_exit_fail_msg( + "%s test: flags = %d, errno = %d\n", + test_name, flags, errno); + } + + ksft_test_result_pass( + "%s test: flags = %d\n", + test_name, flags); return 0; } @@ -72,7 +142,16 @@ static int test_membarrier(void) status = test_membarrier_flags_fail(); if (status) return status; - status = test_membarrier_success(); + status = test_membarrier_shared_success(); + if (status) + return status; + status = test_membarrier_private_expedited_fail(); + if (status) + return status; + status = test_membarrier_register_private_expedited_success(); + if (status) + return status; + status = test_membarrier_private_expedited_success(); if (status) return status; return 0; -- 2.11.0 -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

7 years, 1 month

1
0
0 0

Re: [Linux-kselftest-mirror] [PATCH v9 44/51] selftest/vm: powerpc implementation for generic abstraction

by Breno Leitao

Hi Ram, On Mon, Nov 06, 2017 at 12:57:36AM -0800, Ram Pai wrote: > @@ -206,12 +209,14 @@ void signal_handler(int signum, siginfo_t *si, void *vucontext) > > trapno = uctxt->uc_mcontext.gregs[REG_TRAPNO]; > ip = uctxt->uc_mcontext.gregs[REG_IP_IDX]; > - fpregset = uctxt->uc_mcontext.fpregs; > - fpregs = (void *)fpregset; Since you removed all references for fpregset now, you probably want to remove the declaration of the variable above. > @@ -219,20 +224,21 @@ void signal_handler(int signum, siginfo_t *si, void *vucontext) > * state. We just assume that it is here. > */ > fpregs += 0x70; > -#endif > - pkey_reg_offset = pkey_reg_xstate_offset(); With this code, you removed all the reference for variable pkey_reg_offset, thus, its declaration could be removed also. > - *(u64 *)pkey_reg_ptr = 0x00000000; > + dprintf1("si_pkey from siginfo: %lx\n", si_pkey); > +#if defined(__i386__) || defined(__x86_64__) /* arch */ > + dprintf1("signal pkey_reg from xsave: %016lx\n", *pkey_reg_ptr); > + *(u64 *)pkey_reg_ptr &= reset_bits(si_pkey, PKEY_DISABLE_ACCESS); > +#elif __powerpc64__ Since the variable pkey_reg_ptr is only used for Intel code (inside #ifdefs), you probably want to #ifdef the variable declaration also, avoid triggering "unused variable" warning on non-Intel machines. -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

7 years, 1 month

2
2
0 0

Re: [Linux-kselftest-mirror] [PATCH v9 00/51] powerpc, mm: Memory Protection Keys

by Ram Pai

On Mon, Nov 06, 2017 at 05:22:18PM -0800, Ram Pai wrote: > On Mon, Nov 06, 2017 at 10:28:41PM +0100, Florian Weimer wrote: > > * Ram Pai: > > > > > Testing: > > > ------- > > > This patch series has passed all the protection key > > > tests available in the selftest directory.The > > > tests are updated to work on both x86 and powerpc. > > > The selftests have passed on x86 and powerpc hardware. > > ....snip.... > > What about siglongjmp from a signal handler? > > On powerpc there is some relief. the permissions on a key can be > modified from anywhere, including from the signal handler, and the > effect will be immediate. You dont have to wait till the > signal handler returns for the key permissions to be restore. > > also after return from the sigsetjmp(); > possibly caused by siglongjmp(), the program can restore the permission > on any key. > > Atleast that is my theory. Can you give me a testcase; if you have one > handy. > > > > > <https://sourceware.org/bugzilla/show_bug.cgi?id=22396> > > reading through the bug report, you mention that the following "The application may not be able to save and restore the protection bits for all keys because the kernel API does not actually specify that the set of keys is a small, fixed set." What exact kernel API do you need? This patch set exposes the total number of keys and max keys, through sysfs. https://marc.info/?l=linux-kernel&m=150995950219669&w=2 Is this sufficient? or do you need something else? RP -- To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html

7 years, 1 month

1
0
0 0

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror