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

[PATCH net-next v8 0/3] net: gro: remove network_header use, move p->{flush/flush_id} calculations to L4

by Richard Gobert

The cb fields network_offset and inner_network_offset are used instead of skb->network_header throughout GRO. These fields are then leveraged in the next commit to remove flush_id state from napi_gro_cb, and stateful code in {ipv6,inet}_gro_receive which may be unnecessarily complicated due to encapsulation support in GRO. These fields are checked in L4 instead. 3rd patch adds tests for different flush_id flows in GRO. v7 -> v8: - Remove network_header use in gro - Re-send commits after the dependent patch to net was applied - v7: https://lore.kernel.org/all/20240412155533.115507-1-richardbgobert@gmail.co… v6 -> v7: - Moved bug fixes to a separate submission in net - Added UDP fwd benchmark - v6: https://lore.kernel.org/all/20240410153423.107381-1-richardbgobert@gmail.co… v5 -> v6: - Write inner_network_offset in vxlan and geneve - Ignore is_atomic when DF=0 - v5: https://lore.kernel.org/all/20240408141720.98832-1-richardbgobert@gmail.com/ v4 -> v5: - Add 1st commit - flush id checks in udp_gro_receive segment which can be backported by itself - Add TCP measurements for the 5th commit - Add flush id tests to ensure flush id logic is preserved in GRO - Simplify gro_inet_flush by removing a branch - v4: https://lore.kernel.org/all/202420325182543.87683-1-richardbgobert@gmail.co… v3 -> v4: - Fix code comment and commit message typos - v3: https://lore.kernel.org/all/f939c84a-2322-4393-a5b0-9b1e0be8ed8e@gmail.com/ v2 -> v3: - Use napi_gro_cb instead of skb->{offset} - v2: https://lore.kernel.org/all/2ce1600b-e733-448b-91ac-9d0ae2b866a4@gmail.com/ v1 -> v2: - Pass p_off in *_gro_complete to fix UDP bug - Remove more conditionals and memory fetches from inet_gro_flush - v1: https://lore.kernel.org/netdev/e1d22505-c5f8-4c02-a997-64248480338b@gmail.c… Richard Gobert (3): net: gro: use cb instead of skb->network_header net: gro: move L3 flush checks to tcp_gro_receive and udp_gro_receive_segment selftests/net: add flush id selftests include/net/gro.h | 75 +++++++++++++-- net/core/gro.c | 3 - net/ipv4/af_inet.c | 45 +-------- net/ipv4/tcp_offload.c | 18 +--- net/ipv4/udp_offload.c | 10 +- net/ipv6/ip6_offload.c | 16 +--- net/ipv6/tcpv6_offload.c | 3 +- tools/testing/selftests/net/gro.c | 147 ++++++++++++++++++++++++++++++ 8 files changed, 225 insertions(+), 92 deletions(-) -- 2.36.1

1 year, 3 months

2
9
0 0

[PATCH v6 00/10] Fix Kselftest's vfork() side effects

by Mickaël Salaün

Hi, This sixth series just update the last patch description. Shuah, I think this should be in -next really soon to make sure everything works fine for the v6.9 release, which is not currently the case. I cannot test against all kselftests though. I would prefer to let you handle this, but I guess you're not able to do so and I'll push it on my branch without reply from you. Even if I push it on my branch, please push it on yours too as soon as you see this and I'll remove it from mine. Mark, Jakub, could you please test this series? As reported by Kernel Test Robot [1] and Sean Christopherson [2], some tests fail since v6.9-rc1 . This is due to the use of vfork() which introduced some side effects. Similarly, while making it more generic, a previous commit made some Landlock file system tests flaky, and subject to the host's file system mount configuration. This series fixes all these side effects by replacing vfork() with clone3() and CLONE_VFORK, which is cleaner (no arbitrary shared memory) and makes the Kselftest framework more robust. I tried different approaches and I found this one to be the cleaner and less invasive for current test cases. I successfully ran the following tests (using TEST_F and fork/clone/clone3, and KVM_ONE_VCPU_TEST) with this series: - kvm:fix_hypercall_test - kvm:sync_regs_test - kvm:userspace_msr_exit_test - kvm:vmx_pmu_caps_test - landlock:fs_test - landlock:net_test - landlock:ptrace_test - move_mount_set_group:move_mount_set_group_test - net/af_unix:scm_pidfd - perf_events:remove_on_exec - pidfd:pidfd_getfd_test - pidfd:pidfd_setns_test - seccomp:seccomp_bpf - user_events:abi_test [1] https://lore.kernel.org/oe-lkp/202403291015.1fcfa957-oliver.sang@intel.com [2] https://lore.kernel.org/r/ZjPelW6-AbtYvslu@google.com Previous versions: v1: https://lore.kernel.org/r/20240426172252.1862930-1-mic@digikod.net v2: https://lore.kernel.org/r/20240429130931.2394118-1-mic@digikod.net v3: https://lore.kernel.org/r/20240429191911.2552580-1-mic@digikod.net v4: https://lore.kernel.org/r/20240502210926.145539-1-mic@digikod.net v5: https://lore.kernel.org/r/20240503105820.300927-1-mic@digikod.net Regards, Mickaël Salaün (10): selftests/pidfd: Fix config for pidfd_setns_test selftests/landlock: Fix FS tests when run on a private mount point selftests/harness: Fix fixture teardown selftests/harness: Fix interleaved scheduling leading to race conditions selftests/landlock: Do not allocate memory in fixture data selftests/harness: Constify fixture variants selftests/pidfd: Fix wrong expectation selftests/harness: Share _metadata between forked processes selftests/harness: Fix vfork() side effects selftests/harness: Handle TEST_F()'s explicit exit codes tools/testing/selftests/kselftest_harness.h | 122 +++++++++++++----- tools/testing/selftests/landlock/fs_test.c | 83 +++++++----- tools/testing/selftests/pidfd/config | 2 + .../selftests/pidfd/pidfd_setns_test.c | 2 +- 4 files changed, 143 insertions(+), 66 deletions(-) base-commit: e67572cd2204894179d89bd7b984072f19313b03 -- 2.45.0

1 year, 3 months

3
13
0 0

[PATCH 00/18] HID: Include current HID-BPF fixes in tree

by Benjamin Tissoires

When I introduced HID-BPF, I mentioned that we should ship the HID-BPF programs in the kernel when they are fixes so that everybody can benefit from them. I tried multiple times to do so but I was confronted to a tough problem: how can I make the kernel load them automatically? I went over a few solutions, but it always came down to something either ugly, or either not satisfying (like forcing `bpftool` to be compiled first, or not being able to insert them as a module). OTOH, I was working with Peter on `udev-hid-bpf`[0] as a proof of concept on how a minimal loader should look like. This allowed me to experiment on the BPF files and how they should look like. And after further thoughts, I realized that `udev-hid-bpf` could very well be the `kmod load` that we currently have: - the kernel handles the device normally - a udev event is emitted - a udev rule fires `udev-hid-bpf` and load the appropriate HID-BPF file(s) based on the modalias Given that most HID devices are supposed to work to a minimal level when connected without any driver, this makes the whole HID-BPF programs nice to have but not critical. We can then postpone the HID-BPF loading when userspace is ready. Working with HID-BPF is also a much better user experience for end users (as I predicted). All they have to do is to go to the `udev-hid-bpf` project, fetch an artifact from the MR that concerns them, run `install.sh` (no compilation required), and their devices are fixed (minus some back and forth when the HID-BPF program needs some changes). So I already have that loader available, and it works well enough for our users. But the missing point was still how to "upstream" those BPF fixes? That's where this patch series comes in: we simply store the fixes in the kernel under `drivers/hid/bpf/progs`, provide a way to compile them, but also add tests for them in the selftests dir. Once a program is accepted here, for convenience, the same program will move from a "testing" directory to a "stable" directory on `udev-hid-bpf`. This way, distributions don't need to follow when there is a new program added here, they can just ship the "stable" ones from `udev-hid-bpf`. Signed-off-by: Benjamin Tissoires <bentiss(a)kernel.org> [0] https://gitlab.freedesktop.org/libevdev/udev-hid-bpf/ --- Benjamin Tissoires (18): HID: do not assume HAT Switch logical max < 8 HID: bpf: add first in-tree HID-BPF fix for the XPPen Artist 24 HID: bpf: add in-tree HID-BPF fix for the XPPen Artist 16 HID: bpf: add in-tree HID-BPF fix for the HP Elite Presenter Mouse HID: bpf: add in-tree HID-BPF fix for the IOGear Kaliber Gaming MMOmentum mouse HID: bpf: add in-tree HID-BPF fix for the Wacom ArtPen HID: bpf: add in-tree HID-BPF fix for the XBox Elite 2 over Bluetooth HID: bpf: add in-tree HID-BPF fix for the Huion Kamvas Pro 19 HID: bpf: add in-tree HID-BPF fix for the Raptor Mach 2 selftests/hid: import base_device.py from hid-tools selftests/hid: add support for HID-BPF pre-loading before starting a test selftests/hid: tablets: reduce the number of pen state selftests/hid: tablets: add a couple of XP-PEN tablets selftests/hid: tablets: also check for XP-Pen offset correction selftests/hid: add Huion Kamvas Pro 19 tests selftests/hid: import base_gamepad.py from hid-tools selftests/hid: move the gamepads definitions in the test file selftests/hid: add tests for the Raptor Mach 2 joystick drivers/hid/bpf/progs/FR-TEC__Raptor-Mach-2.bpf.c | 185 ++++++ drivers/hid/bpf/progs/HP__Elite-Presenter.bpf.c | 58 ++ drivers/hid/bpf/progs/Huion__Kamvas-Pro-19.bpf.c | 290 +++++++++ .../hid/bpf/progs/IOGEAR__Kaliber-MMOmentum.bpf.c | 59 ++ drivers/hid/bpf/progs/Makefile | 91 +++ .../hid/bpf/progs/Microsoft__XBox-Elite-2.bpf.c | 133 ++++ drivers/hid/bpf/progs/README | 102 +++ drivers/hid/bpf/progs/Wacom__ArtPen.bpf.c | 173 +++++ drivers/hid/bpf/progs/XPPen__Artist24.bpf.c | 229 +++++++ drivers/hid/bpf/progs/XPPen__ArtistPro16Gen2.bpf.c | 274 ++++++++ drivers/hid/bpf/progs/hid_bpf.h | 15 + drivers/hid/bpf/progs/hid_bpf_helpers.h | 170 +++++ include/linux/hid.h | 6 +- tools/testing/selftests/hid/tests/base.py | 87 ++- tools/testing/selftests/hid/tests/base_device.py | 421 ++++++++++++ tools/testing/selftests/hid/tests/base_gamepad.py | 238 +++++++ tools/testing/selftests/hid/tests/test_gamepad.py | 457 ++++++++++++- tools/testing/selftests/hid/tests/test_tablet.py | 723 +++++++++++++++------ 18 files changed, 3507 insertions(+), 204 deletions(-) --- base-commit: 3e78a6c0d3e02e4cf881dc84c5127e9990f939d6 change-id: 20240328-bpf_sources-be1f3c617c5e Best regards, -- Benjamin Tissoires <bentiss(a)kernel.org>

1 year, 3 months

3
22
0 0

[PATCH] 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.eventfd01 ... # OK global.eventfd01 ok 1 global.eventfd01 # RUN global.eventfd02 ... # OK global.eventfd02 ok 2 global.eventfd02 # RUN global.eventfd03 ... # OK global.eventfd03 ok 3 global.eventfd03 # RUN global.eventfd04 ... # OK global.eventfd04 ok 4 global.eventfd04 # RUN global.eventfd05 ... # OK global.eventfd05 ok 5 global.eventfd05 # RUN global.eventfd06 ... # OK global.eventfd06 ok 6 global.eventfd06 # RUN global.eventfd07 ... # OK global.eventfd07 ok 7 global.eventfd07 # RUN global.eventfd08 ... # OK global.eventfd08 ok 8 global.eventfd08 # RUN global.eventfd09 ... # OK global.eventfd09 ok 9 global.eventfd09 # 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: linux-kselftest(a)vger.kernel.org Cc: linux-kernel(a)vger.kernel.org --- .../filesystems/eventfd/eventfd_test.c | 116 ++++++++++++++++++ 1 file changed, 116 insertions(+) diff --git a/tools/testing/selftests/filesystems/eventfd/eventfd_test.c b/tools/testing/selftests/filesystems/eventfd/eventfd_test.c index f142a137526c..eeab8df5b1b5 100644 --- a/tools/testing/selftests/filesystems/eventfd/eventfd_test.c +++ b/tools/testing/selftests/filesystems/eventfd/eventfd_test.c @@ -183,4 +183,120 @@ 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(eventfd06) +{ + 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); + + 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(eventfd07) +{ + int value = 0; + ssize_t size; + int fd; + + fd = sys_eventfd2(0, 0); + ASSERT_GE(fd, 0); + + size = write(fd, &value, sizeof(value)); + EXPECT_EQ(size, -1); + EXPECT_EQ(errno, EINVAL); + + 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(eventfd08) +{ + 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 < 10000000; 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, 10000000); + + 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(eventfd09) +{ + 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 < 10000000; i++) { + size = write(fd, &value, sizeof(value)); + EXPECT_EQ(size, sizeof(value)); + } + + for (i = 0; i < 10000000; 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, 3 months

2
2
0 0

[PATCH RFC bpf-next 0/8] Implement generic bpf_async cb

by Benjamin Tissoires

This is a RFC, following[0]. It works, still needs some care but this is mainly to see if this will have a chance to get upsrteamed or if I should rely on struct_ops instead. Cheers, Benjamin Signed-off-by: Benjamin Tissoires <bentiss(a)kernel.org> --- Benjamin Tissoires (8): bpf: ignore sleepable prog parameter for kfuncs bpf: add kfunc_meta parameter to push_callback_call() bpf: implement __async and __s_async kfunc suffixes bpf: typedef a type for the bpf_wq callbacks selftests/bpf: rely on wq_callback_fn_t bpf: remove one special case of is_bpf_wq_set_callback_impl_kfunc bpf: implement __aux kfunc argument suffix to fetch prog_aux bpf: rely on __aux suffix for bpf_wq_set_callback_impl kernel/bpf/helpers.c | 10 +- kernel/bpf/verifier.c | 333 +++++++++++++++++++----- tools/testing/selftests/bpf/bpf_experimental.h | 3 +- tools/testing/selftests/bpf/progs/wq.c | 10 +- tools/testing/selftests/bpf/progs/wq_failures.c | 4 +- 5 files changed, 280 insertions(+), 80 deletions(-) --- base-commit: 05cbc217aafbc631a6c2fab4accf95850cb48358 change-id: 20240507-bpf_async-bd2e65847525 Best regards, -- Benjamin Tissoires <bentiss(a)kernel.org>

1 year, 3 months

1
8
0 0

[PATCH net-next v3 0/2] fix icmp error source address over xfrm tunnel

by Antony Antony

Hi, This fix, originally intended for XFRM/IPsec, has been recommended by Steffen Klassert to submit to the net tree. The patch addresses a minor issue related to the IPv4 source address of ICMP error messages, which originated from an old 2011 commit: 415b3334a21a ("icmp: Fix regression in nexthop resolution during replies.") The omission of a "Fixes" tag in the following commit is deliberate to prevent potential test failures and subsequent regression issues that may arise from backporting this patch all stable kerenels. This is a minor fix, anot not security fix. With a seleftest I am submitting this to net-next tree. v2->v3 : fix testscript. The IFS, space, got mangled. v1->v2 : add kernel selftest script Antony Antony (2): xfrm: fix source address in icmp error generation from IPsec gateway selftests/net: add ICMP unreachable over IPsec tunnel net/ipv4/icmp.c | 1 - tools/testing/selftests/net/Makefile | 1 + tools/testing/selftests/net/xfrm_state.sh | 624 ++++++++++++++++++++++ 3 files changed, 625 insertions(+), 1 deletion(-) create mode 100755 tools/testing/selftests/net/xfrm_state.sh -- 2.30.2

1 year, 3 months

4
9
0 0

[PATCH net] selftests/bpf: fix pointer arithmetic in test_xdp_do_redirect

by Michal Schmidt

Cast operation has a higher precedence than addition. The code here wants to zero the 2nd half of the 64-bit metadata, but due to a pointer arithmetic mistake, it writes the zero at offset 16 instead. Just adding parentheses around "data + 4" would fix this, but I think this will be slightly better readable with array syntax. I was unable to test this with tools/testing/selftests/bpf/vmtest.sh, because my glibc is newer than glibc in the provided VM image. So I just checked the difference in the compiled code. objdump -S tools/testing/selftests/bpf/xdp_do_redirect.test.o: - *((__u32 *)data) = 0x42; /* metadata test value */ + ((__u32 *)data)[0] = 0x42; /* metadata test value */ be7: 48 8d 85 30 fc ff ff lea -0x3d0(%rbp),%rax bee: c7 00 42 00 00 00 movl $0x42,(%rax) - *((__u32 *)data + 4) = 0; + ((__u32 *)data)[1] = 0; bf4: 48 8d 85 30 fc ff ff lea -0x3d0(%rbp),%rax - bfb: 48 83 c0 10 add $0x10,%rax + bfb: 48 83 c0 04 add $0x4,%rax bff: c7 00 00 00 00 00 movl $0x0,(%rax) Fixes: 5640b6d89434 ("selftests/bpf: fix "metadata marker" getting overwritten by the netstack") Signed-off-by: Michal Schmidt <mschmidt(a)redhat.com> --- tools/testing/selftests/bpf/prog_tests/xdp_do_redirect.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/bpf/prog_tests/xdp_do_redirect.c b/tools/testing/selftests/bpf/prog_tests/xdp_do_redirect.c index 498d3bdaa4b0..bad0ea167be7 100644 --- a/tools/testing/selftests/bpf/prog_tests/xdp_do_redirect.c +++ b/tools/testing/selftests/bpf/prog_tests/xdp_do_redirect.c @@ -107,8 +107,8 @@ void test_xdp_do_redirect(void) .attach_point = BPF_TC_INGRESS); memcpy(&data[sizeof(__u64)], &pkt_udp, sizeof(pkt_udp)); - *((__u32 *)data) = 0x42; /* metadata test value */ - *((__u32 *)data + 4) = 0; + ((__u32 *)data)[0] = 0x42; /* metadata test value */ + ((__u32 *)data)[1] = 0; skel = test_xdp_do_redirect__open(); if (!ASSERT_OK_PTR(skel, "skel")) -- 2.44.0

1 year, 3 months

4
3
0 0

[PATCH bpf-next v4 0/3] export send_recv_data

by Geliang Tang

From: Geliang Tang <tanggeliang(a)kylinos.cn> v4: - fix a bug in v3, it should be 'if (err)', not 'if (!err)'. - move "selftests/bpf: Use log_err in network_helpers" out of this series. v3: - add two more patches. - use log_err instead of ASSERT in v3. - let send_recv_data return int as Martin suggested. v2: Address Martin's comments for v1 (thanks.) - drop patch 1, "export send_byte helper". - drop "WRITE_ONCE(arg.stop, 0)". - rebased. send_recv_data will be re-used in MPTCP bpf tests, but not included in this set because it depends on other patches that have not been in the bpf-next yet. It will be sent as another set soon. Geliang Tang (3): selftests/bpf: Add struct send_recv_arg selftests/bpf: Export send_recv_data helper selftests/bpf: Support nonblock for send_recv_data tools/testing/selftests/bpf/network_helpers.c | 103 ++++++++++++++++++ tools/testing/selftests/bpf/network_helpers.h | 1 + .../selftests/bpf/prog_tests/bpf_tcp_ca.c | 71 +----------- 3 files changed, 105 insertions(+), 70 deletions(-) -- 2.40.1

1 year, 3 months

2
6
0 0

[PATCH net-next v2] selftest: epoll_busy_poll: epoll busy poll tests

by Joe Damato

Add a simple test for the epoll busy poll ioctls, using the kernel selftest harness. This test ensures that the ioctls have the expected return codes and that the kernel properly gets and sets epoll busy poll parameters. The test can be expanded in the future to do real busy polling (provided another machine to act as the client is available). Signed-off-by: Joe Damato <jdamato(a)fastly.com> --- tools/testing/selftests/net/.gitignore | 1 + tools/testing/selftests/net/Makefile | 2 +- tools/testing/selftests/net/epoll_busy_poll.c | 271 ++++++++++++++++++ 3 files changed, 273 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/net/epoll_busy_poll.c diff --git a/tools/testing/selftests/net/.gitignore b/tools/testing/selftests/net/.gitignore index d996a0ab0765..777cfd027076 100644 --- a/tools/testing/selftests/net/.gitignore +++ b/tools/testing/selftests/net/.gitignore @@ -5,6 +5,7 @@ bind_wildcard csum cmsg_sender diag_uid +epoll_busy_poll fin_ack_lat gro hwtstamp_config diff --git a/tools/testing/selftests/net/Makefile b/tools/testing/selftests/net/Makefile index 5befca249452..b0b893009867 100644 --- a/tools/testing/selftests/net/Makefile +++ b/tools/testing/selftests/net/Makefile @@ -67,7 +67,7 @@ TEST_GEN_FILES += ipsec TEST_GEN_FILES += ioam6_parser TEST_GEN_FILES += gro TEST_GEN_PROGS = reuseport_bpf reuseport_bpf_cpu reuseport_bpf_numa -TEST_GEN_PROGS += reuseport_dualstack reuseaddr_conflict tls tun tap +TEST_GEN_PROGS += reuseport_dualstack reuseaddr_conflict tls tun tap epoll_busy_poll TEST_GEN_FILES += toeplitz TEST_GEN_FILES += cmsg_sender TEST_GEN_FILES += stress_reuseport_listen diff --git a/tools/testing/selftests/net/epoll_busy_poll.c b/tools/testing/selftests/net/epoll_busy_poll.c new file mode 100644 index 000000000000..166fabc6cc7e --- /dev/null +++ b/tools/testing/selftests/net/epoll_busy_poll.c @@ -0,0 +1,271 @@ +// SPDX-License-Identifier: GPL-2.0-or-later + +/* Basic per-epoll context busy poll test. + * + * Only tests the ioctls, but should be expanded to test two connected hosts in + * the future + */ + +#define _GNU_SOURCE + +#include <error.h> +#include <errno.h> +#include <inttypes.h> +#include <limits.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include <sys/epoll.h> +#include <sys/ioctl.h> +#include <sys/socket.h> + +#include "../kselftest_harness.h" + +/* if the headers haven't been updated, we need to define some things */ +#if !defined(EPOLL_IOC_TYPE) +struct epoll_params { + uint32_t busy_poll_usecs; + uint16_t busy_poll_budget; + uint8_t prefer_busy_poll; + + /* pad the struct to a multiple of 64bits */ + uint8_t __pad; +}; + +#define EPOLL_IOC_TYPE 0x8A +#define EPIOCSPARAMS _IOW(EPOLL_IOC_TYPE, 0x01, struct epoll_params) +#define EPIOCGPARAMS _IOR(EPOLL_IOC_TYPE, 0x02, struct epoll_params) +#endif + +FIXTURE(invalid_fd) +{ + int invalid_fd; + struct epoll_params params; +}; + +FIXTURE_SETUP(invalid_fd) +{ + int ret; + + ret = socket(AF_UNIX, SOCK_DGRAM, 0); + EXPECT_NE(-1, ret) + TH_LOG("error creating unix socket"); + + self->invalid_fd = ret; +} + +FIXTURE_TEARDOWN(invalid_fd) +{ + int ret; + + ret = close(self->invalid_fd); + EXPECT_EQ(0, ret); +} + +TEST_F(invalid_fd, test_invalid_fd) +{ + int ret; + + ret = ioctl(self->invalid_fd, EPIOCGPARAMS, &self->params); + + EXPECT_EQ(-1, ret) + TH_LOG("EPIOCGPARAMS on invalid epoll FD should error"); + + EXPECT_EQ(ENOTTY, errno) + TH_LOG("EPIOCGPARAMS on invalid epoll FD should set errno to ENOTTY"); + + memset(&self->params, 0, sizeof(struct epoll_params)); + + ret = ioctl(self->invalid_fd, EPIOCSPARAMS, &self->params); + + EXPECT_EQ(-1, ret) + TH_LOG("EPIOCSPARAMS on invalid epoll FD should error"); + + EXPECT_EQ(ENOTTY, errno) + TH_LOG("EPIOCSPARAMS on invalid epoll FD should set errno to ENOTTY"); +} + +FIXTURE(epoll_busy_poll) +{ + int fd; + struct epoll_params params; + struct epoll_params *invalid_params; +}; + +FIXTURE_SETUP(epoll_busy_poll) +{ + int ret; + + ret = epoll_create1(0); + EXPECT_NE(-1, ret) + TH_LOG("epoll_create1 failed?"); + + self->fd = ret; +} + +FIXTURE_TEARDOWN(epoll_busy_poll) +{ + int ret; + + ret = close(self->fd); + EXPECT_EQ(0, ret); +} + +TEST_F(epoll_busy_poll, test_get_params) +{ + /* begin by getting the epoll params from the kernel + * + * the default should be default and all fields should be zero'd by the + * kernel, so set params fields to garbage to test this. + */ + int ret = 0; + + self->params.busy_poll_usecs = 0xff; + self->params.busy_poll_budget = 0xff; + self->params.prefer_busy_poll = 1; + self->params.__pad = 0xf; + + ret = ioctl(self->fd, EPIOCGPARAMS, &self->params); + EXPECT_EQ(0, ret) + TH_LOG("ioctl EPIOCGPARAMS should succeed"); + + EXPECT_EQ(0, self->params.busy_poll_usecs) + TH_LOG("EPIOCGPARAMS busy_poll_usecs should have been 0"); + + EXPECT_EQ(0, self->params.busy_poll_budget) + TH_LOG("EPIOCGPARAMS busy_poll_budget should have been 0"); + + EXPECT_EQ(0, self->params.prefer_busy_poll) + TH_LOG("EPIOCGPARAMS prefer_busy_poll should have been 0"); + + EXPECT_EQ(0, self->params.__pad) + TH_LOG("EPIOCGPARAMS __pad should have been 0"); + + self->invalid_params = (struct epoll_params *)0xdeadbeef; + ret = ioctl(self->fd, EPIOCGPARAMS, self->invalid_params); + + EXPECT_EQ(-1, ret) + TH_LOG("EPIOCGPARAMS should error with invalid params"); + + EXPECT_EQ(EFAULT, errno) + TH_LOG("EPIOCGPARAMS with invalid params should set errno to EFAULT"); +} + +TEST_F(epoll_busy_poll, test_set_invalid) +{ + int ret; + + memset(&self->params, 0, sizeof(struct epoll_params)); + + self->params.__pad = 1; + + ret = ioctl(self->fd, EPIOCSPARAMS, &self->params); + + EXPECT_EQ(-1, ret) + TH_LOG("EPIOCSPARAMS non-zero __pad should error"); + + EXPECT_EQ(EINVAL, errno) + TH_LOG("EPIOCSPARAMS non-zero __pad errno should be EINVAL"); + + self->params.__pad = 0; + self->params.busy_poll_usecs = (unsigned int)INT_MAX + 1; + + ret = ioctl(self->fd, EPIOCSPARAMS, &self->params); + + EXPECT_EQ(-1, ret) + TH_LOG("EPIOCSPARAMS should error busy_poll_usecs > S32_MAX"); + + EXPECT_EQ(EINVAL, errno) + TH_LOG("EPIOCSPARAMS busy_poll_usecs > S32_MAX errno should be EINVAL"); + + self->params.__pad = 0; + self->params.busy_poll_usecs = 32; + self->params.prefer_busy_poll = 2; + + ret = ioctl(self->fd, EPIOCSPARAMS, &self->params); + + EXPECT_EQ(-1, ret) + TH_LOG("EPIOCSPARAMS should error prefer_busy_poll > 1"); + + EXPECT_EQ(EINVAL, errno) + TH_LOG("EPIOCSPARAMS prefer_busy_poll > 1 errno should be EINVAL"); + + self->params.__pad = 0; + self->params.busy_poll_usecs = 32; + self->params.prefer_busy_poll = 1; + + /* set budget well above kernel's NAPI_POLL_WEIGHT of 64 */ + self->params.busy_poll_budget = 65535; + + ret = ioctl(self->fd, EPIOCSPARAMS, &self->params); + + EXPECT_EQ(-1, ret) + TH_LOG("EPIOCSPARAMS should error busy_poll_budget > NAPI_POLL_WEIGHT"); + + EXPECT_EQ(EPERM, errno) + TH_LOG("EPIOCSPARAMS errno should be EPERM busy_poll_budget > NAPI_POLL_WEIGHT"); + + self->invalid_params = (struct epoll_params *)0xdeadbeef; + ret = ioctl(self->fd, EPIOCSPARAMS, self->invalid_params); + + EXPECT_EQ(-1, ret) + TH_LOG("EPIOCSPARAMS should error when epoll_params is invalid"); + + EXPECT_EQ(EFAULT, errno) + TH_LOG("EPIOCSPARAMS should set errno to EFAULT when epoll_params is invalid"); +} + +TEST_F(epoll_busy_poll, test_set_and_get_valid) +{ + int ret; + + memset(&self->params, 0, sizeof(struct epoll_params)); + + self->params.busy_poll_usecs = 25; + self->params.busy_poll_budget = 16; + self->params.prefer_busy_poll = 1; + + ret = ioctl(self->fd, EPIOCSPARAMS, &self->params); + + EXPECT_EQ(0, ret) + TH_LOG("EPIOCSPARAMS with valid params should not error"); + + /* check that the kernel returns the same values back */ + + memset(&self->params, 0, sizeof(struct epoll_params)); + + ret = ioctl(self->fd, EPIOCGPARAMS, &self->params); + + EXPECT_EQ(0, ret) + TH_LOG("EPIOCGPARAMS should not error"); + + EXPECT_EQ(25, self->params.busy_poll_usecs) + TH_LOG("params.busy_poll_usecs incorrect"); + + EXPECT_EQ(16, self->params.busy_poll_budget) + TH_LOG("params.busy_poll_budget incorrect"); + + EXPECT_EQ(1, self->params.prefer_busy_poll) + TH_LOG("params.prefer_busy_poll incorrect"); + + EXPECT_EQ(0, self->params.__pad) + TH_LOG("params.__pad was not 0"); +} + +TEST_F(epoll_busy_poll, test_invalid_ioctl) +{ + int invalid_ioctl = EPIOCGPARAMS + 10; + int ret; + + ret = ioctl(self->fd, invalid_ioctl, &self->params); + + EXPECT_EQ(-1, ret) + TH_LOG("invalid ioctl should return error"); + + EXPECT_EQ(EINVAL, errno) + TH_LOG("invalid ioctl should set errno to EINVAL"); +} + +TEST_HARNESS_MAIN -- 2.25.1

1 year, 3 months

2
3
0 0

[PATCH v2] selftests: exec: make binaries position independent

by Muhammad Usama Anjum

The -static overrides the -pie and binaries aren't position independent anymore. Use -static-pie instead which would produce a static and position independent binary. This has been caught by clang's warnings: clang: warning: argument unused during compilation: '-pie' [-Wunused-command-line-argument] Tested with both gcc and clang after this change. Fixes: 4d1cd3b2c5c1 ("tools/testing/selftests/exec: fix link error") Signed-off-by: Muhammad Usama Anjum <usama.anjum(a)collabora.com> --- Changes since v1: - Remove unneeded comment --- tools/testing/selftests/exec/Makefile | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tools/testing/selftests/exec/Makefile b/tools/testing/selftests/exec/Makefile index fb4472ddffd81..3c79ec9bf780f 100644 --- a/tools/testing/selftests/exec/Makefile +++ b/tools/testing/selftests/exec/Makefile @@ -29,8 +29,8 @@ $(OUTPUT)/execveat.denatured: $(OUTPUT)/execveat cp $< $@ chmod -x $@ $(OUTPUT)/load_address_4096: load_address.c - $(CC) $(CFLAGS) $(LDFLAGS) -Wl,-z,max-page-size=0x1000 -pie -static $< -o $@ + $(CC) $(CFLAGS) $(LDFLAGS) -Wl,-z,max-page-size=0x1000 -static-pie $< -o $@ $(OUTPUT)/load_address_2097152: load_address.c - $(CC) $(CFLAGS) $(LDFLAGS) -Wl,-z,max-page-size=0x200000 -pie -static $< -o $@ + $(CC) $(CFLAGS) $(LDFLAGS) -Wl,-z,max-page-size=0x200000 -static-pie $< -o $@ $(OUTPUT)/load_address_16777216: load_address.c - $(CC) $(CFLAGS) $(LDFLAGS) -Wl,-z,max-page-size=0x1000000 -pie -static $< -o $@ + $(CC) $(CFLAGS) $(LDFLAGS) -Wl,-z,max-page-size=0x1000000 -static-pie $< -o $@ -- 2.39.2

1 year, 3 months

4
5
0 0

[PATCH v3] selftests/vDSO: Explicit unsigned char conversion for elf_hash

by Edward Liaw

Fixes clang compilation warnings by adding explicit unsigned conversion: parse_vdso.c:206:22: warning: passing 'const char *' to parameter of type 'const unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign] ver_hash = elf_hash(version); ^~~~~~~ parse_vdso.c:59:52: note: passing argument to parameter 'name' here static unsigned long elf_hash(const unsigned char *name) ^ parse_vdso.c:207:46: warning: passing 'const char *' to parameter of type 'const unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign] ELF(Word) chain = vdso_info.bucket[elf_hash(name) % vdso_info.nbucket]; ^~~~ parse_vdso.c:59:52: note: passing argument to parameter 'name' here static unsigned long elf_hash(const unsigned char *name) Fixes: 98eedc3a9dbf ("Document the vDSO and add a reference parser") Signed-off-by: Edward Liaw <edliaw(a)google.com> --- v2: update commit message with correct compiler warning v3: fix checkpatch errors and indentation --- tools/testing/selftests/vDSO/parse_vdso.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/vDSO/parse_vdso.c b/tools/testing/selftests/vDSO/parse_vdso.c index 413f75620a35..9e29ff0657ea 100644 --- a/tools/testing/selftests/vDSO/parse_vdso.c +++ b/tools/testing/selftests/vDSO/parse_vdso.c @@ -203,8 +203,9 @@ void *vdso_sym(const char *version, const char *name) if (!vdso_info.valid) return 0; - ver_hash = elf_hash(version); - ELF(Word) chain = vdso_info.bucket[elf_hash(name) % vdso_info.nbucket]; + ver_hash = elf_hash((const unsigned char *)version); + ELF(Word) chain = vdso_info.bucket[ + elf_hash((const unsigned char *)name) % vdso_info.nbucket]; for (; chain != STN_UNDEF; chain = vdso_info.chain[chain]) { ELF(Sym) *sym = &vdso_info.symtab[chain]; -- 2.45.0.rc0.197.gbae5840b3b-goog

1 year, 3 months

3
7
0 0

[PATCH bpf-next v3] selftests/bpf: Move test_dev_cgroup to prog_tests

by Muhammad Usama Anjum

Move test_dev_cgroup.c to prog_tests/dev_cgroup.c to be able to run it with test_progs. Replace dev_cgroup.bpf.o with skel header file, dev_cgroup.skel.h and load program from it accourdingly. ./test_progs -t dev_cgroup mknod: /tmp/test_dev_cgroup_null: Operation not permitted 64+0 records in 64+0 records out 32768 bytes (33 kB, 32 KiB) copied, 0.000856684 s, 38.2 MB/s dd: failed to open '/dev/full': Operation not permitted dd: failed to open '/dev/random': Operation not permitted #72 test_dev_cgroup:OK Summary: 1/0 PASSED, 0 SKIPPED, 0 FAILED Signed-off-by: Muhammad Usama Anjum <usama.anjum(a)collabora.com> --- Changes since v2: - Replace test_dev_cgroup with serial_test_dev_cgroup as there is probability that the test is racing against another cgroup test - Minor changes to the commit message above I've tested the patch with vmtest.sh on bpf-next/for-next and linux next. It is passing on both. Not sure why it was failed on BPFCI. Test run with vmtest.h: sudo LDLIBS=-static PKG_CONFIG='pkg-config --static' ./vmtest.sh ./test_progs -t dev_cgroup ./test_progs -t dev_cgroup mknod: /tmp/test_dev_cgroup_null: Operation not permitted 64+0 records in 64+0 records out 32768 bytes (33 kB, 32 KiB) copied, 0.000403432 s, 81.2 MB/s dd: failed to open '/dev/full': Operation not permitted dd: failed to open '/dev/random': Operation not permitted #69 dev_cgroup:OK Summary: 1/0 PASSED, 0 SKIPPED, 0 FAILED Changes since v1: - Rename file from test_dev_cgroup.c to dev_cgroup.c - Use ASSERT_* in-place of CHECK --- .../selftests/bpf/prog_tests/dev_cgroup.c | 58 +++++++++++++ tools/testing/selftests/bpf/test_dev_cgroup.c | 85 ------------------- 2 files changed, 58 insertions(+), 85 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/dev_cgroup.c delete mode 100644 tools/testing/selftests/bpf/test_dev_cgroup.c diff --git a/tools/testing/selftests/bpf/prog_tests/dev_cgroup.c b/tools/testing/selftests/bpf/prog_tests/dev_cgroup.c new file mode 100644 index 0000000000000..da0bc209d6a21 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/dev_cgroup.c @@ -0,0 +1,58 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* Copyright (c) 2017 Facebook + */ + +#include <test_progs.h> +#include <time.h> +#include "cgroup_helpers.h" +#include "dev_cgroup.skel.h" + +#define TEST_CGROUP "/test-bpf-based-device-cgroup/" + +void serial_test_dev_cgroup(void) +{ + struct dev_cgroup *skel; + int cgroup_fd, err; + __u32 prog_cnt; + + skel = dev_cgroup__open_and_load(); + if (!ASSERT_OK_PTR(skel, "skel_open_and_load")) + goto cleanup; + + cgroup_fd = cgroup_setup_and_join(TEST_CGROUP); + if (!ASSERT_GT(cgroup_fd, 0, "cgroup_setup_and_join")) + goto cleanup; + + err = bpf_prog_attach(bpf_program__fd(skel->progs.bpf_prog1), cgroup_fd, + BPF_CGROUP_DEVICE, 0); + if (!ASSERT_EQ(err, 0, "bpf_attach")) + goto cleanup; + + err = bpf_prog_query(cgroup_fd, BPF_CGROUP_DEVICE, 0, NULL, NULL, &prog_cnt); + if (!ASSERT_EQ(err, 0, "bpf_query") || (!ASSERT_EQ(prog_cnt, 1, "bpf_query"))) + goto cleanup; + + /* All operations with /dev/zero and /dev/urandom are allowed, + * everything else is forbidden. + */ + ASSERT_EQ(system("rm -f /tmp/test_dev_cgroup_null"), 0, "rm"); + ASSERT_NEQ(system("mknod /tmp/test_dev_cgroup_null c 1 3"), 0, "mknod"); + ASSERT_EQ(system("rm -f /tmp/test_dev_cgroup_null"), 0, "rm"); + + /* /dev/zero is whitelisted */ + ASSERT_EQ(system("rm -f /tmp/test_dev_cgroup_zero"), 0, "rm"); + ASSERT_EQ(system("mknod /tmp/test_dev_cgroup_zero c 1 5"), 0, "mknod"); + ASSERT_EQ(system("rm -f /tmp/test_dev_cgroup_zero"), 0, "rm"); + + ASSERT_EQ(system("dd if=/dev/urandom of=/dev/zero count=64"), 0, "dd"); + + /* src is allowed, target is forbidden */ + ASSERT_NEQ(system("dd if=/dev/urandom of=/dev/full count=64"), 0, "dd"); + + /* src is forbidden, target is allowed */ + ASSERT_NEQ(system("dd if=/dev/random of=/dev/zero count=64"), 0, "dd"); + +cleanup: + cleanup_cgroup_environment(); + dev_cgroup__destroy(skel); +} diff --git a/tools/testing/selftests/bpf/test_dev_cgroup.c b/tools/testing/selftests/bpf/test_dev_cgroup.c deleted file mode 100644 index adeaf63cb6fa3..0000000000000 --- a/tools/testing/selftests/bpf/test_dev_cgroup.c +++ /dev/null @@ -1,85 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only -/* Copyright (c) 2017 Facebook - */ - -#include <stdio.h> -#include <stdlib.h> -#include <string.h> -#include <errno.h> -#include <assert.h> -#include <sys/time.h> - -#include <linux/bpf.h> -#include <bpf/bpf.h> -#include <bpf/libbpf.h> - -#include "cgroup_helpers.h" -#include "testing_helpers.h" - -#define DEV_CGROUP_PROG "./dev_cgroup.bpf.o" - -#define TEST_CGROUP "/test-bpf-based-device-cgroup/" - -int main(int argc, char **argv) -{ - struct bpf_object *obj; - int error = EXIT_FAILURE; - int prog_fd, cgroup_fd; - __u32 prog_cnt; - - /* Use libbpf 1.0 API mode */ - libbpf_set_strict_mode(LIBBPF_STRICT_ALL); - - if (bpf_prog_test_load(DEV_CGROUP_PROG, BPF_PROG_TYPE_CGROUP_DEVICE, - &obj, &prog_fd)) { - printf("Failed to load DEV_CGROUP program\n"); - goto out; - } - - cgroup_fd = cgroup_setup_and_join(TEST_CGROUP); - if (cgroup_fd < 0) { - printf("Failed to create test cgroup\n"); - goto out; - } - - /* Attach bpf program */ - if (bpf_prog_attach(prog_fd, cgroup_fd, BPF_CGROUP_DEVICE, 0)) { - printf("Failed to attach DEV_CGROUP program"); - goto err; - } - - if (bpf_prog_query(cgroup_fd, BPF_CGROUP_DEVICE, 0, NULL, NULL, - &prog_cnt)) { - printf("Failed to query attached programs"); - goto err; - } - - /* All operations with /dev/zero and and /dev/urandom are allowed, - * everything else is forbidden. - */ - assert(system("rm -f /tmp/test_dev_cgroup_null") == 0); - assert(system("mknod /tmp/test_dev_cgroup_null c 1 3")); - assert(system("rm -f /tmp/test_dev_cgroup_null") == 0); - - /* /dev/zero is whitelisted */ - assert(system("rm -f /tmp/test_dev_cgroup_zero") == 0); - assert(system("mknod /tmp/test_dev_cgroup_zero c 1 5") == 0); - assert(system("rm -f /tmp/test_dev_cgroup_zero") == 0); - - assert(system("dd if=/dev/urandom of=/dev/zero count=64") == 0); - - /* src is allowed, target is forbidden */ - assert(system("dd if=/dev/urandom of=/dev/full count=64")); - - /* src is forbidden, target is allowed */ - assert(system("dd if=/dev/random of=/dev/zero count=64")); - - error = 0; - printf("test_dev_cgroup:PASS\n"); - -err: - cleanup_cgroup_environment(); - -out: - return error; -} -- 2.39.2

1 year, 3 months

2
7
0 0

[PATCH v2] bpftool, selftests/hid/bpf: fix 29 clang warnings

by John Hubbard

When building either tools/bpf/bpftool, or tools/testing/selftests/hid, (the same Makefile is used for these), clang generates many instances of the following: "clang: warning: -lLLVM-17: 'linker' input unused" Quentin points out that the LLVM version is only required in $(LIBS), not in $(CFLAGS), so the fix is to remove it from CFLAGS. Suggested-by: Quentin Monnet <qmo(a)kernel.org> Signed-off-by: John Hubbard <jhubbard(a)nvidia.com> --- tools/bpf/bpftool/Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/bpf/bpftool/Makefile b/tools/bpf/bpftool/Makefile index e9154ace80ff..a5445a422109 100644 --- a/tools/bpf/bpftool/Makefile +++ b/tools/bpf/bpftool/Makefile @@ -143,7 +143,7 @@ ifeq ($(feature-llvm),1) # If LLVM is available, use it for JIT disassembly CFLAGS += -DHAVE_LLVM_SUPPORT LLVM_CONFIG_LIB_COMPONENTS := mcdisassembler all-targets - CFLAGS += $(shell $(LLVM_CONFIG) --cflags --libs $(LLVM_CONFIG_LIB_COMPONENTS)) + CFLAGS += $(shell $(LLVM_CONFIG) --cflags) LIBS += $(shell $(LLVM_CONFIG) --libs $(LLVM_CONFIG_LIB_COMPONENTS)) ifeq ($(shell $(LLVM_CONFIG) --shared-mode),static) LIBS += $(shell $(LLVM_CONFIG) --system-libs $(LLVM_CONFIG_LIB_COMPONENTS)) base-commit: f462ae0edd3703edd6f22fe41d336369c38b884b prerequisite-patch-id: b901ece2a5b78503e2fb5480f20e304d36a0ea27 -- 2.45.0

1 year, 3 months

3
2
0 0

[PATCH] selftests/exec: build with -fPIE instead of -pie, to make clang happy

by John Hubbard

clang doesn't deal well with "-pie -static": it warns that -pie is an unused option here. Changing to "-fPIE -static" solves this problem for clang, while keeping the gcc results identical. The problem is visible when building via: make LLVM=1 -C tools/testing/selftests Again: gcc 13 produces identical binaries for all of these programs, both before and after this commit (using "-pie"), and after (using "-fPIE"). Also, the runtime results are the same for both clang and gcc builds. Signed-off-by: John Hubbard <jhubbard(a)nvidia.com> --- tools/testing/selftests/exec/Makefile | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tools/testing/selftests/exec/Makefile b/tools/testing/selftests/exec/Makefile index fb4472ddffd8..b7b54d442378 100644 --- a/tools/testing/selftests/exec/Makefile +++ b/tools/testing/selftests/exec/Makefile @@ -29,8 +29,8 @@ $(OUTPUT)/execveat.denatured: $(OUTPUT)/execveat cp $< $@ chmod -x $@ $(OUTPUT)/load_address_4096: load_address.c - $(CC) $(CFLAGS) $(LDFLAGS) -Wl,-z,max-page-size=0x1000 -pie -static $< -o $@ + $(CC) $(CFLAGS) $(LDFLAGS) -Wl,-z,max-page-size=0x1000 -fPIE -static $< -o $@ $(OUTPUT)/load_address_2097152: load_address.c - $(CC) $(CFLAGS) $(LDFLAGS) -Wl,-z,max-page-size=0x200000 -pie -static $< -o $@ + $(CC) $(CFLAGS) $(LDFLAGS) -Wl,-z,max-page-size=0x200000 -fPIE -static $< -o $@ $(OUTPUT)/load_address_16777216: load_address.c - $(CC) $(CFLAGS) $(LDFLAGS) -Wl,-z,max-page-size=0x1000000 -pie -static $< -o $@ + $(CC) $(CFLAGS) $(LDFLAGS) -Wl,-z,max-page-size=0x1000000 -fPIE -static $< -o $@ base-commit: ddb4c3f25b7b95df3d6932db0b379d768a6ebdf7 prerequisite-patch-id: b901ece2a5b78503e2fb5480f20e304d36a0ea27 -- 2.45.0

1 year, 3 months

2
2
0 0

[PATCH 1/2] selftests/net: suppress clang's "variable-sized type not at the end" warning

by John Hubbard

When building with clang, via: make LLVM=1 -C tools/testing/selftest ...clang warns that "a variable sized type not at the end of a struct or class is a GNU extension". These cases are not easily changed, because they involve structs that are part of the API. Fortunately, however, the tests seem to be doing just fine (specifically, neither affected test runs any differently with gcc vs. clang builds, on my test system) regardless of the warning. So, all the warning is doing is preventing a clean build of selftests/net. Fix this by suppressing this particular clang warning for the selftests/net suite. Signed-off-by: John Hubbard <jhubbard(a)nvidia.com> --- tools/testing/selftests/net/Makefile | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tools/testing/selftests/net/Makefile b/tools/testing/selftests/net/Makefile index 7b6918d5f4af..956481174783 100644 --- a/tools/testing/selftests/net/Makefile +++ b/tools/testing/selftests/net/Makefile @@ -6,6 +6,10 @@ CFLAGS += -I../../../../usr/include/ $(KHDR_INCLUDES) # Additional include paths needed by kselftest.h CFLAGS += -I../ +ifneq ($(LLVM),) + CFLAGS += -Wno-gnu-variable-sized-type-not-at-end +endif + TEST_PROGS := run_netsocktests run_afpackettests test_bpf.sh netdevice.sh \ rtnetlink.sh xfrm_policy.sh test_blackhole_dev.sh TEST_PROGS += fib_tests.sh fib-onlink-tests.sh pmtu.sh udpgso.sh ip_defrag.sh base-commit: f462ae0edd3703edd6f22fe41d336369c38b884b prerequisite-patch-id: b901ece2a5b78503e2fb5480f20e304d36a0ea27 -- 2.45.0

1 year, 3 months

3
4
0 0

[PATCH v2] selftests/netfilter: return a value for several "int" functions

by John Hubbard

When building with clang, via: make LLVM=1 -C tools/testing/selftests ...clang warns, correctly, that several functions declared with an "int" return type are not always returning values in all cases (or at least, clang cannot prove that they always return a value). Fix this by returning an appropriate value for each function. Thanks to Felix Huettner for recommending MNL_CB_OK (which is non-zero) for the return value of the count_entries() callback. Cc: Felix Huettner <felix.huettner(a)mail.schwarz> Signed-off-by: John Hubbard <jhubbard(a)nvidia.com> --- tools/testing/selftests/netfilter/conntrack_dump_flush.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tools/testing/selftests/netfilter/conntrack_dump_flush.c b/tools/testing/selftests/netfilter/conntrack_dump_flush.c index b11ea8ee6719..e9df4ae14e16 100644 --- a/tools/testing/selftests/netfilter/conntrack_dump_flush.c +++ b/tools/testing/selftests/netfilter/conntrack_dump_flush.c @@ -43,6 +43,7 @@ static int build_cta_tuple_v4(struct nlmsghdr *nlh, int type, mnl_attr_nest_end(nlh, nest_proto); mnl_attr_nest_end(nlh, nest); + return 0; } static int build_cta_tuple_v6(struct nlmsghdr *nlh, int type, @@ -71,6 +72,7 @@ static int build_cta_tuple_v6(struct nlmsghdr *nlh, int type, mnl_attr_nest_end(nlh, nest_proto); mnl_attr_nest_end(nlh, nest); + return 0; } static int build_cta_proto(struct nlmsghdr *nlh) @@ -90,6 +92,7 @@ static int build_cta_proto(struct nlmsghdr *nlh) mnl_attr_nest_end(nlh, nest_proto); mnl_attr_nest_end(nlh, nest); + return 0; } static int conntrack_data_insert(struct mnl_socket *sock, struct nlmsghdr *nlh, @@ -207,6 +210,7 @@ static int conntrack_data_generate_v6(struct mnl_socket *sock, static int count_entries(const struct nlmsghdr *nlh, void *data) { reply_counter++; + return MNL_CB_OK; } static int conntracK_count_zone(struct mnl_socket *sock, uint16_t zone) base-commit: f462ae0edd3703edd6f22fe41d336369c38b884b prerequisite-patch-id: b901ece2a5b78503e2fb5480f20e304d36a0ea27 prerequisite-patch-id: 9db2d20be98dc44731d8605a3da64ff118d2546d -- 2.45.0

1 year, 3 months

1
0
0 0

Re: [PATCH 2/2] selftests/netfilter: return a value for several "int" functions

by John Hubbard

On 5/6/24 7:41 AM, Felix Huettner wrote: > On Sun, May 05, 2024 at 02:47:16PM -0700, John Hubbard wrote: ... > > @@ -207,6 +210,7 @@ static int conntrack_data_generate_v6(struct > mnl_socket *sock, > > static int count_entries(const struct nlmsghdr *nlh, void *data) > > { > > reply_counter++; > > + return 0; > > Hi John, > > This will need to return MNL_CB_OK. > Otherwise mnl_cb_run below will abort early and the connection count > will be wrong. > Thanks for catching that, I'm sending a v2 with that fix. I was thinking about it, and expected that the pre-existing code appeared to work because the return value was some non-zero garbage value scrounged off of the stack (or %rax, for example on x86). However, just a quick test showed that *any* value (O, 1==MNL_CB_OK, or no value at all) allows the test to report success...oh, I see, it's reporting PASSED when it really ought to say SKIPPED: $ ./conntrack_dump_flush TAP version 13 1..3 # Starting 3 tests from 1 test cases. # RUN conntrack_dump_flush.test_dump_by_zone ... mnl_socket_open: Protocol not supported # OK conntrack_dump_flush.test_dump_by_zone ok 1 conntrack_dump_flush.test_dump_by_zone # RUN conntrack_dump_flush.test_flush_by_zone ... mnl_socket_open: Protocol not supported # OK conntrack_dump_flush.test_flush_by_zone ok 2 conntrack_dump_flush.test_flush_by_zone # RUN conntrack_dump_flush.test_flush_by_zone_default ... mnl_socket_open: Protocol not supported # OK conntrack_dump_flush.test_flush_by_zone_default ok 3 conntrack_dump_flush.test_flush_by_zone_default # PASSED: 3 / 3 tests passed. # Totals: pass:3 fail:0 xfail:0 xpass:0 skip:0 error:0 As long as we are looking at this, what do you think about this: diff --git a/tools/testing/selftests/netfilter/conntrack_dump_flush.c b/tools/testing/selftests/netfilter/conntrack_dump_flush.c index e9df4ae14e16..4a73afad4de4 100644 --- a/tools/testing/selftests/netfilter/conntrack_dump_flush.c +++ b/tools/testing/selftests/netfilter/conntrack_dump_flush.c @@ -317,12 +317,12 @@ FIXTURE_SETUP(conntrack_dump_flush) self->sock = mnl_socket_open(NETLINK_NETFILTER); if (!self->sock) { perror("mnl_socket_open"); - exit(EXIT_FAILURE); + SKIP(exit(EXIT_FAILURE), "mnl_socket_open() failed"); } if (mnl_socket_bind(self->sock, 0, MNL_SOCKET_AUTOPID) < 0) { perror("mnl_socket_bind"); - exit(EXIT_FAILURE); + SKIP(exit(EXIT_FAILURE), "mnl_socket_bind() failed"); } ret = conntracK_count_zone(self->sock, TEST_ZONE_ID); ...which changes the above output, to: $ ./conntrack_dump_flush TAP version 13 1..3 # Starting 3 tests from 1 test cases. # RUN conntrack_dump_flush.test_dump_by_zone ... mnl_socket_open: Protocol not supported # SKIP mnl_socket_open() failed # OK conntrack_dump_flush.test_dump_by_zone ok 1 conntrack_dump_flush.test_dump_by_zone # SKIP mnl_socket_open() failed # RUN conntrack_dump_flush.test_flush_by_zone ... mnl_socket_open: Protocol not supported # SKIP mnl_socket_open() failed # OK conntrack_dump_flush.test_flush_by_zone ok 2 conntrack_dump_flush.test_flush_by_zone # SKIP mnl_socket_open() failed # RUN conntrack_dump_flush.test_flush_by_zone_default ... mnl_socket_open: Protocol not supported # SKIP mnl_socket_open() failed # OK conntrack_dump_flush.test_flush_by_zone_default ok 3 conntrack_dump_flush.test_flush_by_zone_default # SKIP mnl_socket_open() failed # PASSED: 3 / 3 tests passed. # Totals: pass:0 fail:0 xfail:0 xpass:0 skip:3 error:0 ? thanks, -- John Hubbard NVIDIA

1 year, 3 months

1
0
0 0

[PATCH v4] selftests/vDSO: change elf_hash parameter to signed char

by Edward Liaw

Fixes clang compilation warnings by changing elf_hash's parameter type to char * and casting to unsigned char * inside elf_hash: parse_vdso.c:206:22: warning: passing 'const char *' to parameter of type 'const unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign] ver_hash = elf_hash(version); ^~~~~~~ parse_vdso.c:59:52: note: passing argument to parameter 'name' here static unsigned long elf_hash(const unsigned char *name) ^ parse_vdso.c:207:46: warning: passing 'const char *' to parameter of type 'const unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign] ELF(Word) chain = vdso_info.bucket[elf_hash(name) % vdso_info.nbucket]; ^~~~ parse_vdso.c:59:52: note: passing argument to parameter 'name' here static unsigned long elf_hash(const unsigned char *name) Fixes: 98eedc3a9dbf ("Document the vDSO and add a reference parser") Signed-off-by: Edward Liaw <edliaw(a)google.com> --- v2: updated commit message with correct compiler warning v3: fixed checkpatch errors and indentation https://lore.kernel.org/all/20240501180622.1676340-1-edliaw@google.com/ v4: moved the typecast into elf_hash based on libelf https://sourceforge.net/p/elftoolchain/code/HEAD/tree/trunk/libelf/elf_hash… --- tools/testing/selftests/vDSO/parse_vdso.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/tools/testing/selftests/vDSO/parse_vdso.c b/tools/testing/selftests/vDSO/parse_vdso.c index 413f75620a35..33db8abd7d59 100644 --- a/tools/testing/selftests/vDSO/parse_vdso.c +++ b/tools/testing/selftests/vDSO/parse_vdso.c @@ -56,12 +56,15 @@ static struct vdso_info } vdso_info; /* Straight from the ELF specification. */ -static unsigned long elf_hash(const unsigned char *name) +static unsigned long elf_hash(const char *name) { unsigned long h = 0, g; - while (*name) + const unsigned char *s; + + s = (const unsigned char *) name; + while (*s) { - h = (h << 4) + *name++; + h = (h << 4) + *s++; if (g = h & 0xf0000000) h ^= g >> 24; h &= ~g; -- 2.45.0.rc1.225.g2a3ae87e7f-goog

1 year, 3 months

1
0
0 0

[PATCH v2] selftests/alsa: missing a return value in unused dump_config_tree()

by John Hubbard

dump_config_tree() is declared to return an int, but the compiler cannot prove that it always returns any value at all. This leads to a clang warning, when building via: make LLVM=1 -C tools/testing/selftests Furthermore, Mark Brown noticed that dump_config_tree() isn't even used anymore, so just delete the entire function. Cc: Mark Brown <broonie(a)kernel.org> Signed-off-by: John Hubbard <jhubbard(a)nvidia.com> --- tools/testing/selftests/alsa/conf.c | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/tools/testing/selftests/alsa/conf.c b/tools/testing/selftests/alsa/conf.c index 89e3656a042d..357561c1759b 100644 --- a/tools/testing/selftests/alsa/conf.c +++ b/tools/testing/selftests/alsa/conf.c @@ -105,19 +105,6 @@ static struct card_cfg_data *conf_data_by_card(int card, bool msg) return NULL; } -static int dump_config_tree(snd_config_t *top) -{ - snd_output_t *out; - int err; - - err = snd_output_stdio_attach(&out, stdout, 0); - if (err < 0) - ksft_exit_fail_msg("stdout attach\n"); - if (snd_config_save(top, out)) - ksft_exit_fail_msg("config save\n"); - snd_output_close(out); -} - snd_config_t *conf_load_from_file(const char *filename) { snd_config_t *dst; base-commit: f462ae0edd3703edd6f22fe41d336369c38b884b prerequisite-patch-id: b901ece2a5b78503e2fb5480f20e304d36a0ea27 -- 2.45.0

1 year, 3 months

4
6
0 0

[PATCH] selftests/resctrl: fix clang build warnings related to abs(), labs() calls

by John Hubbard

First of all, in order to build with clang at all, one must first apply Valentin Obst's build fix for LLVM [1]. Furthermore, for this particular resctrl directory, my pending fix [2] must also be applied. Once those fixes are in place, then when building with clang, via: make LLVM=1 -C tools/testing/selftests ...two types of warnings occur: warning: absolute value function 'abs' given an argument of type 'long' but has parameter of type 'int' which may cause truncation of value warning: taking the absolute value of unsigned type 'unsigned long' has no effect Fix these by: a) using labs() in place of abs(), when long integers are involved, and b) don't call labs() unnecessarily. [1] https://lore.kernel.org/all/20240329-selftests-libmk-llvm-rfc-v1-1-2f9ed7d1… [2] https://lore.kernel.org/all/20240503021712.78601-1-jhubbard@nvidia.com/ Signed-off-by: John Hubbard <jhubbard(a)nvidia.com> --- tools/testing/selftests/resctrl/cmt_test.c | 4 ++-- tools/testing/selftests/resctrl/mba_test.c | 2 +- tools/testing/selftests/resctrl/mbm_test.c | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tools/testing/selftests/resctrl/cmt_test.c b/tools/testing/selftests/resctrl/cmt_test.c index a81f91222a89..05a241519ae8 100644 --- a/tools/testing/selftests/resctrl/cmt_test.c +++ b/tools/testing/selftests/resctrl/cmt_test.c @@ -40,11 +40,11 @@ static int show_results_info(unsigned long sum_llc_val, int no_of_bits, int ret; avg_llc_val = sum_llc_val / num_of_runs; - avg_diff = (long)abs(cache_span - avg_llc_val); + avg_diff = (long)(cache_span - avg_llc_val); diff_percent = ((float)cache_span - avg_llc_val) / cache_span * 100; ret = platform && abs((int)diff_percent) > max_diff_percent && - abs(avg_diff) > max_diff; + labs(avg_diff) > max_diff; ksft_print_msg("%s Check cache miss rate within %lu%%\n", ret ? "Fail:" : "Pass:", max_diff_percent); diff --git a/tools/testing/selftests/resctrl/mba_test.c b/tools/testing/selftests/resctrl/mba_test.c index 7946e32e85c8..673b2bb800f7 100644 --- a/tools/testing/selftests/resctrl/mba_test.c +++ b/tools/testing/selftests/resctrl/mba_test.c @@ -77,7 +77,7 @@ static bool show_mba_info(unsigned long *bw_imc, unsigned long *bw_resc) avg_bw_imc = sum_bw_imc / (NUM_OF_RUNS - 1); avg_bw_resc = sum_bw_resc / (NUM_OF_RUNS - 1); - avg_diff = (float)labs(avg_bw_resc - avg_bw_imc) / avg_bw_imc; + avg_diff = (float)(avg_bw_resc - avg_bw_imc) / avg_bw_imc; avg_diff_per = (int)(avg_diff * 100); ksft_print_msg("%s Check MBA diff within %d%% for schemata %u\n", diff --git a/tools/testing/selftests/resctrl/mbm_test.c b/tools/testing/selftests/resctrl/mbm_test.c index d67ffa3ec63a..c873793d016d 100644 --- a/tools/testing/selftests/resctrl/mbm_test.c +++ b/tools/testing/selftests/resctrl/mbm_test.c @@ -33,7 +33,7 @@ show_bw_info(unsigned long *bw_imc, unsigned long *bw_resc, size_t span) avg_bw_imc = sum_bw_imc / 4; avg_bw_resc = sum_bw_resc / 4; - avg_diff = (float)labs(avg_bw_resc - avg_bw_imc) / avg_bw_imc; + avg_diff = (float)(avg_bw_resc - avg_bw_imc) / avg_bw_imc; avg_diff_per = (int)(avg_diff * 100); ret = avg_diff_per > MAX_DIFF_PERCENT; base-commit: f03359bca01bf4372cf2c118cd9a987a5951b1c8 prerequisite-patch-id: b901ece2a5b78503e2fb5480f20e304d36a0ea27 prerequisite-patch-id: 8d96c4b8c3ed6d9ea2588ef7f594ae0f9f83c279 -- 2.45.0

1 year, 3 months

3
8
0 0

[PATCH v5 00/10] Fix Kselftest's vfork() side effects

by Mickaël Salaün

Hi, This fifth series fixes _metadata reset and fixes the last patch to handle code set with direct calls to _exit(). As reported by Kernel Test Robot [1], some pidfd tests fail. This is due to the use of vfork() which introduced some side effects. Similarly, while making it more generic, a previous commit made some Landlock file system tests flaky, and subject to the host's file system mount configuration. This series fixes all these side effects by replacing vfork() with clone3() and CLONE_VFORK, which is cleaner (no arbitrary shared memory) and makes the Kselftest framework more robust. I tried different approaches and I found this one to be the cleaner and less invasive for current test cases. I successfully ran the following tests (using TEST_F and fork/clone/clone3, and KVM_ONE_VCPU_TEST) with this series: - kvm:fix_hypercall_test - kvm:sync_regs_test - kvm:userspace_msr_exit_test - kvm:vmx_pmu_caps_test - landlock:fs_test - landlock:net_test - landlock:ptrace_test - move_mount_set_group:move_mount_set_group_test - net/af_unix:scm_pidfd - perf_events:remove_on_exec - pidfd:pidfd_getfd_test - pidfd:pidfd_setns_test - seccomp:seccomp_bpf - user_events:abi_test [1] https://lore.kernel.org/oe-lkp/202403291015.1fcfa957-oliver.sang@intel.com Previous versions: v1: https://lore.kernel.org/r/20240426172252.1862930-1-mic@digikod.net v2: https://lore.kernel.org/r/20240429130931.2394118-1-mic@digikod.net v3: https://lore.kernel.org/r/20240429191911.2552580-1-mic@digikod.net v4: https://lore.kernel.org/r/20240502210926.145539-1-mic@digikod.net Regards, Mickaël Salaün (10): selftests/pidfd: Fix config for pidfd_setns_test selftests/landlock: Fix FS tests when run on a private mount point selftests/harness: Fix fixture teardown selftests/harness: Fix interleaved scheduling leading to race conditions selftests/landlock: Do not allocate memory in fixture data selftests/harness: Constify fixture variants selftests/pidfd: Fix wrong expectation selftests/harness: Share _metadata between forked processes selftests/harness: Fix vfork() side effects selftests/harness: Handle TEST_F()'s explicit exit codes tools/testing/selftests/kselftest_harness.h | 122 +++++++++++++----- tools/testing/selftests/landlock/fs_test.c | 83 +++++++----- tools/testing/selftests/pidfd/config | 2 + .../selftests/pidfd/pidfd_setns_test.c | 2 +- 4 files changed, 143 insertions(+), 66 deletions(-) base-commit: e67572cd2204894179d89bd7b984072f19313b03 -- 2.45.0

1 year, 3 months

2
12
0 0

[PATCH] selftests/capabilities: fix warn_unused_result build warnings

by Amer Al Shanawany

Fix the following warnings by adding return check and error handling. test_execve.c: In function ‘do_tests’: test_execve.c:100:17: warning: ignoring return value of ‘capng_get_caps_process’ declared with attribute ‘warn_unused_result’ [-Wunused-result] 100 | capng_get_caps_process(); | ^~~~~~~~~~~~~~~~~~~~~~~~ validate_cap.c: In function ‘main’: validate_cap.c:47:9: warning: ignoring return value of ‘capng_get_caps_process’ declared with attribute ‘warn_unused_result’ [-Wunused-result] 47 | capng_get_caps_process(); | ^~~~~~~~~~~~~~~~~~~~~~~~ Signed-off-by: Amer Al Shanawany <amer.shanawany(a)gmail.com> --- tools/testing/selftests/capabilities/test_execve.c | 12 +++++++++--- tools/testing/selftests/capabilities/validate_cap.c | 7 ++++++- 2 files changed, 15 insertions(+), 4 deletions(-) diff --git a/tools/testing/selftests/capabilities/test_execve.c b/tools/testing/selftests/capabilities/test_execve.c index 7cde07a5df78..47bad7ddc5bc 100644 --- a/tools/testing/selftests/capabilities/test_execve.c +++ b/tools/testing/selftests/capabilities/test_execve.c @@ -82,7 +82,7 @@ static bool create_and_enter_ns(uid_t inner_uid) { uid_t outer_uid; gid_t outer_gid; - int i; + int i, ret; bool have_outer_privilege; outer_uid = getuid(); @@ -97,7 +97,10 @@ static bool create_and_enter_ns(uid_t inner_uid) ksft_exit_fail_msg("setresuid - %s\n", strerror(errno)); // Re-enable effective caps - capng_get_caps_process(); + ret = capng_get_caps_process(); + if (ret == -1) + ksft_exit_fail_msg("capng_get_caps_process failed\n"); + for (i = 0; i < CAP_LAST_CAP; i++) if (capng_have_capability(CAPNG_PERMITTED, i)) capng_update(CAPNG_ADD, CAPNG_EFFECTIVE, i); @@ -207,6 +210,7 @@ static void exec_validate_cap(bool eff, bool perm, bool inh, bool ambient) static int do_tests(int uid, const char *our_path) { + int ret; bool have_outer_privilege = create_and_enter_ns(uid); int ourpath_fd = open(our_path, O_RDONLY | O_DIRECTORY); @@ -250,7 +254,9 @@ static int do_tests(int uid, const char *our_path) ksft_exit_fail_msg("chmod - %s\n", strerror(errno)); } - capng_get_caps_process(); + ret = capng_get_caps_process(); + if (ret == -1) + ksft_exit_fail_msg("capng_get_caps_process failed\n"); /* Make sure that i starts out clear */ capng_update(CAPNG_DROP, CAPNG_INHERITABLE, CAP_NET_BIND_SERVICE); diff --git a/tools/testing/selftests/capabilities/validate_cap.c b/tools/testing/selftests/capabilities/validate_cap.c index 60b4e7b716a7..65f2a1c89239 100644 --- a/tools/testing/selftests/capabilities/validate_cap.c +++ b/tools/testing/selftests/capabilities/validate_cap.c @@ -28,6 +28,7 @@ static bool bool_arg(char **argv, int i) int main(int argc, char **argv) { const char *atsec = ""; + int ret; /* * Be careful just in case a setgid or setcapped copy of this @@ -44,7 +45,11 @@ int main(int argc, char **argv) atsec = " (AT_SECURE is not set)"; #endif - capng_get_caps_process(); + ret = capng_get_caps_process(); + if (ret == -1) { + ksft_print_msg("capng_get_caps_process failed\n"); + return 1; + } if (capng_have_capability(CAPNG_EFFECTIVE, CAP_NET_BIND_SERVICE) != bool_arg(argv, 1)) { ksft_print_msg("Wrong effective state%s\n", atsec); -- 2.43.0

1 year, 3 months

2
1
0 0

[PATCH] bpftool, selftests/hid/bpf: fix 29 clang warnings

by John Hubbard

When building either tools/bpf/bpftool, or tools/testing/selftests/hid, (the same Makefile is used for these), clang generates many instances of a warning that is useless here: "clang: warning: -lLLVM-17: 'linker' input unused" Silence this in both locations, by disabling that warning when building with clang. Signed-off-by: John Hubbard <jhubbard(a)nvidia.com> --- tools/bpf/bpftool/Makefile | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tools/bpf/bpftool/Makefile b/tools/bpf/bpftool/Makefile index e9154ace80ff..c7457921d136 100644 --- a/tools/bpf/bpftool/Makefile +++ b/tools/bpf/bpftool/Makefile @@ -133,6 +133,10 @@ CFLAGS += -DUSE_LIBCAP LIBS += -lcap endif +ifneq ($(LLVM),) + CFLAGS += -Wno-unused-command-line-argument +endif + include $(wildcard $(OUTPUT)*.d) all: $(OUTPUT)bpftool base-commit: f462ae0edd3703edd6f22fe41d336369c38b884b prerequisite-patch-id: b901ece2a5b78503e2fb5480f20e304d36a0ea27 -- 2.45.0

1 year, 3 months

2
3
0 0

[PATCH 1/2] selftests/netfilter: use socklen_t, not a signed int, for len

by John Hubbard

When building with clang, via: make LLVM=1 -C tools/testing/selftest ...clang warns about using "int *" interchangeably with "socklen_t *". clang is correct, so fix this by declaring len as a socklen_t, instead of as an int. Signed-off-by: John Hubbard <jhubbard(a)nvidia.com> --- tools/testing/selftests/netfilter/sctp_collision.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/testing/selftests/netfilter/sctp_collision.c b/tools/testing/selftests/netfilter/sctp_collision.c index 21bb1cfd8a85..91df996367e9 100644 --- a/tools/testing/selftests/netfilter/sctp_collision.c +++ b/tools/testing/selftests/netfilter/sctp_collision.c @@ -9,7 +9,8 @@ int main(int argc, char *argv[]) { struct sockaddr_in saddr = {}, daddr = {}; - int sd, ret, len = sizeof(daddr); + int sd, ret; + socklen_t len = sizeof(daddr); struct timeval tv = {25, 0}; char buf[] = "hello"; base-commit: f462ae0edd3703edd6f22fe41d336369c38b884b prerequisite-patch-id: b901ece2a5b78503e2fb5480f20e304d36a0ea27 -- 2.45.0

1 year, 3 months

1
1
0 0

[PATCH] selftests/user_events: silence a clang warning: address of packed member

by John Hubbard

When building with clang, via: make LLVM=1 -C tools/testing/selftest ...clang warns about "taking address of packed member 'write_index' ". This is not particularly helpful, because the test code really wants to write to exactly this location, and if it ends up being unaligned, then the test won't work (and may segfault, depending on the CPU type). If that ever comes up, it will be obvious and can be fixed. But all it's doing now is prevent a clean clang build, so disable the warning. Signed-off-by: John Hubbard <jhubbard(a)nvidia.com> --- tools/testing/selftests/user_events/Makefile | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tools/testing/selftests/user_events/Makefile b/tools/testing/selftests/user_events/Makefile index 10fcd0066203..617e94344711 100644 --- a/tools/testing/selftests/user_events/Makefile +++ b/tools/testing/selftests/user_events/Makefile @@ -1,5 +1,10 @@ # SPDX-License-Identifier: GPL-2.0 CFLAGS += -Wl,-no-as-needed -Wall $(KHDR_INCLUDES) + +ifneq ($(LLVM),) + CFLAGS += -Wno-address-of-packed-member +endif + LDLIBS += -lrt -lpthread -lm TEST_GEN_PROGS = ftrace_test dyn_test perf_test abi_test base-commit: f462ae0edd3703edd6f22fe41d336369c38b884b prerequisite-patch-id: b901ece2a5b78503e2fb5480f20e304d36a0ea27 -- 2.45.0

1 year, 3 months

1
0
0 0

[PATCH] selftests/timers: remove unused irqcount variable

by John Hubbard

When building with clang, via: make LLVM=1 -C tools/testing/selftest ...clang warns about an unused irqcount variable. clang is correct: the variable is incremented and then ignored. Fix this by deleting the irqcount variable. Signed-off-by: John Hubbard <jhubbard(a)nvidia.com> --- tools/testing/selftests/timers/rtcpie.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tools/testing/selftests/timers/rtcpie.c b/tools/testing/selftests/timers/rtcpie.c index 4ef2184f1558..7c07edd0d450 100644 --- a/tools/testing/selftests/timers/rtcpie.c +++ b/tools/testing/selftests/timers/rtcpie.c @@ -29,7 +29,7 @@ static const char default_rtc[] = "/dev/rtc0"; int main(int argc, char **argv) { - int i, fd, retval, irqcount = 0; + int i, fd, retval; unsigned long tmp, data, old_pie_rate; const char *rtc = default_rtc; struct timeval start, end, diff; @@ -120,7 +120,6 @@ int main(int argc, char **argv) fprintf(stderr, " %d",i); fflush(stderr); - irqcount++; } /* Disable periodic interrupts */ base-commit: f462ae0edd3703edd6f22fe41d336369c38b884b prerequisite-patch-id: b901ece2a5b78503e2fb5480f20e304d36a0ea27 -- 2.45.0

1 year, 3 months

1
0
0 0

[PATCH] selftests/alsa: fix a build warning: return a value in all cases

by John Hubbard

dump_config_tree() is declared to return an int, but the compiler cannot prove that it always returns any value at all. This leads to a clang warning, when building via: make LLVM=1 -C tools/testing/selftests Fix this by unconditionally returning the "err" variable if the code reaches the end of the function. Signed-off-by: John Hubbard <jhubbard(a)nvidia.com> --- tools/testing/selftests/alsa/conf.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tools/testing/selftests/alsa/conf.c b/tools/testing/selftests/alsa/conf.c index 89e3656a042d..0109fde53e6f 100644 --- a/tools/testing/selftests/alsa/conf.c +++ b/tools/testing/selftests/alsa/conf.c @@ -116,6 +116,8 @@ static int dump_config_tree(snd_config_t *top) if (snd_config_save(top, out)) ksft_exit_fail_msg("config save\n"); snd_output_close(out); + + return err; } snd_config_t *conf_load_from_file(const char *filename) base-commit: ddb4c3f25b7b95df3d6932db0b379d768a6ebdf7 prerequisite-patch-id: b901ece2a5b78503e2fb5480f20e304d36a0ea27 -- 2.45.0

1 year, 3 months

2
3
0 0

[PATCH net-next v2 0/2] Fix icmp error source address over xfrm tunnel

by Antony Antony

Hi, This fix, originally intended for XFRM/IPsec, has been recommended by Steffen Klassert to submit to the net tree. The patch addresses a minor issue related to the IPv4 source address of ICMP error messages, which originated from an old 2011 commit: 415b3334a21a ("icmp: Fix regression in nexthop resolution during replies.") The omission of a "Fixes" tag in the following commit is deliberate to prevent potential test failures and subsequent regression issues that may arise from backporting this patch all stable kerenels. This is a minor fix, anot not security fix. With a seleftest I am submitting this to net-next tree. v1->v2 : add kernel selftest script Antony Antony (2): xfrm: fix source address in icmp error generation from IPsec gateway selftests: add ICMP unreachable over IPsec tunnel net/ipv4/icmp.c | 1 - tools/testing/selftests/net/Makefile | 1 + tools/testing/selftests/net/xfrm_state.sh | 624 ++++++++++++++++++++++ 3 files changed, 625 insertions(+), 1 deletion(-) create mode 100755 tools/testing/selftests/net/xfrm_state.sh -- 2.30.2

1 year, 3 months

1
2
0 0

[PATCH] selftests: filesystems: add missing stddef header

by Amer Al Shanawany

fix compiler warning and errors when compiling statmount test. Signed-off-by: Amer Al Shanawany <amer.shanawany(a)gmail.com> --- tools/testing/selftests/filesystems/statmount/statmount_test.c | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/testing/selftests/filesystems/statmount/statmount_test.c b/tools/testing/selftests/filesystems/statmount/statmount_test.c index 3eafd7da58e2..e6d7c4f1c85b 100644 --- a/tools/testing/selftests/filesystems/statmount/statmount_test.c +++ b/tools/testing/selftests/filesystems/statmount/statmount_test.c @@ -3,6 +3,7 @@ #define _GNU_SOURCE #include <assert.h> +#include <stddef.h> #include <stdint.h> #include <sched.h> #include <fcntl.h> -- 2.34.1

1 year, 3 months

2
6
0 0

[PATCH] kunit: Cover 'assert.c' with tests

by Ivan Orlov

There are multiple assertion formatting functions in the `assert.c` file, which are not covered with tests yet. Implement the KUnit test for these functions. The test consists of 11 test cases for the following functions: 1) 'is_literal' 2) 'is_str_literal' 3) 'kunit_assert_prologue', test case for multiple assert types 4) 'kunit_assert_print_msg' 5) 'kunit_unary_assert_format' 6) 'kunit_ptr_not_err_assert_format' 7) 'kunit_binary_assert_format' 8) 'kunit_binary_ptr_assert_format' 9) 'kunit_binary_str_assert_format' 10) 'kunit_assert_hexdump' 11) 'kunit_mem_assert_format' The test aims at maximizing the branch coverage for the assertion formatting functions. As you can see, it covers some of the static helper functions as well, so we have to import the test source in the `assert.c` file in order to be able to call and validate them. Signed-off-by: Ivan Orlov <ivan.orlov0322(a)gmail.com> --- lib/kunit/assert.c | 4 + lib/kunit/assert_test.c | 416 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 420 insertions(+) create mode 100644 lib/kunit/assert_test.c diff --git a/lib/kunit/assert.c b/lib/kunit/assert.c index dd1d633d0fe2..ab68c6daf546 100644 --- a/lib/kunit/assert.c +++ b/lib/kunit/assert.c @@ -270,3 +270,7 @@ void kunit_mem_assert_format(const struct kunit_assert *assert, } } EXPORT_SYMBOL_GPL(kunit_mem_assert_format); + +#if IS_ENABLED(CONFIG_KUNIT_TEST) +#include "assert_test.c" +#endif diff --git a/lib/kunit/assert_test.c b/lib/kunit/assert_test.c new file mode 100644 index 000000000000..d54841740761 --- /dev/null +++ b/lib/kunit/assert_test.c @@ -0,0 +1,416 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * KUnit test for the assertion formatting functions. + * Author: Ivan Orlov <ivan.orlov0322(a)gmail.com> + */ +#include <kunit/test.h> + +#define TEST_PTR_EXPECTED_BUF_SIZE 128 + +static void kunit_test_is_literal(struct kunit *test) +{ + KUNIT_EXPECT_TRUE(test, is_literal("5", 5)); + KUNIT_EXPECT_TRUE(test, is_literal("0", 0)); + KUNIT_EXPECT_TRUE(test, is_literal("1234567890", 1234567890)); + KUNIT_EXPECT_TRUE(test, is_literal("-1234567890", -1234567890)); + KUNIT_EXPECT_FALSE(test, is_literal("05", 5)); + KUNIT_EXPECT_FALSE(test, is_literal("", 0)); + KUNIT_EXPECT_FALSE(test, is_literal("-0", 0)); + KUNIT_EXPECT_FALSE(test, is_literal("12#45", 1245)); +} + +static void kunit_test_is_str_literal(struct kunit *test) +{ + KUNIT_EXPECT_TRUE(test, is_str_literal("\"Hello, World!\"", "Hello, World!")); + KUNIT_EXPECT_TRUE(test, is_str_literal("\"\"", "")); + KUNIT_EXPECT_TRUE(test, is_str_literal("\"\"\"", "\"")); + KUNIT_EXPECT_FALSE(test, is_str_literal("", "")); + KUNIT_EXPECT_FALSE(test, is_str_literal("\"", "\"")); + KUNIT_EXPECT_FALSE(test, is_str_literal("\"Abacaba", "Abacaba")); + KUNIT_EXPECT_FALSE(test, is_str_literal("Abacaba\"", "Abacaba")); + KUNIT_EXPECT_FALSE(test, is_str_literal("\"Abacaba\"", "\"Abacaba\"")); +} + +KUNIT_DEFINE_ACTION_WRAPPER(kfree_wrapper, kfree, const void *); + +/* this function is used to get a "char *" string from the string stream and defer its cleanup */ +static char *get_str_from_stream(struct kunit *test, struct string_stream *stream) +{ + char *str = string_stream_get_string(stream); + + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, str); + kunit_add_action(test, kfree_wrapper, (void *)str); + + return str; +} + +static void kunit_test_assert_prologue(struct kunit *test) +{ + struct string_stream *stream; + const struct kunit_loc location = { + .file = "testfile.c", + .line = 1337, + }; + + stream = kunit_alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); + + /* Test an expectation fail prologue */ + kunit_assert_prologue(&location, KUNIT_EXPECTATION, stream); + KUNIT_EXPECT_STREQ(test, get_str_from_stream(test, stream), + "EXPECTATION FAILED at testfile.c:1337\n"); + + /* Test an assertion fail prologue */ + string_stream_clear(stream); + kunit_assert_prologue(&location, KUNIT_ASSERTION, stream); + KUNIT_EXPECT_STREQ(test, get_str_from_stream(test, stream), + "ASSERTION FAILED at testfile.c:1337\n"); +} + +/* + * This function accepts an arbitrary count of parameters and generates a va_format struct, + * which can be used to validate kunit_assert_print_msg function + */ +static void verify_assert_print_msg(struct kunit *test, + struct string_stream *stream, + char *expected, const char *format, ...) +{ + va_list list; + const struct va_format vformat = { + .fmt = format, + .va = &list, + }; + + va_start(list, format); + string_stream_clear(stream); + kunit_assert_print_msg(&vformat, stream); + KUNIT_EXPECT_STREQ(test, get_str_from_stream(test, stream), expected); +} + +static void kunit_test_assert_print_msg(struct kunit *test) +{ + struct string_stream *stream; + + stream = kunit_alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); + + verify_assert_print_msg(test, stream, "\nTest", "Test"); + verify_assert_print_msg(test, stream, "\nAbacaba -123 234", "%s %d %u", + "Abacaba", -123, 234U); + verify_assert_print_msg(test, stream, "", NULL); +} + +/* + * Further code contains the tests for different assert format functions. + * This helper function accepts the assert format function, executes it and + * validates the result string from the stream. + */ +static void validate_assert(assert_format_t format_func, struct kunit *test, + const struct kunit_assert *assert, + const char *expected, struct string_stream *stream) +{ + struct va_format message = { NULL, NULL }; + + string_stream_clear(stream); + format_func(assert, &message, stream); + KUNIT_EXPECT_STREQ(test, get_str_from_stream(test, stream), expected); +} + +static void kunit_test_unary_assert_format(struct kunit *test) +{ + struct string_stream *stream; + struct kunit_assert assert = {}; + struct kunit_unary_assert un_assert = { + .assert = assert, + .condition = "expr", + .expected_true = true, + }; + + stream = kunit_alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); + + validate_assert(kunit_unary_assert_format, test, &un_assert.assert, + KUNIT_SUBTEST_INDENT + "Expected expr to be true, but is false\n", + stream); + + un_assert.expected_true = false; + validate_assert(kunit_unary_assert_format, test, &un_assert.assert, + KUNIT_SUBTEST_INDENT + "Expected expr to be false, but is true\n", + stream); +} + +static void kunit_test_ptr_not_err_assert_format(struct kunit *test) +{ + struct string_stream *stream; + struct kunit_assert assert = {}; + struct kunit_ptr_not_err_assert not_err_assert = { + .assert = assert, + .text = "expr", + .value = NULL, + }; + + stream = kunit_alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); + + /* Value is NULL. The corresponding message should be printed out */ + validate_assert(kunit_ptr_not_err_assert_format, test, + &not_err_assert.assert, + KUNIT_SUBTEST_INDENT + "Expected expr is not null, but is\n", + stream); + + /* Value is not NULL, but looks like an error pointer. Error should be printed out */ + not_err_assert.value = (void *)-12; + validate_assert(kunit_ptr_not_err_assert_format, test, + &not_err_assert.assert, + KUNIT_SUBTEST_INDENT + "Expected expr is not error, but is: -12\n", + stream); +} + +static void kunit_test_binary_assert_format(struct kunit *test) +{ + struct string_stream *stream; + struct kunit_assert assert = {}; + struct kunit_binary_assert_text text = { + .left_text = "1 + 2", + .operation = "==", + .right_text = "2", + }; + const struct kunit_binary_assert binary_assert = { + .assert = assert, + .text = &text, + .left_value = 3, + .right_value = 2, + }; + + stream = kunit_alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); + + /* + * the right argument is "literal" (see test for `is_literal` above), + * so the right argument won't be printed out separately. + */ + validate_assert(kunit_binary_assert_format, test, &binary_assert.assert, + KUNIT_SUBTEST_INDENT + "Expected 1 + 2 == 2, but\n" KUNIT_SUBSUBTEST_INDENT + "1 + 2 == 3 (0x3)\n", + stream); + + /* Now both arguments are not "literal". They both will be printed out separately */ + text.right_text = "4 - 2"; + validate_assert(kunit_binary_assert_format, test, &binary_assert.assert, + KUNIT_SUBTEST_INDENT + "Expected 1 + 2 == 4 - 2, but\n" KUNIT_SUBSUBTEST_INDENT + "1 + 2 == 3 (0x3)\n" KUNIT_SUBSUBTEST_INDENT + "4 - 2 == 2 (0x2)", + stream); + + /* Now the left argument is "literal", so it won't be printed out */ + text.left_text = "3"; + validate_assert(kunit_binary_assert_format, test, &binary_assert.assert, + KUNIT_SUBTEST_INDENT + "Expected 3 == 4 - 2, but\n" KUNIT_SUBSUBTEST_INDENT + "4 - 2 == 2 (0x2)", + stream); + + /* The left and the right arguments are not "literal", so they won't be printed out */ + text.right_text = "2"; + validate_assert(kunit_binary_assert_format, test, &binary_assert.assert, + KUNIT_SUBTEST_INDENT "Expected 3 == 2, but\n", stream); +} + +static void kunit_test_binary_ptr_assert_format(struct kunit *test) +{ + struct string_stream *stream; + struct kunit_assert assert = {}; + char *expected; + static const void *var_a = (void *)0xDEADBEEF; + static const void *var_b = (void *)0xBADDCAFE; + struct kunit_binary_assert_text text = { + .left_text = "var_a", + .operation = "==", + .right_text = "var_b", + }; + struct kunit_binary_ptr_assert binary_ptr_assert = { + .assert = assert, + .text = &text, + .left_value = var_a, + .right_value = var_b, + }; + + expected = kunit_kzalloc(test, TEST_PTR_EXPECTED_BUF_SIZE, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, expected); + /* + * Print the expected string to the buffer first. + * This is necessary as we may have different count of leading zeros in the pointer + * on different architectures. + */ + snprintf(expected, TEST_PTR_EXPECTED_BUF_SIZE, + KUNIT_SUBTEST_INDENT + "Expected var_a == var_b, but\n" KUNIT_SUBSUBTEST_INDENT + "var_a == %px\n" KUNIT_SUBSUBTEST_INDENT "var_b == %px", + var_a, var_b); + + stream = kunit_alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); + validate_assert(kunit_binary_ptr_assert_format, test, + &binary_ptr_assert.assert, expected, stream); +} + +static void kunit_test_binary_str_assert_format(struct kunit *test) +{ + struct string_stream *stream; + struct kunit_assert assert = {}; + static const char *var_a = "abacaba"; + static const char *var_b = "kernel"; + struct kunit_binary_assert_text text = { + .left_text = "var_a", + .operation = "==", + .right_text = "var_b", + }; + struct kunit_binary_str_assert binary_str_assert = { + .assert = assert, + .text = &text, + .left_value = var_a, + .right_value = var_b, + }; + + stream = kunit_alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); + + /* Both arguments are not "string literals", so they should be printed separately */ + validate_assert(kunit_binary_str_assert_format, test, + &binary_str_assert.assert, + KUNIT_SUBTEST_INDENT + "Expected var_a == var_b, but\n" KUNIT_SUBSUBTEST_INDENT + "var_a == \"abacaba\"\n" KUNIT_SUBSUBTEST_INDENT + "var_b == \"kernel\"", + stream); + + /* Left argument is a "string literal", so it shouldn't be printed separately */ + text.left_text = "\"abacaba\""; + validate_assert(kunit_binary_str_assert_format, test, &binary_str_assert.assert, + KUNIT_SUBTEST_INDENT "Expected \"abacaba\" == var_b, but\n" + KUNIT_SUBSUBTEST_INDENT "var_b == \"kernel\"", stream); + + /* Both arguments are "string literals", so they shouldn't be printed separately */ + text.right_text = "\"kernel\""; + validate_assert(kunit_binary_str_assert_format, test, &binary_str_assert.assert, + KUNIT_SUBTEST_INDENT "Expected \"abacaba\" == \"kernel\", but\n", stream); +} + +static const u8 hex_testbuf1[] = { 0x26, 0x74, 0x6b, 0x9c, 0x55, + 0x45, 0x9d, 0x47, 0xd6, 0x47, + 0x1, 0x89, 0x8c, 0x81, 0x94, + 0x12, 0xfe, 0x01 }; +static const u8 hex_testbuf2[] = { 0x26, 0x74, 0x6b, 0x9c, 0x55, + 0x45, 0x9d, 0x47, 0x21, 0x47, + 0xcd, 0x89, 0x24, 0x50, 0x94, + 0x12, 0xba, 0x01 }; +static void kunit_test_assert_hexdump(struct kunit *test) +{ + struct string_stream *stream; + + stream = kunit_alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); + /* + * Check that we are getting numbers like <xx> on the right places. + * Also check that we get a newline after 16 bytes + */ + kunit_assert_hexdump(stream, hex_testbuf1, hex_testbuf2, sizeof(hex_testbuf1)); + KUNIT_EXPECT_STREQ(test, get_str_from_stream(test, stream), KUNIT_SUBSUBTEST_INDENT + " 26 74 6b 9c 55 45 9d 47 <d6> 47 <01> 89 <8c><81> 94 12 \n" + KUNIT_SUBSUBTEST_INDENT "<fe> 01 "); + + /* + * We shouldn't get any <xx> numbers when comparing the buffer with itself. + * We still should get a newline after 16 printed bytes + */ + string_stream_clear(stream); + kunit_assert_hexdump(stream, hex_testbuf1, hex_testbuf1, sizeof(hex_testbuf1)); + KUNIT_EXPECT_STREQ(test, get_str_from_stream(test, stream), + KUNIT_SUBSUBTEST_INDENT + " 26 74 6b 9c 55 45 9d 47 d6 47 01 89 8c 81 94 12 \n" + KUNIT_SUBSUBTEST_INDENT " fe 01 "); +} + +static void kunit_test_mem_assert_format(struct kunit *test) +{ + struct string_stream *stream; + struct string_stream *expected_stream; + struct kunit_assert assert = {}; + static const struct kunit_binary_assert_text text = { + .left_text = "hex_testbuf1", + .operation = "==", + .right_text = "hex_testbuf2", + }; + struct kunit_mem_assert mem_assert = { + .assert = assert, + .text = &text, + .left_value = NULL, + .right_value = hex_testbuf2, + .size = sizeof(hex_testbuf1), + }; + + expected_stream = kunit_alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, expected_stream); + stream = kunit_alloc_string_stream(test, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); + + /* The left value is NULL */ + validate_assert(kunit_mem_assert_format, test, &mem_assert.assert, + KUNIT_SUBTEST_INDENT + "Expected hex_testbuf1 is not null, but is\n", + stream); + + /* The right value is NULL, the left value is not NULL */ + mem_assert.left_value = hex_testbuf1; + mem_assert.right_value = NULL; + validate_assert(kunit_mem_assert_format, test, &mem_assert.assert, + KUNIT_SUBTEST_INDENT + "Expected hex_testbuf2 is not null, but is\n", + stream); + + /* Both arguments are not null */ + mem_assert.left_value = hex_testbuf1; + mem_assert.right_value = hex_testbuf2; + + /* + * Building the expected buffer. + */ + string_stream_add(expected_stream, + KUNIT_SUBTEST_INDENT "Expected hex_testbuf1 == hex_testbuf2, but\n"); + string_stream_add(expected_stream, KUNIT_SUBSUBTEST_INDENT "hex_testbuf1 ==\n"); + kunit_assert_hexdump(expected_stream, hex_testbuf1, hex_testbuf2, mem_assert.size); + string_stream_add(expected_stream, + "\n" KUNIT_SUBSUBTEST_INDENT "hex_testbuf2 ==\n"); + kunit_assert_hexdump(expected_stream, hex_testbuf2, hex_testbuf1, mem_assert.size); + + validate_assert(kunit_mem_assert_format, test, &mem_assert.assert, + get_str_from_stream(test, expected_stream), stream); +} + +struct kunit_case assert_test_cases[] = { + KUNIT_CASE(kunit_test_is_literal), + KUNIT_CASE(kunit_test_is_str_literal), + KUNIT_CASE(kunit_test_assert_prologue), + KUNIT_CASE(kunit_test_assert_print_msg), + KUNIT_CASE(kunit_test_unary_assert_format), + KUNIT_CASE(kunit_test_ptr_not_err_assert_format), + KUNIT_CASE(kunit_test_binary_assert_format), + KUNIT_CASE(kunit_test_binary_ptr_assert_format), + KUNIT_CASE(kunit_test_binary_str_assert_format), + KUNIT_CASE(kunit_test_assert_hexdump), + KUNIT_CASE(kunit_test_mem_assert_format), + {} +}; + +struct kunit_suite assert_test_suite = { + .name = "kunit-assert", + .test_cases = assert_test_cases, +}; + +kunit_test_suites(&assert_test_suite); -- 2.34.1

1 year, 3 months

2
6
0 0

[PATCH] selftests: kselftest_deps: fix l5_test() empty variable

by Lu Dai

In the function l5_test(), variable $tests is empty when there is no .mk file in the subsystem to be tested. It causes the following grep operation stuck. This fix check the variable $tests, return when it is empty. Signed-off-by: Lu Dai <dai.lu(a)exordes.com> --- tools/testing/selftests/kselftest_deps.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/testing/selftests/kselftest_deps.sh b/tools/testing/selftests/kselftest_deps.sh index de59cc8f03c3..487e49fdf2a6 100755 --- a/tools/testing/selftests/kselftest_deps.sh +++ b/tools/testing/selftests/kselftest_deps.sh @@ -244,6 +244,7 @@ l4_test() l5_test() { tests=$(find $(dirname "$test") -type f -name "*.mk") + [[ -z "${tests// }" ]] && return test_libs=$(grep "^IOURING_EXTRA_LIBS +\?=" $tests | \ cut -d "=" -f 2) -- 2.39.2

1 year, 3 months

1
0
0 0

[PATCH for-next] selftests/ftrace: Fix required features for VFS type test case

by Masami Hiramatsu (Google)

From: Masami Hiramatsu (Google) <mhiramat(a)kernel.org> Since the VFS type argument test case uses fprobe events, it must check the availablity of dynamic_events file and fprobe events syntax in README. Without this fix, the test fails if CONFIG_FPROBE_EVENTS=n. Fixes: ee97e5e135c6 ("selftests/ftrace: add fprobe test cases for VFS type "%pd" and "%pD"") Signed-off-by: Masami Hiramatsu (Google) <mhiramat(a)kernel.org> --- .../ftrace/test.d/dynevent/fprobe_args_vfs.tc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/testing/selftests/ftrace/test.d/dynevent/fprobe_args_vfs.tc b/tools/testing/selftests/ftrace/test.d/dynevent/fprobe_args_vfs.tc index 49a833bf334c..c6a9d2466a71 100644 --- a/tools/testing/selftests/ftrace/test.d/dynevent/fprobe_args_vfs.tc +++ b/tools/testing/selftests/ftrace/test.d/dynevent/fprobe_args_vfs.tc @@ -1,7 +1,8 @@ #!/bin/sh # SPDX-License-Identifier: GPL-2.0 # description: Fprobe event VFS type argument -# requires: kprobe_events "%pd/%pD":README +# requires: dynamic_events "%pd/%pD":README "f[:[<group>/][<event>]] <func-name>[%return] [<args>]":README + : "Test argument %pd with name for fprobe" echo 'f:testprobe dput name=$arg1:%pd' > dynamic_events

1 year, 3 months

1
0
0 0

[PATCH 0/2] selftests/ftrace: Fix some errors

by Masami Hiramatsu (Google)

Here is a couple of patches for fixing errors on ftracetest. Shuah, can you pick these to your fixes branch? Or I also can push it. Thank you, --- Masami Hiramatsu (Google) (2): selftests/ftrace: Fix BTFARG testcase to check fprobe is enabled correctly selftests/ftrace: Fix checkbashisms errors .../ftrace/test.d/dynevent/add_remove_btfarg.tc | 2 +- .../ftrace/test.d/dynevent/fprobe_entry_arg.tc | 2 +- .../ftrace/test.d/kprobe/kretprobe_entry_arg.tc | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) -- Masami Hiramatsu (Google) <mhiramat(a)kernel.org>

1 year, 3 months

1
2
0 0

[PATCH net-next] selftest: epoll_busy_poll: epoll busy poll tests

by Joe Damato

Add a simple test for the epoll busy poll ioctls. This test ensures that the ioctls have the expected return codes and that the kernel properly gets and sets epoll busy poll parameters. The test can be expanded in the future to do real busy polling (provided another machine to act as the client is available). To run the test (use -s for "simple" test): ./epoll_busy_poll -s On success, nothing is written to stdout/stderr and the exit code is 0. Signed-off-by: Joe Damato <jdamato(a)fastly.com> --- tools/testing/selftests/net/.gitignore | 1 + tools/testing/selftests/net/Makefile | 1 + tools/testing/selftests/net/epoll_busy_poll.c | 279 ++++++++++++++++++ 3 files changed, 281 insertions(+) create mode 100644 tools/testing/selftests/net/epoll_busy_poll.c diff --git a/tools/testing/selftests/net/.gitignore b/tools/testing/selftests/net/.gitignore index d996a0ab0765..777cfd027076 100644 --- a/tools/testing/selftests/net/.gitignore +++ b/tools/testing/selftests/net/.gitignore @@ -5,6 +5,7 @@ bind_wildcard csum cmsg_sender diag_uid +epoll_busy_poll fin_ack_lat gro hwtstamp_config diff --git a/tools/testing/selftests/net/Makefile b/tools/testing/selftests/net/Makefile index 5befca249452..c83c5d9c1ad9 100644 --- a/tools/testing/selftests/net/Makefile +++ b/tools/testing/selftests/net/Makefile @@ -84,6 +84,7 @@ TEST_GEN_FILES += sctp_hello TEST_GEN_FILES += csum TEST_GEN_FILES += ip_local_port_range TEST_GEN_FILES += bind_wildcard +TEST_GEN_FILES += epoll_busy_poll TEST_PROGS += test_vxlan_mdb.sh TEST_PROGS += test_bridge_neigh_suppress.sh TEST_PROGS += test_vxlan_nolocalbypass.sh diff --git a/tools/testing/selftests/net/epoll_busy_poll.c b/tools/testing/selftests/net/epoll_busy_poll.c new file mode 100644 index 000000000000..3066a41a2acb --- /dev/null +++ b/tools/testing/selftests/net/epoll_busy_poll.c @@ -0,0 +1,279 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* Basic per-epoll context busy poll test. + * + * Only tests the ioctls, but should be expanded to test two connected hosts in + * the future + */ + +#define _GNU_SOURCE + +#include <error.h> +#include <errno.h> +#include <inttypes.h> +#include <limits.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include <sys/epoll.h> +#include <sys/ioctl.h> +#include <sys/socket.h> + +/* if the headers haven't been updated, we need to define some things */ +#if !defined(EPOLL_IOC_TYPE) +struct epoll_params { + uint32_t busy_poll_usecs; + uint16_t busy_poll_budget; + uint8_t prefer_busy_poll; + + /* pad the struct to a multiple of 64bits */ + uint8_t __pad; +}; + +#define EPOLL_IOC_TYPE 0x8A +#define EPIOCSPARAMS _IOW(EPOLL_IOC_TYPE, 0x01, struct epoll_params) +#define EPIOCGPARAMS _IOR(EPOLL_IOC_TYPE, 0x02, struct epoll_params) +#endif + +enum epoll_test_types { + TEST_UNDEFINED = -1, + TEST_SIMPLE = 0, +}; + +static enum epoll_test_types test_type = TEST_UNDEFINED; + +static void usage(const char *filepath) +{ + error(1, 0, "Usage: %s [options]", filepath); +} + +static void parse_opts(int argc, char **argv) +{ + int c; + + while ((c = getopt(argc, argv, "s")) != -1) { + switch (c) { + case 's': + test_type = TEST_SIMPLE; + break; + } + } + + if (optind != argc) + usage(argv[0]); +} + +static void do_simple_test_get_params(int fd) +{ + /* begin by getting the epoll params from the kernel + * + * the default should be default and all fields should be zero'd by the + * kernel, so set params fields to garbage to test this. + */ + struct epoll_params *invalid_params; + struct epoll_params params; + int ret = 0; + + params.busy_poll_usecs = 0xff; + params.busy_poll_budget = 0xff; + params.prefer_busy_poll = 1; + params.__pad = 0xf; + + if (ioctl(fd, EPIOCGPARAMS, &params) != 0) + error(1, errno, "ioctl EPIOCGPARAMS"); + + if (params.busy_poll_usecs != 0) + error(1, 0, "EPIOCGPARAMS busy_poll_usecs should have been 0"); + + if (params.busy_poll_budget != 0) + error(1, 0, "EPIOCGPARAMS busy_poll_budget should have been 0"); + + if (params.prefer_busy_poll != 0) + error(1, 0, "EPIOCGPARAMS prefer_busy_poll should have been 0"); + + if (params.__pad != 0) + error(1, 0, "EPIOCGPARAMS __pad should have been 0"); + + invalid_params = (struct epoll_params *)0xdeadbeef; + ret = ioctl(fd, EPIOCGPARAMS, invalid_params); + if (ret != -1) + error(1, 0, "EPIOCGPARAMS should error with invalid params"); + + if (errno != EFAULT) + error(1, 0, + "EPIOCGPARAMS with invalid params should set errno to EFAULT"); +} + +static void do_simple_test_set_invalid(int fd) +{ + /* Set some unacceptable values and check for error */ + struct epoll_params *invalid_params; + struct epoll_params params; + int ret; + + memset(&params, 0, sizeof(struct epoll_params)); + + params.__pad = 1; + + ret = ioctl(fd, EPIOCSPARAMS, &params); + + if (ret != -1) + error(1, 0, "EPIOCSPARAMS with non-zero __pad should error"); + + if (errno != EINVAL) + error(1, 0, "EPIOCSPARAMS with non-zero __pad errno should be EINVAL"); + + params.__pad = 0; + params.busy_poll_usecs = (unsigned int)INT_MAX + 1; + + ret = ioctl(fd, EPIOCSPARAMS, &params); + + if (ret != -1) + error(1, 0, "EPIOCSPARAMS should error busy_poll_usecs > S32_MAX"); + + if (errno != EINVAL) + error(1, 0, "EPIOCSPARAMS with busy_poll_usecs > S32_MAX, errno should be EINVAL"); + + params.__pad = 0; + params.busy_poll_usecs = 32; + params.prefer_busy_poll = 2; + + ret = ioctl(fd, EPIOCSPARAMS, &params); + + if (ret != -1) + error(1, 0, "EPIOCSPARAMS should error prefer_busy_poll > 1"); + + if (errno != EINVAL) + error(1, 0, "EPIOCSPARAMS with prefer_busy_poll > 1 errno should be EINVAL"); + + params.__pad = 0; + params.busy_poll_usecs = 32; + params.prefer_busy_poll = 1; + params.busy_poll_budget = 65535; + + ret = ioctl(fd, EPIOCSPARAMS, &params); + + if (ret != -1) + error(1, 0, "EPIOCSPARAMS should error busy_poll_budget > NAPI_POLL_WEIGHT"); + + if (errno != EPERM) + error(1, 0, + "EPIOCSPARAMS with busy_poll_budget > NAPI_POLL_WEIGHT (without CAP_NET_ADMIN) errno should be EPERM"); + + invalid_params = (struct epoll_params *)0xdeadbeef; + ret = ioctl(fd, EPIOCSPARAMS, invalid_params); + + if (ret != -1) + error(1, 0, "EPIOCSPARAMS should error when epoll_params is invalid"); + + if (errno != EFAULT) + error(1, 0, "EPIOCSPARAMS should set errno to EFAULT when epoll_params is invalid"); +} + +static void do_simple_test_set_and_get_valid(int fd) +{ + struct epoll_params params; + int ret; + + memset(&params, 0, sizeof(struct epoll_params)); + + params.busy_poll_usecs = 25; + params.busy_poll_budget = 16; + params.prefer_busy_poll = 1; + + ret = ioctl(fd, EPIOCSPARAMS, &params); + + if (ret != 0) + error(1, errno, "EPIOCSPARAMS with valid params should not error"); + + /* check that the kernel returns the same values back */ + + memset(&params, 0, sizeof(struct epoll_params)); + + ret = ioctl(fd, EPIOCGPARAMS, &params); + + if (ret != 0) + error(1, errno, "EPIOCGPARAMS should not error"); + + if (params.busy_poll_usecs != 25 || + params.busy_poll_budget != 16 || + params.prefer_busy_poll != 1 || + params.__pad != 0) + error(1, 0, "EPIOCGPARAMS returned incorrect values"); +} + +static void do_simple_test_invalid_fd(void) +{ + struct epoll_params params; + int ret; + int fd; + + fd = socket(AF_UNIX, SOCK_DGRAM, 0); + + if (fd == -1) + error(1, errno, "creating unix socket"); + + ret = ioctl(fd, EPIOCGPARAMS, &params); + + if (ret != -1) + error(1, 0, "EPIOCGPARAMS on invalid epoll FD should error"); + + if (errno != ENOTTY) + error(1, 0, "EPIOCGPARAMS on invalid epoll FD should set errno to ENOTTY"); + + memset(&params, 0, sizeof(struct epoll_params)); + + ret = ioctl(fd, EPIOCSPARAMS, &params); + + if (ret != -1) + error(1, 0, "EPIOCSPARAMS on invalid epoll FD should error"); + + if (errno != ENOTTY) + error(1, 0, "EPIOCSPARAMS on invalid epoll FD should set errno to ENOTTY"); +} + +static void do_simple_test_invalid_ioctl(int fd) +{ + struct epoll_params params; + int invalid_ioctl = EPIOCGPARAMS + 10; + int ret; + + ret = ioctl(fd, invalid_ioctl, &params); + + if (ret != -1) + error(1, 0, "invalid ioctl should return error"); + + if (errno != EINVAL) + error(1, 0, "invalid ioctl should set errno to EINVAL"); +} + +static void do_simple_test(void) +{ + int fd; + + fd = epoll_create1(0); + if (fd == -1) + error(1, errno, "epoll_create"); + + do_simple_test_invalid_fd(); + do_simple_test_invalid_ioctl(fd); + do_simple_test_get_params(fd); + do_simple_test_set_invalid(fd); + do_simple_test_set_and_get_valid(fd); + + if (close(fd)) + error(1, errno, "close"); +} + +int main(int argc, char **argv) +{ + parse_opts(argc, argv); + + if (test_type == TEST_SIMPLE) + do_simple_test(); + else + error(1, 0, "unknown test type: %d", test_type); + + return 0; +} -- 2.25.1

1 year, 3 months

2
3
0 0

kselftest/next kselftest-livepatch: 1 runs, 1 regressions (v6.9-rc4-36-g70bfefe4252d7)

by kernelci.org bot

kselftest/next kselftest-livepatch: 1 runs, 1 regressions (v6.9-rc4-36-g70bfefe4252d7) Regressions Summary ------------------- platform | arch | lab | compiler | defconfig | regressions ----------------+------+---------------+----------+------------------------------+------------ imx6q-sabrelite | arm | lab-collabora | gcc-10 | multi_v7_defconfig+kselftest | 1 Details: https://kernelci.org/test/job/kselftest/branch/next/kernel/v6.9-rc4-36-g70b… Test: kselftest-livepatch Tree: kselftest Branch: next Describe: v6.9-rc4-36-g70bfefe4252d7 URL: https://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest.git SHA: 70bfefe4252d7ab57fb49348ca5b66ad9298e46e Test Regressions ---------------- platform | arch | lab | compiler | defconfig | regressions ----------------+------+---------------+----------+------------------------------+------------ imx6q-sabrelite | arm | lab-collabora | gcc-10 | multi_v7_defconfig+kselftest | 1 Details: https://kernelci.org/test/plan/id/6635687051b08916c84c42da Results: 1 PASS, 1 FAIL, 0 SKIP Full config: multi_v7_defconfig+kselftest Compiler: gcc-10 (arm-linux-gnueabihf-gcc (Debian 10.2.1-6) 10.2.1 20210110) Plain log: https://storage.kernelci.org//kselftest/next/v6.9-rc4-36-g70bfefe4252d7/arm… HTML log: https://storage.kernelci.org//kselftest/next/v6.9-rc4-36-g70bfefe4252d7/arm… Rootfs: http://storage.kernelci.org/images/rootfs/debian/bookworm-kselftest/2024031… * kselftest-livepatch.shardfile-livepatch: https://kernelci.org/test/case/id/6635687051b08916c84c42dc failing since 79 days (last pass: v6.8-rc1, first fail: v6.8-rc1-32-g345e8abe4c355) 2024-05-03T22:43:22.173115 / # 2024-05-03T22:43:22.183109 2024-05-03T22:43:27.326213 / # export NFS_ROOTFS='/var/lib/lava/dispatcher/tmp/13633047/extract-nfsrootfs-c03ooedj' 2024-05-03T22:43:27.342473 export NFS_ROOTFS='/var/lib/lava/dispatcher/tmp/13633047/extract-nfsrootfs-c03ooedj' 2024-05-03T22:43:29.569322 / # export NFS_SERVER_IP='192.168.201.1' 2024-05-03T22:43:29.580248 export NFS_SERVER_IP='192.168.201.1' 2024-05-03T22:43:29.697807 / # # 2024-05-03T22:43:29.705994 # 2024-05-03T22:43:29.823718 / # export SHELL=/bin/bash 2024-05-03T22:43:29.834056 export SHELL=/bin/bash ... (94 line(s) more)

1 year, 3 months

1
0
0 0

kselftest/next kselftest-lkdtm: 2 runs, 1 regressions (v6.9-rc4-36-g70bfefe4252d7)

by kernelci.org bot

kselftest/next kselftest-lkdtm: 2 runs, 1 regressions (v6.9-rc4-36-g70bfefe4252d7) Regressions Summary ------------------- platform | arch | lab | compiler | defconfig | regressions ----------------+------+---------------+----------+------------------------------+------------ imx6q-sabrelite | arm | lab-collabora | gcc-10 | multi_v7_defconfig+kselftest | 1 Details: https://kernelci.org/test/job/kselftest/branch/next/kernel/v6.9-rc4-36-g70b… Test: kselftest-lkdtm Tree: kselftest Branch: next Describe: v6.9-rc4-36-g70bfefe4252d7 URL: https://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest.git SHA: 70bfefe4252d7ab57fb49348ca5b66ad9298e46e Test Regressions ---------------- platform | arch | lab | compiler | defconfig | regressions ----------------+------+---------------+----------+------------------------------+------------ imx6q-sabrelite | arm | lab-collabora | gcc-10 | multi_v7_defconfig+kselftest | 1 Details: https://kernelci.org/test/plan/id/66356a3dc9262a7ecb4c42de Results: 0 PASS, 1 FAIL, 0 SKIP Full config: multi_v7_defconfig+kselftest Compiler: gcc-10 (arm-linux-gnueabihf-gcc (Debian 10.2.1-6) 10.2.1 20210110) Plain log: https://storage.kernelci.org//kselftest/next/v6.9-rc4-36-g70bfefe4252d7/arm… HTML log: https://storage.kernelci.org//kselftest/next/v6.9-rc4-36-g70bfefe4252d7/arm… Rootfs: http://storage.kernelci.org/images/rootfs/debian/bookworm-kselftest/2024031… * kselftest-lkdtm.login: https://kernelci.org/test/case/id/66356a3dc9262a7ecb4c42df failing since 8 days (last pass: v6.9-rc4-19-g00ab560eb0e3, first fail: v6.9-rc4-32-g693fe2f6a9ea)

1 year, 3 months

1
0
0 0

kselftest/next build: 4 builds: 0 failed, 4 passed, 1 warning (v6.9-rc4-36-g70bfefe4252d7)

by kernelci.org bot

kselftest/next build: 4 builds: 0 failed, 4 passed, 1 warning (v6.9-rc4-36-g70bfefe4252d7) Full Build Summary: https://kernelci.org/build/kselftest/branch/next/kernel/v6.9-rc4-36-g70bfef… Tree: kselftest Branch: next Git Describe: v6.9-rc4-36-g70bfefe4252d7 Git Commit: 70bfefe4252d7ab57fb49348ca5b66ad9298e46e Git URL: https://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest.git Built: 3 unique architectures Warnings Detected: arm: i386: x86_64: x86_64_defconfig+kselftest (clang-16): 1 warning Warnings summary: 1 vmlinux.o: warning: objtool: set_ftrace_ops_ro+0x23: relocation to !ENDBR: .text+0x14ea89 ================================================================================ Detailed per-defconfig build reports: -------------------------------------------------------------------------------- i386_defconfig+kselftest (i386, gcc-10) — PASS, 0 errors, 0 warnings, 0 section mismatches -------------------------------------------------------------------------------- multi_v7_defconfig+kselftest (arm, gcc-10) — PASS, 0 errors, 0 warnings, 0 section mismatches -------------------------------------------------------------------------------- x86_64_defconfig+kselftest (x86_64, gcc-10) — PASS, 0 errors, 0 warnings, 0 section mismatches -------------------------------------------------------------------------------- x86_64_defconfig+kselftest (x86_64, clang-16) — PASS, 0 errors, 1 warning, 0 section mismatches Warnings: vmlinux.o: warning: objtool: set_ftrace_ops_ro+0x23: relocation to !ENDBR: .text+0x14ea89 --- For more info write to <info(a)kernelci.org>

1 year, 3 months

1
0
0 0

[PATCH net-next v2] selftests: drv-net: add checksum tests

by Willem de Bruijn

From: Willem de Bruijn <willemb(a)google.com> Run tools/testing/selftest/net/csum.c as part of drv-net. This binary covers multiple scenarios, based on arguments given, for both IPv4 and IPv6: - Accept UDP correct checksum - Detect UDP invalid checksum - Accept TCP correct checksum - Detect TCP invalid checksum - Transmit UDP: basic checksum offload - Transmit UDP: zero checksum conversion The test direction is reversed between receive and transmit tests, so that the NIC under test is always the local machine. In total this adds up to 12 testcases, with more to follow. For conciseness, I replaced individual functions with a function factory. Also detect hardware offload feature availability using Ethtool netlink and skip tests when either feature is off. This need may be common for offload feature tests and eventually deserving of a thin wrapper in lib.py. Missing are the PF_PACKET based send tests ('-P'). These use virtio_net_hdr to program hardware checksum offload. Which requires looking up the local MAC address and (harder) the MAC of the next hop. I'll have to give it some though how to do that robustly and where that code would belong. Tested: make -C tools/testing/selftests/ \ TARGETS="drivers/net drivers/net/hw" \ install INSTALL_PATH=/tmp/ksft cd /tmp/ksft sudo NETIF=ens4 REMOTE_TYPE=ssh \ REMOTE_ARGS="root(a)10.40.0.2" \ LOCAL_V4="10.40.0.1" REMOTE_V4="10.40.0.2" \ ./run_kselftest.sh -t drivers/net/hw:csum.py Signed-off-by: Willem de Bruijn <willemb(a)google.com> --- Changes - v1->v2 - remove dependency on tools/testing/selftests/net: move csum - remove test output from git commit message: has noisy (expected) failures on test platform after bkg changes --- .../testing/selftests/drivers/net/hw/Makefile | 1 + .../testing/selftests/drivers/net/hw/csum.py | 114 ++++++++++++++++++ tools/testing/selftests/net/.gitignore | 1 - tools/testing/selftests/net/Makefile | 1 - tools/testing/selftests/net/lib/.gitignore | 2 + tools/testing/selftests/net/lib/Makefile | 7 ++ tools/testing/selftests/net/{ => lib}/csum.c | 0 7 files changed, 124 insertions(+), 2 deletions(-) create mode 100755 tools/testing/selftests/drivers/net/hw/csum.py create mode 100644 tools/testing/selftests/net/lib/.gitignore rename tools/testing/selftests/net/{ => lib}/csum.c (100%) diff --git a/tools/testing/selftests/drivers/net/hw/Makefile b/tools/testing/selftests/drivers/net/hw/Makefile index 1dd732855d76..4933d045ab66 100644 --- a/tools/testing/selftests/drivers/net/hw/Makefile +++ b/tools/testing/selftests/drivers/net/hw/Makefile @@ -1,6 +1,7 @@ # SPDX-License-Identifier: GPL-2.0+ OR MIT TEST_PROGS = \ + csum.py \ devlink_port_split.py \ ethtool.sh \ ethtool_extended_state.sh \ diff --git a/tools/testing/selftests/drivers/net/hw/csum.py b/tools/testing/selftests/drivers/net/hw/csum.py new file mode 100755 index 000000000000..7e3a955fc426 --- /dev/null +++ b/tools/testing/selftests/drivers/net/hw/csum.py @@ -0,0 +1,114 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: GPL-2.0 + +"""Run the tools/testing/selftests/net/csum testsuite.""" + +from os import path + +from lib.py import ksft_run, ksft_exit, KsftSkipEx +from lib.py import EthtoolFamily, NetDrvEpEnv +from lib.py import bkg, cmd, wait_port_listen + +def test_receive(cfg, ipv4=False, extra_args=None): + """Test local nic checksum receive. Remote host sends crafted packets.""" + if not cfg.have_rx_csum: + raise KsftSkipEx(f"Test requires rx checksum offload on {cfg.ifname}") + + if ipv4: + ip_args = f"-4 -S {cfg.remote_v4} -D {cfg.v4}" + else: + ip_args = f"-6 -S {cfg.remote_v6} -D {cfg.v6}" + + rx_cmd = f"{cfg.bin_local} -i {cfg.ifname} -n 100 {ip_args} -r 1 -R {extra_args}" + tx_cmd = f"{cfg.bin_remote} -i {cfg.ifname} -n 100 {ip_args} -r 1 -T {extra_args}" + + with bkg(rx_cmd, exit_wait=True): + wait_port_listen(34000, proto='udp') + cmd(tx_cmd, host=cfg.remote) + + +def test_transmit(cfg, ipv4=False, extra_args=None): + """Test local nic checksum transmit. Remote host verifies packets.""" + if not cfg.have_tx_csum: + raise KsftSkipEx(f"Test requires tx checksum offload on {cfg.ifname}") + + if ipv4: + ip_args = f"-4 -S {cfg.v4} -D {cfg.remote_v4}" + else: + ip_args = f"-6 -S {cfg.v6} -D {cfg.remote_v6}" + + # Cannot randomize input when calculating zero checksum + if extra_args != "-U -Z": + extra_args += " -r 1" + + rx_cmd = f"{cfg.bin_remote} -i {cfg.ifname} -L 1 -n 100 {ip_args} -R {extra_args}" + tx_cmd = f"{cfg.bin_local} -i {cfg.ifname} -L 1 -n 100 {ip_args} -T {extra_args}" + + with bkg(rx_cmd, host=cfg.remote, exit_wait=True): + wait_port_listen(34000, proto='udp', host=cfg.remote) + cmd(tx_cmd) + + +def test_builder(name, cfg, ipv4=False, tx=False, extra_args=""): + """Construct specific tests from the common template. + + Most tests follow the same basic pattern, differing only in + Direction of the test and optional flags passed to csum.""" + def f(cfg): + if ipv4: + cfg.require_v4() + else: + cfg.require_v6() + + if tx: + test_transmit(cfg, ipv4, extra_args) + else: + test_receive(cfg, ipv4, extra_args) + + if ipv4: + f.__name__ = "ipv4_" + name + else: + f.__name__ = "ipv6_" + name + return f + + +def check_nic_features(cfg) -> None: + """Test whether Tx and Rx checksum offload are enabled. + + If the device under test has either off, then skip the relevant tests.""" + cfg.have_tx_csum = False + cfg.have_rx_csum = False + + ethnl = EthtoolFamily() + features = ethnl.features_get({"header": {"dev-index": cfg.ifindex}}) + for f in features["active"]["bits"]["bit"]: + if f["name"] == "tx-checksum-ip-generic": + cfg.have_tx_csum = True + elif f["name"] == "rx-checksum": + cfg.have_rx_csum = True + + +def main() -> None: + with NetDrvEpEnv(__file__, nsim_test=False) as cfg: + check_nic_features(cfg) + + cfg.bin_local = path.abspath(path.dirname(__file__) + "/../../../net/lib/csum") + cfg.bin_remote = cfg.remote.deploy(cfg.bin_local) + + cases = [] + for ipv4 in [True, False]: + cases.append(test_builder("rx_tcp", cfg, ipv4, False, "-t")) + cases.append(test_builder("rx_tcp_invalid", cfg, ipv4, False, "-t -E")) + + cases.append(test_builder("rx_udp", cfg, ipv4, False, "")) + cases.append(test_builder("rx_udp_invalid", cfg, ipv4, False, "-E")) + + cases.append(test_builder("tx_udp_csum_offload", cfg, ipv4, True, "-U")) + cases.append(test_builder("tx_udp_zero_checksum", cfg, ipv4, True, "-U -Z")) + + ksft_run(cases=cases, args=(cfg, )) + ksft_exit() + + +if __name__ == "__main__": + main() diff --git a/tools/testing/selftests/net/.gitignore b/tools/testing/selftests/net/.gitignore index d996a0ab0765..74ae1068229c 100644 --- a/tools/testing/selftests/net/.gitignore +++ b/tools/testing/selftests/net/.gitignore @@ -2,7 +2,6 @@ bind_bhash bind_timewait bind_wildcard -csum cmsg_sender diag_uid fin_ack_lat diff --git a/tools/testing/selftests/net/Makefile b/tools/testing/selftests/net/Makefile index 5befca249452..052c21438dc4 100644 --- a/tools/testing/selftests/net/Makefile +++ b/tools/testing/selftests/net/Makefile @@ -81,7 +81,6 @@ TEST_PROGS += test_ingress_egress_chaining.sh TEST_GEN_PROGS += so_incoming_cpu TEST_PROGS += sctp_vrf.sh TEST_GEN_FILES += sctp_hello -TEST_GEN_FILES += csum TEST_GEN_FILES += ip_local_port_range TEST_GEN_FILES += bind_wildcard TEST_PROGS += test_vxlan_mdb.sh diff --git a/tools/testing/selftests/net/lib/.gitignore b/tools/testing/selftests/net/lib/.gitignore new file mode 100644 index 000000000000..1ebc6187f421 --- /dev/null +++ b/tools/testing/selftests/net/lib/.gitignore @@ -0,0 +1,2 @@ +# SPDX-License-Identifier: GPL-2.0-only +csum diff --git a/tools/testing/selftests/net/lib/Makefile b/tools/testing/selftests/net/lib/Makefile index 48557e6250dd..82c3264b115e 100644 --- a/tools/testing/selftests/net/lib/Makefile +++ b/tools/testing/selftests/net/lib/Makefile @@ -1,8 +1,15 @@ # SPDX-License-Identifier: GPL-2.0 +CFLAGS = -Wall -Wl,--no-as-needed -O2 -g +CFLAGS += -I../../../../../usr/include/ $(KHDR_INCLUDES) +# Additional include paths needed by kselftest.h +CFLAGS += -I../../ + TEST_FILES := ../../../../../Documentation/netlink/specs TEST_FILES += ../../../../net/ynl +TEST_GEN_FILES += csum + TEST_INCLUDES := $(wildcard py/*.py) include ../../lib.mk diff --git a/tools/testing/selftests/net/csum.c b/tools/testing/selftests/net/lib/csum.c similarity index 100% rename from tools/testing/selftests/net/csum.c rename to tools/testing/selftests/net/lib/csum.c -- 2.45.0.rc1.225.g2a3ae87e7f-goog

1 year, 3 months

1
1
0 0

[PATCH v3] selftest/tty: Use harness framework in tty

by Shengyu Li

Use kselftest_harness.h to simplify the code structure by eliminating conditional logic. Enhance diagnostics by directly printing relevant info, such as access and modification times, upon test failure. Reflecting common I/O optimizations, the access time usually remains unchanged, while the modify time is expected to update. Accordingly, these elements have been logically separated. Signed-off-by: Shengyu Li <shengyu.li.evgeny(a)gmail.com> --- v3: Explain the need for refactoring v2: Fixed the last Assert --- .../testing/selftests/tty/tty_tstamp_update.c | 49 +++++++++---------- 1 file changed, 22 insertions(+), 27 deletions(-) diff --git a/tools/testing/selftests/tty/tty_tstamp_update.c b/tools/testing/selftests/tty/tty_tstamp_update.c index 0ee97943dccc..38de211e0715 100644 --- a/tools/testing/selftests/tty/tty_tstamp_update.c +++ b/tools/testing/selftests/tty/tty_tstamp_update.c @@ -9,7 +9,7 @@ #include <unistd.h> #include <linux/limits.h> -#include "../kselftest.h" +#include "../kselftest_harness.h" #define MIN_TTY_PATH_LEN 8 @@ -42,47 +42,42 @@ static int write_dev_tty(void) return r; } -int main(int argc, char **argv) +TEST(tty_tstamp_update) { int r; char tty[PATH_MAX] = {}; struct stat st1, st2; - ksft_print_header(); - ksft_set_plan(1); + ASSERT_GE(readlink("/proc/self/fd/0", tty, PATH_MAX), 0) + TH_LOG("readlink on /proc/self/fd/0 failed: %m"); - r = readlink("/proc/self/fd/0", tty, PATH_MAX); - if (r < 0) - ksft_exit_fail_msg("readlink on /proc/self/fd/0 failed: %m\n"); - - if (!tty_valid(tty)) - ksft_exit_skip("invalid tty path '%s'\n", tty); + ASSERT_TRUE(tty_valid(tty)) { + TH_LOG("SKIP: invalid tty path '%s'", tty); + _exit(KSFT_SKIP); + } - r = stat(tty, &st1); - if (r < 0) - ksft_exit_fail_msg("stat failed on tty path '%s': %m\n", tty); + ASSERT_GE(stat(tty, &st1), 0) + TH_LOG("stat failed on tty path '%s': %m", tty); /* We need to wait at least 8 seconds in order to observe timestamp change */ /* https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?… */ sleep(10); r = write_dev_tty(); - if (r < 0) - ksft_exit_fail_msg("failed to write to /dev/tty: %s\n", - strerror(-r)); + ASSERT_GE(r, 0) + TH_LOG("failed to write to /dev/tty: %s", strerror(-r)); - r = stat(tty, &st2); - if (r < 0) - ksft_exit_fail_msg("stat failed on tty path '%s': %m\n", tty); + ASSERT_GE(stat(tty, &st2), 0) + TH_LOG("stat failed on tty path '%s': %m", tty); + + /* Validate unchanged atime under 'relatime' to ensure minimal disk I/O */ + EXPECT_EQ(st1.st_atim.tv_sec, st2.st_atim.tv_sec); /* We wrote to the terminal so timestamps should have been updated */ - if (st1.st_atim.tv_sec == st2.st_atim.tv_sec && - st1.st_mtim.tv_sec == st2.st_mtim.tv_sec) { - ksft_test_result_fail("tty timestamps not updated\n"); - ksft_exit_fail(); - } + ASSERT_NE(st1.st_mtim.tv_sec, st2.st_mtim.tv_sec) + TH_LOG("tty timestamps not updated"); - ksft_test_result_pass( - "timestamps of terminal '%s' updated after write to /dev/tty\n", tty); - return EXIT_SUCCESS; + TH_LOG("timestamps of terminal '%s' updated after write to /dev/tty", + tty); } +TEST_HARNESS_MAIN -- 2.25.1

1 year, 3 months

1
0
0 0

[PATCH V5] KVM: selftests: Add a new option to rseq_test

by Zide Chen

Currently, the migration worker delays 1-10 us, assuming that one KVM_RUN iteration only takes a few microseconds. But if the CPU low power wakeup latency is large enough, for example, hundreds or even thousands of microseconds deep C-state exit latencies on x86 server CPUs, it may happen that it's not able to wakeup the target CPU before the migration worker starts to migrate the vCPU thread to the next CPU. If the system workload is light, most CPUs could be at a certain low power state, which may result in less successful migrations and fail the migration/KVM_RUN ratio sanity check. But this is not supposed to be deemed a test failure. This patch adds a command line option to skip the sanity check in this case. Co-developed-by: Dongsheng Zhang <dongsheng.x.zhang(a)intel.com> Signed-off-by: Dongsheng Zhang <dongsheng.x.zhang(a)intel.com> Signed-off-by: Zide Chen <zide.chen(a)intel.com> --- V2: - removed the busy loop implementation - add the new "-s" option V3: - drop the usleep randomization code - removed the term C-state for less confusion for non-x86 archetectures - changed patch subject v4: - replaced Signed-off-by with Co-developed-by - changed command line option from "-s" to "-u" - Adopted the much clearer assertion error messages provided by Sean. V5: - Fixed the missing SoB --- tools/testing/selftests/kvm/rseq_test.c | 35 +++++++++++++++++++++++-- 1 file changed, 33 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/kvm/rseq_test.c b/tools/testing/selftests/kvm/rseq_test.c index 28f97fb52044..ad418a5c59dd 100644 --- a/tools/testing/selftests/kvm/rseq_test.c +++ b/tools/testing/selftests/kvm/rseq_test.c @@ -186,12 +186,35 @@ static void calc_min_max_cpu(void) "Only one usable CPU, task migration not possible"); } +static void help(const char *name) +{ + puts(""); + printf("usage: %s [-h] [-u]\n", name); + printf(" -u: Don't sanity check the number of successful KVM_RUNs\n"); + puts(""); + exit(0); +} + int main(int argc, char *argv[]) { int r, i, snapshot; struct kvm_vm *vm; struct kvm_vcpu *vcpu; u32 cpu, rseq_cpu; + bool skip_sanity_check = false; + int opt; + + while ((opt = getopt(argc, argv, "hu")) != -1) { + switch (opt) { + case 'u': + skip_sanity_check = true; + break; + case 'h': + default: + help(argv[0]); + break; + } + } r = sched_getaffinity(0, sizeof(possible_mask), &possible_mask); TEST_ASSERT(!r, "sched_getaffinity failed, errno = %d (%s)", errno, @@ -254,9 +277,17 @@ int main(int argc, char *argv[]) * getcpu() to stabilize. A 2:1 migration:KVM_RUN ratio is a fairly * conservative ratio on x86-64, which can do _more_ KVM_RUNs than * migrations given the 1us+ delay in the migration task. + * + * Another reason why it may have small migration:KVM_RUN ratio is that, + * on systems with large low power mode wakeup latency, it may happen + * quite often that the scheduler is not able to wake up the target CPU + * before the vCPU thread is scheduled to another CPU. */ - TEST_ASSERT(i > (NR_TASK_MIGRATIONS / 2), - "Only performed %d KVM_RUNs, task stalled too much?", i); + TEST_ASSERT(skip_sanity_check || i > (NR_TASK_MIGRATIONS / 2), + "Only performed %d KVM_RUNs, task stalled too much? \n" + " Try disabling deep sleep states to reduce CPU wakeup latency,\n" + " e.g. via cpuidle.off=1 or setting /dev/cpu_dma_latency to '0',\n" + " or run with -u to disable this sanity check.", i); pthread_join(migration_thread, NULL); -- 2.34.1

1 year, 3 months

2
1
0 0

[PATCH] selftests: default to host arch for LLVM builds

by Valentin Obst

Align the behavior for gcc and clang builds by interpreting unset `ARCH` and `CROSS_COMPILE` variables in `LLVM` builds as a sign that the user wants to build for the host architecture. This patch preserves the properties that setting the `ARCH` variable to an unknown value will trigger an error that complains about insufficient information, and that a set `CROSS_COMPILE` variable will override the target triple that is determined based on presence/absence of `ARCH`. When compiling with clang, i.e., `LLVM` is set, an unset `ARCH` variable in combination with an unset `CROSS_COMPILE` variable, i.e., compiling for the host architecture, leads to compilation failures since `lib.mk` can not determine the clang target triple. In this case, the following error message is displayed for each subsystem that does not set `ARCH` in its own Makefile before including `lib.mk` (lines wrapped at 75 chrs): make[1]: Entering directory '/mnt/build/linux/tools/testing/selftests/ sysctl' ../lib.mk:33: *** Specify CROSS_COMPILE or add '--target=' option to lib.mk. Stop. make[1]: Leaving directory '/mnt/build/linux/tools/testing/selftests/ sysctl' In the same scenario a gcc build would default to the host architecture, i.e., it would use plain `gcc`. Fixes: 795285ef2425 ("selftests: Fix clang cross compilation") Reviewed-by: Mark Brown <broonie(a)kernel.org> Signed-off-by: Valentin Obst <kernel(a)valentinobst.de> --- I am not entirely sure whether this behavior is in fact known and intended and whether the way to obtain the host target triple is sufficiently general. The flag was introduced in llvm-8 with [1], it will be an error in older clang versions. The target triple you get with `-print-target-triple` may not be the same that you would get when explicitly setting ARCH to you host architecture. For example on my x86_64 system it get `x86_64-pc-linux-gnu` instead of `x86_64-linux-gnu`, similar deviations were observed when testing other clang binaries on compiler-explorer, e.g., [2]. An alternative could be to simply do: ARCH ?= $(shell uname -m) before using it to select the target. Possibly with some post processing, but at that point we would likely be replicating `scripts/subarch.include`. This is what some subsystem Makefiles do before including `lib.mk`. This change might make it possible to remove the explicit setting of `ARCH` from the few subsystem Makefiles that do it. [1]: https://reviews.llvm.org/D50755 [2]: https://godbolt.org/z/r7Gn9bvv1 Changes in v1: - Shortened commit message. - Link to RFC: https://lore.kernel.org/r/20240303-selftests-libmk-llvm-rfc-v1-1-9ab53e365e… --- tools/testing/selftests/lib.mk | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/lib.mk b/tools/testing/selftests/lib.mk index da2cade3bab0..8ae203d8ed7f 100644 --- a/tools/testing/selftests/lib.mk +++ b/tools/testing/selftests/lib.mk @@ -7,6 +7,8 @@ else ifneq ($(filter -%,$(LLVM)),) LLVM_SUFFIX := $(LLVM) endif +CLANG := $(LLVM_PREFIX)clang$(LLVM_SUFFIX) + CLANG_TARGET_FLAGS_arm := arm-linux-gnueabi CLANG_TARGET_FLAGS_arm64 := aarch64-linux-gnu CLANG_TARGET_FLAGS_hexagon := hexagon-linux-musl @@ -18,7 +20,13 @@ CLANG_TARGET_FLAGS_riscv := riscv64-linux-gnu CLANG_TARGET_FLAGS_s390 := s390x-linux-gnu CLANG_TARGET_FLAGS_x86 := x86_64-linux-gnu CLANG_TARGET_FLAGS_x86_64 := x86_64-linux-gnu -CLANG_TARGET_FLAGS := $(CLANG_TARGET_FLAGS_$(ARCH)) + +# Default to host architecture if ARCH is not explicitly given. +ifeq ($(ARCH),) +CLANG_TARGET_FLAGS := $(shell $(CLANG) -print-target-triple) +else +CLANG_TARGET_FLAGS := $(CLANG_TARGET_FLAGS_$(ARCH)) +endif ifeq ($(CROSS_COMPILE),) ifeq ($(CLANG_TARGET_FLAGS),) @@ -30,7 +38,7 @@ else CLANG_FLAGS += --target=$(notdir $(CROSS_COMPILE:%-=%)) endif # CROSS_COMPILE -CC := $(LLVM_PREFIX)clang$(LLVM_SUFFIX) $(CLANG_FLAGS) -fintegrated-as +CC := $(CLANG) $(CLANG_FLAGS) -fintegrated-as else CC := $(CROSS_COMPILE)gcc endif # LLVM --- base-commit: 4cece764965020c22cff7665b18a012006359095 change-id: 20240303-selftests-libmk-llvm-rfc-5fe3cfa9f094 Best regards, -- Valentin Obst <kernel(a)valentinobst.de>

1 year, 3 months

4
7
0 0

[PATCH 0/4] selftests/cgroups: fix clang build failures, warnings

by John Hubbard

Hi, Just a bunch of fixes as part of my work to make selftests build cleanly with clang. Enjoy! thanks, John Hubbard John Hubbard (4): selftests/cgroup: fix clang build failures for abs() calls selftests/cgroup: fix clang warnings: uninitialized fd variable selftests/cgroup: cpu_hogger init: use {} instead of {NULL} selftests/cgroup: fix uninitialized variables in test_zswap.c tools/testing/selftests/cgroup/cgroup_util.h | 2 +- tools/testing/selftests/cgroup/test_cpu.c | 4 ++-- tools/testing/selftests/cgroup/test_kmem.c | 4 ++-- tools/testing/selftests/cgroup/test_memcontrol.c | 4 +++- tools/testing/selftests/cgroup/test_zswap.c | 4 ++-- 5 files changed, 10 insertions(+), 8 deletions(-) base-commit: f03359bca01bf4372cf2c118cd9a987a5951b1c8 prerequisite-patch-id: b901ece2a5b78503e2fb5480f20e304d36a0ea27 -- 2.45.0

1 year, 3 months

4
10
0 0

[PATCH v2] selftest/tty: Use harness framework in tty

by Shengyu Li

Similarly, this one is based on automated tools and a very small percentage of manual modifications to automatically refactor the version that uses kselftest_harness.h, which is logically clearer. Signed-off-by: Shengyu Li <shengyu.li.evgeny(a)gmail.com> --- v2: Fixed the last Assert --- .../testing/selftests/tty/tty_tstamp_update.c | 44 +++++-------------- 1 file changed, 11 insertions(+), 33 deletions(-) diff --git a/tools/testing/selftests/tty/tty_tstamp_update.c b/tools/testing/selftests/tty/tty_tstamp_update.c index 9e1a40f5db17..5894022eb879 100644 --- a/tools/testing/selftests/tty/tty_tstamp_update.c +++ b/tools/testing/selftests/tty/tty_tstamp_update.c @@ -9,7 +9,7 @@ #include <unistd.h> #include <linux/limits.h> -#include "../kselftest.h" +#include "../kselftest_harness.h" #define MIN_TTY_PATH_LEN 8 @@ -42,65 +42,43 @@ static int write_dev_tty(void) return r; } -int main(int argc, char **argv) +TEST(tty_tstamp_update) { - int r; char tty[PATH_MAX] = {}; struct stat st1, st2; - int result = KSFT_FAIL; - ksft_print_header(); - ksft_set_plan(1); - - r = readlink("/proc/self/fd/0", tty, PATH_MAX); - if (r < 0) { + ASSERT_GE(readlink("/proc/self/fd/0", tty, PATH_MAX), 0) { ksft_print_msg("readlink on /proc/self/fd/0 failed: %m\n"); - goto out; } if (!tty_valid(tty)) { - ksft_print_msg("invalid tty path '%s'\n", tty); - result = KSFT_SKIP; - goto out; - + ksft_print_msg("SKIP: invalid tty path '%s'\n", tty); + exit(KSFT_SKIP); } - r = stat(tty, &st1); - if (r < 0) { + ASSERT_GE(stat(tty, &st1), 0) { ksft_print_msg("stat failed on tty path '%s': %m\n", tty); - goto out; } /* We need to wait at least 8 seconds in order to observe timestamp change */ /* https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?… */ sleep(10); - r = write_dev_tty(); - if (r < 0) { - ksft_print_msg("failed to write to /dev/tty: %s\n", - strerror(-r)); - goto out; + ASSERT_GE(write_dev_tty(), 0) { + ksft_perror("failed to write to /dev/tty"); } - r = stat(tty, &st2); - if (r < 0) { + ASSERT_GE(stat(tty, &st2), 0) { ksft_print_msg("stat failed on tty path '%s': %m\n", tty); - goto out; } /* We wrote to the terminal so timestamps should have been updated */ - if (st1.st_atim.tv_sec == st2.st_atim.tv_sec && + ASSERT_FALSE(st1.st_atim.tv_sec == st2.st_atim.tv_sec && st1.st_mtim.tv_sec == st2.st_mtim.tv_sec) { ksft_print_msg("tty timestamps not updated\n"); - goto out; } ksft_print_msg( "timestamps of terminal '%s' updated after write to /dev/tty\n", tty); - result = KSFT_PASS; - -out: - ksft_test_result_report(result, "tty_tstamp_update\n"); - - ksft_finished(); } +TEST_HARNESS_MAIN -- 2.25.1

1 year, 3 months

2
1
0 0

[PATCH] selftest/tty: Use harness framework in tty

by Shengyu Li

Similarly, this one is based on automated tools and a very small percentage of manual modifications to automatically refactor the version that uses kselftest_harness.h, which is logically clearer. Signed-off-by: Shengyu Li <shengyu.li.evgeny(a)gmail.com> --- .../testing/selftests/tty/tty_tstamp_update.c | 48 ++++++------------- 1 file changed, 14 insertions(+), 34 deletions(-) diff --git a/tools/testing/selftests/tty/tty_tstamp_update.c b/tools/testing/selftests/tty/tty_tstamp_update.c index 9e1a40f5db17..cdaa6a15ee65 100644 --- a/tools/testing/selftests/tty/tty_tstamp_update.c +++ b/tools/testing/selftests/tty/tty_tstamp_update.c @@ -9,7 +9,7 @@ #include <unistd.h> #include <linux/limits.h> -#include "../kselftest.h" +#include "../kselftest_harness.h" #define MIN_TTY_PATH_LEN 8 @@ -42,65 +42,45 @@ static int write_dev_tty(void) return r; } -int main(int argc, char **argv) +TEST(tty_tstamp_update) { - int r; char tty[PATH_MAX] = {}; struct stat st1, st2; - int result = KSFT_FAIL; - ksft_print_header(); - ksft_set_plan(1); - - r = readlink("/proc/self/fd/0", tty, PATH_MAX); - if (r < 0) { + ASSERT_GE(readlink("/proc/self/fd/0", tty, PATH_MAX), 0) { ksft_print_msg("readlink on /proc/self/fd/0 failed: %m\n"); - goto out; } if (!tty_valid(tty)) { - ksft_print_msg("invalid tty path '%s'\n", tty); - result = KSFT_SKIP; - goto out; - + ksft_print_msg("SKIP: invalid tty path '%s'\n", tty); + exit(KSFT_SKIP); } - r = stat(tty, &st1); - if (r < 0) { + ASSERT_GE(stat(tty, &st1), 0) { ksft_print_msg("stat failed on tty path '%s': %m\n", tty); - goto out; } /* We need to wait at least 8 seconds in order to observe timestamp change */ /* https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?… */ sleep(10); - r = write_dev_tty(); - if (r < 0) { - ksft_print_msg("failed to write to /dev/tty: %s\n", - strerror(-r)); - goto out; + ASSERT_GE(write_dev_tty(), 0) { + ksft_perror("failed to write to /dev/tty"); } - r = stat(tty, &st2); - if (r < 0) { + ASSERT_GE(stat(tty, &st2), 0) { ksft_print_msg("stat failed on tty path '%s': %m\n", tty); - goto out; } /* We wrote to the terminal so timestamps should have been updated */ - if (st1.st_atim.tv_sec == st2.st_atim.tv_sec && - st1.st_mtim.tv_sec == st2.st_mtim.tv_sec) { + ASSERT_NE(st1.st_atim.tv_sec, st2.st_atim.tv_sec) { + ksft_print_msg("tty timestamps not updated\n"); + } + ASSERT_NE(st1.st_mtim.tv_sec, st2.st_mtim.tv_sec) { ksft_print_msg("tty timestamps not updated\n"); - goto out; } ksft_print_msg( "timestamps of terminal '%s' updated after write to /dev/tty\n", tty); - result = KSFT_PASS; - -out: - ksft_test_result_report(result, "tty_tstamp_update\n"); - - ksft_finished(); } +TEST_HARNESS_MAIN -- 2.25.1

1 year, 3 months

2
1
0 0

[PATCH] selftests/binderfs: use the Makefile's rules, not Make's implicit rules

by John Hubbard

First of all, in order to build with clang at all, one must first apply Valentin Obst's build fix for LLVM [1]. Once that is done, then when building with clang, via: make LLVM=1 -C tools/testing/selftests ...the following error occurs: clang: error: cannot specify -o when generating multiple output files This is because clang, unlike gcc, won't accept invocations of this form: clang file1.c header2.h While trying to fix this, I noticed that: a) selftests/lib.mk already avoids the problem, and b) The binderfs Makefile indavertently bypasses the selftests/lib.mk build system, and quitely uses Make's implicit build rules for .c files instead. The Makefile attempts to set up both a dependency and a source file, neither of which was needed, because lib.mk is able to automatically handle both. This line: binderfs_test: binderfs_test.c ...causes Make's implicit rules to run, which builds binderfs_test without ever looking at lib.mk. Fix this by simply deleting the "binderfs_test:" Makefile target and letting lib.mk handle it instead. [1] https://lore.kernel.org/all/20240329-selftests-libmk-llvm-rfc-v1-1-2f9ed7d1… Fixes: 6e29225af902 ("binderfs: port tests to test harness infrastructure") Cc: Christian Brauner <brauner(a)kernel.org> Signed-off-by: John Hubbard <jhubbard(a)nvidia.com> --- tools/testing/selftests/filesystems/binderfs/Makefile | 2 -- 1 file changed, 2 deletions(-) diff --git a/tools/testing/selftests/filesystems/binderfs/Makefile b/tools/testing/selftests/filesystems/binderfs/Makefile index c2f7cef919c0..eb4c3b411934 100644 --- a/tools/testing/selftests/filesystems/binderfs/Makefile +++ b/tools/testing/selftests/filesystems/binderfs/Makefile @@ -3,6 +3,4 @@ CFLAGS += $(KHDR_INCLUDES) -pthread TEST_GEN_PROGS := binderfs_test -binderfs_test: binderfs_test.c ../../kselftest.h ../../kselftest_harness.h - include ../../lib.mk base-commit: f03359bca01bf4372cf2c118cd9a987a5951b1c8 prerequisite-patch-id: b901ece2a5b78503e2fb5480f20e304d36a0ea27 -- 2.45.0

1 year, 3 months

3
2
0 0

[PATCH] selftests/resctrl: fix clang build failure: use LOCAL_HDRS

by John Hubbard

First of all, in order to build with clang at all, one must first apply Valentin Obst's build fix for LLVM [1]. Once that is done, then when building with clang, via: make LLVM=1 -C tools/testing/selftests ...the following error occurs: clang: error: cannot specify -o when generating multiple output files This is because clang, unlike gcc, won't accept invocations of this form: clang file1.c header2.h Fix this by using selftests/lib.mk facilities for tracking local header file dependencies: add them to LOCAL_HDRS, leaving only the .c files to be passed to the compiler. [1] https://lore.kernel.org/all/20240329-selftests-libmk-llvm-rfc-v1-1-2f9ed7d1… Fixes: 8e289f454289 ("selftests/resctrl: Add resctrl.h into build deps") Cc: Ilpo Järvinen <ilpo.jarvinen(a)linux.intel.com> Signed-off-by: John Hubbard <jhubbard(a)nvidia.com> --- tools/testing/selftests/resctrl/Makefile | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tools/testing/selftests/resctrl/Makefile b/tools/testing/selftests/resctrl/Makefile index 2deac2031de9..021863f86053 100644 --- a/tools/testing/selftests/resctrl/Makefile +++ b/tools/testing/selftests/resctrl/Makefile @@ -5,6 +5,8 @@ CFLAGS += $(KHDR_INCLUDES) TEST_GEN_PROGS := resctrl_tests +LOCAL_HDRS += $(wildcard *.h) + include ../lib.mk -$(OUTPUT)/resctrl_tests: $(wildcard *.[ch]) +$(OUTPUT)/resctrl_tests: $(wildcard *.c) base-commit: f03359bca01bf4372cf2c118cd9a987a5951b1c8 prerequisite-patch-id: b901ece2a5b78503e2fb5480f20e304d36a0ea27 -- 2.45.0

1 year, 3 months

3
2
0 0

[PATCH] Documentation: kselftest: fix codeblock

by Yo-Jung (Leo) Lin

Add extra colon to mark command in the next paragraph as codeblock Signed-off-by: Yo-Jung (Leo) Lin <0xff07(a)gmail.com> --- Documentation/dev-tools/kselftest.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Documentation/dev-tools/kselftest.rst b/Documentation/dev-tools/kselftest.rst index ff10dc6eef5d..dcf634e411bd 100644 --- a/Documentation/dev-tools/kselftest.rst +++ b/Documentation/dev-tools/kselftest.rst @@ -183,7 +183,7 @@ expected time it takes to run a test. If you have control over the systems which will run the tests you can configure a test runner on those systems to use a greater or lower timeout on the command line as with the `-o` or the `--override-timeout` argument. For example to use 165 seconds instead -one would use: +one would use:: $ ./run_kselftest.sh --override-timeout 165 -- 2.34.1

1 year, 3 months

2
1
0 0

[PATCH v2] KVM: selftests: Use TAP interface in the set_memory_region test

by Thomas Huth

Use the kselftest_harness.h interface in this test to get TAP output, so that it is easier for the user to see what the test is doing. (Note: We are not using the KVM_ONE_VCPU_TEST_SUITE() macro here since these tests are creating their VMs with the vm_create_barebones() function, not with vm_create_with_one_vcpu()) Reviewed-by: Andrew Jones <ajones(a)ventanamicro.com> Signed-off-by: Thomas Huth <thuth(a)redhat.com> --- v2: - Rebase to linux-next branch - Make "loops" variable static - Added Andrew's Reviewed-by .../selftests/kvm/set_memory_region_test.c | 86 +++++++++---------- 1 file changed, 42 insertions(+), 44 deletions(-) diff --git a/tools/testing/selftests/kvm/set_memory_region_test.c b/tools/testing/selftests/kvm/set_memory_region_test.c index 68c899d27561..a5c9bee5235a 100644 --- a/tools/testing/selftests/kvm/set_memory_region_test.c +++ b/tools/testing/selftests/kvm/set_memory_region_test.c @@ -16,6 +16,7 @@ #include <test_util.h> #include <kvm_util.h> #include <processor.h> +#include "kselftest_harness.h" /* * s390x needs at least 1MB alignment, and the x86_64 MOVE/DELETE tests need a @@ -38,6 +39,8 @@ extern const uint64_t final_rip_end; static sem_t vcpu_ready; +static int loops; + static inline uint64_t guest_spin_on_val(uint64_t spin_val) { uint64_t val; @@ -219,6 +222,13 @@ static void test_move_memory_region(void) kvm_vm_free(vm); } +TEST(move_in_use_region) +{ + ksft_print_msg("Testing MOVE of in-use region, %d loops\n", loops); + for (int i = 0; i < loops; i++) + test_move_memory_region(); +} + static void guest_code_delete_memory_region(void) { uint64_t val; @@ -308,12 +318,19 @@ static void test_delete_memory_region(void) kvm_vm_free(vm); } -static void test_zero_memory_regions(void) +TEST(delete_in_use_region) +{ + ksft_print_msg("Testing DELETE of in-use region, %d loops\n", loops); + for (int i = 0; i < loops; i++) + test_delete_memory_region(); +} + +TEST(zero_memory_regions) { struct kvm_vcpu *vcpu; struct kvm_vm *vm; - pr_info("Testing KVM_RUN with zero added memory regions\n"); + ksft_print_msg("Testing KVM_RUN with zero added memory regions\n"); vm = vm_create_barebones(); vcpu = __vm_vcpu_add(vm, 0); @@ -326,7 +343,7 @@ static void test_zero_memory_regions(void) } #endif /* __x86_64__ */ -static void test_invalid_memory_region_flags(void) +TEST(invalid_memory_region_flags) { uint32_t supported_flags = KVM_MEM_LOG_DIRTY_PAGES; const uint32_t v2_only_flags = KVM_MEM_GUEST_MEMFD; @@ -389,7 +406,7 @@ static void test_invalid_memory_region_flags(void) * Test it can be added memory slots up to KVM_CAP_NR_MEMSLOTS, then any * tentative to add further slots should fail. */ -static void test_add_max_memory_regions(void) +TEST(add_max_memory_regions) { int ret; struct kvm_vm *vm; @@ -408,13 +425,13 @@ static void test_add_max_memory_regions(void) max_mem_slots = kvm_check_cap(KVM_CAP_NR_MEMSLOTS); TEST_ASSERT(max_mem_slots > 0, "KVM_CAP_NR_MEMSLOTS should be greater than 0"); - pr_info("Allowed number of memory slots: %i\n", max_mem_slots); + ksft_print_msg("Allowed number of memory slots: %i\n", max_mem_slots); vm = vm_create_barebones(); /* Check it can be added memory slots up to the maximum allowed */ - pr_info("Adding slots 0..%i, each memory region with %dK size\n", - (max_mem_slots - 1), MEM_REGION_SIZE >> 10); + ksft_print_msg("Adding slots 0..%i, each memory region with %dK size\n", + (max_mem_slots - 1), MEM_REGION_SIZE >> 10); mem = mmap(NULL, (size_t)max_mem_slots * MEM_REGION_SIZE + alignment, PROT_READ | PROT_WRITE, @@ -455,12 +472,21 @@ static void test_invalid_guest_memfd(struct kvm_vm *vm, int memfd, TEST_ASSERT(r == -1 && errno == EINVAL, "%s", msg); } -static void test_add_private_memory_region(void) +static bool has_cap_guest_memfd(void) +{ + return kvm_has_cap(KVM_CAP_GUEST_MEMFD) && + (kvm_check_cap(KVM_CAP_VM_TYPES) & BIT(KVM_X86_SW_PROTECTED_VM)); +} + +TEST(add_private_memory_region) { struct kvm_vm *vm, *vm2; int memfd, i; - pr_info("Testing ADD of KVM_MEM_GUEST_MEMFD memory regions\n"); + if (!has_cap_guest_memfd()) + SKIP(return, "Missing KVM_MEM_GUEST_MEMFD / KVM_X86_SW_PROTECTED_VM"); + + ksft_print_msg("Testing ADD of KVM_MEM_GUEST_MEMFD memory regions\n"); vm = vm_create_barebones_type(KVM_X86_SW_PROTECTED_VM); @@ -491,13 +517,16 @@ static void test_add_private_memory_region(void) kvm_vm_free(vm); } -static void test_add_overlapping_private_memory_regions(void) +TEST(add_overlapping_private_memory_regions) { struct kvm_vm *vm; int memfd; int r; - pr_info("Testing ADD of overlapping KVM_MEM_GUEST_MEMFD memory regions\n"); + if (!has_cap_guest_memfd()) + SKIP(return, "Missing KVM_MEM_GUEST_MEMFD / KVM_X86_SW_PROTECTED_VM"); + + ksft_print_msg("Testing ADD of overlapping KVM_MEM_GUEST_MEMFD memory regions\n"); vm = vm_create_barebones_type(KVM_X86_SW_PROTECTED_VM); @@ -536,46 +565,15 @@ static void test_add_overlapping_private_memory_regions(void) close(memfd); kvm_vm_free(vm); } + #endif int main(int argc, char *argv[]) { -#ifdef __x86_64__ - int i, loops; - - /* - * FIXME: the zero-memslot test fails on aarch64 and s390x because - * KVM_RUN fails with ENOEXEC or EFAULT. - */ - test_zero_memory_regions(); -#endif - - test_invalid_memory_region_flags(); - - test_add_max_memory_regions(); - -#ifdef __x86_64__ - if (kvm_has_cap(KVM_CAP_GUEST_MEMFD) && - (kvm_check_cap(KVM_CAP_VM_TYPES) & BIT(KVM_X86_SW_PROTECTED_VM))) { - test_add_private_memory_region(); - test_add_overlapping_private_memory_regions(); - } else { - pr_info("Skipping tests for KVM_MEM_GUEST_MEMFD memory regions\n"); - } - if (argc > 1) loops = atoi_positive("Number of iterations", argv[1]); else loops = 10; - pr_info("Testing MOVE of in-use region, %d loops\n", loops); - for (i = 0; i < loops; i++) - test_move_memory_region(); - - pr_info("Testing DELETE of in-use region, %d loops\n", loops); - for (i = 0; i < loops; i++) - test_delete_memory_region(); -#endif - - return 0; + return test_harness_run(argc, argv); } -- 2.44.0

1 year, 3 months

3
4
0 0

[PATCH 00/10] mm/damon: misc fixes and improvements

by SeongJae Park

Add miscelleneous and non-urgent fixes and improvements for DAMON code, selftests, and documents. SeongJae Park (10): mm/damon/core: initialize ->esz_bp from damos_quota_init_priv() selftests/damon/_damon_sysfs: check errors from nr_schemes file reads selftests/damon/_damon_sysfs: find sysfs mount point from /proc/mounts selftests/damon/_damon_sysfs: use 'is' instead of '==' for 'None' selftests/damon: classify tests for functionalities and regressions Docs/admin-guide/mm/damon/usage: fix wrong example of DAMOS filter matching sysfs file Docs/admin-guide/mm/damon/usage: fix wrong schemes effective quota update command Docs/mm/damon/design: use a list for supported filters Docs/mm/damon/maintainer-profile: change the maintainer's timezone from PST to PT Docs/mm/damon/maintainer-profile: allow posting patches based on damon/next tree Documentation/admin-guide/mm/damon/usage.rst | 6 +- Documentation/mm/damon/design.rst | 46 +++++---- Documentation/mm/damon/maintainer-profile.rst | 13 +-- mm/damon/core.c | 1 + tools/testing/selftests/damon/Makefile | 13 ++- tools/testing/selftests/damon/_damon_sysfs.py | 95 +++++++++++-------- 6 files changed, 100 insertions(+), 74 deletions(-) base-commit: fc7314cb6b750187a1366e0bf9da4c3ca8cfd064 -- 2.39.2

1 year, 3 months

1
5
0 0

[PATCH v5 00/17] riscv: Support vendor extensions and xtheadvector

by Charlie Jenkins

This patch series ended up much larger than expected, please bear with me! The goal here is to support vendor extensions, starting at probing the device tree and ending with reporting to userspace. The main design objective was to allow vendors to operate independently of each other. This has been achieved by delegating vendor extensions to a their own files and then accumulating the extensions in arch/riscv/kernel/vendor_extensions.c. Each vendor will have their own list of extensions they support. There is a new hwprobe key RISCV_HWPROBE_KEY_VENDOR_EXT_THEAD_0 that is used to request which thead vendor extensions are supported on the current platform. This allows future vendors to allocate hwprobe keys for their vendor. On to the xtheadvector specific code. xtheadvector is a custom extension that is based upon riscv vector version 0.7.1 [1]. All of the vector routines have been modified to support this alternative vector version based upon whether xtheadvector was determined to be supported at boot. I have tested this with an Allwinner Nezha board. I ran into issues booting the board on 6.9-rc1 so I applied these patches to 6.8. There are a couple of minor merge conflicts that do arrise when doing that, so please let me know if you have been able to boot this board with a 6.9 kernel. I used SkiffOS [2] to manage building the image, but upgraded the U-Boot version to Samuel Holland's more up-to-date version [3] and changed out the device tree used by U-Boot with the device trees that are present in upstream linux and this series. Thank you Samuel for all of the work you did to make this task possible. To test the integration, I used the riscv vector kselftests. I modified the test cases to be able to more easily extend them, and then added a xtheadvector target that works by calling hwprobe and swapping out the vector asm if needed. [1] https://github.com/T-head-Semi/thead-extension-spec/blob/95358cb2cca9489361… [2] https://github.com/skiffos/SkiffOS/tree/master/configs/allwinner/nezha [3] https://github.com/smaeul/u-boot/commit/2e89b706f5c956a70c989cd31665f1429e9… Signed-off-by: Charlie Jenkins <charlie(a)rivosinc.com> --- Changes in v5: - Make all vendors have the same size bitmap - Extract vendor hwprobe code into helper macro - Fix bug related to the handling of vendor extensions in the parsing of the isa string (Conor) - Fix bug with the vendor bitmap being incorrectly populated (Evan) - Add vendor extensions to /proc/cpuinfo - Link to v4: https://lore.kernel.org/r/20240426-dev-charlie-support_thead_vector_6_9-v4-… Changes in v4: - Disable vector immediately if vlenb from the device tree is not homogeneous - Hide vendor extension code behind a hidden config that vendor extensions select to eliminate the code when kernel is compiled without vendor extensions - Clear up naming conventions and introduce some defines to make the vendor extension code clearer - Link to v3: https://lore.kernel.org/r/20240420-dev-charlie-support_thead_vector_6_9-v3-… Changes in v3: - Allow any hardware to support any vendor extension, rather than restricting the vendor extensions to the same vendor as the hardware - Introduce config options to enable/disable a vendor's extensions - Link to v2: https://lore.kernel.org/r/20240415-dev-charlie-support_thead_vector_6_9-v2-… Changes in v2: - Added commit hash to xtheadvector - Simplified riscv,isa vector removal fix to not mess with the DT riscv,vendorid - Moved riscv,vendorid parsing into a different patch and cache the value to be used by alternative patching - Reduce riscv,vendorid missing severity to "info" - Separate vendor extension list to vendor files - xtheadvector no longer puts v in the elf_hwcap - Only patch vendor extension if all harts are associated with the same vendor. This is the best chance the kernel has for working properly if there are multiple vendors. - Split hwprobe vendor keys out into vendor file - Add attribution for Heiko's patches - Link to v1: https://lore.kernel.org/r/20240411-dev-charlie-support_thead_vector_6_9-v1-… --- Charlie Jenkins (15): dt-bindings: riscv: Add xtheadvector ISA extension description riscv: vector: Use vlenb from DT riscv: dts: allwinner: Add xtheadvector to the D1/D1s devicetree riscv: Extend cpufeature.c to detect vendor extensions riscv: Add vendor extensions to /proc/cpuinfo riscv: Introduce vendor variants of extension helpers riscv: cpufeature: Extract common elements from extension checking riscv: Convert xandespmu to use the vendor extension framework riscv: csr: Add CSR encodings for VCSR_VXRM/VCSR_VXSAT riscv: Add xtheadvector instruction definitions riscv: vector: Support xtheadvector save/restore riscv: hwprobe: Add thead vendor extension probing riscv: hwprobe: Document thead vendor extensions and xtheadvector extension selftests: riscv: Fix vector tests selftests: riscv: Support xtheadvector in vector tests Conor Dooley (1): dt-bindings: riscv: cpus: add a vlen register length property Heiko Stuebner (1): RISC-V: define the elements of the VCSR vector CSR Documentation/arch/riscv/hwprobe.rst | 10 + Documentation/devicetree/bindings/riscv/cpus.yaml | 6 + .../devicetree/bindings/riscv/extensions.yaml | 10 + arch/riscv/Kconfig | 2 + arch/riscv/Kconfig.vendor | 44 +++ arch/riscv/boot/dts/allwinner/sun20i-d1s.dtsi | 3 +- arch/riscv/errata/andes/errata.c | 2 + arch/riscv/errata/sifive/errata.c | 3 + arch/riscv/errata/thead/errata.c | 3 + arch/riscv/include/asm/cpufeature.h | 98 ++++--- arch/riscv/include/asm/csr.h | 13 + arch/riscv/include/asm/hwcap.h | 1 - arch/riscv/include/asm/hwprobe.h | 4 +- arch/riscv/include/asm/switch_to.h | 2 +- arch/riscv/include/asm/vector.h | 247 +++++++++++++---- arch/riscv/include/asm/vendor_extensions.h | 103 +++++++ arch/riscv/include/asm/vendor_extensions/andes.h | 19 ++ arch/riscv/include/asm/vendor_extensions/thead.h | 42 +++ .../include/asm/vendor_extensions/thead_hwprobe.h | 18 ++ .../include/asm/vendor_extensions/vendor_hwprobe.h | 34 +++ arch/riscv/include/uapi/asm/hwprobe.h | 3 +- arch/riscv/include/uapi/asm/vendor/thead.h | 3 + arch/riscv/kernel/Makefile | 2 + arch/riscv/kernel/cpu.c | 35 ++- arch/riscv/kernel/cpufeature.c | 171 +++++++++--- arch/riscv/kernel/kernel_mode_vector.c | 8 +- arch/riscv/kernel/process.c | 4 +- arch/riscv/kernel/signal.c | 6 +- arch/riscv/kernel/sys_hwprobe.c | 5 + arch/riscv/kernel/vector.c | 25 +- arch/riscv/kernel/vendor_extensions.c | 66 +++++ arch/riscv/kernel/vendor_extensions/Makefile | 5 + arch/riscv/kernel/vendor_extensions/andes.c | 18 ++ arch/riscv/kernel/vendor_extensions/thead.c | 18 ++ .../riscv/kernel/vendor_extensions/thead_hwprobe.c | 19 ++ drivers/perf/riscv_pmu_sbi.c | 9 +- tools/testing/selftests/riscv/vector/.gitignore | 3 +- tools/testing/selftests/riscv/vector/Makefile | 17 +- .../selftests/riscv/vector/v_exec_initval_nolibc.c | 93 +++++++ tools/testing/selftests/riscv/vector/v_helpers.c | 67 +++++ tools/testing/selftests/riscv/vector/v_helpers.h | 7 + tools/testing/selftests/riscv/vector/v_initval.c | 22 ++ .../selftests/riscv/vector/v_initval_nolibc.c | 68 ----- .../selftests/riscv/vector/vstate_exec_nolibc.c | 20 +- .../testing/selftests/riscv/vector/vstate_prctl.c | 295 ++++++++++++--------- 45 files changed, 1312 insertions(+), 341 deletions(-) --- base-commit: 4cece764965020c22cff7665b18a012006359095 change-id: 20240411-dev-charlie-support_thead_vector_6_9-1591fc2a431d -- - Charlie

1 year, 3 months

3
27
0 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror