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

[PATCH V2 0/3] riscv: add support for restartable sequence

by Vincent Chen

Add RSEQ, restartable sequence, support and related selftest to RISCV. The Kconfig option HAVE_REGS_AND_STACK_ACCESS_API is also required by RSEQ because RSEQ will modify the content of pt_regs.sepc through instruction_pointer_set() during the fixup procedure. In order to select the config HAVE_REGS_AND_STACK_ACCESS_API, the missing APIs for accessing pt_regs are also added in this patch set. The relevant RSEQ tests in kselftest require the Binutils patch "RISC-V: Fix linker problems with TLS copy relocs" to avoid placing PREINIT_ARRAY and TLS variable of librseq.so at the same address. https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;a=commit;h=3e7bd7f… A segmental fault will happen if binutils misses this patch. Patrick Stählin (1): riscv: add required functions to enable HAVE_REGS_AND_STACK_ACCESS_API Vincent Chen (2): riscv: Add support for restartable sequence rseq/selftests: Add support for riscv Changes since v1: 1. Use the correct register name to access pt_regs arch/riscv/Kconfig | 2 + arch/riscv/include/asm/ptrace.h | 29 +- arch/riscv/kernel/entry.S | 4 + arch/riscv/kernel/ptrace.c | 99 +++++ arch/riscv/kernel/signal.c | 2 + tools/testing/selftests/rseq/param_test.c | 23 ++ tools/testing/selftests/rseq/rseq-riscv.h | 622 ++++++++++++++++++++++++++++++ tools/testing/selftests/rseq/rseq.h | 2 + 8 files changed, 782 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/rseq/rseq-riscv.h -- 2.7.4

3 years, 6 months

3
8
0 0

[PATCH bpf-next 0/3] libbpf: btf typed data dumping fixes (__int128 usage, error propagation)

by Alan Maguire

This series aims to resolve further issues with the BTF typed data dumping interfaces in libbpf. Compilation failures with use of __int128 on 32-bit platforms were reported [1]. As a result, the use of __int128 in libbpf typed data dumping is replaced with __u64 usage for bitfield manipulations. In the case of 128-bit integer values, they are simply split into two 64-bit hex values for display (patch 1). Tests are added for __int128 display in patch 2, using conditional compilation to avoid problems with a lack of __int128 support. Patch 3 resolves an issue Andrii noted about error propagation when handling enum data display. More followup work is required to ensure multi-dimensional char array display works correctly. [1] https://lore.kernel.org/bpf/1626362126-27775-1-git-send-email-alan.maguire@… Alan Maguire (3): libbpf: avoid use of __int128 in typed dump display selftests/bpf: add __int128-specific tests for typed data dump libbpf: propagate errors when retrieving enum value for typed data display tools/lib/bpf/btf_dump.c | 67 +++++++++++++---------- tools/testing/selftests/bpf/prog_tests/btf_dump.c | 17 ++++++ 2 files changed, 55 insertions(+), 29 deletions(-) -- 1.8.3.1

3 years, 6 months

2
6
0 0

[PATCH] lib/test: convert test_min_heap.c to use KUnit

by Daniel Latypov

We leave the file names and Kconfig option unchanged for now to minimize disruption. So functionally, this just means that the test output will be slightly changed and it'll now depend on CONFIG_KUNIT=y/m. It'll still run at boot time and can still be built as a loadable module, but it can now be run a bit more easily via: $ ./tools/testing/kunit/kunit.py run By default, the above command will run with CONFIG_KUNIT_ALL_TESTS=y. Users could run this test individually via something like: $ ./tools/testing/kunit/kunit.py run --kunitconfig /dev/stdin <<EOF CONFIG_KUNIT=y CONFIG_TEST_MIN_HEAP=y EOF Example output: [14:57:54] ============================================================ [14:57:54] ======== [PASSED] lib_minmax_heap ======== [14:57:54] [PASSED] test_min_heap [14:57:54] [PASSED] test_max_heap [14:57:54] ============================================================ [14:57:54] Testing complete. 2 tests run. 0 failed. 0 crashed. 0 skipped. [14:57:54] Elapsed time: 39.696s total, 0.001s configuring, 36.705s building, 0.000s running Note: this is the time it took after a `make mrproper`. Signed-off-by: Daniel Latypov <dlatypov(a)google.com> --- lib/Kconfig.debug | 5 ++- lib/test_min_heap.c | 102 ++++++++++++++++++++------------------------ 2 files changed, 49 insertions(+), 58 deletions(-) diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index 831212722924..36e9529ede65 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -2068,8 +2068,9 @@ config TEST_LIST_SORT If unsure, say N. config TEST_MIN_HEAP - tristate "Min heap test" - depends on DEBUG_KERNEL || m + tristate "Min heap test" if !KUNIT_ALL_TESTS + depends on KUNIT + default KUNIT_ALL_TESTS help Enable this to turn on min heap function tests. This test is executed only once during system boot (so affects only boot time), diff --git a/lib/test_min_heap.c b/lib/test_min_heap.c index d19c8080fd4d..c0f1ef78c08e 100644 --- a/lib/test_min_heap.c +++ b/lib/test_min_heap.c @@ -1,27 +1,27 @@ // SPDX-License-Identifier: GPL-2.0-only -#define pr_fmt(fmt) "min_heap_test: " fmt - /* * Test cases for the min max heap. */ +#include <kunit/test.h> + #include <linux/log2.h> #include <linux/min_heap.h> #include <linux/module.h> #include <linux/printk.h> #include <linux/random.h> -static __init bool less_than(const void *lhs, const void *rhs) +static bool less_than(const void *lhs, const void *rhs) { return *(int *)lhs < *(int *)rhs; } -static __init bool greater_than(const void *lhs, const void *rhs) +static bool greater_than(const void *lhs, const void *rhs) { return *(int *)lhs > *(int *)rhs; } -static __init void swap_ints(void *lhs, void *rhs) +static void swap_ints(void *lhs, void *rhs) { int temp = *(int *)lhs; @@ -29,37 +29,27 @@ static __init void swap_ints(void *lhs, void *rhs) *(int *)rhs = temp; } -static __init int pop_verify_heap(bool min_heap, - struct min_heap *heap, - const struct min_heap_callbacks *funcs) +static void pop_verify_heap(struct kunit *test, bool min_heap, + struct min_heap *heap, + const struct min_heap_callbacks *funcs) { int *values = heap->data; - int err = 0; int last; last = values[0]; min_heap_pop(heap, funcs); while (heap->nr > 0) { if (min_heap) { - if (last > values[0]) { - pr_err("error: expected %d <= %d\n", last, - values[0]); - err++; - } + KUNIT_EXPECT_LE(test, last, values[0]); } else { - if (last < values[0]) { - pr_err("error: expected %d >= %d\n", last, - values[0]); - err++; - } + KUNIT_EXPECT_GE(test, last, values[0]); } last = values[0]; min_heap_pop(heap, funcs); } - return err; } -static __init int test_heapify_all(bool min_heap) +static void test_heapify_all(struct kunit *test, bool min_heap) { int values[] = { 3, 1, 2, 4, 0x8000000, 0x7FFFFFF, 0, -3, -1, -2, -4, 0x8000000, 0x7FFFFFF }; @@ -73,11 +63,11 @@ static __init int test_heapify_all(bool min_heap) .less = min_heap ? less_than : greater_than, .swp = swap_ints, }; - int i, err; + int i; /* Test with known set of values. */ min_heapify_all(&heap, &funcs); - err = pop_verify_heap(min_heap, &heap, &funcs); + pop_verify_heap(test, min_heap, &heap, &funcs); /* Test with randomly generated values. */ @@ -86,12 +76,10 @@ static __init int test_heapify_all(bool min_heap) values[i] = get_random_int(); min_heapify_all(&heap, &funcs); - err += pop_verify_heap(min_heap, &heap, &funcs); - - return err; + pop_verify_heap(test, min_heap, &heap, &funcs); } -static __init int test_heap_push(bool min_heap) +static void test_heap_push(struct kunit *test, bool min_heap) { const int data[] = { 3, 1, 2, 4, 0x80000000, 0x7FFFFFFF, 0, -3, -1, -2, -4, 0x80000000, 0x7FFFFFFF }; @@ -106,25 +94,23 @@ static __init int test_heap_push(bool min_heap) .less = min_heap ? less_than : greater_than, .swp = swap_ints, }; - int i, temp, err; + int i, temp; /* Test with known set of values copied from data. */ for (i = 0; i < ARRAY_SIZE(data); i++) min_heap_push(&heap, &data[i], &funcs); - err = pop_verify_heap(min_heap, &heap, &funcs); + pop_verify_heap(test, min_heap, &heap, &funcs); /* Test with randomly generated values. */ while (heap.nr < heap.size) { temp = get_random_int(); min_heap_push(&heap, &temp, &funcs); } - err += pop_verify_heap(min_heap, &heap, &funcs); - - return err; + pop_verify_heap(test, min_heap, &heap, &funcs); } -static __init int test_heap_pop_push(bool min_heap) +static void test_heap_pop_push(struct kunit *test, bool min_heap) { const int data[] = { 3, 1, 2, 4, 0x80000000, 0x7FFFFFFF, 0, -3, -1, -2, -4, 0x80000000, 0x7FFFFFFF }; @@ -139,7 +125,7 @@ static __init int test_heap_pop_push(bool min_heap) .less = min_heap ? less_than : greater_than, .swp = swap_ints, }; - int i, temp, err; + int i, temp; /* Fill values with data to pop and replace. */ temp = min_heap ? 0x80000000 : 0x7FFFFFFF; @@ -150,7 +136,7 @@ static __init int test_heap_pop_push(bool min_heap) for (i = 0; i < ARRAY_SIZE(data); i++) min_heap_pop_push(&heap, &data[i], &funcs); - err = pop_verify_heap(min_heap, &heap, &funcs); + pop_verify_heap(test, min_heap, &heap, &funcs); heap.nr = 0; for (i = 0; i < ARRAY_SIZE(data); i++) @@ -161,34 +147,38 @@ static __init int test_heap_pop_push(bool min_heap) temp = get_random_int(); min_heap_pop_push(&heap, &temp, &funcs); } - err += pop_verify_heap(min_heap, &heap, &funcs); + pop_verify_heap(test, min_heap, &heap, &funcs); +} - return err; +static void test_heap(struct kunit *test, bool min_heap) +{ + test_heapify_all(test, min_heap); + test_heap_push(test, min_heap); + test_heap_pop_push(test, min_heap); } -static int __init test_min_heap_init(void) +static void test_min_heap(struct kunit *test) { - int err = 0; - - err += test_heapify_all(true); - err += test_heapify_all(false); - err += test_heap_push(true); - err += test_heap_push(false); - err += test_heap_pop_push(true); - err += test_heap_pop_push(false); - if (err) { - pr_err("test failed with %d errors\n", err); - return -EINVAL; - } - pr_info("test passed\n"); - return 0; + test_heap(test, true); } -module_init(test_min_heap_init); -static void __exit test_min_heap_exit(void) +static void test_max_heap(struct kunit *test) { - /* do nothing */ + test_heap(test, false); } -module_exit(test_min_heap_exit); + +static struct kunit_case __refdata minmax_heap_test_cases[] = { + KUNIT_CASE(test_min_heap), + KUNIT_CASE(test_max_heap), + {} +}; + +static struct kunit_suite minmax_heap_test_suite = { + .name = "lib_minmax_heap", + .test_cases = minmax_heap_test_cases, +}; + +kunit_test_suites(&minmax_heap_test_suite); + MODULE_LICENSE("GPL"); base-commit: 2734d6c1b1a089fb593ef6a23d4b70903526fe0c -- 2.32.0.402.g57bb445576-goog

3 years, 6 months

1
1
0 0

[PATCH v6 bpf-next 0/3] libbpf: BTF dumper support for typed data

by Alan Maguire

Add a libbpf dumper function that supports dumping a representation of data passed in using the BTF id associated with the data in a manner similar to the bpf_snprintf_btf helper. Default output format is identical to that dumped by bpf_snprintf_btf() (bar using tabs instead of spaces for indentation, but the indent string can be customized also); for example, a "struct sk_buff" representation would look like this: (struct sk_buff){ (union){ (struct){ .next = (struct sk_buff *)0xffffffffffffffff, .prev = (struct sk_buff *)0xffffffffffffffff, (union){ .dev = (struct net_device *)0xffffffffffffffff, .dev_scratch = (long unsigned int)18446744073709551615, }, }, ... Patch 1 implements the dump functionality in a manner similar to that in kernel/bpf/btf.c, but with a view to fitting into libbpf more naturally. For example, rather than using flags, boolean dump options are used to control output. In addition, rather than combining checks for display (such as is this field zero?) and actual display - as is done for the kernel code - the code is organized to separate zero and overflow checks from type display. Patch 2 adds ASSERT_STRNEQ() for use in the following BTF dumper tests. Patch 3 consists of selftests that utilize a dump printf function to snprintf the dump output to a string for comparison with expected output. Tests deliberately mirror those in snprintf_btf helper test to keep output consistent, but also cover overflow handling, var/section display. Changes since v5 [1] - readjust dump options to avoid unnecessary padding (Andrii, patch 1). - tidied up bitfield data checking/retrieval using Andrii's suggestions. Removed code where we adjust data pointer prior to calling bitfield functions as this adjustment is not needed, provided we use the type size as the number of bytes to iterate over when retrieving the full value we apply bit shifting operations to retrieve the bitfield value. With these chances, the *_int_bits() functions were no longer needed (Andrii, patch 1). - coalesced the "is zero" checking for ints, floats and pointers into btf_dump_base_type_check_zero(), using a memcmp() of the size of the data. This can be derived from t->size for ints and floats, and pointer size is retrieved from dump's ptr_sz field (Andrii, patch 1). - Added alignment-aware handling for int, enum, float retrieval. Packed data structures can force ints, enums and floats to be aligned on different boundaries; for example, the struct p { char f1; int f2; } __attribute__((packed)); ...will have the int f2 field offset at byte 1, rather than at byte 4 for an unpacked structure. The problem is directly dereferencing that as an int is problematic on some platforms. For ints and enums, we can reuse bitfield retrieval to get the value for display, while for floats we use a local union of the floating-point types and memcpy into it, ensuring we can then dereference pointers into that union which will have safe alignment (Andrii, patch 1). - added comments to explain why we increment depth prior to displaying opening parens, and decrement it prior to displaying closing parens for structs, unions and arrays. The reason is that we don't want to have a trailing newline when displaying a type. The logic that handles this says "don't show a newline when the depth we're at is 0". For this to work for opening parens then we need to bump depth before showing opening parens + newline, and when we close out structure we need to show closing parens after reducing depth so that we don't append a newline to a top-level structure. So as a result we have struct foo {\n struct bar {\n }\n } - silently truncate provided indent string with strncat() if > 31 bytes (Andrii, patch 1). - fixed ASSERT_STRNEQ() macro to show only n bytes of string (Andrii, patch 2). - fixed strncat() of type data string to avoid stack corruption (Andrii, patch 3). - removed early returns from dump type tests (Andrii, patch 3). - have tests explicitly specify prefix (enum, struct, union) (Andrii, patch 3). - switch from CHECK() to ASSERT_* where possible (Andrii, patch 3). Changes since v4 [2] - Andrii kindly provided code to unify emitting a prepended cast (for example "(int)") with existing code, and this had the nice benefit of adding array indices in type specifications (Andrii, patches 1, 3) - Fixed indent_str option to make it a const char *, stored in a fixed-length buffer internally (Andrii, patch 1) - Reworked bit shift logic to minimize endian-specific interactions, and use same macros as found elsewhere in libbpf to determine endianness (Andrii, patch 1) - Fixed type emitting to ensure that a trailing '\n' is not displayed; newlines are added during struct/array display, but for a single type the last character is no longer a newline (Andrii, patches 1, 3) - Added support for ASSERT_STRNEQ() macro (Andrii, patch 2) - Split tests into subtests for int, char, enum etc rather than one "dump type data" subtest (Andrii, patch 3) - Made better use of ASSERT* macros (Andrii, patch 3) - Got rid of some other TEST_* macros that were unneeded (Andrii, patch 3) - Switched to using "struct fs_context" to verify enum bitfield values (Andrii, patch 3) Changes since v3 [3] - Retained separation of emitting of type name cast prefixing type values from existing functionality such as btf_dump_emit_type_chain() since initial code-shared version had so many exceptions it became hard to read. For example, we don't emit a type name if the type to be displayed is an array member, we also always emit "forward" definitions for structs/unions that aren't really forward definitions (we just want a "struct foo" output for "(struct foo){.bar = ...". We also always ignore modifiers const/volatile/restrict as they clutter output when emitting large types. - Added configurable 4-char indent string option; defaults to tab (Andrii) - Added support for BTF_KIND_FLOAT and associated tests (Andrii) - Added support for BTF_KIND_FUNC_PROTO function pointers to improve output of "ops" structures; for example: (struct file_operations){ .owner = (struct module *)0xffffffffffffffff, .llseek = (loff_t(*)(struct file *, loff_t, int))0xffffffffffffffff, ... Added associated test also (Andrii) - Added handling for enum bitfields and associated test (Andrii) - Allocation of "struct btf_dump_data" done on-demand (Andrii) - Removed ".field = " output from function emitting type name and into caller (Andrii) - Removed BTF_INT_OFFSET() support (Andrii) - Use libbpf_err() to set errno for error cases (Andrii) - btf_dump_dump_type_data() returns size written, which is used when returning successfully from btf_dump__dump_type_data() (Andrii) Changes since v2 [4] - Renamed function to btf_dump__dump_type_data, reorganized arguments such that opts are last (Andrii) - Modified code to separate questions about display such as have we overflowed?/is this field zero? from actual display of typed data, such that we ask those questions separately from the code that actually displays typed data (Andrii) - Reworked code to handle overflow - where we do not provide enough data for the type we wish to display - by returning -E2BIG and attempting to present as much data as possible. Such a mode of operation allows for tracers which retrieve partial data (such as first 1024 bytes of a "struct task_struct" say), and want to display that partial data, while also knowing that it is not the full type. Such tracers can then denote this (perhaps via "..." or similar). - Explored reusing existing type emit functions, such as passing in a type id stack with a single type id to btf_dump_emit_type_chain() to support the display of typed data where a "cast" is prepended to the data to denote its type; "(int)1", "(struct foo){", etc. However the task of emitting a ".field_name = (typecast)" did not match well with model of walking the stack to display innermost types first and made the resultant code harder to read. Added a dedicated btf_dump_emit_type_name() function instead which is only ~70 lines (Andrii) - Various cleanups around bitfield macros, unneeded member iteration macros, avoiding compiler complaints when displaying int da ta by casting to long long, etc (Andrii) - Use DECLARE_LIBBPF_OPTS() in defining opts for tests (Andrii) - Added more type tests, overflow tests, var tests and section tests. Changes since RFC [5] - The initial approach explored was to share the kernel code with libbpf using #defines to paper over the different needs; however it makes more sense to try and fit in with libbpf code style for maintenance. A comment in the code points at the implementation in kernel/bpf/btf.c and notes that any issues found in it should be fixed there or vice versa; mirroring the tests should help with this also (Andrii) [1] https://lore.kernel.org/bpf/1624092968-5598-1-git-send-email-alan.maguire@o… [2] https://lore.kernel.org/bpf/CAEf4BzYtbnphCkhz0epMKE4zWfvSOiMpu+-SXp9hadsrRA… [3] https://lore.kernel.org/bpf/1622131170-8260-1-git-send-email-alan.maguire@o… [4] https://lore.kernel.org/bpf/1610921764-7526-1-git-send-email-alan.maguire@o… [5] https://lore.kernel.org/bpf/1610386373-24162-1-git-send-email-alan.maguire@… Alan Maguire (3): libbpf: BTF dumper support for typed data selftests/bpf: add ASSERT_STRNEQ() variant for test_progs selftests/bpf: add dump type data tests to btf dump tests tools/lib/bpf/btf.h | 19 + tools/lib/bpf/btf_dump.c | 819 +++++++++++++++++++++- tools/lib/bpf/libbpf.map | 1 + tools/testing/selftests/bpf/prog_tests/btf_dump.c | 600 ++++++++++++++++ tools/testing/selftests/bpf/test_progs.h | 12 + 5 files changed, 1446 insertions(+), 5 deletions(-) -- 1.8.3.1

3 years, 6 months

3
9
0 0

[GIT PULL] KUnit update for Linux 5.14-rc2

by Shuah Khan

Hi Linus, Please pull the following KUnit fixes update for Linux 5,14-rc2 This KUnit fixes update for Linux 5.14-rc2 consists of fixes to kunit tool and documentation: -- asserts on older python versions. -- fixes to misleading error messages when TAP header format is incorrect or when file is missing. -- fixes documentation dropping obsolete information about uml_abort coverage. -- removing unnecessary annotations diff is attached. Thanks, -- Shuah ---------------------------------------------------------------- The following changes since commit e73f0f0ee7541171d89f2e2491130c7771ba58d3: Linux 5.14-rc1 (2021-07-11 15:07:40 -0700) are available in the Git repository at: git://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest tags/linux-kselftest-kunit-fixes-5.14-rc2 for you to fetch changes up to df4b0807ca1a62822342d404b863eff933d15762: kunit: tool: Assert the version requirement (2021-07-12 14:02:32 -0600) ---------------------------------------------------------------- linux-kselftest-kunit-fixes-5.14-rc2 This KUnit fixes update for Linux 5.14-rc2 consists of fixes to kunit tool and documentation: -- asserts on older python versions. -- fixes to misleading error messages when TAP header format is incorrect or when file is missing. -- fixes documentation dropping obsolete information about uml_abort coverage. -- removing unnecessary annotations ---------------------------------------------------------------- Daniel Latypov (2): Documentation: kunit: drop obsolete note about uml_abort for coverage kunit: tool: remove unnecessary "annotations" import Rae Moar (1): kunit: tool: Fix error messages for cases of no tests and wrong TAP header SeongJae Park (1): kunit: tool: Assert the version requirement Documentation/dev-tools/kunit/running_tips.rst | 14 +------------- tools/testing/kunit/kunit.py | 2 ++ tools/testing/kunit/kunit_kernel.py | 6 ++---- tools/testing/kunit/kunit_parser.py | 6 ++++-- tools/testing/kunit/kunit_tool_test.py | 16 +++++++++++++--- ...og => test_is_test_passed-no_tests_run_no_header.log} | 0 .../test_is_test_passed-no_tests_run_with_header.log | 2 ++ 7 files changed, 24 insertions(+), 22 deletions(-) rename tools/testing/kunit/test_data/{test_is_test_passed-no_tests_run.log => test_is_test_passed-no_tests_run_no_header.log} (100%) create mode 100644 tools/testing/kunit/test_data/test_is_test_passed-no_tests_run_with_header.log ----------------------------------------------------------------

3 years, 6 months

2
1
0 0

[GIT PULL] Kselftest update for Linux 5.14-rc2

by Shuah Khan

Hi Linus, Please pull the following Kselftest fixes update for Linux 5.14-rc2 This Kselftest fixes update for Linux 5.14-rc2 consists of fix to memory-hotplug hot-remove test to stop spamming logs with dump_page() entries and slowing the system down to a crawl. diff is attached. thanks, -- Shuah ---------------------------------------------------------------- The following changes since commit e73f0f0ee7541171d89f2e2491130c7771ba58d3: Linux 5.14-rc1 (2021-07-11 15:07:40 -0700) are available in the Git repository at: git://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest tags/linux-kselftest-fixes-5.14-rc2 for you to fetch changes up to 0c0f6299ba71faf610e311605e09e96331c45f28: selftests: memory-hotplug: avoid spamming logs with dump_page(), ratio limit hot-remove error test (2021-07-12 14:20:01 -0600) ---------------------------------------------------------------- linux-kselftest-fixes-5.14-rc2 This Kselftest fixes update for Linux 5.14-rc2 consists of fix to memory-hotplug hot-remove test to stop spamming logs with dump_page() entries and slowing the system down to a crawl. ---------------------------------------------------------------- Paolo Pisati (1): selftests: memory-hotplug: avoid spamming logs with dump_page(), ratio limit hot-remove error test tools/testing/selftests/memory-hotplug/mem-on-off-test.sh | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) ----------------------------------------------------------------

3 years, 6 months

2
1
0 0

[PATCH v8 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 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 | 954 +++++++++++++++++++++++++++ 2 files changed, 955 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..05373dbd02b9 --- /dev/null +++ b/tools/testing/selftests/x86/amx.c @@ -0,0 +1,954 @@ +// 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; + +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) { + 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) +{ + 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, 0); + if (rc & 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); + + 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 = true; + if (xrstor_safe(xsave_buffer, -1, -1)) { + nerrs++; + printf("[FAIL]\tSucceeded at child.\n"); + } else { + printf("[OK]\tBlocked at child.\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 = 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("\tAt signal return,\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 v2 bpf-next 0/3] libbpf: BTF typed dump cleanups

by Alan Maguire

Fix issues with libbpf BTF typed dump code. Patch 1 addresses handling of unaligned data. Patch 2 fixes issues Andrii noticed when compiling on ppc64le. Patch 3 simplifies typed dump by getting rid of allocation of dump data structure which tracks dump state etc. Changes since v1: - Andrii suggested using a function instead of a macro for checking alignment of data, and pointed out that we need to consider dump ptr size versus native pointer size (patch 1) Alan Maguire (3): libbpf: clarify/fix unaligned data issues for btf typed dump libbpf: fix compilation errors on ppc64le for btf dump typed data libbpf: btf typed dump does not need to allocate dump data tools/lib/bpf/btf_dump.c | 39 ++++++++++++++++++++++++++++++--------- 1 file changed, 30 insertions(+), 9 deletions(-) -- 1.8.3.1

3 years, 6 months

2
8
0 0

[PATCH bpf-next] libbpf: clarify/fix unaligned data issues for btf typed dump

by Alan Maguire

If data is packed, data structures can store it outside of usual boundaries. For example a 4-byte int can be stored on a unaligned boundary in a case like this: struct s { char f1; int f2; } __attribute((packed)); ...the int is stored at an offset of one byte. Some platforms have problems dereferencing data that is not aligned with its size, and code exists to handle most cases of this for BTF typed data display. However pointer display was missed, and a simple macro to test if "data_is_unaligned(data, data_sz)" would help clarify this code. Suggested-by: Andrii Nakryiko <andrii(a)kernel.org> Signed-off-by: Alan Maguire <alan.maguire(a)oracle.com> --- tools/lib/bpf/btf_dump.c | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/tools/lib/bpf/btf_dump.c b/tools/lib/bpf/btf_dump.c index 929cf93..9dfe9c1 100644 --- a/tools/lib/bpf/btf_dump.c +++ b/tools/lib/bpf/btf_dump.c @@ -1654,6 +1654,8 @@ static int btf_dump_base_type_check_zero(struct btf_dump *d, return 0; } +#define data_is_unaligned(data, data_sz) (((uintptr_t)data) % data_sz) + static int btf_dump_int_data(struct btf_dump *d, const struct btf_type *t, __u32 type_id, @@ -1672,7 +1674,7 @@ static int btf_dump_int_data(struct btf_dump *d, /* handle packed int data - accesses of integers not aligned on * int boundaries can cause problems on some platforms. */ - if (((uintptr_t)data) % sz) + if (data_is_unaligned(data, sz)) return btf_dump_bitfield_data(d, t, data, 0, 0); switch (sz) { @@ -1739,7 +1741,7 @@ static int btf_dump_float_data(struct btf_dump *d, int sz = t->size; /* handle unaligned data; copy to local union */ - if (((uintptr_t)data) % sz) { + if (data_is_unaligned(data, sz)) { memcpy(&fl, data, sz); flp = &fl; } @@ -1897,7 +1899,10 @@ static int btf_dump_ptr_data(struct btf_dump *d, __u32 id, const void *data) { - btf_dump_type_values(d, "%p", *(void **)data); + void *ptrval; + + memcpy(&ptrval, data, d->ptr_sz); + btf_dump_type_values(d, "%p", ptrval); return 0; } @@ -1910,7 +1915,7 @@ static int btf_dump_get_enum_value(struct btf_dump *d, int sz = t->size; /* handle unaligned enum value */ - if (((uintptr_t)data) % sz) { + if (data_is_unaligned(data, sz)) { *value = (__s64)btf_dump_bitfield_get_data(d, t, data, 0, 0); return 0; } -- 1.8.3.1

3 years, 6 months

2
1
0 0

[PATCH v2 0/6] cgroup/cpuset: Add new cpuset partition type & empty effecitve cpus

by Waiman Long

v2: - Drop v1 patch 1. - Break out some cosmetic changes into a separate patch (patch #1). - Add a new patch to clarify the transition to invalid partition root is mainly caused by hotplug events. - Enhance the partition root state test including CPU online/offline behavior and fix issues found by the test. This patchset makes the following three major changes to the cpuset v2 code: Patch 2: Clarify the use of invalid partition root and add new checks to make sure that normal cpuset control file operations will not be allowed to create invalid partition root. It also fixes some of the issues in existing code. Patch 3: Add a new partition state "isolated" to create a partition root without load balancing. This is for handling intermitten workloads that have a strict low latency requirement. Patch 4: Allow partition roots that are not the top cpuset to distribute all its cpus to child partitions as long as there is no task associated with that partition root. This allows more flexibility for middleware to manage multiple partitions. Patch 5 updates the cgroup-v2.rst file accordingly. Patch 5 adds a new cpuset test to test the new cpuset partition code. Waiman Long (6): cgroup/cpuset: Miscellaneous code cleanup cgroup/cpuset: Clarify the use of invalid partition root cgroup/cpuset: Add a new isolated cpus.partition type cgroup/cpuset: Allow non-top parent partition root to distribute out all CPUs cgroup/cpuset: Update description of cpuset.cpus.partition in cgroup-v2.rst kselftest/cgroup: Add cpuset v2 partition root state test Documentation/admin-guide/cgroup-v2.rst | 65 +- kernel/cgroup/cpuset.c | 285 ++++++--- tools/testing/selftests/cgroup/Makefile | 2 +- .../selftests/cgroup/test_cpuset_prs.sh | 558 ++++++++++++++++++ 4 files changed, 794 insertions(+), 116 deletions(-) create mode 100755 tools/testing/selftests/cgroup/test_cpuset_prs.sh -- 2.18.1

3 years, 6 months

4
18
0 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror