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

[RESEDN PATCH v2] selftests: introduce additional eventfd test coverage

by Wen Yang

Add several new test cases which assert corner cases on the eventfd mechanism, for example, the supplied buffer is less than 8 bytes, attempting to write a value that is too large, etc. ./eventfd_test # Starting 9 tests from 1 test cases. # RUN global.eventfd_check_flag_rdwr ... # OK global.eventfd_check_flag_rdwr ok 1 global.eventfd_check_flag_rdwr # RUN global.eventfd_check_flag_cloexec ... # OK global.eventfd_check_flag_cloexec ok 2 global.eventfd_check_flag_cloexec # RUN global.eventfd_check_flag_nonblock ... # OK global.eventfd_check_flag_nonblock ok 3 global.eventfd_check_flag_nonblock # RUN global.eventfd_chek_flag_cloexec_and_nonblock ... # OK global.eventfd_chek_flag_cloexec_and_nonblock ok 4 global.eventfd_chek_flag_cloexec_and_nonblock # RUN global.eventfd_check_flag_semaphore ... # OK global.eventfd_check_flag_semaphore ok 5 global.eventfd_check_flag_semaphore # RUN global.eventfd_check_write ... # OK global.eventfd_check_write ok 6 global.eventfd_check_write # RUN global.eventfd_check_read ... # OK global.eventfd_check_read ok 7 global.eventfd_check_read # RUN global.eventfd_check_read_with_nonsemaphore ... # OK global.eventfd_check_read_with_nonsemaphore ok 8 global.eventfd_check_read_with_nonsemaphore # RUN global.eventfd_check_read_with_semaphore ... # OK global.eventfd_check_read_with_semaphore ok 9 global.eventfd_check_read_with_semaphore # PASSED: 9 / 9 tests passed. # Totals: pass:9 fail:0 xfail:0 xpass:0 skip:0 error:0 Signed-off-by: Wen Yang <wen.yang(a)linux.dev> Cc: SShuah Khan <shuah(a)kernel.org> Cc: Christian Brauner <brauner(a)kernel.org> Cc: Andrei Vagin <avagin(a)google.com> Cc: Mathieu Desnoyers <mathieu.desnoyers(a)efficios.com> Cc: Steven Rostedt <rostedt(a)goodmis.org> Cc: Andrew Morton <akpm(a)linux-foundation.org> Cc: Dave Young <dyoung(a)redhat.com> Cc: Tim Bird <tim.bird(a)sony.com> Cc: linux-kselftest(a)vger.kernel.org Cc: linux-kernel(a)vger.kernel.org --- v2: use strings which indicate what is being tested, that are useful to a human .../filesystems/eventfd/eventfd_test.c | 136 +++++++++++++++++- 1 file changed, 131 insertions(+), 5 deletions(-) diff --git a/tools/testing/selftests/filesystems/eventfd/eventfd_test.c b/tools/testing/selftests/filesystems/eventfd/eventfd_test.c index f142a137526c..85acb4e3ef00 100644 --- a/tools/testing/selftests/filesystems/eventfd/eventfd_test.c +++ b/tools/testing/selftests/filesystems/eventfd/eventfd_test.c @@ -13,6 +13,8 @@ #include <sys/eventfd.h> #include "../../kselftest_harness.h" +#define EVENTFD_TEST_ITERATIONS 100000UL + struct error { int code; char msg[512]; @@ -40,7 +42,7 @@ static inline int sys_eventfd2(unsigned int count, int flags) return syscall(__NR_eventfd2, count, flags); } -TEST(eventfd01) +TEST(eventfd_check_flag_rdwr) { int fd, flags; @@ -54,7 +56,7 @@ TEST(eventfd01) close(fd); } -TEST(eventfd02) +TEST(eventfd_check_flag_cloexec) { int fd, flags; @@ -68,7 +70,7 @@ TEST(eventfd02) close(fd); } -TEST(eventfd03) +TEST(eventfd_check_flag_nonblock) { int fd, flags; @@ -83,7 +85,7 @@ TEST(eventfd03) close(fd); } -TEST(eventfd04) +TEST(eventfd_chek_flag_cloexec_and_nonblock) { int fd, flags; @@ -161,7 +163,7 @@ static int verify_fdinfo(int fd, struct error *err, const char *prefix, return 0; } -TEST(eventfd05) +TEST(eventfd_check_flag_semaphore) { struct error err = {0}; int fd, ret; @@ -183,4 +185,128 @@ TEST(eventfd05) close(fd); } +/* + * A write(2) fails with the error EINVAL if the size of the supplied buffer + * is less than 8 bytes, or if an attempt is made to write the value + * 0xffffffffffffffff. + */ +TEST(eventfd_check_write) +{ + uint64_t value = 1; + ssize_t size; + int fd; + + fd = sys_eventfd2(0, 0); + ASSERT_GE(fd, 0); + + size = write(fd, &value, sizeof(int)); + EXPECT_EQ(size, -1); + EXPECT_EQ(errno, EINVAL); + + size = write(fd, &value, sizeof(value)); + EXPECT_EQ(size, sizeof(value)); + + value = (uint64_t)-1; + size = write(fd, &value, sizeof(value)); + EXPECT_EQ(size, -1); + EXPECT_EQ(errno, EINVAL); + + close(fd); +} + +/* + * A read(2) fails with the error EINVAL if the size of the supplied buffer is + * less than 8 bytes. + */ +TEST(eventfd_check_read) +{ + uint64_t value; + ssize_t size; + int fd; + + fd = sys_eventfd2(1, 0); + ASSERT_GE(fd, 0); + + size = read(fd, &value, sizeof(int)); + EXPECT_EQ(size, -1); + EXPECT_EQ(errno, EINVAL); + + size = read(fd, &value, sizeof(value)); + EXPECT_EQ(size, sizeof(value)); + EXPECT_EQ(value, 1); + + close(fd); +} + + +/* + * If EFD_SEMAPHORE was not specified and the eventfd counter has a nonzero + * value, then a read(2) returns 8 bytes containing that value, and the + * counter's value is reset to zero. + * If the eventfd counter is zero at the time of the call to read(2), then the + * call fails with the error EAGAIN if the file descriptor has been made nonblocking. + */ +TEST(eventfd_check_read_with_nonsemaphore) +{ + uint64_t value; + ssize_t size; + int fd; + int i; + + fd = sys_eventfd2(0, EFD_NONBLOCK); + ASSERT_GE(fd, 0); + + value = 1; + for (i = 0; i < EVENTFD_TEST_ITERATIONS; i++) { + size = write(fd, &value, sizeof(value)); + EXPECT_EQ(size, sizeof(value)); + } + + size = read(fd, &value, sizeof(value)); + EXPECT_EQ(size, sizeof(uint64_t)); + EXPECT_EQ(value, EVENTFD_TEST_ITERATIONS); + + size = read(fd, &value, sizeof(value)); + EXPECT_EQ(size, -1); + EXPECT_EQ(errno, EAGAIN); + + close(fd); +} + +/* + * If EFD_SEMAPHORE was specified and the eventfd counter has a nonzero value, + * then a read(2) returns 8 bytes containing the value 1, and the counter's + * value is decremented by 1. + * If the eventfd counter is zero at the time of the call to read(2), then the + * call fails with the error EAGAIN if the file descriptor has been made nonblocking. + */ +TEST(eventfd_check_read_with_semaphore) +{ + uint64_t value; + ssize_t size; + int fd; + int i; + + fd = sys_eventfd2(0, EFD_SEMAPHORE|EFD_NONBLOCK); + ASSERT_GE(fd, 0); + + value = 1; + for (i = 0; i < EVENTFD_TEST_ITERATIONS; i++) { + size = write(fd, &value, sizeof(value)); + EXPECT_EQ(size, sizeof(value)); + } + + for (i = 0; i < EVENTFD_TEST_ITERATIONS; i++) { + size = read(fd, &value, sizeof(value)); + EXPECT_EQ(size, sizeof(value)); + EXPECT_EQ(value, 1); + } + + size = read(fd, &value, sizeof(value)); + EXPECT_EQ(size, -1); + EXPECT_EQ(errno, EAGAIN); + + close(fd); +} + TEST_HARNESS_MAIN -- 2.25.1

1 year, 5 months

1
0
0 0

[PATCH] selftest: mm: Test if hugepage does not get leaked during __bio_release_pages()

by Donet Tom

Commit 1b151e2435fc ("block: Remove special-casing of compound pages") caused a change in behaviour when releasing the pages if the buffer does not start at the beginning of the page. This was because the calculation of the number of pages to release was incorrect. This was fixed by commit 38b43539d64b ("block: Fix page refcounts for unaligned buffers in __bio_release_pages()"). We pin the user buffer during direct I/O writes. If this buffer is a hugepage, bio_release_page() will unpin it and decrement all references and pin counts at ->bi_end_io. However, if any references to the hugepage remain post-I/O, the hugepage will not be freed upon unmap, leading to a memory leak. This patch verifies that a hugepage, used as a user buffer for DIO operations, is correctly freed upon unmapping, regardless of whether the offsets are aligned or unaligned w.r.t page boundary. Test Result Fail Scenario (Without the fix) -------------------------------------------------------- []# ./hugetlb_dio TAP version 13 1..4 No. Free pages before allocation : 7 No. Free pages after munmap : 7 ok 1 : Huge pages freed successfully ! No. Free pages before allocation : 7 No. Free pages after munmap : 7 ok 2 : Huge pages freed successfully ! No. Free pages before allocation : 7 No. Free pages after munmap : 7 ok 3 : Huge pages freed successfully ! No. Free pages before allocation : 7 No. Free pages after munmap : 6 not ok 4 : Huge pages not freed! Totals: pass:3 fail:1 xfail:0 xpass:0 skip:0 error:0 Test Result PASS Scenario (With the fix) --------------------------------------------------------- []#./hugetlb_dio TAP version 13 1..4 No. Free pages before allocation : 7 No. Free pages after munmap : 7 ok 1 : Huge pages freed successfully ! No. Free pages before allocation : 7 No. Free pages after munmap : 7 ok 2 : Huge pages freed successfully ! No. Free pages before allocation : 7 No. Free pages after munmap : 7 ok 3 : Huge pages freed successfully ! No. Free pages before allocation : 7 No. Free pages after munmap : 7 ok 4 : Huge pages freed successfully ! Totals: pass:4 fail:0 xfail:0 xpass:0 skip:0 error:0 Signed-off-by: Donet Tom <donettom(a)linux.ibm.com> Signed-off-by: Ritesh Harjani (IBM) <ritesh.list(a)gmail.com> --- tools/testing/selftests/mm/Makefile | 1 + tools/testing/selftests/mm/hugetlb_dio.c | 118 +++++++++++++++++++++++ 2 files changed, 119 insertions(+) create mode 100644 tools/testing/selftests/mm/hugetlb_dio.c diff --git a/tools/testing/selftests/mm/Makefile b/tools/testing/selftests/mm/Makefile index eb5f39a2668b..87d8130b3376 100644 --- a/tools/testing/selftests/mm/Makefile +++ b/tools/testing/selftests/mm/Makefile @@ -71,6 +71,7 @@ TEST_GEN_FILES += ksm_functional_tests TEST_GEN_FILES += mdwe_test TEST_GEN_FILES += hugetlb_fault_after_madv TEST_GEN_FILES += hugetlb_madv_vs_map +TEST_GEN_FILES += hugetlb_dio ifneq ($(ARCH),arm64) TEST_GEN_FILES += soft-dirty diff --git a/tools/testing/selftests/mm/hugetlb_dio.c b/tools/testing/selftests/mm/hugetlb_dio.c new file mode 100644 index 000000000000..6f6587c7913c --- /dev/null +++ b/tools/testing/selftests/mm/hugetlb_dio.c @@ -0,0 +1,118 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * This program tests for hugepage leaks after DIO writes to a file using a + * hugepage as the user buffer. During DIO, the user buffer is pinned and + * should be properly unpinned upon completion. This patch verifies that the + * kernel correctly unpins the buffer at DIO completion for both aligned and + * unaligned user buffer offsets (w.r.t page boundary), ensuring the hugepage + * is freed upon unmapping. + */ + +#define _GNU_SOURCE +#include <stdio.h> +#include <sys/stat.h> +#include <stdlib.h> +#include <fcntl.h> +#include <stdint.h> +#include <unistd.h> +#include <string.h> +#include <sys/mman.h> +#include "vm_util.h" +#include "../kselftest.h" + +void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off) +{ + int fd; + char *buffer = NULL; + char *orig_buffer = NULL; + size_t h_pagesize = 0; + size_t writesize; + int free_hpage_b = 0; + int free_hpage_a = 0; + + writesize = end_off - start_off; + + /* Get the default huge page size */ + h_pagesize = default_huge_page_size(); + if (!h_pagesize) + ksft_exit_fail_msg("Unable to determine huge page size\n"); + + /* Open the file to DIO */ + fd = open("/tmp", O_TMPFILE | O_RDWR | O_DIRECT); + if (fd < 0) + ksft_exit_fail_msg("Error opening file"); + + /* Get the free huge pages before allocation */ + free_hpage_b = get_free_hugepages(); + if (free_hpage_b == 0) { + close(fd); + ksft_exit_skip("No free hugepage, exiting!\n"); + } + + /* Allocate a hugetlb page */ + orig_buffer = mmap(NULL, h_pagesize, PROT_READ | PROT_WRITE, MAP_PRIVATE + | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0); + if (orig_buffer == MAP_FAILED) { + close(fd); + ksft_exit_fail_msg("Error mapping memory"); + } + buffer = orig_buffer; + buffer += start_off; + + memset(buffer, 'A', writesize); + + /* Write the buffer to the file */ + if (write(fd, buffer, writesize) != (writesize)) { + munmap(orig_buffer, h_pagesize); + close(fd); + ksft_exit_fail_msg("Error writing to file"); + } + + /* unmap the huge page */ + munmap(orig_buffer, h_pagesize); + close(fd); + + /* Get the free huge pages after unmap*/ + free_hpage_a = get_free_hugepages(); + + /* + * If the no. of free hugepages before allocation and after unmap does + * not match - that means there could still be a page which is pinned. + */ + if (free_hpage_a != free_hpage_b) { + printf("No. Free pages before allocation : %d\n", free_hpage_b); + printf("No. Free pages after munmap : %d\n", free_hpage_a); + ksft_test_result_fail(": Huge pages not freed!\n"); + } else { + printf("No. Free pages before allocation : %d\n", free_hpage_b); + printf("No. Free pages after munmap : %d\n", free_hpage_a); + ksft_test_result_pass(": Huge pages freed successfully !\n"); + } +} + +int main(void) +{ + size_t pagesize = 0; + + ksft_print_header(); + ksft_set_plan(4); + + /* Get base page size */ + pagesize = psize(); + + /* start and end is aligned to pagesize */ + run_dio_using_hugetlb(0, (pagesize * 3)); + + /* start is aligned but end is not aligned */ + run_dio_using_hugetlb(0, (pagesize * 3) - (pagesize / 2)); + + /* start is unaligned and end is aligned */ + run_dio_using_hugetlb(pagesize / 2, (pagesize * 3)); + + /* both start and end are unaligned */ + run_dio_using_hugetlb(pagesize / 2, (pagesize * 3) + (pagesize / 2)); + + ksft_finished(); + return 0; +} + -- 2.39.3

1 year, 5 months

5
12
0 0

[PATCH] selftests/mm: Fix build warnings on ppc64

by Michael Ellerman

Fix warnings like: In file included from uffd-unit-tests.c:8: uffd-unit-tests.c: In function ‘uffd_poison_handle_fault’: uffd-common.h:45:33: warning: format ‘%llu’ expects argument of type ‘long long unsigned int’, but argument 3 has type ‘__u64’ {aka ‘long unsigned int’} [-Wformat=] By switching to unsigned long long for u64 for ppc64 builds. Signed-off-by: Michael Ellerman <mpe(a)ellerman.id.au> --- tools/testing/selftests/mm/gup_test.c | 1 + tools/testing/selftests/mm/uffd-common.h | 1 + 2 files changed, 2 insertions(+) diff --git a/tools/testing/selftests/mm/gup_test.c b/tools/testing/selftests/mm/gup_test.c index bd335cf9bc0e..bdeaac67ff9a 100644 --- a/tools/testing/selftests/mm/gup_test.c +++ b/tools/testing/selftests/mm/gup_test.c @@ -1,3 +1,4 @@ +#define __SANE_USERSPACE_TYPES__ // Use ll64 #include <fcntl.h> #include <errno.h> #include <stdio.h> diff --git a/tools/testing/selftests/mm/uffd-common.h b/tools/testing/selftests/mm/uffd-common.h index cc5629c3d2aa..a70ae10b5f62 100644 --- a/tools/testing/selftests/mm/uffd-common.h +++ b/tools/testing/selftests/mm/uffd-common.h @@ -8,6 +8,7 @@ #define __UFFD_COMMON_H__ #define _GNU_SOURCE +#define __SANE_USERSPACE_TYPES__ // Use ll64 #include <stdio.h> #include <errno.h> #include <unistd.h> -- 2.45.1

1 year, 5 months

2
1
0 0

[PATCH 0/2] selftests/ftrace: Fix config related issues

by Masami Hiramatsu (Google)

Here is a couple of patches to fix some issues related to kconfig. I found these issues when I built the kernel with tools/testing/selftests/ftrace/config. Thank you, --- Masami Hiramatsu (Google) (2): selftests/ftrace: Fix to check required event file selftests/ftrace: Update required config tools/testing/selftests/ftrace/config | 26 +++++++++++++++----- .../ftrace/test.d/dynevent/test_duplicates.tc | 2 +- 2 files changed, 20 insertions(+), 8 deletions(-) -- Masami Hiramatsu (Google) <mhiramat(a)kernel.org>

1 year, 5 months

2
4
0 0

[PATCH bpf-next v4 0/6] use network helpers, part 5

by Geliang Tang

From: Geliang Tang <tanggeliang(a)kylinos.cn> This patchset uses post_socket_cb and post_connect_cb callbacks of struct network_helper_opts to refactor do_test() in bpf_tcp_ca.c to move dctcp test dedicated code out of do_test() into test_dctcp(). v4: - address Martin's comments in v3 (thanks). - drop 2 patches, keep "type" as the individual arg to start_server_addr, connect_to_addr and start_server_str. v3: - Add 4 new patches, 1-3 are cleanups. 4 adds a new helper. - address Martin's comments in v2. v2: - rebased on commit "selftests/bpf: Add test for the use of new args in cong_control" Geliang Tang (6): selftests/bpf: Drop struct post_socket_opts selftests/bpf: Add start_server_str helper selftests/bpf: Use post_socket_cb in connect_to_fd_opts selftests/bpf: Use start_server_str in bpf_tcp_ca selftests/bpf: Use connect_to_fd_opts in do_test in bpf_tcp_ca selftests/bpf: Add post_connect_cb callback tools/testing/selftests/bpf/network_helpers.c | 39 +++-- tools/testing/selftests/bpf/network_helpers.h | 9 +- .../selftests/bpf/prog_tests/bpf_tcp_ca.c | 138 +++++++++++++----- .../bpf/prog_tests/sockopt_inherit.c | 2 +- .../bpf/test_tcp_check_syncookie_user.c | 4 +- 5 files changed, 133 insertions(+), 59 deletions(-) -- 2.43.0

1 year, 5 months

2
9
0 0

[PATCH v3 00/29] riscv control-flow integrity for usermode

by Deepak Gupta

Sending out v3 for cpu assisted riscv user mode control flow integrity. v2 [9] was sent a week ago for this riscv usermode control flow integrity enabling. RFC patchset was (v1) early this year (January) [7]. changes in v3 -------------- envcfg: logic to pick up base envcfg had a bug where `ENVCFG_CBZE` could have been picked on per task basis, even though CPU didn't implement it. Fixed in this series. dt-bindings: As suggested, split into separate commit. fixed the messaging that spec is in public review arch_is_shadow_stack change: arch_is_shadow_stack changed to vma_is_shadow_stack hwprobe: zicfiss / zicfilp if present will get enumerated in hwprobe selftests: As suggested, added object and binary filenames to .gitignore Selftest binary anyways need to be compiled with cfi enabled compiler which will make sure that landing pad and shadow stack are enabled. Thus removed separate enable/disable tests. Cleaned up tests a bit. changes in v2 --------------- As part of testing effort, compiled a rootfs with shadow stack and landing pad enabled (libraries and binaries) and booted to shell. As part of long running tests, I have been able to run some spec 2006 benchmarks [8] (here link is provided only for list of benchmarks that were tested for long running tests, excel sheet provided here actually is for some static stats like code size growth on spec binaries). Thus converting from RFC to regular patchset. Securing control-flow integrity for usermode requires following - Securing forward control flow : All callsites must reach reach a target that they actually intend to reach. - Securing backward control flow : All function returns must return to location where they were called from. This patch series use riscv cpu extension `zicfilp` [2] to secure forward control flow and `zicfiss` [2] to secure backward control flow. `zicfilp` enforces that all indirect calls or jmps must land on a landing pad instr and label embedded in landing pad instr must match a value programmed in `x7` register (at callsite via compiler). `zicfiss` introduces shadow stack which can only be writeable via shadow stack instructions (sspush and ssamoswap) and thus can't be tampered with via inadvertent stores. More details about extension can be read from [2] and there are details in documentation as well (in this patch series). Using config `CONFIG_RISCV_USER_CFI`, kernel support for riscv control flow integrity for user mode programs can be compiled in the kernel. Enabling of control flow integrity for user programs is left to user runtime (specifically expected from dynamic loader). There has been a lot of earlier discussion on the enabling topic around x86 shadow stack enabling [3, 4, 5] and overall consensus had been to let dynamic loader (or usermode) to decide for enabling the feature. This patch series introduces arch agnostic `prctls` to enable shadow stack and indirect branch tracking. And implements them on riscv. arm64 is expected to implement shadow stack part of these arch agnostic `prctls` [6] Changes since last time *********************** Spec changes ------------ - Forward cfi spec has become much simpler. `lpad` instruction is pseudo for `auipc rd, <20bit_imm>`. `lpad` checks x7 against 20bit embedded in instr. Thus label width is 20bit. - Shadow stack management instructions are reduced to sspush - to push x1/x5 on shadow stack sspopchk - pops from shadow stack and comapres with x1/x5. ssamoswap - atomically swap value on shadow stack. rdssp - reads current shadow stack pointer - Shadow stack accesses on readonly memory always raise AMO/store page fault. `sspopchk` is load but if underlying page is readonly, it'll raise a store page fault. It simplifies hardware and kernel for COW handling for shadow stack pages. - riscv defines a new exception type `software check exception` and control flow violations raise software check exception. - enabling controls for shadow stack and landing are in xenvcfg CSR and controls lower privilege mode enabling. As an example senvcfg controls enabling for U and menvcfg controls enabling for S mode. core mm shadow stack enabling ----------------------------- Shadow stack for x86 usermode are now in mainline and thus this patch series builds on top of that for arch-agnostic mm related changes. Big thanks and shout out to Rick Edgecombe for that. selftests --------- Created some minimal selftests to test the patch series. [1] - https://lore.kernel.org/lkml/20230213045351.3945824-1-debug@rivosinc.com/ [2] - https://github.com/riscv/riscv-cfi [3] - https://lore.kernel.org/lkml/ZWHcBq0bJ+15eeKs@finisterre.sirena.org.uk/T/#m… [4] - https://lore.kernel.org/all/20220130211838.8382-1-rick.p.edgecombe@intel.co… [5] - https://lore.kernel.org/lkml/CAHk-=wgP5mk3poVeejw16Asbid0ghDt4okHnWaWKLBkRh… [6] - https://lore.kernel.org/linux-mm/20231122-arm64-gcs-v7-2-201c483bd775@kerne… [7] - https://lore.kernel.org/lkml/20240125062739.1339782-1-debug@rivosinc.com/ [8] - https://docs.google.com/spreadsheets/d/1_cHGH4ctNVvFRiS7hW9dEGKtXLAJ3aX4Z_i… [9] - https://lore.kernel.org/lkml/20240329044459.3990638-1-debug@rivosinc.com/

1 year, 5 months

9
81
0 0

[PATCH v10 0/5] Introduce mseal

by jeffxu＠chromium.org

From: Jeff Xu <jeffxu(a)chromium.org> This is V10 version, it rebases v9 patch to 6.9.rc3. We also applied and tested mseal() in chrome and chromebook. ------------------------------------------------------------------ This patchset proposes a new mseal() syscall for the Linux kernel. In a nutshell, mseal() protects the VMAs of a given virtual memory range against modifications, such as changes to their permission bits. Modern CPUs support memory permissions, such as the read/write (RW) and no-execute (NX) bits. Linux has supported NX since the release of kernel version 2.6.8 in August 2004 [1]. The memory permission feature improves the security stance on memory corruption bugs, as an attacker cannot simply write to arbitrary memory and point the code to it. The memory must be marked with the X bit, or else an exception will occur. Internally, the kernel maintains the memory permissions in a data structure called VMA (vm_area_struct). mseal() additionally protects the VMA itself against modifications of the selected seal type. Memory sealing is useful to mitigate memory corruption issues where a corrupted pointer is passed to a memory management system. For example, such an attacker primitive can break control-flow integrity guarantees since read-only memory that is supposed to be trusted can become writable or .text pages can get remapped. Memory sealing can automatically be applied by the runtime loader to seal .text and .rodata pages and applications can additionally seal security critical data at runtime. A similar feature already exists in the XNU kernel with the VM_FLAGS_PERMANENT [3] flag and on OpenBSD with the mimmutable syscall [4]. Also, Chrome wants to adopt this feature for their CFI work [2] and this patchset has been designed to be compatible with the Chrome use case. Two system calls are involved in sealing the map: mmap() and mseal(). The new mseal() is an syscall on 64 bit CPU, and with following signature: int mseal(void addr, size_t len, unsigned long flags) addr/len: memory range. flags: reserved. mseal() blocks following operations for the given memory range. 1> Unmapping, moving to another location, and shrinking the size, via munmap() and mremap(), can leave an empty space, therefore can be replaced with a VMA with a new set of attributes. 2> Moving or expanding a different VMA into the current location, via mremap(). 3> Modifying a VMA via mmap(MAP_FIXED). 4> Size expansion, via mremap(), does not appear to pose any specific risks to sealed VMAs. It is included anyway because the use case is unclear. In any case, users can rely on merging to expand a sealed VMA. 5> mprotect() and pkey_mprotect(). 6> Some destructive madvice() behaviors (e.g. MADV_DONTNEED) for anonymous memory, when users don't have write permission to the memory. Those behaviors can alter region contents by discarding pages, effectively a memset(0) for anonymous memory. The idea that inspired this patch comes from Stephen Röttger’s work in V8 CFI [5]. Chrome browser in ChromeOS will be the first user of this API. Indeed, the Chrome browser has very specific requirements for sealing, which are distinct from those of most applications. For example, in the case of libc, sealing is only applied to read-only (RO) or read-execute (RX) memory segments (such as .text and .RELRO) to prevent them from becoming writable, the lifetime of those mappings are tied to the lifetime of the process. Chrome wants to seal two large address space reservations that are managed by different allocators. The memory is mapped RW- and RWX respectively but write access to it is restricted using pkeys (or in the future ARM permission overlay extensions). The lifetime of those mappings are not tied to the lifetime of the process, therefore, while the memory is sealed, the allocators still need to free or discard the unused memory. For example, with madvise(DONTNEED). However, always allowing madvise(DONTNEED) on this range poses a security risk. For example if a jump instruction crosses a page boundary and the second page gets discarded, it will overwrite the target bytes with zeros and change the control flow. Checking write-permission before the discard operation allows us to control when the operation is valid. In this case, the madvise will only succeed if the executing thread has PKEY write permissions and PKRU changes are protected in software by control-flow integrity. Although the initial version of this patch series is targeting the Chrome browser as its first user, it became evident during upstream discussions that we would also want to ensure that the patch set eventually is a complete solution for memory sealing and compatible with other use cases. The specific scenario currently in mind is glibc's use case of loading and sealing ELF executables. To this end, Stephen is working on a change to glibc to add sealing support to the dynamic linker, which will seal all non-writable segments at startup. Once this work is completed, all applications will be able to automatically benefit from these new protections. In closing, I would like to formally acknowledge the valuable contributions received during the RFC process, which were instrumental in shaping this patch: Jann Horn: raising awareness and providing valuable insights on the destructive madvise operations. Liam R. Howlett: perf optimization. Linus Torvalds: assisting in defining system call signature and scope. Theo de Raadt: sharing the experiences and insight gained from implementing mimmutable() in OpenBSD. MM perf benchmarks ================== This patch adds a loop in the mprotect/munmap/madvise(DONTNEED) to check the VMAs’ sealing flag, so that no partial update can be made, when any segment within the given memory range is sealed. To measure the performance impact of this loop, two tests are developed. [8] The first is measuring the time taken for a particular system call, by using clock_gettime(CLOCK_MONOTONIC). The second is using PERF_COUNT_HW_REF_CPU_CYCLES (exclude user space). Both tests have similar results. The tests have roughly below sequence: for (i = 0; i < 1000, i++) create 1000 mappings (1 page per VMA) start the sampling for (j = 0; j < 1000, j++) mprotect one mapping stop and save the sample delete 1000 mappings calculates all samples. Below tests are performed on Intel(R) Pentium(R) Gold 7505 @ 2.00GHz, 4G memory, Chromebook. Based on the latest upstream code: The first test (measuring time) syscall__ vmas t t_mseal delta_ns per_vma % munmap__ 1 909 944 35 35 104% munmap__ 2 1398 1502 104 52 107% munmap__ 4 2444 2594 149 37 106% munmap__ 8 4029 4323 293 37 107% munmap__ 16 6647 6935 288 18 104% munmap__ 32 11811 12398 587 18 105% mprotect 1 439 465 26 26 106% mprotect 2 1659 1745 86 43 105% mprotect 4 3747 3889 142 36 104% mprotect 8 6755 6969 215 27 103% mprotect 16 13748 14144 396 25 103% mprotect 32 27827 28969 1142 36 104% madvise_ 1 240 262 22 22 109% madvise_ 2 366 442 76 38 121% madvise_ 4 623 751 128 32 121% madvise_ 8 1110 1324 215 27 119% madvise_ 16 2127 2451 324 20 115% madvise_ 32 4109 4642 534 17 113% The second test (measuring cpu cycle) syscall__ vmas cpu cmseal delta_cpu per_vma % munmap__ 1 1790 1890 100 100 106% munmap__ 2 2819 3033 214 107 108% munmap__ 4 4959 5271 312 78 106% munmap__ 8 8262 8745 483 60 106% munmap__ 16 13099 14116 1017 64 108% munmap__ 32 23221 24785 1565 49 107% mprotect 1 906 967 62 62 107% mprotect 2 3019 3203 184 92 106% mprotect 4 6149 6569 420 105 107% mprotect 8 9978 10524 545 68 105% mprotect 16 20448 21427 979 61 105% mprotect 32 40972 42935 1963 61 105% madvise_ 1 434 497 63 63 115% madvise_ 2 752 899 147 74 120% madvise_ 4 1313 1513 200 50 115% madvise_ 8 2271 2627 356 44 116% madvise_ 16 4312 4883 571 36 113% madvise_ 32 8376 9319 943 29 111% Based on the result, for 6.8 kernel, sealing check adds 20-40 nano seconds, or around 50-100 CPU cycles, per VMA. In addition, I applied the sealing to 5.10 kernel: The first test (measuring time) syscall__ vmas t tmseal delta_ns per_vma % munmap__ 1 357 390 33 33 109% munmap__ 2 442 463 21 11 105% munmap__ 4 614 634 20 5 103% munmap__ 8 1017 1137 120 15 112% munmap__ 16 1889 2153 263 16 114% munmap__ 32 4109 4088 -21 -1 99% mprotect 1 235 227 -7 -7 97% mprotect 2 495 464 -30 -15 94% mprotect 4 741 764 24 6 103% mprotect 8 1434 1437 2 0 100% mprotect 16 2958 2991 33 2 101% mprotect 32 6431 6608 177 6 103% madvise_ 1 191 208 16 16 109% madvise_ 2 300 324 24 12 108% madvise_ 4 450 473 23 6 105% madvise_ 8 753 806 53 7 107% madvise_ 16 1467 1592 125 8 108% madvise_ 32 2795 3405 610 19 122% The second test (measuring cpu cycle) syscall__ nbr_vma cpu cmseal delta_cpu per_vma % munmap__ 1 684 715 31 31 105% munmap__ 2 861 898 38 19 104% munmap__ 4 1183 1235 51 13 104% munmap__ 8 1999 2045 46 6 102% munmap__ 16 3839 3816 -23 -1 99% munmap__ 32 7672 7887 216 7 103% mprotect 1 397 443 46 46 112% mprotect 2 738 788 50 25 107% mprotect 4 1221 1256 35 9 103% mprotect 8 2356 2429 72 9 103% mprotect 16 4961 4935 -26 -2 99% mprotect 32 9882 10172 291 9 103% madvise_ 1 351 380 29 29 108% madvise_ 2 565 615 49 25 109% madvise_ 4 872 933 61 15 107% madvise_ 8 1508 1640 132 16 109% madvise_ 16 3078 3323 245 15 108% madvise_ 32 5893 6704 811 25 114% For 5.10 kernel, sealing check adds 0-15 ns in time, or 10-30 CPU cycles, there is even decrease in some cases. It might be interesting to compare 5.10 and 6.8 kernel The first test (measuring time) syscall__ vmas t_5_10 t_6_8 delta_ns per_vma % munmap__ 1 357 909 552 552 254% munmap__ 2 442 1398 956 478 316% munmap__ 4 614 2444 1830 458 398% munmap__ 8 1017 4029 3012 377 396% munmap__ 16 1889 6647 4758 297 352% munmap__ 32 4109 11811 7702 241 287% mprotect 1 235 439 204 204 187% mprotect 2 495 1659 1164 582 335% mprotect 4 741 3747 3006 752 506% mprotect 8 1434 6755 5320 665 471% mprotect 16 2958 13748 10790 674 465% mprotect 32 6431 27827 21397 669 433% madvise_ 1 191 240 49 49 125% madvise_ 2 300 366 67 33 122% madvise_ 4 450 623 173 43 138% madvise_ 8 753 1110 357 45 147% madvise_ 16 1467 2127 660 41 145% madvise_ 32 2795 4109 1314 41 147% The second test (measuring cpu cycle) syscall__ vmas cpu_5_10 c_6_8 delta_cpu per_vma % munmap__ 1 684 1790 1106 1106 262% munmap__ 2 861 2819 1958 979 327% munmap__ 4 1183 4959 3776 944 419% munmap__ 8 1999 8262 6263 783 413% munmap__ 16 3839 13099 9260 579 341% munmap__ 32 7672 23221 15549 486 303% mprotect 1 397 906 509 509 228% mprotect 2 738 3019 2281 1140 409% mprotect 4 1221 6149 4929 1232 504% mprotect 8 2356 9978 7622 953 423% mprotect 16 4961 20448 15487 968 412% mprotect 32 9882 40972 31091 972 415% madvise_ 1 351 434 82 82 123% madvise_ 2 565 752 186 93 133% madvise_ 4 872 1313 442 110 151% madvise_ 8 1508 2271 763 95 151% madvise_ 16 3078 4312 1234 77 140% madvise_ 32 5893 8376 2483 78 142% From 5.10 to 6.8 munmap: added 250-550 ns in time, or 500-1100 in cpu cycle, per vma. mprotect: added 200-750 ns in time, or 500-1200 in cpu cycle, per vma. madvise: added 33-50 ns in time, or 70-110 in cpu cycle, per vma. In comparison to mseal, which adds 20-40 ns or 50-100 CPU cycles, the increase from 5.10 to 6.8 is significantly larger, approximately ten times greater for munmap and mprotect. When I discuss the mm performance with Brian Makin, an engineer worked on performance, it was brought to my attention that such a performance benchmarks, which measuring millions of mm syscall in a tight loop, may not accurately reflect real-world scenarios, such as that of a database service. Also this is tested using a single HW and ChromeOS, the data from another HW or distribution might be different. It might be best to take this data with a grain of salt. Change history: =============== V10: - rebase to 6.9.rc3 (no code change, resolve conflict only) - Stephen Röttger applied mseal() in Chrome code, and I tested it on chromebook, the mseal() is working as designed. V9: - remove mmap(PROT_SEAL) and mmap(MAP_SEALABLE) (Linus, Theo de Raadt) - Update mseal_test to check for prot bit (Liam R. Howlett) - Update documentation to give more detail on sealing check (Liam R. Howlett) - Add seal_elf test. - Add performance measure data. - mseal_test: fix arm build. https://lore.kernel.org/all/20240214151130.616240-1-jeffxu@chromium.org/ V8: - perf optimization in mmap. (Liam R. Howlett) - add one testcase (test_seal_zero_address) - Update mseal.rst to add note for MAP_SEALABLE. https://lore.kernel.org/lkml/20240131175027.3287009-1-jeffxu@chromium.org/ V7: - fix index.rst (Randy Dunlap) - fix arm build (Randy Dunlap) - return EPERM for blocked operations (Theo de Raadt) https://lore.kernel.org/linux-mm/20240122152905.2220849-2-jeffxu@chromium.o… V6: - Drop RFC from subject, Given Linus's general approval. - Adjust syscall number for mseal (main Jan.11/2024) - Code style fix (Matthew Wilcox) - selftest: use ksft macros (Muhammad Usama Anjum) - Document fix. (Randy Dunlap) https://lore.kernel.org/all/20240111234142.2944934-1-jeffxu@chromium.org/ V5: - fix build issue in mseal-Wire-up-mseal-syscall (Suggested by Linus Torvalds, and Greg KH) - updates on selftest. https://lore.kernel.org/lkml/20240109154547.1839886-1-jeffxu@chromium.org/#r V4: (Suggested by Linus Torvalds) - new signature: mseal(start,len,flags) - 32 bit is not supported. vm_seal is removed, use vm_flags instead. - single bit in vm_flags for sealed state. - CONFIG_MSEAL kernel config is removed. - single bit of PROT_SEAL in the "Prot" field of mmap(). Other changes: - update selftest (Suggested by Muhammad Usama Anjum) - update documentation. https://lore.kernel.org/all/20240104185138.169307-1-jeffxu@chromium.org/ V3: - Abandon per-syscall approach, (Suggested by Linus Torvalds). - Organize sealing types around their functionality, such as MM_SEAL_BASE, MM_SEAL_PROT_PKEY. - Extend the scope of sealing from calls originated in userspace to both kernel and userspace. (Suggested by Linus Torvalds) - Add seal type support in mmap(). (Suggested by Pedro Falcato) - Add a new sealing type: MM_SEAL_DISCARD_RO_ANON to prevent destructive operations of madvise. (Suggested by Jann Horn and Stephen Röttger) - Make sealed VMAs mergeable. (Suggested by Jann Horn) - Add MAP_SEALABLE to mmap() - Add documentation - mseal.rst https://lore.kernel.org/linux-mm/20231212231706.2680890-2-jeffxu@chromium.o… v2: Use _BITUL to define MM_SEAL_XX type. Use unsigned long for seal type in sys_mseal() and other functions. Remove internal VM_SEAL_XX type and convert_user_seal_type(). Remove MM_ACTION_XX type. Remove caller_origin(ON_BEHALF_OF_XX) and replace with sealing bitmask. Add more comments in code. Add a detailed commit message. https://lore.kernel.org/lkml/20231017090815.1067790-1-jeffxu@chromium.org/ v1: https://lore.kernel.org/lkml/20231016143828.647848-1-jeffxu@chromium.org/ ---------------------------------------------------------------- [1] https://kernelnewbies.org/Linux_2_6_8 [2] https://v8.dev/blog/control-flow-integrity [3] https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b… [4] https://man.openbsd.org/mimmutable.2 [5] https://docs.google.com/document/d/1O2jwK4dxI3nRcOJuPYkonhTkNQfbmwdvxQMyXge… [6] https://lore.kernel.org/lkml/CAG48ez3ShUYey+ZAFsU2i1RpQn0a5eOs2hzQ426Fkcgnf… [7] https://lore.kernel.org/lkml/20230515130553.2311248-1-jeffxu@chromium.org/ [8] https://github.com/peaktocreek/mmperf Jeff Xu (5): mseal: Wire up mseal syscall mseal: add mseal syscall selftest mm/mseal memory sealing mseal:add documentation selftest mm/mseal read-only elf memory segment Documentation/userspace-api/index.rst | 1 + Documentation/userspace-api/mseal.rst | 199 ++ arch/alpha/kernel/syscalls/syscall.tbl | 1 + arch/arm/tools/syscall.tbl | 1 + arch/arm64/include/asm/unistd.h | 2 +- arch/arm64/include/asm/unistd32.h | 2 + arch/m68k/kernel/syscalls/syscall.tbl | 1 + arch/microblaze/kernel/syscalls/syscall.tbl | 1 + arch/mips/kernel/syscalls/syscall_n32.tbl | 1 + arch/mips/kernel/syscalls/syscall_n64.tbl | 1 + arch/mips/kernel/syscalls/syscall_o32.tbl | 1 + arch/parisc/kernel/syscalls/syscall.tbl | 1 + arch/powerpc/kernel/syscalls/syscall.tbl | 1 + arch/s390/kernel/syscalls/syscall.tbl | 1 + arch/sh/kernel/syscalls/syscall.tbl | 1 + arch/sparc/kernel/syscalls/syscall.tbl | 1 + arch/x86/entry/syscalls/syscall_32.tbl | 1 + arch/x86/entry/syscalls/syscall_64.tbl | 1 + arch/xtensa/kernel/syscalls/syscall.tbl | 1 + include/linux/syscalls.h | 1 + include/uapi/asm-generic/unistd.h | 5 +- kernel/sys_ni.c | 1 + mm/Makefile | 4 + mm/internal.h | 37 + mm/madvise.c | 12 + mm/mmap.c | 31 +- mm/mprotect.c | 10 + mm/mremap.c | 31 + mm/mseal.c | 307 ++++ tools/testing/selftests/mm/.gitignore | 2 + tools/testing/selftests/mm/Makefile | 2 + tools/testing/selftests/mm/mseal_test.c | 1836 +++++++++++++++++++ tools/testing/selftests/mm/seal_elf.c | 183 ++ 33 files changed, 2678 insertions(+), 3 deletions(-) create mode 100644 Documentation/userspace-api/mseal.rst create mode 100644 mm/mseal.c create mode 100644 tools/testing/selftests/mm/mseal_test.c create mode 100644 tools/testing/selftests/mm/seal_elf.c -- 2.44.0.683.g7961c838ac-goog

1 year, 5 months

15
54
0 0

selftests: clone3: clone3_cap_checkpoint_restore fails - Could not set CAP_CHECKPOINT_RESTORE

by Naresh Kamboju

selftests clone3 cap_checkpoint_restore fails on all devices. Reported-by: Linux Kernel Functional Testing <lkft(a)linaro.org> [ 97.198602] audit: type=1701 audit(1651167820.383:12): auid=4294967295 uid=0 gid=0 ses=4294967295 pid=1732 comm=\"clone3_cap_chec\" exe=\"/opt/kselftests/default-in-kernel/clone3/clone3_cap_checkpoint_restore\" sig=6 res=1 # selftests: clone3: clone3_cap_checkpoint_restore # TAP version 13 # 1..1 # # Starting 1 tests from 1 test cases. # # RUN global.clone3_cap_checkpoint_restore ... # # clone3_cap_checkpoint_restore.c:155:clone3_cap_checkpoint_restore:Child has PID 1733 # # clone3() syscall supported # cap_set_proc: Operation not permitted # # clone3_cap_checkpoint_restore.c:164:clone3_cap_checkpoint_restore:Expected set_capability() (-1) == 0 (0) # # clone3_cap_checkpoint_restore.c:165:clone3_cap_checkpoint_restore:Could not set CAP_CHECKPOINT_RESTORE # # clone3_cap_checkpoint_restore: Test terminated by assertion # # FAIL global.clone3_cap_checkpoint_restore # not ok 1 global.clone3_cap_checkpoint_restore # # FAILED: 0 / 1 tests passed. # # Totals: pass:0 fail:1 xfail:0 xpass:0 skip:0 error:0 not ok 4 selftests: clone3: clone3_cap_checkpoint_restore # exit=1 Test details links, https://lkft.validation.linaro.org/scheduler/job/5812724#L2074 Test results comparison link, https://qa-reports.linaro.org/lkft/linux-next-master/build/next-20221107/te… https://qa-reports.linaro.org/lkft/linux-next-master/build/next-20221107/te… https://qa-reports.linaro.org/lkft/linux-next-master/build/next-20221107/te… metadata: git_ref: master git_repo: https://gitlab.com/Linaro/lkft/mirrors/next/linux-next git_sha: d8e87774068af213ab5b058b1b114dc397b577aa git_describe: next-20221107 kernel_version: 6.1.0-rc3 kernel-config: https://builds.tuxbuild.com/2HChVOSNxUpvfAfLTnaK7zyTdUi/config build-url: https://gitlab.com/Linaro/lkft/mirrors/next/linux-next/-/pipelines/687092361 artifact-location: https://builds.tuxbuild.com/2HChVOSNxUpvfAfLTnaK7zyTdUi toolchain: gcc-11 -- Linaro LKFT https://lkft.linaro.org

1 year, 5 months

3
3
0 0

[linus:master] [kunit] 3a35c13007: kunit.VCAP_API_DebugFS_Testsuite.vcap_api_show_admin_raw_test.fail

by kernel test robot

Hello, this was reported in https://lore.kernel.org/all/202404151340.5b152d96-lkp@intel.com/ since we still observed same failure after the commit is merged in mainline, we just report again FYI. kernel test robot noticed "kunit.VCAP_API_DebugFS_Testsuite.vcap_api_show_admin_raw_test.fail" on: commit: 3a35c13007dea132a65f07de05c26b87837fadc2 ("kunit: Handle test faults") https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git master [test failed in linus/master 6e51b4b5bbc07e52b226017936874715629932d1] [test failed on linux-next/master 632483ea8004edfadd035de36e1ab2c7c4f53158] in testcase: kunit version: with following parameters: group: group-03 compiler: gcc-13 test machine: 4 threads 1 sockets Intel(R) Core(TM) i3-3220 CPU @ 3.30GHz (Ivy Bridge) with 8G memory (please refer to attached dmesg/kmsg for entire log/backtrace) If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags | Reported-by: kernel test robot <oliver.sang(a)intel.com> | Closes: https://lore.kernel.org/oe-lkp/202405241710.148db8b0-oliver.sang@intel.com [ 116.216583] # vcap_api_show_admin_raw_test: EXPECTATION FAILED at drivers/net/ethernet/microchip/vcap/vcap_api_debugfs_kunit.c:377 Expected test_expected == test_pr_buffer[0], but test_expected == " addr: 786, X6 rule, keysets: VCAP_KFS_MAC_ETYPE " test_pr_buffer[0] == "" [ 116.222467] not ok 2 vcap_api_show_admin_raw_test The kernel config and materials to reproduce are available at: https://download.01.org/0day-ci/archive/20240524/202405241710.148db8b0-oliv… -- 0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki

1 year, 5 months

1
0
0 0

[PATCH v5 00/68] Define _GNU_SOURCE for sources using

by Edward Liaw

Centralizes the definition of _GNU_SOURCE into KHDR_INCLUDES and removes redefinitions of _GNU_SOURCE from source code. 809216233555 ("selftests/harness: remove use of LINE_MAX") introduced asprintf into kselftest_harness.h, which is a GNU extension and needs _GNU_SOURCE to either be defined prior to including headers or with the -D_GNU_SOURCE flag passed to the compiler. v1: https://lore.kernel.org/linux-kselftest/20240430235057.1351993-1-edliaw@goo… v2: https://lore.kernel.org/linux-kselftest/20240507214254.2787305-1-edliaw@goo… - Add -D_GNU_SOURCE to KHDR_INCLUDES so that it is in a single location. - Remove #define _GNU_SOURCE from source code to resolve redefinition warnings. v3: https://lore.kernel.org/linux-kselftest/20240509200022.253089-1-edliaw@goog… - Rebase onto linux-next 20240508. - Split patches by directory. - Add -D_GNU_SOURCE directly to CFLAGS in lib.mk. - Delete additional _GNU_SOURCE definitions from source code in linux-next. - Delete additional -D_GNU_SOURCE flags from Makefiles. v4: https://lore.kernel.org/linux-kselftest/20240510000842.410729-1-edliaw@goog… - Rebase onto linux-next 20240509. - Remove Fixes tag from patches that drop _GNU_SOURCE definition. - Restore space between comment and includes for selftests/damon. v5: - Rebase onto linux-next 20240521 - Drop initial patches that modify KHDR_INCLUDES. - Incorporate Mark Brown's patch to replace static_assert with warning. - Don't drop #define _GNU_SOURCE from nolibc and wireguard. - Change Makefiles for x86 and vDSO to append to CFLAGS. Edward Liaw (67): selftests: Compile with -D_GNU_SOURCE when including lib.mk selftests/arm64: Drop define _GNU_SOURCE selftests/arm64: Drop duplicate -D_GNU_SOURCE selftests/bpf: Drop define _GNU_SOURCE selftests/breakpoints: Drop define _GNU_SOURCE selftests/cachestat: Drop define _GNU_SOURCE selftests/capabilities: Drop define _GNU_SOURCE selftests/cgroup: Drop define _GNU_SOURCE selftests/clone3: Drop define _GNU_SOURCE selftests/core: Drop define _GNU_SOURCE selftests/damon: Drop define _GNU_SOURCE selftests/drivers: Drop define _GNU_SOURCE selftests/exec: Drop duplicate -D_GNU_SOURCE selftests/fchmodat2: Drop define _GNU_SOURCE selftests/filelock: Drop define _GNU_SOURCE selftests/filesystems: Drop define _GNU_SOURCE selftests/firmware: Drop define _GNU_SOURCE selftests/fpu: Drop define _GNU_SOURCE selftests/futex: Drop define _GNU_SOURCE selftests/futex: Drop duplicate -D_GNU_SOURCE selftests/intel_pstate: Drop duplicate -D_GNU_SOURCE selftests/iommu: Drop duplicate -D_GNU_SOURCE selftests/ipc: Drop define _GNU_SOURCE selftests/kcmp: Drop define _GNU_SOURCE selftests/landlock: Drop define _GNU_SOURCE selftests/lsm: Drop define _GNU_SOURCE selftests/membarrier: Drop define _GNU_SOURCE selftests/memfd: Drop define _GNU_SOURCE selftests/mincore: Drop define _GNU_SOURCE selftests/mm: Drop define _GNU_SOURCE selftests/mount: Drop define _GNU_SOURCE selftests/mount_setattr: Drop define _GNU_SOURCE selftests/move_mount_set_group: Drop define _GNU_SOURCE selftests/mqueue: Drop define _GNU_SOURCE selftests/net: Drop define _GNU_SOURCE selftests/net: Drop duplicate -D_GNU_SOURCE selftests/nsfs: Drop define _GNU_SOURCE selftests/openat2: Drop define _GNU_SOURCE selftests/perf_events: Drop define _GNU_SOURCE selftests/pid_namespace: Drop define _GNU_SOURCE selftests/pidfd: Drop define _GNU_SOURCE selftests/ptrace: Drop define _GNU_SOURCE selftests/powerpc: Drop define _GNU_SOURCE selftests/proc: Drop define _GNU_SOURCE selftests/proc: Drop duplicate -D_GNU_SOURCE selftests/ptp: Drop define _GNU_SOURCE selftests/resctrl: Drop duplicate -D_GNU_SOURCE selftests/riscv: Drop define _GNU_SOURCE selftests/riscv: Drop duplicate -D_GNU_SOURCE selftests/rlimits: Drop define _GNU_SOURCE selftests/rseq: Drop define _GNU_SOURCE selftests/safesetid: Drop define _GNU_SOURCE selftests/sched: Drop define _GNU_SOURCE selftests/seccomp: Drop define _GNU_SOURCE selftests/sigaltstack: Drop define _GNU_SOURCE selftests/sgx: Compile with -D_GNU_SOURCE selftests/splice: Drop define _GNU_SOURCE selftests/syscall_user_dispatch: Drop define _GNU_SOURCE selftests/thermal: Drop define _GNU_SOURCE selftests/timens: Drop define _GNU_SOURCE selftests/tmpfs: Drop duplicate -D_GNU_SOURCE selftests/uevent: Drop define _GNU_SOURCE selftests/user_events: Drop define _GNU_SOURCE selftests/vDSO: Append to CFLAGS in Makefile selftests/vDSO: Drop define _GNU_SOURCE selftests/x86: Append to CFLAGS in Makefile selftests/x86: Drop define _GNU_SOURCE Mark Brown (1): kselftest: Desecalate reporting of missing _GNU_SOURCE tools/testing/selftests/arm64/fp/fp-ptrace.c | 3 --- tools/testing/selftests/arm64/fp/fp-stress.c | 2 -- tools/testing/selftests/arm64/fp/vlset.c | 1 - tools/testing/selftests/arm64/mte/check_buffer_fill.c | 3 --- tools/testing/selftests/arm64/mte/check_child_memory.c | 3 --- tools/testing/selftests/arm64/mte/check_gcr_el1_cswitch.c | 3 --- tools/testing/selftests/arm64/mte/check_ksm_options.c | 3 --- tools/testing/selftests/arm64/mte/check_mmap_options.c | 3 --- tools/testing/selftests/arm64/mte/check_tags_inclusion.c | 3 --- tools/testing/selftests/arm64/mte/check_user_mem.c | 3 --- tools/testing/selftests/arm64/pauth/pac.c | 3 --- tools/testing/selftests/arm64/signal/Makefile | 2 +- tools/testing/selftests/bpf/bench.c | 1 - tools/testing/selftests/bpf/benchs/bench_trigger.c | 1 - tools/testing/selftests/bpf/cgroup_helpers.c | 1 - tools/testing/selftests/bpf/map_tests/task_storage_map.c | 1 - tools/testing/selftests/bpf/network_helpers.c | 2 -- tools/testing/selftests/bpf/prog_tests/bind_perm.c | 1 - tools/testing/selftests/bpf/prog_tests/bpf_cookie.c | 1 - tools/testing/selftests/bpf/prog_tests/bpf_iter_setsockopt.c | 1 - tools/testing/selftests/bpf/prog_tests/bpf_obj_pinning.c | 1 - tools/testing/selftests/bpf/prog_tests/btf_endian.c | 1 - tools/testing/selftests/bpf/prog_tests/btf_skc_cls_ingress.c | 2 -- tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c | 2 -- tools/testing/selftests/bpf/prog_tests/cgrp_local_storage.c | 2 -- tools/testing/selftests/bpf/prog_tests/cls_redirect.c | 3 --- tools/testing/selftests/bpf/prog_tests/connect_ping.c | 2 -- tools/testing/selftests/bpf/prog_tests/core_retro.c | 1 - tools/testing/selftests/bpf/prog_tests/d_path.c | 1 - tools/testing/selftests/bpf/prog_tests/deny_namespace.c | 1 - tools/testing/selftests/bpf/prog_tests/fexit_sleep.c | 1 - .../selftests/bpf/prog_tests/flow_dissector_reattach.c | 2 -- tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c | 1 - tools/testing/selftests/bpf/prog_tests/htab_reuse.c | 1 - tools/testing/selftests/bpf/prog_tests/htab_update.c | 1 - tools/testing/selftests/bpf/prog_tests/map_in_map.c | 1 - tools/testing/selftests/bpf/prog_tests/ns_current_pid_tgid.c | 2 -- tools/testing/selftests/bpf/prog_tests/perf_branches.c | 1 - tools/testing/selftests/bpf/prog_tests/perf_buffer.c | 1 - tools/testing/selftests/bpf/prog_tests/perf_event_stackmap.c | 1 - tools/testing/selftests/bpf/prog_tests/perf_link.c | 1 - tools/testing/selftests/bpf/prog_tests/perf_skip.c | 2 -- tools/testing/selftests/bpf/prog_tests/preempted_bpf_ma_op.c | 1 - tools/testing/selftests/bpf/prog_tests/rcu_read_lock.c | 2 -- tools/testing/selftests/bpf/prog_tests/reg_bounds.c | 2 -- tools/testing/selftests/bpf/prog_tests/ringbuf.c | 1 - tools/testing/selftests/bpf/prog_tests/ringbuf_multi.c | 1 - tools/testing/selftests/bpf/prog_tests/setget_sockopt.c | 2 -- tools/testing/selftests/bpf/prog_tests/sk_assign.c | 2 -- tools/testing/selftests/bpf/prog_tests/sk_lookup.c | 2 -- tools/testing/selftests/bpf/prog_tests/sock_fields.c | 2 -- tools/testing/selftests/bpf/prog_tests/task_kfunc.c | 2 -- tools/testing/selftests/bpf/prog_tests/task_local_storage.c | 2 -- tools/testing/selftests/bpf/prog_tests/task_pt_regs.c | 1 - tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c | 2 -- tools/testing/selftests/bpf/prog_tests/tcp_hdr_options.c | 2 -- tools/testing/selftests/bpf/prog_tests/test_bpf_ma.c | 1 - .../testing/selftests/bpf/prog_tests/test_bpf_syscall_macro.c | 1 - tools/testing/selftests/bpf/prog_tests/test_bpffs.c | 1 - tools/testing/selftests/bpf/prog_tests/test_overhead.c | 1 - tools/testing/selftests/bpf/prog_tests/token.c | 1 - tools/testing/selftests/bpf/prog_tests/trace_ext.c | 2 -- tools/testing/selftests/bpf/prog_tests/trampoline_count.c | 1 - tools/testing/selftests/bpf/prog_tests/user_ringbuf.c | 2 -- tools/testing/selftests/bpf/prog_tests/xdp_bonding.c | 2 -- tools/testing/selftests/bpf/prog_tests/xdp_synproxy.c | 2 -- tools/testing/selftests/bpf/test_flow_dissector.c | 3 --- tools/testing/selftests/bpf/test_lru_map.c | 1 - tools/testing/selftests/bpf/test_progs.c | 1 - tools/testing/selftests/bpf/test_tcpnotify_user.c | 1 - tools/testing/selftests/bpf/veristat.c | 1 - tools/testing/selftests/bpf/xskxceiver.c | 2 -- tools/testing/selftests/breakpoints/breakpoint_test_arm64.c | 3 --- tools/testing/selftests/breakpoints/step_after_suspend_test.c | 3 --- tools/testing/selftests/cachestat/test_cachestat.c | 2 -- tools/testing/selftests/capabilities/test_execve.c | 2 -- tools/testing/selftests/cgroup/cgroup_util.c | 3 --- tools/testing/selftests/cgroup/test_core.c | 2 -- tools/testing/selftests/cgroup/test_cpu.c | 2 -- tools/testing/selftests/cgroup/test_hugetlb_memcg.c | 2 -- tools/testing/selftests/cgroup/test_kmem.c | 2 -- tools/testing/selftests/cgroup/test_memcontrol.c | 2 -- tools/testing/selftests/cgroup/test_zswap.c | 2 -- tools/testing/selftests/clone3/clone3.c | 2 -- .../testing/selftests/clone3/clone3_cap_checkpoint_restore.c | 2 -- tools/testing/selftests/clone3/clone3_clear_sighand.c | 2 -- tools/testing/selftests/clone3/clone3_selftests.h | 1 - tools/testing/selftests/clone3/clone3_set_tid.c | 2 -- tools/testing/selftests/core/close_range_test.c | 2 -- tools/testing/selftests/damon/debugfs_target_ids_pid_leak.c | 2 -- .../damon/debugfs_target_ids_read_before_terminate_race.c | 1 - tools/testing/selftests/drivers/dma-buf/udmabuf.c | 1 - tools/testing/selftests/exec/Makefile | 1 - tools/testing/selftests/fchmodat2/fchmodat2_test.c | 2 -- tools/testing/selftests/filelock/ofdlocks.c | 2 -- tools/testing/selftests/filesystems/binderfs/binderfs_test.c | 2 -- tools/testing/selftests/filesystems/devpts_pts.c | 1 - tools/testing/selftests/filesystems/dnotify_test.c | 1 - tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c | 2 -- tools/testing/selftests/filesystems/eventfd/eventfd_test.c | 2 -- tools/testing/selftests/filesystems/fat/rename_exchange.c | 2 -- tools/testing/selftests/filesystems/overlayfs/dev_in_maps.c | 2 -- .../testing/selftests/filesystems/statmount/statmount_test.c | 3 --- tools/testing/selftests/firmware/fw_namespace.c | 1 - tools/testing/selftests/fpu/test_fpu.c | 2 -- tools/testing/selftests/futex/functional/Makefile | 2 +- tools/testing/selftests/futex/functional/futex_requeue_pi.c | 3 --- tools/testing/selftests/intel_pstate/Makefile | 2 +- tools/testing/selftests/iommu/Makefile | 2 -- tools/testing/selftests/ipc/msgque.c | 1 - tools/testing/selftests/kcmp/kcmp_test.c | 2 -- tools/testing/selftests/kselftest_harness.h | 2 +- tools/testing/selftests/landlock/base_test.c | 2 -- tools/testing/selftests/landlock/fs_test.c | 2 -- tools/testing/selftests/landlock/net_test.c | 2 -- tools/testing/selftests/landlock/ptrace_test.c | 2 -- tools/testing/selftests/lib.mk | 3 +++ tools/testing/selftests/lsm/common.c | 2 -- tools/testing/selftests/lsm/lsm_get_self_attr_test.c | 2 -- tools/testing/selftests/lsm/lsm_list_modules_test.c | 2 -- tools/testing/selftests/lsm/lsm_set_self_attr_test.c | 2 -- tools/testing/selftests/membarrier/membarrier_test_impl.h | 1 - .../selftests/membarrier/membarrier_test_multi_thread.c | 1 - .../selftests/membarrier/membarrier_test_single_thread.c | 1 - tools/testing/selftests/memfd/common.c | 1 - tools/testing/selftests/memfd/fuse_test.c | 2 -- tools/testing/selftests/memfd/memfd_test.c | 1 - tools/testing/selftests/mincore/mincore_selftest.c | 3 --- tools/testing/selftests/mm/cow.c | 1 - tools/testing/selftests/mm/gup_longterm.c | 1 - tools/testing/selftests/mm/hugepage-mmap.c | 1 - tools/testing/selftests/mm/hugepage-mremap.c | 2 -- tools/testing/selftests/mm/hugetlb-madvise.c | 2 -- tools/testing/selftests/mm/hugetlb-read-hwpoison.c | 2 -- tools/testing/selftests/mm/khugepaged.c | 1 - tools/testing/selftests/mm/ksm_functional_tests.c | 1 - tools/testing/selftests/mm/madv_populate.c | 1 - tools/testing/selftests/mm/map_populate.c | 2 -- tools/testing/selftests/mm/memfd_secret.c | 2 -- tools/testing/selftests/mm/mlock2-tests.c | 1 - tools/testing/selftests/mm/mrelease_test.c | 1 - tools/testing/selftests/mm/mremap_dontunmap.c | 1 - tools/testing/selftests/mm/mremap_test.c | 2 -- tools/testing/selftests/mm/mseal_test.c | 1 - tools/testing/selftests/mm/pagemap_ioctl.c | 1 - tools/testing/selftests/mm/pkey-helpers.h | 1 - tools/testing/selftests/mm/protection_keys.c | 1 - tools/testing/selftests/mm/seal_elf.c | 1 - tools/testing/selftests/mm/split_huge_page_test.c | 2 -- tools/testing/selftests/mm/thuge-gen.c | 2 -- tools/testing/selftests/mm/uffd-common.h | 1 - tools/testing/selftests/mount/nosymfollow-test.c | 1 - tools/testing/selftests/mount/unprivileged-remount-test.c | 1 - tools/testing/selftests/mount_setattr/mount_setattr_test.c | 1 - .../move_mount_set_group/move_mount_set_group_test.c | 1 - tools/testing/selftests/mqueue/mq_perf_tests.c | 1 - tools/testing/selftests/net/af_unix/diag_uid.c | 2 -- tools/testing/selftests/net/af_unix/scm_pidfd.c | 1 - tools/testing/selftests/net/af_unix/scm_rights.c | 1 - tools/testing/selftests/net/af_unix/unix_connect.c | 2 -- tools/testing/selftests/net/epoll_busy_poll.c | 2 -- tools/testing/selftests/net/gro.c | 3 --- tools/testing/selftests/net/ip_defrag.c | 3 --- tools/testing/selftests/net/ipsec.c | 3 --- tools/testing/selftests/net/ipv6_flowlabel.c | 3 --- tools/testing/selftests/net/ipv6_flowlabel_mgr.c | 3 --- tools/testing/selftests/net/lib/csum.c | 3 --- tools/testing/selftests/net/mptcp/mptcp_connect.c | 3 --- tools/testing/selftests/net/mptcp/mptcp_inq.c | 3 --- tools/testing/selftests/net/mptcp/mptcp_sockopt.c | 3 --- tools/testing/selftests/net/msg_zerocopy.c | 3 --- tools/testing/selftests/net/netfilter/audit_logread.c | 2 -- tools/testing/selftests/net/netfilter/conntrack_dump_flush.c | 3 --- tools/testing/selftests/net/nettest.c | 2 -- tools/testing/selftests/net/psock_fanout.c | 3 --- tools/testing/selftests/net/psock_snd.c | 3 --- tools/testing/selftests/net/reuseport_addr_any.c | 3 --- tools/testing/selftests/net/reuseport_bpf_cpu.c | 3 --- tools/testing/selftests/net/reuseport_bpf_numa.c | 3 --- tools/testing/selftests/net/reuseport_dualstack.c | 3 --- tools/testing/selftests/net/so_incoming_cpu.c | 1 - tools/testing/selftests/net/so_netns_cookie.c | 1 - tools/testing/selftests/net/so_txtime.c | 3 --- tools/testing/selftests/net/tap.c | 3 --- tools/testing/selftests/net/tcp_ao/Makefile | 2 +- tools/testing/selftests/net/tcp_fastopen_backup_key.c | 1 - tools/testing/selftests/net/tcp_inq.c | 2 -- tools/testing/selftests/net/tcp_mmap.c | 1 - tools/testing/selftests/net/tls.c | 3 --- tools/testing/selftests/net/toeplitz.c | 3 --- tools/testing/selftests/net/tun.c | 3 --- tools/testing/selftests/net/txring_overwrite.c | 3 --- tools/testing/selftests/net/txtimestamp.c | 3 --- tools/testing/selftests/net/udpgso.c | 3 --- tools/testing/selftests/net/udpgso_bench_rx.c | 3 --- tools/testing/selftests/net/udpgso_bench_tx.c | 3 --- tools/testing/selftests/nsfs/owner.c | 1 - tools/testing/selftests/nsfs/pidns.c | 1 - tools/testing/selftests/openat2/helpers.c | 2 -- tools/testing/selftests/openat2/helpers.h | 1 - tools/testing/selftests/openat2/openat2_test.c | 2 -- tools/testing/selftests/openat2/rename_attack_test.c | 2 -- tools/testing/selftests/openat2/resolve_test.c | 2 -- tools/testing/selftests/perf_events/remove_on_exec.c | 2 -- tools/testing/selftests/perf_events/sigtrap_threads.c | 2 -- tools/testing/selftests/perf_events/watermark_signal.c | 2 -- tools/testing/selftests/pid_namespace/regression_enomem.c | 1 - tools/testing/selftests/pidfd/pidfd.h | 1 - tools/testing/selftests/pidfd/pidfd_fdinfo_test.c | 2 -- tools/testing/selftests/pidfd/pidfd_getfd_test.c | 2 -- tools/testing/selftests/pidfd/pidfd_open_test.c | 2 -- tools/testing/selftests/pidfd/pidfd_poll_test.c | 2 -- tools/testing/selftests/pidfd/pidfd_setns_test.c | 2 -- tools/testing/selftests/pidfd/pidfd_test.c | 2 -- tools/testing/selftests/pidfd/pidfd_wait.c | 2 -- tools/testing/selftests/powerpc/benchmarks/context_switch.c | 2 -- tools/testing/selftests/powerpc/benchmarks/exec_target.c | 2 -- tools/testing/selftests/powerpc/benchmarks/fork.c | 2 -- tools/testing/selftests/powerpc/benchmarks/futex_bench.c | 3 --- tools/testing/selftests/powerpc/dexcr/hashchk_test.c | 3 --- tools/testing/selftests/powerpc/dscr/dscr_default_test.c | 3 --- tools/testing/selftests/powerpc/dscr/dscr_explicit_test.c | 3 --- tools/testing/selftests/powerpc/dscr/dscr_sysfs_thread_test.c | 1 - tools/testing/selftests/powerpc/mm/exec_prot.c | 2 -- tools/testing/selftests/powerpc/mm/pkey_exec_prot.c | 2 -- tools/testing/selftests/powerpc/mm/pkey_siginfo.c | 2 -- tools/testing/selftests/powerpc/mm/tlbie_test.c | 2 -- tools/testing/selftests/powerpc/papr_vpd/papr_vpd.c | 1 - tools/testing/selftests/powerpc/pmu/count_instructions.c | 3 --- tools/testing/selftests/powerpc/pmu/count_stcx_fail.c | 3 --- tools/testing/selftests/powerpc/pmu/ebb/ebb.c | 3 --- .../selftests/powerpc/pmu/ebb/instruction_count_test.c | 3 --- tools/testing/selftests/powerpc/pmu/event.c | 2 -- tools/testing/selftests/powerpc/pmu/lib.c | 3 --- tools/testing/selftests/powerpc/pmu/per_event_excludes.c | 3 --- tools/testing/selftests/powerpc/ptrace/perf-hwbreak.c | 3 --- tools/testing/selftests/powerpc/ptrace/ptrace-syscall.c | 2 -- .../testing/selftests/powerpc/signal/sig_sc_double_restart.c | 1 - tools/testing/selftests/powerpc/signal/sigreturn_kernel.c | 3 --- tools/testing/selftests/powerpc/signal/sigreturn_vdso.c | 3 --- tools/testing/selftests/powerpc/syscalls/ipc_unmuxed.c | 2 -- tools/testing/selftests/powerpc/tm/tm-exec.c | 2 -- tools/testing/selftests/powerpc/tm/tm-poison.c | 2 -- .../testing/selftests/powerpc/tm/tm-signal-context-force-tm.c | 2 -- tools/testing/selftests/powerpc/tm/tm-signal-sigreturn-nt.c | 2 -- tools/testing/selftests/powerpc/tm/tm-tmspr.c | 2 -- tools/testing/selftests/powerpc/tm/tm-trap.c | 2 -- tools/testing/selftests/powerpc/tm/tm-unavailable.c | 2 -- tools/testing/selftests/powerpc/utils.c | 3 --- tools/testing/selftests/proc/Makefile | 1 - tools/testing/selftests/proc/proc-empty-vm.c | 3 --- tools/testing/selftests/ptp/testptp.c | 1 - tools/testing/selftests/ptrace/get_set_sud.c | 1 - tools/testing/selftests/ptrace/peeksiginfo.c | 1 - tools/testing/selftests/resctrl/Makefile | 2 +- tools/testing/selftests/riscv/hwprobe/cbo.c | 1 - tools/testing/selftests/riscv/hwprobe/which-cpus.c | 1 - tools/testing/selftests/riscv/mm/Makefile | 2 +- tools/testing/selftests/rlimits/rlimits-per-userns.c | 1 - tools/testing/selftests/rseq/basic_percpu_ops_test.c | 1 - tools/testing/selftests/rseq/basic_test.c | 2 -- tools/testing/selftests/rseq/param_test.c | 1 - tools/testing/selftests/rseq/rseq.c | 2 -- tools/testing/selftests/safesetid/safesetid-test.c | 1 - tools/testing/selftests/sched/cs_prctl_test.c | 2 -- tools/testing/selftests/seccomp/seccomp_benchmark.c | 1 - tools/testing/selftests/seccomp/seccomp_bpf.c | 2 -- tools/testing/selftests/sgx/Makefile | 2 +- tools/testing/selftests/sgx/sigstruct.c | 1 - tools/testing/selftests/sigaltstack/sas.c | 2 -- tools/testing/selftests/splice/default_file_splice_read.c | 1 - tools/testing/selftests/splice/splice_read.c | 1 - tools/testing/selftests/syscall_user_dispatch/sud_benchmark.c | 2 -- tools/testing/selftests/syscall_user_dispatch/sud_test.c | 2 -- .../selftests/thermal/intel/power_floor/power_floor_test.c | 3 --- .../thermal/intel/workload_hint/workload_hint_test.c | 3 --- tools/testing/selftests/timens/clock_nanosleep.c | 1 - tools/testing/selftests/timens/exec.c | 1 - tools/testing/selftests/timens/futex.c | 1 - tools/testing/selftests/timens/gettime_perf.c | 1 - tools/testing/selftests/timens/procfs.c | 1 - tools/testing/selftests/timens/timens.c | 1 - tools/testing/selftests/timens/timer.c | 1 - tools/testing/selftests/timens/timerfd.c | 1 - tools/testing/selftests/timens/vfork_exec.c | 1 - tools/testing/selftests/tmpfs/Makefile | 1 - tools/testing/selftests/uevent/uevent_filtering.c | 2 -- tools/testing/selftests/user_events/abi_test.c | 2 -- tools/testing/selftests/vDSO/Makefile | 2 +- tools/testing/selftests/vDSO/vdso_test_abi.c | 1 - tools/testing/selftests/vDSO/vdso_test_clock_getres.c | 2 -- tools/testing/selftests/vDSO/vdso_test_correctness.c | 3 --- tools/testing/selftests/x86/Makefile | 2 +- tools/testing/selftests/x86/amx.c | 2 -- tools/testing/selftests/x86/check_initial_reg_state.c | 3 --- tools/testing/selftests/x86/corrupt_xstate_header.c | 3 --- tools/testing/selftests/x86/entry_from_vm86.c | 3 --- tools/testing/selftests/x86/fsgsbase.c | 2 -- tools/testing/selftests/x86/fsgsbase_restore.c | 2 -- tools/testing/selftests/x86/ioperm.c | 2 -- tools/testing/selftests/x86/iopl.c | 2 -- tools/testing/selftests/x86/lam.c | 1 - tools/testing/selftests/x86/ldt_gdt.c | 2 -- tools/testing/selftests/x86/mov_ss_trap.c | 2 -- tools/testing/selftests/x86/nx_stack.c | 2 -- tools/testing/selftests/x86/ptrace_syscall.c | 2 -- tools/testing/selftests/x86/sigaltstack.c | 2 -- tools/testing/selftests/x86/sigreturn.c | 3 --- tools/testing/selftests/x86/single_step_syscall.c | 3 --- tools/testing/selftests/x86/syscall_arg_fault.c | 3 --- tools/testing/selftests/x86/syscall_numbering.c | 3 --- tools/testing/selftests/x86/sysret_rip.c | 3 --- tools/testing/selftests/x86/sysret_ss_attrs.c | 3 --- tools/testing/selftests/x86/test_FCMOV.c | 4 ---- tools/testing/selftests/x86/test_FCOMI.c | 4 ---- tools/testing/selftests/x86/test_FISTTP.c | 4 ---- tools/testing/selftests/x86/test_mremap_vdso.c | 1 - tools/testing/selftests/x86/test_shadow_stack.c | 3 --- tools/testing/selftests/x86/test_syscall_vdso.c | 4 ---- tools/testing/selftests/x86/test_vsyscall.c | 3 --- tools/testing/selftests/x86/unwind_vdso.c | 3 --- tools/testing/selftests/x86/vdso_restorer.c | 3 --- 322 files changed, 13 insertions(+), 605 deletions(-) -- 2.45.1.288.g0e0cd299f1-goog

1 year, 5 months

12
88
0 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror