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

[PATCH bpf-next v2 0/5] sockmap: add sockmap support for unix stream socket

by Jiang Wang

This patch series add support for unix stream type for sockmap. Sockmap already supports TCP, UDP, unix dgram types. The unix stream support is similar to unix dgram. Also add selftests for unix stream type in sockmap tests. Jiang Wang (5): af_unix: add read_sock for stream socket types af_unix: add unix_stream_proto for sockmap selftest/bpf: add tests for sockmap with unix stream type. selftest/bpf: change udp to inet in some function names selftest/bpf: add new tests in sockmap for unix stream to tcp. include/net/af_unix.h | 8 +- net/core/sock_map.c | 8 +- net/unix/af_unix.c | 88 +++++++++++++++--- net/unix/unix_bpf.c | 93 ++++++++++++++----- .../selftests/bpf/prog_tests/sockmap_listen.c | 48 ++++++---- 5 files changed, 192 insertions(+), 53 deletions(-) v1 -> v2 : - Call unhash in shutdown. - Clean up unix_create1 a bit. - Return -ENOTCONN if socket is not connected. -- 2.20.1

3 years, 6 months

3
7
0 0

[PATCH v9 23/26] selftest/x86/amx: Test cases for the AMX state management

by Chang S. Bae

This selftest verifies that the XSTATE arch_prctl works for AMX state and that a forked task has the AMX state in the INIT-state. In addition, this test verifies that the kernel correctly context switches unique AMX data, when multiple threads are using AMX. The test also verifies that ptrace() can insert data into existing threads. Finally, add a test case to verify that unused states are excluded, by leaving a known pattern on the signal stack and verifying that it is still intact after taking a subsequent signal. These test cases do not depend on AMX compiler support, as they employ userspace-XSAVE directly to access AMX state. Signed-off-by: Chang S. Bae <chang.seok.bae(a)intel.com> Reviewed-by: Len Brown <len.brown(a)intel.com> Cc: linux-kernel(a)vger.kernel.org Cc: linux-kselftest(a)vger.kernel.org --- Changes from v8: * Adjust for the arch_prctl change. * Assure XTILECFG is recovered upon sigreturn.. Changes from v7: * Adjust for SIGILL. * Test XTILECFG for legacy signal delivery. Changes from v6: * Adjust for the syscall and ptrace path changes. Changes from v5: * Adjusted arch_prctl for the updated ABI. * Added test for the dynamic signal xstate buffer. * Fixed XSAVE buffer's header data. Changes from v4: * Added test for arch_prctl. * Excluded tile config details to focus on testing the kernel's ability to manage dynamic user state. * Removed tile instructions. * Simplified the fork() and ptrace() test routine. * Massaged the changelog. Changes from v2: * Updated the test messages and the changelog as tile data is not inherited to a child anymore. * Removed bytecode for the instructions already supported by binutils. * Changed to check the XSAVE availability in a reliable way. Changes from v1: * Removed signal testing code --- tools/testing/selftests/x86/Makefile | 2 +- tools/testing/selftests/x86/amx.c | 968 +++++++++++++++++++++++++++ 2 files changed, 969 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/x86/amx.c diff --git a/tools/testing/selftests/x86/Makefile b/tools/testing/selftests/x86/Makefile index b4142cd1c5c2..8a1f62ab3c8e 100644 --- a/tools/testing/selftests/x86/Makefile +++ b/tools/testing/selftests/x86/Makefile @@ -18,7 +18,7 @@ TARGETS_C_32BIT_ONLY := entry_from_vm86 test_syscall_vdso unwind_vdso \ test_FCMOV test_FCOMI test_FISTTP \ vdso_restorer TARGETS_C_64BIT_ONLY := fsgsbase sysret_rip syscall_numbering \ - corrupt_xstate_header + corrupt_xstate_header amx # Some selftests require 32bit support enabled also on 64bit systems TARGETS_C_32BIT_NEEDED := ldt_gdt ptrace_syscall diff --git a/tools/testing/selftests/x86/amx.c b/tools/testing/selftests/x86/amx.c new file mode 100644 index 000000000000..afd8c66ca206 --- /dev/null +++ b/tools/testing/selftests/x86/amx.c @@ -0,0 +1,968 @@ +// SPDX-License-Identifier: GPL-2.0 + +#define _GNU_SOURCE +#include <err.h> +#include <errno.h> +#include <elf.h> +#include <pthread.h> +#include <setjmp.h> +#include <stdio.h> +#include <string.h> +#include <stdbool.h> +#include <unistd.h> +#include <x86intrin.h> + +#include <linux/futex.h> + +#include <sys/ptrace.h> +#include <sys/shm.h> +#include <sys/syscall.h> +#include <sys/wait.h> +#include <sys/uio.h> + +#ifndef __x86_64__ +# error This test is 64-bit only +#endif + +static inline uint64_t xgetbv(uint32_t index) +{ + uint32_t eax, edx; + + asm volatile("xgetbv;" + : "=a" (eax), "=d" (edx) + : "c" (index)); + return eax + ((uint64_t)edx << 32); +} + +static inline void cpuid(uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx) +{ + asm volatile("cpuid;" + : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx) + : "0" (*eax), "2" (*ecx)); +} + +static inline void xsave(void *xbuf, uint32_t lo, uint32_t hi) +{ + asm volatile("xsave (%%rdi)" + : : "D" (xbuf), "a" (lo), "d" (hi) + : "memory"); +} + +static inline void xrstor(void *xbuf, uint32_t lo, uint32_t hi) +{ + asm volatile("xrstor (%%rdi)" + : : "D" (xbuf), "a" (lo), "d" (hi)); +} + +static void sethandler(int sig, void (*handler)(int, siginfo_t *, void *), + int flags) +{ + struct sigaction sa; + + memset(&sa, 0, sizeof(sa)); + sa.sa_sigaction = handler; + sa.sa_flags = SA_SIGINFO | flags; + sigemptyset(&sa.sa_mask); + if (sigaction(sig, &sa, 0)) + err(1, "sigaction"); +} + +static void clearhandler(int sig) +{ + struct sigaction sa; + + memset(&sa, 0, sizeof(sa)); + sa.sa_handler = SIG_DFL; + sigemptyset(&sa.sa_mask); + if (sigaction(sig, &sa, 0)) + err(1, "sigaction"); +} + +static jmp_buf jmpbuf; + +/* Hardware info check: */ + +static bool noxsave; + +static void handle_noxsave(int sig, siginfo_t *si, void *ctx_void) +{ + noxsave = true; + siglongjmp(jmpbuf, 1); +} + +#define XFEATURE_XTILECFG 17 +#define XFEATURE_XTILEDATA 18 +#define XFEATURE_MASK_XTILECFG (1 << XFEATURE_XTILECFG) +#define XFEATURE_MASK_XTILEDATA (1 << XFEATURE_XTILEDATA) +#define XFEATURE_MASK_XTILE (XFEATURE_MASK_XTILECFG | XFEATURE_MASK_XTILEDATA) + +static inline bool check_xtile(void) +{ + bool xtile_enable; + + sethandler(SIGILL, handle_noxsave, 0); + + if ((!sigsetjmp(jmpbuf, 1)) && (xgetbv(0) & XFEATURE_MASK_XTILE)) { + xtile_enable = true; + goto out; + } + xtile_enable = false; +out: + clearhandler(SIGILL); + return xtile_enable; +} + +static uint32_t xsave_size; +static uint32_t xsave_xtiledata_offset, xsave_xtilecfg_offset; +static uint32_t xtiledata_size, xtilecfg_size; + +static struct _tile_spec { + uint16_t bytes_per_row; + uint16_t max_names; + uint16_t max_rows; +} tile_spec; + +#define XSTATE_CPUID 0xd +#define XSTATE_USER_STATE_SUBLEAVE 0x0 +#define TILE_CPUID 0x1d +#define TILE_PALETTE_ID 0x1 + +static void check_cpuid(void) +{ + uint32_t eax, ebx, ecx, edx; + + eax = XSTATE_CPUID; + ecx = XSTATE_USER_STATE_SUBLEAVE; + + cpuid(&eax, &ebx, &ecx, &edx); + if (!ebx) + err(1, "xstate cpuid: xsave size"); + + xsave_size = ebx; + + eax = XSTATE_CPUID; + ecx = XFEATURE_XTILECFG; + + cpuid(&eax, &ebx, &ecx, &edx); + if (!eax || !ebx) + err(1, "xstate cpuid: tile config state"); + + xtilecfg_size = eax; + xsave_xtilecfg_offset = ebx; + + eax = XSTATE_CPUID; + ecx = XFEATURE_XTILEDATA; + + cpuid(&eax, &ebx, &ecx, &edx); + if (!eax || !ebx) + err(1, "xstate cpuid: tile data state"); + + xtiledata_size = eax; + xsave_xtiledata_offset = ebx; + + eax = TILE_CPUID; + ecx = TILE_PALETTE_ID; + + cpuid(&eax, &ebx, &ecx, &edx); + if (!eax || !ebx || !ecx) + err(1, "tile cpuid: palette 1"); + + tile_spec.max_names = ebx >> 16; + tile_spec.bytes_per_row = ebx; + tile_spec.max_rows = ecx; +} + +/* The helpers for managing XSAVE buffer and tile states: */ + +void *alloc_xsave_buffer(void) +{ + void *xbuf; + + /* XSAVE buffer should be 64B-aligned. */ + xbuf = aligned_alloc(64, xsave_size); + if (!xbuf) + err(1, "aligned_alloc()"); + return xbuf; +} + +#define XSAVE_HDR_OFFSET 512 +#define XSAVE_HDR_SIZE 64 + +static inline void clear_xstate_header(void *buffer) +{ + memset(buffer + XSAVE_HDR_OFFSET, 0, XSAVE_HDR_SIZE); +} + +static inline uint64_t get_xstatebv(void *buffer) +{ + return *(uint64_t *)(buffer + XSAVE_HDR_OFFSET); +} + +static inline void set_xstatebv(void *buffer, uint64_t bv) +{ + *(uint64_t *)(buffer + XSAVE_HDR_OFFSET) = bv; +} + +static void set_rand_tiledata(void *tiledata) +{ + int *ptr = tiledata; + int data = rand(); + int i; + + for (i = 0; i < xtiledata_size / sizeof(int); i++, ptr++) + *ptr = data; +} + +#define MAX_TILES 16 +#define RESERVED_BYTES 14 + +struct tile_config { + uint8_t palette_id; + uint8_t start_row; + uint8_t reserved[RESERVED_BYTES]; + uint16_t colsb[MAX_TILES]; + uint8_t rows[MAX_TILES]; +}; + +static void set_tilecfg(void *tilecfg) +{ + struct tile_config *cfg = tilecfg; + int i; + + memset(cfg, 0, sizeof(*cfg)); + cfg->palette_id = TILE_PALETTE_ID; + for (i = 0; i < tile_spec.max_names; i++) { + cfg->colsb[i] = tile_spec.bytes_per_row; + cfg->rows[i] = tile_spec.max_rows; + } +} + +static void *xsave_buffer, *tiledata, *tilecfg; +static int nerrs, errs; + +/* See 'struct _fpx_sw_bytes' at sigcontext.h */ +#define SW_BYTES_OFFSET 464 +/* N.B. The struct's field name varies so read from the offset. */ +#define SW_BYTES_BV_OFFSET (SW_BYTES_OFFSET + 8) + +static inline struct _fpx_sw_bytes *get_fpx_sw_bytes(void *buffer) +{ + return (struct _fpx_sw_bytes *)(buffer + SW_BYTES_OFFSET); +} + +static inline uint64_t get_fpx_sw_bytes_xstatebv(void *buffer) +{ + return *(uint64_t *)(buffer + SW_BYTES_BV_OFFSET); +} + +static volatile bool noperm; +static bool check_tilecfg_sigframe; + +static void handle_noperm(int sig, siginfo_t *si, void *ctx_void) +{ + ucontext_t *ctx = (ucontext_t *)ctx_void; + void *xbuf = ctx->uc_mcontext.fpregs; + struct _fpx_sw_bytes *sw_bytes; + + printf("\tAt SIGILL handler,\n"); + + if (si->si_code != ILL_ILLOPC) { + errs++; + printf("[FAIL]\tInvalid signal code (%x).\n", si->si_code); + } else { + printf("[OK]\tValid signal code (ILL_ILLOPC).\n"); + } + + sw_bytes = get_fpx_sw_bytes(xbuf); + if (!(sw_bytes->xstate_size < xsave_xtiledata_offset) && + !(get_fpx_sw_bytes_xstatebv(xbuf) & XFEATURE_MASK_XTILEDATA)) { + printf("[OK]\tValid xstate size and mask in the SW data of xstate buffer.\n"); + } else { + errs++; + printf("[FAIL]\tInvalid xstate size and/or mask in the SW data of xstate buf.\n"); + } + + if (check_tilecfg_sigframe) { + if (memcmp(tilecfg, xbuf + xsave_xtilecfg_offset, xtilecfg_size)) { + errs++; + printf("[FAIL]\tTILECFG is corrupted.\n"); + } else { + printf("[OK]\tTILECFG is successfully delivered.\n"); + } + } + + noperm = true; + ctx->uc_mcontext.gregs[REG_RIP] += 3; /* Skip the faulting XRSTOR */ +} + +/* Return true if XRSTOR is successful; otherwise, false. */ +static inline bool xrstor_safe(void *buffer, uint32_t lo, uint32_t hi) +{ + noperm = false; + xrstor(buffer, lo, hi); + return !noperm; +} + +/* arch_prctl test */ + +#define ARCH_SET_STATE_ENABLE 0x1021 +#define ARCH_GET_STATE_ENABLE 0x1022 + +static void enable_tiledata(void) +{ + unsigned long bitmask; + long rc; + + rc = syscall(SYS_arch_prctl, ARCH_SET_STATE_ENABLE, XFEATURE_MASK_XTILEDATA); + if (rc) + goto fail; + + rc = syscall(SYS_arch_prctl, ARCH_GET_STATE_ENABLE, &bitmask); + if (rc) + err(1, "ARCH_GET_STATE_ENABLE"); + else if (bitmask & XFEATURE_MASK_XTILEDATA) + return; + +fail: + err(1, "ARCH_SET_STATE_ENABLE"); +} + +#define TEST_EXECV_ARG "nested" + +static void test_arch_prctl(int argc, char **argv) +{ + pid_t parent, child, grandchild; + + parent = fork(); + if (parent < 0) { + err(1, "fork"); + } else if (parent > 0) { + int status; + + wait(&status); + if (!WIFEXITED(status) || WEXITSTATUS(status)) + err(1, "arch_prctl test parent exit"); + return; + } + + printf("[RUN]\tCheck ARCH_SET_STATE_ENABLE around process fork().\n"); + + printf("\tFork a child.\n"); + child = fork(); + if (child < 0) { + err(1, "fork"); + } else if (child > 0) { + int status; + + enable_tiledata(); + printf("\tDo ARCH_SET_STATE_ENABLE at parent\n"); + + wait(&status); + if (!WIFEXITED(status) || WEXITSTATUS(status)) + err(1, "arch_prctl test child exit"); + _exit(0); + } + + clear_xstate_header(xsave_buffer); + + /* By default, XTILECFG is permitted to use. */ + set_xstatebv(xsave_buffer, XFEATURE_MASK_XTILECFG); + set_tilecfg(xsave_buffer + xsave_xtilecfg_offset); + xrstor(xsave_buffer, -1, -1); + memcpy(tilecfg, xsave_buffer + xsave_xtilecfg_offset, xtilecfg_size); + + set_xstatebv(xsave_buffer, XFEATURE_MASK_XTILEDATA); + set_rand_tiledata(xsave_buffer + xsave_xtiledata_offset); + + printf("\tLoad tile data without ARCH_SET_STATE_ENABLE at child.\n"); + /* + * Test XTILECFG state delivery via signal, when XTILEDATA is not + * permitted. + */ + check_tilecfg_sigframe = true; + if (xrstor_safe(xsave_buffer, -1, -1)) { + nerrs++; + printf("[FAIL]\tSucceeded at child.\n"); + } else { + printf("[OK]\tBlocked at child.\n"); + + /* Assure XTILECFG state recovery at sigreturn. */ + printf("\tReturn from signal handler,\n"); + xsave(xsave_buffer, XFEATURE_MASK_XTILECFG, 0); + if (memcmp(tilecfg, xsave_buffer + xsave_xtilecfg_offset, xtilecfg_size)) { + nerrs++; + printf("[FAIL]\tTilecfg is not restored.\n"); + } else { + printf("[OK]\tTilecfg is restored.\n"); + } + } + + printf("\tDo ARCH_SET_STATE_ENABLE at child.\n"); + enable_tiledata(); + + printf("\tLoad tile data with ARCH_SET_STATE_ENABLE at child:\n"); + check_tilecfg_sigframe = false; + if (xrstor_safe(xsave_buffer, -1, -1)) { + printf("[OK]\tSucceeded at child.\n"); + } else { + nerrs++; + printf("[FAIL]\tBlocked at child.\n"); + } + + printf("\tFork a grandchild.\n"); + grandchild = fork(); + if (grandchild < 0) { + err(1, "fork"); + } else if (!grandchild) { + char *args[] = {argv[0], TEST_EXECV_ARG, NULL}; + + if (xrstor_safe(xsave_buffer, -1, -1)) { + printf("[OK]\tSucceeded at grandchild.\n"); + } else { + nerrs++; + printf("[FAIL]\tBlocked at grandchild.\n"); + } + nerrs += execv(args[0], args); + } else { + int status; + + wait(&status); + if (!WIFEXITED(status) || WEXITSTATUS(status)) + err(1, "fork test grandchild"); + } + _exit(0); +} + +/* Testing tile data inheritance */ + +static void test_fork(void) +{ + pid_t child, grandchild; + + child = fork(); + if (child < 0) { + err(1, "fork"); + } else if (child > 0) { + int status; + + wait(&status); + if (!WIFEXITED(status) || WEXITSTATUS(status)) + err(1, "fork test child"); + return; + } + + printf("[RUN]\tCheck tile data inheritance.\n\tBefore fork(), load tile data -- yes:\n"); + + clear_xstate_header(xsave_buffer); + set_xstatebv(xsave_buffer, XFEATURE_MASK_XTILE); + set_tilecfg(xsave_buffer + xsave_xtilecfg_offset); + set_rand_tiledata(xsave_buffer + xsave_xtiledata_offset); + xrstor_safe(xsave_buffer, -1, -1); + + grandchild = fork(); + if (grandchild < 0) { + err(1, "fork"); + } else if (grandchild > 0) { + int status; + + wait(&status); + if (!WIFEXITED(status) || WEXITSTATUS(status)) + err(1, "fork test grand child"); + _exit(0); + } + + if (xgetbv(1) & XFEATURE_MASK_XTILE) { + nerrs++; + printf("[FAIL]\tIn a child, AMX state is not initialized.\n"); + } else { + printf("[OK]\tIn a child, AMX state is initialized.\n"); + } + _exit(0); +} + +/* Context switching test */ + +#define ITERATIONS 10 +#define NUM_THREADS 5 + +struct futex_info { + int current; + int *futex; + int next; +}; + +static inline void command_wait(struct futex_info *info, int value) +{ + do { + sched_yield(); + } while (syscall(SYS_futex, info->futex, FUTEX_WAIT, value, 0, 0, 0)); +} + +static inline void command_wake(struct futex_info *info, int value) +{ + do { + *info->futex = value; + while (!syscall(SYS_futex, info->futex, FUTEX_WAKE, 1, 0, 0, 0)) + sched_yield(); + } while (0); +} + +static inline int get_iterative_value(int id) +{ + return ((id << 1) & ~0x1); +} + +static inline int get_endpoint_value(int id) +{ + return ((id << 1) | 0x1); +} + +static void *check_tiledata(void *info) +{ + struct futex_info *finfo = (struct futex_info *)info; + void *xbuf, *tdata; + int i; + + xbuf = alloc_xsave_buffer(); + tdata = malloc(xtiledata_size); + if (!tdata) + err(1, "malloc()"); + + set_xstatebv(xbuf, XFEATURE_MASK_XTILEDATA); + set_rand_tiledata(xbuf + xsave_xtiledata_offset); + xrstor_safe(xbuf, -1, -1); + memcpy(tdata, xbuf + xsave_xtiledata_offset, xtiledata_size); + + for (i = 0; i < ITERATIONS; i++) { + command_wait(finfo, get_iterative_value(finfo->current)); + + xsave(xbuf, XFEATURE_MASK_XTILEDATA, 0); + if (memcmp(tdata, xbuf + xsave_xtiledata_offset, xtiledata_size)) + errs++; + + set_rand_tiledata(xbuf + xsave_xtiledata_offset); + xrstor_safe(xbuf, -1, -1); + memcpy(tdata, xbuf + xsave_xtiledata_offset, xtiledata_size); + + command_wake(finfo, get_iterative_value(finfo->next)); + } + + command_wait(finfo, get_endpoint_value(finfo->current)); + + free(xbuf); + free(tdata); + return NULL; +} + +static int create_threads(int num, struct futex_info *finfo) +{ + const int shm_id = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT | 0666); + int *futex = shmat(shm_id, NULL, 0); + pthread_t thread; + int i; + + for (i = 0; i < num; i++) { + finfo[i].futex = futex; + finfo[i].current = i + 1; + finfo[i].next = (i + 2) % (num + 1); + + if (pthread_create(&thread, NULL, check_tiledata, &finfo[i])) + err(1, "pthread_create()"); + } + return 0; +} + +static void test_context_switch(void) +{ + struct futex_info *finfo; + int i; + + printf("[RUN]\tCheck tile data context switches.\n"); + printf("\t# of context switches -- %u, # of threads -- %d:\n", + ITERATIONS * NUM_THREADS, NUM_THREADS); + + errs = 0; + + finfo = malloc(sizeof(*finfo) * NUM_THREADS); + if (!finfo) + err(1, "malloc()"); + + create_threads(NUM_THREADS, finfo); + + for (i = 0; i < ITERATIONS; i++) { + command_wake(finfo, get_iterative_value(1)); + command_wait(finfo, get_iterative_value(0)); + } + + for (i = 1; i <= NUM_THREADS; i++) + command_wake(finfo, get_endpoint_value(i)); + + if (errs) { + nerrs += errs; + printf("[FAIL]\tIncorrect cases were found -- (%d / %u).\n", + errs, ITERATIONS * NUM_THREADS); + } else { + printf("[OK]\tNo incorrect case was found.\n"); + } + + free(finfo); +} + +/* Ptrace test */ + +static bool ptracee_state_perm; + +static int inject_tiledata(pid_t target) +{ + struct iovec iov; + + iov.iov_base = xsave_buffer; + iov.iov_len = xsave_size; + + clear_xstate_header(xsave_buffer); + set_xstatebv(xsave_buffer, XFEATURE_MASK_XTILEDATA); + set_rand_tiledata(xsave_buffer + xsave_xtiledata_offset); + memcpy(tiledata, xsave_buffer + xsave_xtiledata_offset, xtiledata_size); + + if (ptrace(PTRACE_SETREGSET, target, (uint32_t)NT_X86_XSTATE, &iov)) { + if (errno != EFAULT) + err(1, "PTRACE_SETREGSET"); + else + return errno; + } + + if (ptrace(PTRACE_GETREGSET, target, (uint32_t)NT_X86_XSTATE, &iov)) + err(1, "PTRACE_GETREGSET"); + + if (!memcmp(tiledata, xsave_buffer + xsave_xtiledata_offset, xtiledata_size)) + return 0; + else + return -1; +} + +static void test_tile_write(void) +{ + int status, rc; + pid_t child; + bool pass; + + child = fork(); + if (child < 0) { + err(1, "fork"); + } else if (!child) { + if (ptracee_state_perm) + enable_tiledata(); + + if (ptrace(PTRACE_TRACEME, 0, NULL, NULL)) + err(1, "PTRACE_TRACEME"); + + raise(SIGTRAP); + _exit(0); + } + + do { + wait(&status); + } while (WSTOPSIG(status) != SIGTRAP); + + printf("\tInject tile data %s ARCH_SET_STATE_ENABLE\n", + ptracee_state_perm ? "with" : "without"); + + rc = inject_tiledata(child); + pass = (rc == EFAULT && !ptracee_state_perm) || + (!rc && ptracee_state_perm); + if (!pass) + nerrs++; + printf("[%s]\tTile data was %swritten on ptracee.\n", + pass ? "OK" : "FAIL", errs ? "not " : ""); + + ptrace(PTRACE_DETACH, child, NULL, NULL); + wait(&status); + if (!WIFEXITED(status) || WEXITSTATUS(status)) + err(1, "ptrace test"); +} + +static void test_ptrace(void) +{ + printf("[RUN]\tCheck ptrace() to inject tile data.\n"); + + ptracee_state_perm = false; + test_tile_write(); + + ptracee_state_perm = true; + test_tile_write(); +} + +/* Signal handling test */ + +static bool init_tiledata, load_tiledata; +static volatile bool signaled, sigstk_prefill; + +#define SIGFRAME_TILEDATA_SIGNATURE 0xEE + +static void handle_sigstk_prefill(int sig, siginfo_t *info, void *ctx_void) +{ + void *xbuf = ((ucontext_t *)ctx_void)->uc_mcontext.fpregs; + struct _fpx_sw_bytes *sw_bytes = get_fpx_sw_bytes(xsave); + + if (sw_bytes->xstate_size >= (xsave_xtiledata_offset + xtiledata_size)) { + memset(xbuf + xsave_xtiledata_offset, SIGFRAME_TILEDATA_SIGNATURE, + xtiledata_size); + } + + sigstk_prefill = true; +} + +static void handle_signal(int sig, siginfo_t *info, void *ctx_void) +{ + bool tiledata_area, tiledata_bit, tiledata_inuse; + void *xbuf = ((ucontext_t *)ctx_void)->uc_mcontext.fpregs; + struct _fpx_sw_bytes *sw_bytes = get_fpx_sw_bytes(xbuf); + char d = SIGFRAME_TILEDATA_SIGNATURE; + int i; + + printf("\tAt signal delivery,\n"); + + /* Check SW reserved data in the buffer: */ + if ((sw_bytes->xstate_size >= (xsave_xtiledata_offset + xtiledata_size)) && + (get_fpx_sw_bytes_xstatebv(xbuf) & XFEATURE_MASK_XTILEDATA)) { + printf("[OK]\tValid xstate size and mask in the SW data of xstate buffer\n"); + } else { + errs++; + printf("[FAIL]\tInvalid xstate size and/or mask in the SW data of xstate buffer\n"); + } + + /* Check XSAVE buffer header: */ + tiledata_inuse = (load_tiledata && !init_tiledata); + tiledata_bit = get_xstatebv(xbuf) & XFEATURE_MASK_XTILEDATA; + + if (tiledata_bit == tiledata_inuse) { + printf("[OK]\tTiledata bit is %sset in XSTATE_BV of xstate buffer.\n", + tiledata_bit ? "" : "not "); + } else { + errs++; + printf("[FAIL]\tTiledata bit is %sset in XSTATE_BV of xstate buffer.\n", + tiledata_bit ? "" : "not "); + } + + /* + * Check the sigframe data: + */ + + tiledata_inuse = (load_tiledata && !init_tiledata); + tiledata_area = false; + if (sw_bytes->xstate_size >= (xsave_xtiledata_offset + xtiledata_size)) { + for (i = 0; i < xtiledata_size; i++) { + if (memcmp(xbuf + xsave_xtiledata_offset + i, &d, 1)) { + tiledata_area = true; + break; + } + } + } + + if (tiledata_area == tiledata_inuse) { + printf("[OK]\tTiledata is %ssaved in signal buffer.\n", + tiledata_area ? "" : "not "); + } else { + errs++; + printf("[FAIL]\tTiledata is %ssaved in signal buffer.\n", + tiledata_area ? "" : "not "); + } + + /* Load random tiledata to test sigreturn: */ + clear_xstate_header(xsave_buffer); + set_xstatebv(xsave_buffer, XFEATURE_MASK_XTILEDATA); + set_rand_tiledata(xsave_buffer + xsave_xtiledata_offset); + xrstor_safe(xsave_buffer, -1, -1); + signaled = true; +} + +static void test_signal_handling(void) +{ + pid_t child; + + signaled = false; + sigstk_prefill = false; + + child = fork(); + if (child < 0) { + err(1, "fork"); + } else if (child > 0) { + do { + int status; + + wait(&status); + if (WIFSTOPPED(status)) + kill(child, SIGCONT); + else if (WIFEXITED(status) && !WEXITSTATUS(status)) + break; + else + err(1, "signal test child"); + } while (1); + return; + } + + printf("\tBefore signal, load tile data -- %s", load_tiledata ? "yes, " : "no:\n"); + if (load_tiledata) + printf("re-initialized -- %s:\n", init_tiledata ? "yes" : "no"); + + /* + * Raise SIGUSR1 to pre-fill sig stack. Also, load tiledata to size the pre-fill. + */ + + if (load_tiledata) { + clear_xstate_header(xsave_buffer); + set_xstatebv(xsave_buffer, XFEATURE_MASK_XTILEDATA); + xrstor_safe(xsave_buffer, -1, -1); + } + + raise(SIGUSR1); + if (!sigstk_prefill) + err(1, "SIGUSR1"); + + /* + * Raise SIGALRM to test AMX state handling in signal delivery. Set up the state and + * data before the test. + */ + + if (load_tiledata) { + clear_xstate_header(xsave_buffer); + set_xstatebv(xsave_buffer, XFEATURE_MASK_XTILEDATA); + set_rand_tiledata(xsave_buffer + xsave_xtiledata_offset); + xrstor_safe(xsave_buffer, -1, -1); + + if (init_tiledata) { + clear_xstate_header(xsave_buffer); + set_xstatebv(xsave_buffer, 0); + xrstor_safe(xsave_buffer, -1, -1); + memset(tiledata, 0, xtiledata_size); + } else { + memcpy(tiledata, xsave_buffer + xsave_xtiledata_offset, + xtiledata_size); + } + } else { + memset(tiledata, 0, xtiledata_size); + } + + raise(SIGALRM); + if (!signaled) + err(1, "SIGALRM"); + + printf("\tReturn from signal handler,\n"); + xsave(xsave_buffer, XFEATURE_MASK_XTILEDATA, 0); + if (memcmp(tiledata, xsave_buffer + xsave_xtiledata_offset, xtiledata_size)) { + errs++; + printf("[FAIL]\tTiledata is not restored.\n"); + } else { + printf("[OK]\tTiledata is restored.\n"); + } + + if (errs) + nerrs++; + _exit(0); +} + +static void test_signal(void) +{ + printf("[RUN]\tCheck tile data state in signal path:\n"); + + sethandler(SIGALRM, handle_signal, 0); + sethandler(SIGUSR1, handle_sigstk_prefill, 0); + + load_tiledata = false; + init_tiledata = false; + errs = 0; + test_signal_handling(); + + load_tiledata = true; + init_tiledata = false; + errs = 0; + test_signal_handling(); + + load_tiledata = true; + init_tiledata = true; + errs = 0; + test_signal_handling(); + + clearhandler(SIGALRM); + clearhandler(SIGUSR1); +} + +int main(int argc, char **argv) +{ + cpu_set_t cpuset; + + if (argc == 2) { + int ret; + + if (strcmp(argv[1], TEST_EXECV_ARG)) + return 0; + + printf("\tRun after execv().\n"); + + xsave_buffer = alloc_xsave_buffer(); + clear_xstate_header(xsave_buffer); + + set_xstatebv(xsave_buffer, XFEATURE_MASK_XTILE); + set_rand_tiledata(xsave_buffer + xsave_xtiledata_offset); + + sethandler(SIGILL, handle_noperm, 0); + + if (xrstor_safe(xsave_buffer, -1, -1)) { + printf("[FAIL]\tSucceeded after execv().\n"); + ret = 1; + } else { + printf("[OK]\tBlocked after execv().\n"); + ret = 0; + } + + clearhandler(SIGILL); + free(xsave_buffer); + _exit(ret); + } + + /* Check hardware availability at first */ + + if (!check_xtile()) { + printf("%s is disabled.\n", noxsave ? "XSAVE" : "AMX"); + return 0; + } + + check_cpuid(); + + xsave_buffer = alloc_xsave_buffer(); + clear_xstate_header(xsave_buffer); + + tiledata = malloc(xtiledata_size); + if (!tiledata) + err(1, "malloc()"); + + tilecfg = malloc(xtilecfg_size); + if (!tilecfg) + err(1, "malloc()"); + set_tilecfg(tilecfg); + + nerrs = 0; + + sethandler(SIGILL, handle_noperm, 0); + + CPU_ZERO(&cpuset); + CPU_SET(0, &cpuset); + + if (sched_setaffinity(0, sizeof(cpuset), &cpuset) != 0) + err(1, "sched_setaffinity to CPU 0"); + + test_arch_prctl(argc, argv); + test_ptrace(); + + enable_tiledata(); + test_context_switch(); + test_fork(); + test_signal(); + + clearhandler(SIGILL); + + free(tilecfg); + free(tiledata); + free(xsave_buffer); + return nerrs ? 1 : 0; +} -- 2.17.1

3 years, 6 months

1
0
0 0

[PATCH v3 2/3] kunit: Add support for suite initialization and cleanup

by Bart Van Assche

A common feature of unit testing frameworks is support for sharing a test configuration across multiple unit tests. Add this functionality to the KUnit framework. This functionality will be used in the next patch in this series. Reviewed-by: Brendan Higgins <brendanhiggins(a)google.com> Cc: David Gow <davidgow(a)google.com> Cc: Shuah Khan <skhan(a)linuxfoundation.org> Cc: kunit-dev(a)googlegroups.com Cc: linux-kselftest(a)vger.kernel.org Cc: Bodo Stroesser <bostroesser(a)gmail.com> Cc: Martin K. Petersen <martin.petersen(a)oracle.com> Cc: Yanko Kaneti <yaneti(a)declera.com> Signed-off-by: Bart Van Assche <bvanassche(a)acm.org> --- include/kunit/test.h | 4 ++++ lib/kunit/test.c | 14 ++++++++++++++ 2 files changed, 18 insertions(+) diff --git a/include/kunit/test.h b/include/kunit/test.h index 24b40e5c160b..a6eef96a409c 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -215,6 +215,8 @@ static inline char *kunit_status_to_ok_not_ok(enum kunit_status status) * struct kunit_suite - describes a related collection of &struct kunit_case * * @name: the name of the test. Purely informational. + * @init_suite: called once per test suite before the test cases. + * @exit_suite: called once per test suite after all test cases. * @init: called before every test case. * @exit: called after every test case. * @test_cases: a null terminated array of test cases. @@ -229,6 +231,8 @@ static inline char *kunit_status_to_ok_not_ok(enum kunit_status status) */ struct kunit_suite { const char name[256]; + int (*init_suite)(void); + void (*exit_suite)(void); int (*init)(struct kunit *test); void (*exit)(struct kunit *test); struct kunit_case *test_cases; diff --git a/lib/kunit/test.c b/lib/kunit/test.c index d79ecb86ea57..c271692ced93 100644 --- a/lib/kunit/test.c +++ b/lib/kunit/test.c @@ -397,9 +397,19 @@ int kunit_run_tests(struct kunit_suite *suite) { char param_desc[KUNIT_PARAM_DESC_SIZE]; struct kunit_case *test_case; + int res = 0; kunit_print_subtest_start(suite); + if (suite->init_suite) + res = suite->init_suite(); + + if (res < 0) { + kunit_log(KERN_INFO, suite, KUNIT_SUBTEST_INDENT + "# Suite initialization failed (%d)\n", res); + goto end; + } + kunit_suite_for_each_test_case(suite, test_case) { struct kunit test = { .param_value = NULL, .param_index = 0 }; test_case->status = KUNIT_SKIPPED; @@ -439,6 +449,10 @@ int kunit_run_tests(struct kunit_suite *suite) test.status_comment); } + if (suite->exit_suite) + suite->exit_suite(); + +end: kunit_print_subtest_end(suite); return 0;

3 years, 6 months

1
0
0 0

[PATCH v2] selftests/sgx: Fix Q1 and Q2 calculation in sigstruct.c

by Jarkko Sakkinen

From: Tianjia Zhang <tianjia.zhang(a)linux.alibaba.com> Q1 and Q2 are numbers with *maximum* length of 384 bytes. If the calculated length of Q1 and Q2 is less than 384 bytes, things will go wrong. E.g. if Q2 is 383 bytes, then 1. The bytes of q2 are copied to sigstruct->q2 in calc_q1q2(). 2. The entire sigstruct->q2 is reversed, which results it being 256 * Q2, given that the last byte of sigstruct->q2 is added to before the bytes given by calc_q1q2(). Either change in key or measurement can trigger the bug. E.g. an unmeasured heap could cause a devastating change in Q1 or Q2. Reverse exactly the bytes of Q1 and Q2 in calc_q1q2() before returning to the caller. Fixes: dedde2634570 ("selftests/sgx: Trigger the reclaimer in the selftests") Link: https://lore.kernel.org/linux-sgx/20210301051836.30738-1-tianjia.zhang@linu… Signed-off-by: Tianjia Zhang <tianjia.zhang(a)linux.alibaba.com> Signed-off-by: Jarkko Sakkinen <jarkko(a)kernel.org> --- The original patch did a bad job explaining the code change but it turned out making sense. I wrote a new description. v2: - Added a fixes tag. tools/testing/selftests/sgx/sigstruct.c | 41 +++++++++++++------------ 1 file changed, 21 insertions(+), 20 deletions(-) diff --git a/tools/testing/selftests/sgx/sigstruct.c b/tools/testing/selftests/sgx/sigstruct.c index dee7a3d6c5a5..92bbc5a15c39 100644 --- a/tools/testing/selftests/sgx/sigstruct.c +++ b/tools/testing/selftests/sgx/sigstruct.c @@ -55,10 +55,27 @@ static bool alloc_q1q2_ctx(const uint8_t *s, const uint8_t *m, return true; } +static void reverse_bytes(void *data, int length) +{ + int i = 0; + int j = length - 1; + uint8_t temp; + uint8_t *ptr = data; + + while (i < j) { + temp = ptr[i]; + ptr[i] = ptr[j]; + ptr[j] = temp; + i++; + j--; + } +} + static bool calc_q1q2(const uint8_t *s, const uint8_t *m, uint8_t *q1, uint8_t *q2) { struct q1q2_ctx ctx; + int len; if (!alloc_q1q2_ctx(s, m, &ctx)) { fprintf(stderr, "Not enough memory for Q1Q2 calculation\n"); @@ -89,8 +106,10 @@ static bool calc_q1q2(const uint8_t *s, const uint8_t *m, uint8_t *q1, goto out; } - BN_bn2bin(ctx.q1, q1); - BN_bn2bin(ctx.q2, q2); + len = BN_bn2bin(ctx.q1, q1); + reverse_bytes(q1, len); + len = BN_bn2bin(ctx.q2, q2); + reverse_bytes(q2, len); free_q1q2_ctx(&ctx); return true; @@ -152,22 +171,6 @@ static RSA *gen_sign_key(void) return key; } -static void reverse_bytes(void *data, int length) -{ - int i = 0; - int j = length - 1; - uint8_t temp; - uint8_t *ptr = data; - - while (i < j) { - temp = ptr[i]; - ptr[i] = ptr[j]; - ptr[j] = temp; - i++; - j--; - } -} - enum mrtags { MRECREATE = 0x0045544145524345, MREADD = 0x0000000044444145, @@ -367,8 +370,6 @@ bool encl_measure(struct encl *encl) /* BE -> LE */ reverse_bytes(sigstruct->signature, SGX_MODULUS_SIZE); reverse_bytes(sigstruct->modulus, SGX_MODULUS_SIZE); - reverse_bytes(sigstruct->q1, SGX_MODULUS_SIZE); - reverse_bytes(sigstruct->q2, SGX_MODULUS_SIZE); EVP_MD_CTX_destroy(ctx); RSA_free(key); -- 2.32.0

3 years, 6 months

2
5
0 0

[PATCH v2 0/4] Swap and fault all the pages of the test enclave binary

by Jarkko Sakkinen

Create a heap for the test enclave, which has the same size as all available Enclave Page Cache (EPC) pages in the system. This will guarantee that all test_encl.elf pages *and* SGX Enclave Control Structure (SECS) have been swapped out by the page reclaimer during the load time. Actually, this adds a bit more stress than that since part of the EPC gets reserved for the Version Array (VA) pages. For each test, the page fault handler gets triggered in two occasions: - When SGX_IOC_ENCLAVE_INIT is performed, SECS gets swapped in by the page fault handler. - During the execution, each page that is referenced gets swapped in by the page fault handler. Jarkko Sakkinen (3): x86/sgx: Add /sys/kernel/debug/x86/sgx_total_mem selftests/sgx: Assign source for each segment selftests/sgx: Trigger the reclaimer and #PF handler Tianjia Zhang (1): selftests/sgx: Fix calculations for sub-maximum field sizes Documentation/x86/sgx.rst | 6 +++ arch/x86/kernel/cpu/sgx/main.c | 10 ++++- tools/testing/selftests/sgx/load.c | 38 ++++++++++++++---- tools/testing/selftests/sgx/main.c | 42 +++++++++++++++++++- tools/testing/selftests/sgx/main.h | 4 +- tools/testing/selftests/sgx/sigstruct.c | 53 +++++++++++++------------ 6 files changed, 117 insertions(+), 36 deletions(-) -- 2.32.0

3 years, 6 months

2
6
0 0

[PATCH 1/2] kunit: tool: make --raw_output support only showing kunit output

by Daniel Latypov

--raw_output is nice, but it would be nicer if could show only output after KUnit tests ahve started. So change the flag to allow specifying a string ('kunit'). Make it so `--raw_output` alone will default to `--raw_output=all` and have the same original behavior. Drop the small kunit_parser.raw_output() function since it feels wrong to put it in "kunit_parser.py" when the point of it is to not parse anything. E.g. $ ./tools/testing/kunit/kunit.py run --raw_output=kunit ... [15:24:07] Starting KUnit Kernel ... TAP version 14 1..1 # Subtest: example 1..3 # example_simple_test: initializing ok 1 - example_simple_test # example_skip_test: initializing # example_skip_test: You should not see a line below. ok 2 - example_skip_test # SKIP this test should be skipped # example_mark_skipped_test: initializing # example_mark_skipped_test: You should see a line below. # example_mark_skipped_test: You should see this line. ok 3 - example_mark_skipped_test # SKIP this test should be skipped ok 1 - example [15:24:10] Elapsed time: 6.487s total, 0.001s configuring, 3.510s building, 0.000s running Signed-off-by: Daniel Latypov <dlatypov(a)google.com> --- Documentation/dev-tools/kunit/kunit-tool.rst | 9 ++++++--- tools/testing/kunit/kunit.py | 20 +++++++++++++++----- tools/testing/kunit/kunit_parser.py | 4 ---- tools/testing/kunit/kunit_tool_test.py | 9 +++++++++ 4 files changed, 30 insertions(+), 12 deletions(-) diff --git a/Documentation/dev-tools/kunit/kunit-tool.rst b/Documentation/dev-tools/kunit/kunit-tool.rst index c7ff9afe407a..ae52e0f489f9 100644 --- a/Documentation/dev-tools/kunit/kunit-tool.rst +++ b/Documentation/dev-tools/kunit/kunit-tool.rst @@ -114,9 +114,12 @@ results in TAP format, you can pass the ``--raw_output`` argument. ./tools/testing/kunit/kunit.py run --raw_output -.. note:: - The raw output from test runs may contain other, non-KUnit kernel log - lines. +The raw output from test runs may contain other, non-KUnit kernel log +lines. You can see just KUnit output with ``--raw_output=kunit``: + +.. code-block:: bash + + ./tools/testing/kunit/kunit.py run --raw_output=kunit If you have KUnit results in their raw TAP format, you can parse them and print the human-readable summary with the ``parse`` command for kunit_tool. This diff --git a/tools/testing/kunit/kunit.py b/tools/testing/kunit/kunit.py index 7174377c2172..5a931456e718 100755 --- a/tools/testing/kunit/kunit.py +++ b/tools/testing/kunit/kunit.py @@ -16,6 +16,7 @@ assert sys.version_info >= (3, 7), "Python version is too old" from collections import namedtuple from enum import Enum, auto +from typing import Iterable import kunit_config import kunit_json @@ -114,7 +115,16 @@ def parse_tests(request: KunitParseRequest) -> KunitResult: 'Tests not Parsed.') if request.raw_output: - kunit_parser.raw_output(request.input_data) + output: Iterable[str] = request.input_data + if request.raw_output == 'all': + pass + elif request.raw_output == 'kunit': + output = kunit_parser.extract_tap_lines(output) + else: + print(f'Unknown --raw_output option "{request.raw_output}"', file=sys.stderr) + for line in output: + print(line.rstrip()) + else: test_result = kunit_parser.parse_run_tests(request.input_data) parse_end = time.time() @@ -135,7 +145,6 @@ def parse_tests(request: KunitParseRequest) -> KunitResult: return KunitResult(KunitStatus.SUCCESS, test_result, parse_end - parse_start) - def run_tests(linux: kunit_kernel.LinuxSourceTree, request: KunitRequest) -> KunitResult: run_start = time.time() @@ -181,7 +190,7 @@ def add_common_opts(parser) -> None: parser.add_argument('--build_dir', help='As in the make command, it specifies the build ' 'directory.', - type=str, default='.kunit', metavar='build_dir') + type=str, default='.kunit', metavar='build_dir') parser.add_argument('--make_options', help='X=Y make option, can be repeated.', action='append') @@ -246,8 +255,9 @@ def add_exec_opts(parser) -> None: action='append') def add_parse_opts(parser) -> None: - parser.add_argument('--raw_output', help='don\'t format output from kernel', - action='store_true') + parser.add_argument('--raw_output', help='If set don\'t format output from kernel. ' + 'If set to --raw_output=kunit, filters to just KUnit output.', + type=str, nargs='?', const='all', default=None) parser.add_argument('--json', nargs='?', help='Stores test results in a JSON, and either ' diff --git a/tools/testing/kunit/kunit_parser.py b/tools/testing/kunit/kunit_parser.py index b88db3f51dc5..84938fefbac0 100644 --- a/tools/testing/kunit/kunit_parser.py +++ b/tools/testing/kunit/kunit_parser.py @@ -106,10 +106,6 @@ def extract_tap_lines(kernel_output: Iterable[str]) -> LineStream: yield line_num, line[prefix_len:] return LineStream(lines=isolate_kunit_output(kernel_output)) -def raw_output(kernel_output) -> None: - for line in kernel_output: - print(line.rstrip()) - DIVIDER = '=' * 60 RESET = '\033[0;0m' diff --git a/tools/testing/kunit/kunit_tool_test.py b/tools/testing/kunit/kunit_tool_test.py index 628ab00f74bc..619c4554cbff 100755 --- a/tools/testing/kunit/kunit_tool_test.py +++ b/tools/testing/kunit/kunit_tool_test.py @@ -399,6 +399,15 @@ class KUnitMainTest(unittest.TestCase): self.assertNotEqual(call, mock.call(StrContains('Testing complete.'))) self.assertNotEqual(call, mock.call(StrContains(' 0 tests run'))) + def test_run_raw_output_kunit(self): + self.linux_source_mock.run_kernel = mock.Mock(return_value=[]) + kunit.main(['run', '--raw_output=kunit'], self.linux_source_mock) + self.assertEqual(self.linux_source_mock.build_reconfig.call_count, 1) + self.assertEqual(self.linux_source_mock.run_kernel.call_count, 1) + for call in self.print_mock.call_args_list: + self.assertNotEqual(call, mock.call(StrContains('Testing complete.'))) + self.assertNotEqual(call, mock.call(StrContains(' 0 tests run'))) + def test_exec_timeout(self): timeout = 3453 kunit.main(['exec', '--timeout', str(timeout)], self.linux_source_mock) base-commit: f684616e08e9cd9db3cd53fe2e068dfe02481657 -- 2.32.0.554.ge1b32706d8-goog

3 years, 6 months

1
1
0 0

[PATCH v2 2/3] kunit: Add support for suite initialization and cleanup

by Bart Van Assche

Reviewed-by: Brendan Higgins <brendanhiggins(a)google.com> Cc: David Gow <davidgow(a)google.com> Cc: Shuah Khan <skhan(a)linuxfoundation.org> Cc: kunit-dev(a)googlegroups.com Cc: linux-kselftest(a)vger.kernel.org Cc: Bodo Stroesser <bostroesser(a)gmail.com> Cc: Martin K. Petersen <martin.petersen(a)oracle.com> Cc: Yanko Kaneti <yaneti(a)declera.com> Signed-off-by: Bart Van Assche <bvanassche(a)acm.org> --- include/kunit/test.h | 4 ++++ lib/kunit/test.c | 14 ++++++++++++++ 2 files changed, 18 insertions(+) diff --git a/include/kunit/test.h b/include/kunit/test.h index 24b40e5c160b..a6eef96a409c 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -215,6 +215,8 @@ static inline char *kunit_status_to_ok_not_ok(enum kunit_status status) * struct kunit_suite - describes a related collection of &struct kunit_case * * @name: the name of the test. Purely informational. + * @init_suite: called once per test suite before the test cases. + * @exit_suite: called once per test suite after all test cases. * @init: called before every test case. * @exit: called after every test case. * @test_cases: a null terminated array of test cases. @@ -229,6 +231,8 @@ static inline char *kunit_status_to_ok_not_ok(enum kunit_status status) */ struct kunit_suite { const char name[256]; + int (*init_suite)(void); + void (*exit_suite)(void); int (*init)(struct kunit *test); void (*exit)(struct kunit *test); struct kunit_case *test_cases; diff --git a/lib/kunit/test.c b/lib/kunit/test.c index d79ecb86ea57..c271692ced93 100644 --- a/lib/kunit/test.c +++ b/lib/kunit/test.c @@ -397,9 +397,19 @@ int kunit_run_tests(struct kunit_suite *suite) { char param_desc[KUNIT_PARAM_DESC_SIZE]; struct kunit_case *test_case; + int res = 0; kunit_print_subtest_start(suite); + if (suite->init_suite) + res = suite->init_suite(); + + if (res < 0) { + kunit_log(KERN_INFO, suite, KUNIT_SUBTEST_INDENT + "# Suite initialization failed (%d)\n", res); + goto end; + } + kunit_suite_for_each_test_case(suite, test_case) { struct kunit test = { .param_value = NULL, .param_index = 0 }; test_case->status = KUNIT_SKIPPED; @@ -439,6 +449,10 @@ int kunit_run_tests(struct kunit_suite *suite) test.status_comment); } + if (suite->exit_suite) + suite->exit_suite(); + +end: kunit_print_subtest_end(suite); return 0;

3 years, 6 months

3
7
0 0

[PATCH v2 0/4] kselftest/arm64: Vector length configuration tests

by Mark Brown

Currently we don't have full automated tests for the vector length configuation ABIs offered for SVE, we have a helper binary for setting the vector length which can be used for manual tests and we use the prctl() interface to enumerate the vector lengths but don't actually verify that the vector lengths enumerated were set. This patch series provides a small helper which allows us to get the currently configured vector length using the RDVL instruction via either a library call or stdout of a process and then uses this to both add verification of enumerated vector lengths to our existing tests and also add a new test program which exercises both the prctl() and sysfs interfaces. In preparation for the forthcomng support for the Scalable Matrix Extension (SME) [1] which introduces a new vector length managed via a very similar hardware interface the helper and new test program are parameterised with the goal of allowing reuse for SME. [1] https://community.arm.com/developer/ip-products/processors/b/processors-ip-… v2: - Tweak log message on failure in sve-probe-vls. - Stylistic changes in vec-syscfg. - Flush stdout before forking in vec-syscfg. - Use EXIT_FAILURE. - Use fdopen() to get child output. - Replace a bunch of UNIX API usage with stdio. - Add a TODO list. - Verify that we're root before testing writes to /proc. Mark Brown (4): kselftest/arm64: Provide a helper binary and "library" for SVE RDVL kselftest/arm64: Validate vector lengths are set in sve-probe-vls kselftest/arm64: Add tests for SVE vector configuration kselftest/arm64: Add a TODO list for floating point tests tools/testing/selftests/arm64/fp/.gitignore | 2 + tools/testing/selftests/arm64/fp/Makefile | 11 +- tools/testing/selftests/arm64/fp/TODO | 3 + tools/testing/selftests/arm64/fp/rdvl-sve.c | 14 + tools/testing/selftests/arm64/fp/rdvl.S | 9 + tools/testing/selftests/arm64/fp/rdvl.h | 8 + .../selftests/arm64/fp/sve-probe-vls.c | 5 + tools/testing/selftests/arm64/fp/vec-syscfg.c | 580 ++++++++++++++++++ 8 files changed, 629 insertions(+), 3 deletions(-) create mode 100644 tools/testing/selftests/arm64/fp/TODO create mode 100644 tools/testing/selftests/arm64/fp/rdvl-sve.c create mode 100644 tools/testing/selftests/arm64/fp/rdvl.S create mode 100644 tools/testing/selftests/arm64/fp/rdvl.h create mode 100644 tools/testing/selftests/arm64/fp/vec-syscfg.c base-commit: ff1176468d368232b684f75e82563369208bc371 -- 2.20.1

3 years, 6 months

3
12
0 0

Re: [PATCH 3/4] kunit: Add support for suite initialization and cleanup

by Brendan Higgins

On Fri, Jul 23, 2021 at 2:24 PM Bart Van Assche <bvanassche(a)acm.org> wrote: > > Cc: Brendan Higgins <brendanhiggins(a)google.com> > Cc: Bodo Stroesser <bostroesser(a)gmail.com> > Cc: Martin K. Petersen <martin.petersen(a)oracle.com> > Cc: Yanko Kaneti <yaneti(a)declera.com> Please also CC davidgow(a)google.com, skhan(a)linuxfoundation.org, kunit-dev(a)googlegroups.com, and linux-kselftest(a)vger.kernel.org for KUnit changes in the future. > Signed-off-by: Bart Van Assche <bvanassche(a)acm.org> This seems pretty sensible. Reviewed-by: Brendan Higgins <brendanhiggins(a)google.com> > --- > include/kunit/test.h | 4 ++++ > lib/kunit/test.c | 14 ++++++++++++++ > 2 files changed, 18 insertions(+) > > diff --git a/include/kunit/test.h b/include/kunit/test.h > index 24b40e5c160b..a6eef96a409c 100644 > --- a/include/kunit/test.h > +++ b/include/kunit/test.h > @@ -215,6 +215,8 @@ static inline char *kunit_status_to_ok_not_ok(enum kunit_status status) > * struct kunit_suite - describes a related collection of &struct kunit_case > * > * @name: the name of the test. Purely informational. > + * @init_suite: called once per test suite before the test cases. > + * @exit_suite: called once per test suite after all test cases. > * @init: called before every test case. > * @exit: called after every test case. > * @test_cases: a null terminated array of test cases. > @@ -229,6 +231,8 @@ static inline char *kunit_status_to_ok_not_ok(enum kunit_status status) > */ > struct kunit_suite { > const char name[256]; > + int (*init_suite)(void); > + void (*exit_suite)(void); I like this idea. Many other unit testing libraries in other languages have something similar. I think it probably makes sense to not use any kind of context object here (as you have done); nevertheless, I still think it is an appropriate question for the list. > int (*init)(struct kunit *test); > void (*exit)(struct kunit *test); > struct kunit_case *test_cases; > diff --git a/lib/kunit/test.c b/lib/kunit/test.c > index d79ecb86ea57..c271692ced93 100644 > --- a/lib/kunit/test.c > +++ b/lib/kunit/test.c > @@ -397,9 +397,19 @@ int kunit_run_tests(struct kunit_suite *suite) > { > char param_desc[KUNIT_PARAM_DESC_SIZE]; > struct kunit_case *test_case; > + int res = 0; > > kunit_print_subtest_start(suite); > > + if (suite->init_suite) > + res = suite->init_suite(); > + > + if (res < 0) { > + kunit_log(KERN_INFO, suite, KUNIT_SUBTEST_INDENT > + "# Suite initialization failed (%d)\n", res); > + goto end; > + } > + > kunit_suite_for_each_test_case(suite, test_case) { > struct kunit test = { .param_value = NULL, .param_index = 0 }; > test_case->status = KUNIT_SKIPPED; > @@ -439,6 +449,10 @@ int kunit_run_tests(struct kunit_suite *suite) > test.status_comment); > } > > + if (suite->exit_suite) > + suite->exit_suite(); > + > +end: > kunit_print_subtest_end(suite); > > return 0;

3 years, 6 months

2
1
0 0

[PATCH v1 0/3] kselftest/arm64: Vector length configuration tests

by Mark Brown

Currently we don't have full automated tests for the vector length configuation ABIs offered for SVE, we have a helper binary for setting the vector length which can be used for manual tests and we use the prctl() interface to enumerate the vector lengths but don't actually verify that the vector lengths enumerated were set. This patch series provides a small helper which allows us to get the currently configured vector length using the RDVL instruction via either a library call or stdout of a process and then uses this to both add verification of enumerated vector lengths to our existing tests and also add a new test program which exercises both the prctl() and sysfs interfaces. In preparation for the forthcomng support for the Scalable Matrix Extension (SME) [1] which introduces a new vector length managed via a very similar hardware interface the helper and new test program are parameterised with the goal of allowing reuse for SME. [1] https://community.arm.com/developer/ip-products/processors/b/processors-ip-… Mark Brown (3): kselftest/arm64: Provide a helper binary and "library" for SVE RDVL kselftest/arm64: Validate vector lengths are set in sve-probe-vls kselftest/arm64: Add tests for SVE vector configuration tools/testing/selftests/arm64/fp/.gitignore | 2 + tools/testing/selftests/arm64/fp/Makefile | 11 +- tools/testing/selftests/arm64/fp/rdvl-sve.c | 14 + tools/testing/selftests/arm64/fp/rdvl.S | 9 + tools/testing/selftests/arm64/fp/rdvl.h | 8 + .../selftests/arm64/fp/sve-probe-vls.c | 5 + tools/testing/selftests/arm64/fp/vec-syscfg.c | 578 ++++++++++++++++++ 7 files changed, 624 insertions(+), 3 deletions(-) create mode 100644 tools/testing/selftests/arm64/fp/rdvl-sve.c create mode 100644 tools/testing/selftests/arm64/fp/rdvl.S create mode 100644 tools/testing/selftests/arm64/fp/rdvl.h create mode 100644 tools/testing/selftests/arm64/fp/vec-syscfg.c base-commit: ff1176468d368232b684f75e82563369208bc371 -- 2.20.1

3 years, 6 months

2
14
0 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror