January 2025 - Linux-kselftest-mirror

[RFC PATCH 0/4] PMU partitioning driver support

by Colton Lewis

This series introduces support in the ARM PMUv3 driver for partitioning PMU counters into two separate ranges by taking advantage of the MDCR_EL2.HPMN register field. The advantage of a partitioned PMU would be to allow KVM guests direct access to a subset of PMU functionality, greatly reducing the overhead of performance monitoring in guests. While this series could be accepted on its own merits, practically there is a lot more to be done before it will be fully useful, so I'm sending as an RFC for now. This patch is based on v6.13-rc7. It needs a small additional change after Oliver's Debug cleanups series going into 6.14, specifically this patch [1], because it changes kvm_arm_setup_mdcr_el2() to initialize HPMN from a cached value read early in the boot process instead of reading from the register. The only sensible way I can see to deal with this is returning to reading the register. [1] https://lore.kernel.org/kvmarm/20241219224116.3941496-3-oliver.upton@linux.… Colton Lewis (4): perf: arm_pmuv3: Introduce module param to partition the PMU KVM: arm64: Make guests see only counters they can access perf: arm_pmuv3: Generalize counter bitmasks perf: arm_pmuv3: Keep out of guest counter partition arch/arm/include/asm/arm_pmuv3.h | 10 ++ arch/arm64/include/asm/arm_pmuv3.h | 10 ++ arch/arm64/kvm/pmu-emul.c | 8 +- drivers/perf/arm_pmuv3.c | 113 ++++++++++++++++-- include/linux/perf/arm_pmu.h | 2 + include/linux/perf/arm_pmuv3.h | 34 +++++- .../kvm/aarch64/vpmu_counter_access.c | 2 +- 7 files changed, 160 insertions(+), 19 deletions(-) base-commit: 5bc55a333a2f7316b58edc7573e8e893f7acb532 -- 2.48.1.262.g85cc9f2d1e-goog

2 months, 1 week

4
14
0 0

Re: [PATCH 2/3] KVM: x86: Add support for VMware guest specific hypercalls

by Doug Covelli

On Wed, Nov 13, 2024 at 2:31 AM Paolo Bonzini <pbonzini(a)redhat.com> wrote: > > > > Il mar 12 nov 2024, 21:44 Doug Covelli <doug.covelli(a)broadcom.com> ha scritto: >> >> > Split irqchip should be the best tradeoff. Without it, moves from cr8 >> > stay in the kernel, but moves to cr8 always go to userspace with a >> > KVM_EXIT_SET_TPR exit. You also won't be able to use Intel >> > flexpriority (in-processor accelerated TPR) because KVM does not know >> > which bits are set in IRR. So it will be *really* every move to cr8 >> > that goes to userspace. >> >> Sorry to hijack this thread but is there a technical reason not to allow CR8 >> based accesses to the TPR (not MMIO accesses) when the in-kernel local APIC is >> not in use? > > > No worries, you're not hijacking :) The only reason is that it would be more code for a seldom used feature and anyway with worse performance. (To be clear, CR8 based accesses are allowed, but stores cause an exit in order to check the new TPR against IRR. That's because KVM's API does not have an equivalent of the TPR threshold as you point out below). I have not really looked at the code but it seems like it could also simplify things as CR8 would be handled more uniformly regardless of who is virtualizing the local APIC. >> Also I could not find these documented anywhere but with MSFT's APIC our monitor >> relies on extensions for trapping certain events such as INIT/SIPI plus LINT0 >> and SVR writes: >> >> UINT64 X64ApicInitSipiExitTrap : 1; // WHvRunVpExitReasonX64ApicInitSipiTrap >> UINT64 X64ApicWriteLint0ExitTrap : 1; // WHvRunVpExitReasonX64ApicWriteTrap >> UINT64 X64ApicWriteLint1ExitTrap : 1; // WHvRunVpExitReasonX64ApicWriteTrap >> UINT64 X64ApicWriteSvrExitTrap : 1; // WHvRunVpExitReasonX64ApicWriteTrap > > > There's no need for this in KVM's in-kernel APIC model. INIT and SIPI are handled in the hypervisor and you can get the current state of APs via KVM_GET_MPSTATE. LINT0 and LINT1 are injected with KVM_INTERRUPT and KVM_NMI respectively, and they obey IF/PPR and NMI blocking respectively, plus the interrupt shadow; so there's no need for userspace to know when LINT0/LINT1 themselves change. The spurious interrupt vector register is also handled completely in kernel. I realize that KVM can handle LINT0/SVR updates themselves but our interrupt subsystem relies on knowing the current values of these registers even when not virtualizing the local APIC. I suppose we could use KVM_GET_LAPIC to sync things up on demand but that seems like it might nor be great from a performance point of view. >> I did not see any similar functionality for KVM. Does anything like that exist? >> In any case we would be happy to add support for handling CR8 accesses w/o >> exiting w/o the in-kernel APIC along with some sort of a way to configure the >> TPR threshold if folks are not opposed to that. > > > As far I know everybody who's using KVM (whether proprietary or open source) has had no need for that, so I don't think it's a good idea to make the API more complex. Performance of Windows guests is going to be bad anyway with userspace APIC. From what I have seen the exit cost with KVM is significantly lower than with WHP/Hyper-V. I don't think performance of Windows guests with userspace APIC emulation would be bad if CR8 exits could be avoided (Linux guests perf isn't bad from what I have observed and the main difference is the astronomical number of CR8 exits). It seems like it would be pretty decent although I agree if you want the absolute best performance then you would want to use the in kernel APIC to speed up handling of ICR/EOI writes but those are relatively infrequent compared to CR8 accesses . Anyway I just saw Sean's response while writing this and it seems he is not in favor of avoiding CR8 exits w/o the in kernel APIC either so I suppose we will have to look into making use of the in kernel APIC. Doug > Paolo > >> Doug >> >> > > For now I think it makes sense to handle BDOOR_CMD_GET_VCPU_INFO at userlevel >> > > like we do on Windows and macOS. >> > > >> > > BDOOR_CMD_GETTIME/BDOOR_CMD_GETTIMEFULL are similar with the former being >> > > deprecated in favor of the latter. Both do essentially the same thing which is >> > > to return the host OS's time - on Linux this is obtained via gettimeofday. I >> > > believe this is mainly used by tools to fix up the VM's time when resuming from >> > > suspend. I think it is fine to continue handling these at userlevel. >> > >> > As long as the TSC is not involved it should be okay. >> > >> > Paolo >> > >> > > > >> Anyway, one question apart from this: is the API the same for the I/O >> > > > >> port and hypercall backdoors? >> > > > > >> > > > > Yeah the calls and arguments are the same. The hypercall based >> > > > > interface is an attempt to modernize the backdoor since as you pointed >> > > > > out the I/O based interface is kind of hacky as it bypasses the normal >> > > > > checks for an I/O port access at CPL3. It would be nice to get rid of >> > > > > it but unfortunately I don't think that will happen in the foreseeable >> > > > > future as there are a lot of existing VMs out there with older SW that >> > > > > still uses this interface. >> > > > >> > > > Yeah, but I think it still justifies that the KVM_ENABLE_CAP API can >> > > > enable the hypercall but not the I/O port. >> > > > >> > > > Paolo >> > >> >> -- >> This electronic communication and the information and any files transmitted >> with it, or attached to it, are confidential and are intended solely for >> the use of the individual or entity to whom it is addressed and may contain >> information that is confidential, legally privileged, protected by privacy >> laws, or otherwise restricted from disclosure to anyone else. If you are >> not the intended recipient or the person responsible for delivering the >> e-mail to the intended recipient, you are hereby notified that any use, >> copying, distributing, dissemination, forwarding, printing, or copying of >> this e-mail is strictly prohibited. If you received this e-mail in error, >> please return the e-mail to the sender, delete it from your computer, and >> destroy any printed copy of it. >> -- This electronic communication and the information and any files transmitted with it, or attached to it, are confidential and are intended solely for the use of the individual or entity to whom it is addressed and may contain information that is confidential, legally privileged, protected by privacy laws, or otherwise restricted from disclosure to anyone else. If you are not the intended recipient or the person responsible for delivering the e-mail to the intended recipient, you are hereby notified that any use, copying, distributing, dissemination, forwarding, printing, or copying of this e-mail is strictly prohibited. If you received this e-mail in error, please return the e-mail to the sender, delete it from your computer, and destroy any printed copy of it.

2 months, 1 week

3
12
0 0

[PATCH 0/6] selftests/nolibc: wire up riscv32

by Thomas Weißschuh

Nolibc has support for riscv32. But the testsuite did not allow to test it so far. Add a test configuration. Signed-off-by: Thomas Weißschuh <linux(a)weissschuh.net> --- Thomas Weißschuh (6): tools/nolibc: add support for waitid() selftests/nolibc: use waitid() over waitpid() selftests/nolibc: use a pipe to in vfprintf tests selftests/nolibc: skip tests for unimplemented syscalls selftests/nolibc: rename riscv to riscv64 selftests/nolibc: add configurations for riscv32 tools/include/nolibc/sys.h | 18 ++++++++++++ tools/testing/selftests/nolibc/Makefile | 11 +++++++ tools/testing/selftests/nolibc/nolibc-test.c | 44 ++++++++++++++++------------ tools/testing/selftests/nolibc/run-tests.sh | 2 +- 4 files changed, 56 insertions(+), 19 deletions(-) --- base-commit: 499551201b5f4fd3c0618a3e95e3d0d15ea18f31 change-id: 20241219-nolibc-rv32-cff8a3e22394 Best regards, -- Thomas Weißschuh <linux(a)weissschuh.net>

2 months, 1 week

4
12
0 0

[PATCH RFC net-next] netconsole: selftest: Add test for fragmented messages

by Breno Leitao

Add a new selftest to verify netconsole's handling of messages that exceed the packet size limit and require fragmentation. The test sends messages with varying sizes and userdata, validating that: 1. Large messages are correctly fragmented and reassembled 2. Userdata fields are properly preserved across fragments 3. Messages work correctly with and without kernel release version appending The test creates a networking environment using netdevsim, sends messages through /dev/kmsg, and verifies the received fragments maintain message integrity. Signed-off-by: Breno Leitao <leitao(a)debian.org> --- tools/testing/selftests/drivers/net/Makefile | 1 + .../selftests/drivers/net/lib/sh/lib_netcons.sh | 7 ++ .../drivers/net/netcons_fragmented_msg.sh | 122 +++++++++++++++++++++ 3 files changed, 130 insertions(+) diff --git a/tools/testing/selftests/drivers/net/Makefile b/tools/testing/selftests/drivers/net/Makefile index 137470bdee0c7fd2517bd1baafc12d575de4b4ac..c7f1c443f2af091aa13f67dd1df9ae05d7a43f40 100644 --- a/tools/testing/selftests/drivers/net/Makefile +++ b/tools/testing/selftests/drivers/net/Makefile @@ -7,6 +7,7 @@ TEST_INCLUDES := $(wildcard lib/py/*.py) \ TEST_PROGS := \ netcons_basic.sh \ + netcons_fragmented_msg.sh \ netcons_overflow.sh \ ping.py \ queues.py \ diff --git a/tools/testing/selftests/drivers/net/lib/sh/lib_netcons.sh b/tools/testing/selftests/drivers/net/lib/sh/lib_netcons.sh index 3acaba41ac7b21aa2fd8457ed640a5ac8a41bc12..0c262b123fdd3082c40b2bd899ec626d223226ed 100644 --- a/tools/testing/selftests/drivers/net/lib/sh/lib_netcons.sh +++ b/tools/testing/selftests/drivers/net/lib/sh/lib_netcons.sh @@ -110,6 +110,13 @@ function create_dynamic_target() { echo 1 > "${NETCONS_PATH}"/enabled } +# Do not append the release to the header of the message +function disable_release_append() { + echo 0 > "${NETCONS_PATH}"/enabled + echo 0 > "${NETCONS_PATH}"/release + echo 1 > "${NETCONS_PATH}"/enabled +} + function cleanup() { local NSIM_DEV_SYS_DEL="/sys/bus/netdevsim/del_device" diff --git a/tools/testing/selftests/drivers/net/netcons_fragmented_msg.sh b/tools/testing/selftests/drivers/net/netcons_fragmented_msg.sh new file mode 100755 index 0000000000000000000000000000000000000000..d175d5b9db662ab9a6ee203794569cc620801a4f --- /dev/null +++ b/tools/testing/selftests/drivers/net/netcons_fragmented_msg.sh @@ -0,0 +1,122 @@ +#!/usr/bin/env bash +# SPDX-License-Identifier: GPL-2.0 + +# Test netconsole's message fragmentation functionality. +# +# When a message exceeds the maximum packet size, netconsole splits it into +# multiple fragments for transmission. This test verifies: +# - Correct fragmentation of large messages +# - Proper reassembly of fragments at the receiver +# - Preservation of userdata across fragments +# - Behavior with and without kernel release version appending +# +# Author: Breno Leitao <leitao(a)debian.org> + +set -euo pipefail + +SCRIPTDIR=$(dirname "$(readlink -e "${BASH_SOURCE[0]}")") + +source "${SCRIPTDIR}"/lib/sh/lib_netcons.sh + +modprobe netdevsim 2> /dev/null || true +modprobe netconsole 2> /dev/null || true + +# The content of kmsg will be save to the following file +OUTPUT_FILE="/tmp/${TARGET}" + +# set userdata to a long value. In this case, it is "1-2-3-4...50-" +USERDATA_VALUE=$(printf -- '%.2s-' {1..60}) + +# Convert the header string in a regexp, so, we can remove +# the second header as well. +# A header looks like "13,468,514729715,-,ncfrag=0/1135;". If +# release is appended, you might find something like:L +# "6.13.0-04048-g4f561a87745a,13,468,514729715,-,ncfrag=0/1135;" +function header_to_regex() { + # header is everything before ; + local HEADER="${1}" + REGEX=$(echo "${HEADER}" | cut -d'=' -f1) + echo "${REGEX}=[0-9]*\/[0-9]*;" +} + +# We have two headers in the message. Remove both to get the full message, +# and extract the full message. +function extract_msg() { + local MSGFILE="${1}" + # Extract the header, which is the very first thing that arrives in the + # first list. + HEADER=$(sed -n '1p' "${MSGFILE}" | cut -d';' -f1) + HEADER_REGEX=$(header_to_regex "${HEADER}") + + # Remove the two headers from the received message + # This will return the message without any header, similarly to what + # was sent. + sed "s/""${HEADER_REGEX}""//g" "${MSGFILE}" +} + +# Validate the message, which has two messages glued together. +# unwrap them to make sure all the characters were transmitted. +# File will look like the following: +# 13,468,514729715,-,ncfrag=0/1135;MSG1=MSG2=MSG3=MSG4=MSG5=MSG6=MSG7=MSG8=MSG9=MSG10=MSG11=MSG12=MSG13=MSG14=MSG15=MSG16=MSG17=MSG18=MSG19=MSG20=MSG21=MSG22=MSG23=MSG24=MSG25=MSG26=MSG27=MSG28=MSG29=MSG30=MSG31=MSG32=MSG33=MSG34=MSG35=MSG36=MSG37=MSG38=MSG39=MSG40=MSG41=MSG42=MSG43=MSG44=MSG45=MSG46=MSG47=MSG48=MSG49=MSG50=MSG51=MSG52=MSG53=MSG54=MSG55=MSG56=MSG57=MSG58=MSG59=MSG60=MSG61=MSG62=MSG63=MSG64=MSG65=MSG66=MSG67=MSG68=MSG69=MSG70=MSG71=MSG72=MSG73=MSG74=MSG75=MSG76=MSG77=MSG78=MSG79=MSG80=MSG81=MSG82=MSG83=MSG84=MSG85=MSG86=MSG87=MSG88=MSG89=MSG90=MSG91=MSG92=MSG93=MSG94=MSG95=MSG96=MSG97=MSG98=MSG99=MSG100=MSG101=MSG102=MSG103=MSG104=MSG105=MSG106=MSG107=MSG108=MSG109=MSG110=MSG111=MSG112=MSG113=MSG114=MSG115=MSG116=MSG117=MSG118=MSG119=MSG120=MSG121=MSG122=MSG123=MSG124=MSG125=MSG126=MSG127=MSG128=MSG129=MSG130=MSG131=MSG132=MSG133=MSG134=MSG135=MSG136=MSG137=MSG138=MSG139=MSG140=MSG141=MSG142=MSG143=MSG144=MSG145=MSG146=MSG147=MSG148=MSG149=MSG150=: netcons_nzmJQ +# key=1-2-13,468,514729715,-,ncfrag=967/1135;3-4-5-6-7-8-9-10-11-12-13-14-15-16-17-18-19-20-21-22-23-24-25-26-27-28-29-30-31-32-33-34-35-36-37-38-39-40-41-42-43-44-45-46-47-48-49-50-51-52-53-54-55-56-57-58-59-60- +function validate_fragmented_result() { + # Discard the netconsole headers, and assemble the full message + RCVMSG=$(extract_msg "${1}") + + # check for the main message + if ! echo "${RCVMSG}" | grep -q "${MSG}"; then + echo "Message body doesn't match." >&2 + echo "msg received=" "${RCVMSG}" >&2 + exit "${ksft_fail}" + fi + + # check userdata + if ! echo "${RCVMSG}" | grep -q "${USERDATA_VALUE}"; then + echo "message userdata doesn't match" >&2 + echo "msg received=" "${RCVMSG}" >&2 + exit "${ksft_fail}" + fi + # test passed. hooray +} + +# Check for basic system dependency and exit if not found +check_for_dependencies +# Set current loglevel to KERN_INFO(6), and default to KERN_NOTICE(5) +echo "6 5" > /proc/sys/kernel/printk +# Remove the namespace, interfaces and netconsole target on exit +trap cleanup EXIT +# Create one namespace and two interfaces +set_network +# Create a dynamic target for netconsole +create_dynamic_target +# Set userdata "key" with the "value" value +set_user_data + + +# TEST 1: Send message and userdata. They will fragment +# ======= +MSG=$(printf -- 'MSG%.3s=' {1..150}) + +# Listen for netconsole port inside the namespace and destination interface +listen_port_and_save_to "${OUTPUT_FILE}" & +# Wait for socat to start and listen to the port. +wait_local_port_listen "${NAMESPACE}" "${PORT}" udp +# Send the message +echo "${MSG}: ${TARGET}" > /dev/kmsg +# Wait until socat saves the file to disk +busywait "${BUSYWAIT_TIMEOUT}" test -s "${OUTPUT_FILE}" +# Check if the message was not corrupted +validate_fragmented_result "${OUTPUT_FILE}" + +# TEST 2: Test with smaller message, and without release appended +# ======= +MSG=$(printf -- 'FOOBAR%.3s=' {1..100}) +# Let's disable release and test again. +disable_release_append + +listen_port_and_save_to "${OUTPUT_FILE}" & +wait_local_port_listen "${NAMESPACE}" "${PORT}" udp +echo "${MSG}: ${TARGET}" > /dev/kmsg +busywait "${BUSYWAIT_TIMEOUT}" test -s "${OUTPUT_FILE}" +validate_fragmented_result "${OUTPUT_FILE}" +exit "${ksft_pass}" --- base-commit: 0ad9617c78acbc71373fb341a6f75d4012b01d69 change-id: 20250129-netcons_frag_msgs-91506d136f50 Best regards, -- Breno Leitao <leitao(a)debian.org>

2 months, 1 week

2
4
0 0

[PATCH bpf-next v4 00/14] selftests/bpf: Migrate test_xdp_redirect_multi.sh to test_progs

by Bastien Curutchet (eBPF Foundation)

Hi all, This patch series continues the work to migrate the *.sh tests into prog_tests framework. test_xdp_redirect_multi.sh tests the XDP redirections done through bpf_redirect_map(). This is already partly covered by test_xdp_veth.c that already tests map redirections at XDP level. What isn't covered yet by test_xdp_veth is the use of the broadcast flags (BPF_F_BROADCAST or BPF_F_EXCLUDE_INGRESS) and XDP egress programs. Hence, this patch series add test cases to test_xdp_veth.c to get rid of the test_xdp_redirect_multi.sh: - PATCH 1 Add an helper to generate unique names - PATCH 2 to 9 rework test_xdp_veth to make it more generic and allow to configure different test cases - PATCH 10 adds test cases for 'classic' bpf_redirect_map() - PATCH 11 and 12 cover the broadcast flags - PATCH 13 covers the XDP egress programs - PATCH 14 removes test_xdp_redirect_multi.sh Signed-off-by: Bastien Curutchet (eBPF Foundation) <bastien.curutchet(a)bootlin.com> --- Changes in v4: - Remove the NO_IP #define - append_tid() takes string's size as input to ensure there is enough space to fit the thread ID at the end - Fix PATCH 12's commit log - Link to v3: https://lore.kernel.org/r/20250128-redirect-multi-v3-0-c1ce69997c01@bootlin… Changes in v3: - Add append_tid() helper and use unique names to allow parallel testing - Check create_network()'s return value through ASSERT_OK() - Remove check_ping() and unused defines - Change next_veth type (from string to int) - Link to v2: https://lore.kernel.org/r/20250121-redirect-multi-v2-0-fc9cacabc6b2@bootlin… Changes in v2: - Use serial_test_* to avoid conflict between tests - Link to v1: https://lore.kernel.org/r/20250121-redirect-multi-v1-0-b215e35ff505@bootlin… --- Bastien Curutchet (eBPF Foundation) (14): selftests/bpf: helpers: Add append_tid() selftests/bpf: test_xdp_veth: Remove unused defines selftests/bpf: test_xdp_veth: Remove unecessarry check_ping() selftests/bpf: test_xdp_veth: Use int to describe next veth selftests/bpf: test_xdp_veth: Split network configuration selftests/bpf: test_xdp_veth: Rename config[] selftests/bpf: test_xdp_veth: Add prog_config[] table selftests/bpf: test_xdp_veth: Add XDP flags to prog_configuration selftests/bpf: test_xdp_veth: Use unique names selftests/bpf: test_xdp_veth: Add new test cases for XDP flags selftests/bpf: Optionally select broadcasting flags selftests/bpf: test_xdp_veth: Add XDP broadcast redirection tests selftests/bpf: test_xdp_veth: Add XDP program on egress test selftests/bpf: Remove test_xdp_redirect_multi.sh tools/testing/selftests/bpf/Makefile | 2 - tools/testing/selftests/bpf/network_helpers.c | 17 + tools/testing/selftests/bpf/network_helpers.h | 12 + .../selftests/bpf/prog_tests/test_xdp_veth.c | 588 ++++++++++++++++----- .../testing/selftests/bpf/progs/xdp_redirect_map.c | 89 ++++ .../selftests/bpf/progs/xdp_redirect_multi_kern.c | 41 +- .../selftests/bpf/test_xdp_redirect_multi.sh | 214 -------- tools/testing/selftests/bpf/xdp_redirect_multi.c | 226 -------- 8 files changed, 615 insertions(+), 574 deletions(-) --- base-commit: 421ec9c8f46a25743870a8cbaff76de293752e00 change-id: 20250103-redirect-multi-245d6eafb5d1 Best regards, -- Bastien Curutchet (eBPF Foundation) <bastien.curutchet(a)bootlin.com>

2 months, 1 week

3
16
0 0

[PATCH v3 net] udp: gso: do not drop small packets when PMTU reduces

by Yan Zhai

Commit 4094871db1d6 ("udp: only do GSO if # of segs > 1") avoided GSO for small packets. But the kernel currently dismisses GSO requests only after checking MTU/PMTU on gso_size. This means any packets, regardless of their payload sizes, could be dropped when PMTU becomes smaller than requested gso_size. We encountered this issue in production and it caused a reliability problem that new QUIC connection cannot be established before PMTU cache expired, while non GSO sockets still worked fine at the same time. Ideally, do not check any GSO related constraints when payload size is smaller than requested gso_size, and return EMSGSIZE instead of EINVAL on MTU/PMTU check failure to be more specific on the error cause. Fixes: 4094871db1d6 ("udp: only do GSO if # of segs > 1") Signed-off-by: Yan Zhai <yan(a)cloudflare.com> Suggested-by: Willem de Bruijn <willemdebruijn.kernel(a)gmail.com> --- v2->v3: simplify the code; adding two test cases v1->v2: add a missing MTU check when fall back to no GSO mode; Fixed up commit message to be more precise. v2: https://lore.kernel.org/netdev/Z5swit7ykNRbJFMS@debian.debian/T/#u v1: https://lore.kernel.org/all/Z5cgWh%2F6bRQm9vVU@debian.debian/ --- net/ipv4/udp.c | 4 ++-- net/ipv6/udp.c | 4 ++-- tools/testing/selftests/net/udpgso.c | 26 ++++++++++++++++++++++++++ 3 files changed, 30 insertions(+), 4 deletions(-) diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c index c472c9a57cf6..a9bb9ce5438e 100644 --- a/net/ipv4/udp.c +++ b/net/ipv4/udp.c @@ -1141,9 +1141,9 @@ static int udp_send_skb(struct sk_buff *skb, struct flowi4 *fl4, const int hlen = skb_network_header_len(skb) + sizeof(struct udphdr); - if (hlen + cork->gso_size > cork->fragsize) { + if (hlen + min(datalen, cork->gso_size) > cork->fragsize) { kfree_skb(skb); - return -EINVAL; + return -EMSGSIZE; } if (datalen > cork->gso_size * UDP_MAX_SEGMENTS) { kfree_skb(skb); diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c index 6671daa67f4f..c6ea438b5c75 100644 --- a/net/ipv6/udp.c +++ b/net/ipv6/udp.c @@ -1389,9 +1389,9 @@ static int udp_v6_send_skb(struct sk_buff *skb, struct flowi6 *fl6, const int hlen = skb_network_header_len(skb) + sizeof(struct udphdr); - if (hlen + cork->gso_size > cork->fragsize) { + if (hlen + min(datalen, cork->gso_size) > cork->fragsize) { kfree_skb(skb); - return -EINVAL; + return -EMSGSIZE; } if (datalen > cork->gso_size * UDP_MAX_SEGMENTS) { kfree_skb(skb); diff --git a/tools/testing/selftests/net/udpgso.c b/tools/testing/selftests/net/udpgso.c index 3f2fca02fec5..36ff28af4b19 100644 --- a/tools/testing/selftests/net/udpgso.c +++ b/tools/testing/selftests/net/udpgso.c @@ -102,6 +102,19 @@ struct testcase testcases_v4[] = { .gso_len = CONST_MSS_V4, .r_num_mss = 1, }, + { + /* datalen <= MSS < gso_len: will fall back to no GSO */ + .tlen = CONST_MSS_V4, + .gso_len = CONST_MSS_V4 + 1, + .r_num_mss = 0, + .r_len_last = CONST_MSS_V4, + }, + { + /* MSS < datalen < gso_len: fail */ + .tlen = CONST_MSS_V4 + 1, + .gso_len = CONST_MSS_V4 + 2, + .tfail = true, + }, { /* send a single MSS + 1B */ .tlen = CONST_MSS_V4 + 1, @@ -205,6 +218,19 @@ struct testcase testcases_v6[] = { .gso_len = CONST_MSS_V6, .r_num_mss = 1, }, + { + /* datalen <= MSS < gso_len: will fall back to no GSO */ + .tlen = CONST_MSS_V6, + .gso_len = CONST_MSS_V6 + 1, + .r_num_mss = 0, + .r_len_last = CONST_MSS_V6, + }, + { + /* MSS < datalen < gso_len: fail */ + .tlen = CONST_MSS_V6 + 1, + .gso_len = CONST_MSS_V6 + 2, + .tfail = true + }, { /* send a single MSS + 1B */ .tlen = CONST_MSS_V6 + 1, -- 2.30.2

2 months, 1 week

3
2
0 0

[PATCH] scanf: convert self-test to KUnit

by Tamir Duberstein

Convert the scanf() self-test to a KUnit test. In the interest of keeping the patch reasonably-sized this doesn't rename the file in accordance with usual kunit conventions nor does it refactor the tests into proper parameterized tests - it's all one big test case. Signed-off-by: Tamir Duberstein <tamird(a)gmail.com> --- This is one of just 3 remaining "Test Module" kselftests (the others being bitmap and printf), the rest having been converted to KUnit. In addition to the enclosed patch, please consider this an RFC on the removal of the "Test Module" kselftest machinery. I tested this using: $ tools/testing/kunit/kunit.py run --arch arm64 --make_options LLVM=1 scanf --- arch/m68k/configs/amiga_defconfig | 1 - arch/m68k/configs/apollo_defconfig | 1 - arch/m68k/configs/atari_defconfig | 1 - arch/m68k/configs/bvme6000_defconfig | 1 - arch/m68k/configs/hp300_defconfig | 1 - arch/m68k/configs/mac_defconfig | 1 - arch/m68k/configs/multi_defconfig | 1 - arch/m68k/configs/mvme147_defconfig | 1 - arch/m68k/configs/mvme16x_defconfig | 1 - arch/m68k/configs/q40_defconfig | 1 - arch/m68k/configs/sun3_defconfig | 1 - arch/m68k/configs/sun3x_defconfig | 1 - arch/powerpc/configs/ppc64_defconfig | 1 - lib/Kconfig.debug | 20 +- lib/Makefile | 2 +- lib/test_scanf.c | 704 +++++++++++++++++------------------ tools/testing/selftests/lib/Makefile | 2 +- tools/testing/selftests/lib/config | 1 - tools/testing/selftests/lib/scanf.sh | 4 - 19 files changed, 358 insertions(+), 388 deletions(-) diff --git a/arch/m68k/configs/amiga_defconfig b/arch/m68k/configs/amiga_defconfig index dbf2ea561c85..e85a4b3a9847 100644 --- a/arch/m68k/configs/amiga_defconfig +++ b/arch/m68k/configs/amiga_defconfig @@ -623,7 +623,6 @@ CONFIG_ASYNC_RAID6_TEST=m CONFIG_TEST_HEXDUMP=m CONFIG_TEST_KSTRTOX=m CONFIG_TEST_PRINTF=m -CONFIG_TEST_SCANF=m CONFIG_TEST_BITMAP=m CONFIG_TEST_UUID=m CONFIG_TEST_XARRAY=m diff --git a/arch/m68k/configs/apollo_defconfig b/arch/m68k/configs/apollo_defconfig index b0fd199cc0a4..232b885cc26e 100644 --- a/arch/m68k/configs/apollo_defconfig +++ b/arch/m68k/configs/apollo_defconfig @@ -580,7 +580,6 @@ CONFIG_ASYNC_RAID6_TEST=m CONFIG_TEST_HEXDUMP=m CONFIG_TEST_KSTRTOX=m CONFIG_TEST_PRINTF=m -CONFIG_TEST_SCANF=m CONFIG_TEST_BITMAP=m CONFIG_TEST_UUID=m CONFIG_TEST_XARRAY=m diff --git a/arch/m68k/configs/atari_defconfig b/arch/m68k/configs/atari_defconfig index bb5b2d3b6c10..228af5b4cd42 100644 --- a/arch/m68k/configs/atari_defconfig +++ b/arch/m68k/configs/atari_defconfig @@ -600,7 +600,6 @@ CONFIG_ASYNC_RAID6_TEST=m CONFIG_TEST_HEXDUMP=m CONFIG_TEST_KSTRTOX=m CONFIG_TEST_PRINTF=m -CONFIG_TEST_SCANF=m CONFIG_TEST_BITMAP=m CONFIG_TEST_UUID=m CONFIG_TEST_XARRAY=m diff --git a/arch/m68k/configs/bvme6000_defconfig b/arch/m68k/configs/bvme6000_defconfig index 8315a13bab73..cbc59aed3d97 100644 --- a/arch/m68k/configs/bvme6000_defconfig +++ b/arch/m68k/configs/bvme6000_defconfig @@ -572,7 +572,6 @@ CONFIG_ASYNC_RAID6_TEST=m CONFIG_TEST_HEXDUMP=m CONFIG_TEST_KSTRTOX=m CONFIG_TEST_PRINTF=m -CONFIG_TEST_SCANF=m CONFIG_TEST_BITMAP=m CONFIG_TEST_UUID=m CONFIG_TEST_XARRAY=m diff --git a/arch/m68k/configs/hp300_defconfig b/arch/m68k/configs/hp300_defconfig index 350370657e5f..8d3787b8fe6d 100644 --- a/arch/m68k/configs/hp300_defconfig +++ b/arch/m68k/configs/hp300_defconfig @@ -582,7 +582,6 @@ CONFIG_ASYNC_RAID6_TEST=m CONFIG_TEST_HEXDUMP=m CONFIG_TEST_KSTRTOX=m CONFIG_TEST_PRINTF=m -CONFIG_TEST_SCANF=m CONFIG_TEST_BITMAP=m CONFIG_TEST_UUID=m CONFIG_TEST_XARRAY=m diff --git a/arch/m68k/configs/mac_defconfig b/arch/m68k/configs/mac_defconfig index f942b4755702..a68893d83361 100644 --- a/arch/m68k/configs/mac_defconfig +++ b/arch/m68k/configs/mac_defconfig @@ -599,7 +599,6 @@ CONFIG_ASYNC_RAID6_TEST=m CONFIG_TEST_HEXDUMP=m CONFIG_TEST_KSTRTOX=m CONFIG_TEST_PRINTF=m -CONFIG_TEST_SCANF=m CONFIG_TEST_BITMAP=m CONFIG_TEST_UUID=m CONFIG_TEST_XARRAY=m diff --git a/arch/m68k/configs/multi_defconfig b/arch/m68k/configs/multi_defconfig index b1eaad02efab..9a17526cefd2 100644 --- a/arch/m68k/configs/multi_defconfig +++ b/arch/m68k/configs/multi_defconfig @@ -686,7 +686,6 @@ CONFIG_ASYNC_RAID6_TEST=m CONFIG_TEST_HEXDUMP=m CONFIG_TEST_KSTRTOX=m CONFIG_TEST_PRINTF=m -CONFIG_TEST_SCANF=m CONFIG_TEST_BITMAP=m CONFIG_TEST_UUID=m CONFIG_TEST_XARRAY=m diff --git a/arch/m68k/configs/mvme147_defconfig b/arch/m68k/configs/mvme147_defconfig index 6309a4442bb3..5cf2e2860044 100644 --- a/arch/m68k/configs/mvme147_defconfig +++ b/arch/m68k/configs/mvme147_defconfig @@ -572,7 +572,6 @@ CONFIG_ASYNC_RAID6_TEST=m CONFIG_TEST_HEXDUMP=m CONFIG_TEST_KSTRTOX=m CONFIG_TEST_PRINTF=m -CONFIG_TEST_SCANF=m CONFIG_TEST_BITMAP=m CONFIG_TEST_UUID=m CONFIG_TEST_XARRAY=m diff --git a/arch/m68k/configs/mvme16x_defconfig b/arch/m68k/configs/mvme16x_defconfig index 3feb0731f814..eb395749bc75 100644 --- a/arch/m68k/configs/mvme16x_defconfig +++ b/arch/m68k/configs/mvme16x_defconfig @@ -573,7 +573,6 @@ CONFIG_ASYNC_RAID6_TEST=m CONFIG_TEST_HEXDUMP=m CONFIG_TEST_KSTRTOX=m CONFIG_TEST_PRINTF=m -CONFIG_TEST_SCANF=m CONFIG_TEST_BITMAP=m CONFIG_TEST_UUID=m CONFIG_TEST_XARRAY=m diff --git a/arch/m68k/configs/q40_defconfig b/arch/m68k/configs/q40_defconfig index ea04b1b0da7d..8891f12c2a18 100644 --- a/arch/m68k/configs/q40_defconfig +++ b/arch/m68k/configs/q40_defconfig @@ -589,7 +589,6 @@ CONFIG_ASYNC_RAID6_TEST=m CONFIG_TEST_HEXDUMP=m CONFIG_TEST_KSTRTOX=m CONFIG_TEST_PRINTF=m -CONFIG_TEST_SCANF=m CONFIG_TEST_BITMAP=m CONFIG_TEST_UUID=m CONFIG_TEST_XARRAY=m diff --git a/arch/m68k/configs/sun3_defconfig b/arch/m68k/configs/sun3_defconfig index f52d9af92153..a49ff5330e5b 100644 --- a/arch/m68k/configs/sun3_defconfig +++ b/arch/m68k/configs/sun3_defconfig @@ -569,7 +569,6 @@ CONFIG_ASYNC_RAID6_TEST=m CONFIG_TEST_HEXDUMP=m CONFIG_TEST_KSTRTOX=m CONFIG_TEST_PRINTF=m -CONFIG_TEST_SCANF=m CONFIG_TEST_BITMAP=m CONFIG_TEST_UUID=m CONFIG_TEST_XARRAY=m diff --git a/arch/m68k/configs/sun3x_defconfig b/arch/m68k/configs/sun3x_defconfig index f348447824da..3022ff492136 100644 --- a/arch/m68k/configs/sun3x_defconfig +++ b/arch/m68k/configs/sun3x_defconfig @@ -570,7 +570,6 @@ CONFIG_ASYNC_RAID6_TEST=m CONFIG_TEST_HEXDUMP=m CONFIG_TEST_KSTRTOX=m CONFIG_TEST_PRINTF=m -CONFIG_TEST_SCANF=m CONFIG_TEST_BITMAP=m CONFIG_TEST_UUID=m CONFIG_TEST_XARRAY=m diff --git a/arch/powerpc/configs/ppc64_defconfig b/arch/powerpc/configs/ppc64_defconfig index 465eb96c755e..819387cbbe69 100644 --- a/arch/powerpc/configs/ppc64_defconfig +++ b/arch/powerpc/configs/ppc64_defconfig @@ -445,7 +445,6 @@ CONFIG_STRING_SELFTEST=m CONFIG_TEST_STRING_HELPERS=m CONFIG_TEST_KSTRTOX=m CONFIG_TEST_PRINTF=m -CONFIG_TEST_SCANF=m CONFIG_TEST_BITMAP=m CONFIG_TEST_UUID=m CONFIG_TEST_XARRAY=m diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index 1af972a92d06..716c4ef857bb 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -2427,6 +2427,23 @@ config ASYNC_RAID6_TEST config TEST_HEXDUMP tristate "Test functions located in the hexdump module at runtime" +config SCANF_KUNIT_TEST + tristate "KUnit test scanf() family of functions at runtime" if !KUNIT_ALL_TESTS + depends on KUNIT + default KUNIT_ALL_TESTS + help + Enable this option to test the scanf functions at boot. + + KUnit tests run during boot and output the results to the debug log + in TAP format (http://testanything.org/). Only useful for kernel devs + running the KUnit test harness, and not intended for inclusion into a + production build. + + For more information on KUnit and unit tests in general please refer + to the KUnit documentation in Documentation/dev-tools/kunit/. + + If unsure, say N. + config STRING_KUNIT_TEST tristate "KUnit test string functions at runtime" if !KUNIT_ALL_TESTS depends on KUNIT @@ -2443,9 +2460,6 @@ config TEST_KSTRTOX config TEST_PRINTF tristate "Test printf() family of functions at runtime" -config TEST_SCANF - tristate "Test scanf() family of functions at runtime" - config TEST_BITMAP tristate "Test bitmap_*() family of functions at runtime" help diff --git a/lib/Makefile b/lib/Makefile index d5cfc7afbbb8..8f1cf22bd83b 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -52,6 +52,7 @@ obj-y += bcd.o sort.o parser.o debug_locks.o random32.o \ percpu-refcount.o rhashtable.o base64.o \ once.o refcount.o rcuref.o usercopy.o errseq.o bucket_locks.o \ generic-radix-tree.o bitmap-str.o +obj-$(CONFIG_SCANF_KUNIT_TEST) += test_scanf.o obj-$(CONFIG_STRING_KUNIT_TEST) += string_kunit.o obj-y += string_helpers.o obj-$(CONFIG_STRING_HELPERS_KUNIT_TEST) += string_helpers_kunit.o @@ -85,7 +86,6 @@ obj-$(CONFIG_TEST_STATIC_KEYS) += test_static_keys.o obj-$(CONFIG_TEST_STATIC_KEYS) += test_static_key_base.o obj-$(CONFIG_TEST_DYNAMIC_DEBUG) += test_dynamic_debug.o obj-$(CONFIG_TEST_PRINTF) += test_printf.o -obj-$(CONFIG_TEST_SCANF) += test_scanf.o obj-$(CONFIG_TEST_BITMAP) += test_bitmap.o ifeq ($(CONFIG_CC_IS_CLANG)$(CONFIG_KASAN),yy) diff --git a/lib/test_scanf.c b/lib/test_scanf.c index 44f8508c9d88..70364ce20ec3 100644 --- a/lib/test_scanf.c +++ b/lib/test_scanf.c @@ -5,8 +5,8 @@ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt +#include <kunit/test.h> #include <linux/bitops.h> -#include <linux/init.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/overflow.h> @@ -15,148 +15,123 @@ #include <linux/slab.h> #include <linux/string.h> -#include "../tools/testing/selftests/kselftest_module.h" - #define BUF_SIZE 1024 -KSTM_MODULE_GLOBALS(); -static char *test_buffer __initdata; -static char *fmt_buffer __initdata; -static struct rnd_state rnd_state __initdata; +static char *test_buffer; +static char *fmt_buffer; +static struct rnd_state rnd_state; -typedef int (*check_fn)(const void *check_data, const char *string, +typedef void (*check_fn)(struct kunit *test, const void *check_data, const char *string, const char *fmt, int n_args, va_list ap); -static void __scanf(4, 6) __init -_test(check_fn fn, const void *check_data, const char *string, const char *fmt, +static void __scanf(5, 7) +_test(struct kunit *test, check_fn fn, const void *check_data, const char *string, const char *fmt, int n_args, ...) { va_list ap, ap_copy; - int ret; - - total_tests++; va_start(ap, n_args); va_copy(ap_copy, ap); - ret = vsscanf(string, fmt, ap_copy); + KUNIT_EXPECT_EQ_MSG(test, vsscanf(string, fmt, ap_copy), n_args, + "vsscanf(\"%s\", \"%s\", ...)", string, fmt); va_end(ap_copy); - if (ret != n_args) { - pr_warn("vsscanf(\"%s\", \"%s\", ...) returned %d expected %d\n", - string, fmt, ret, n_args); - goto fail; - } - - ret = (*fn)(check_data, string, fmt, n_args, ap); - if (ret) - goto fail; - - va_end(ap); - - return; - -fail: - failed_tests++; + (*fn)(test, check_data, string, fmt, n_args, ap); va_end(ap); } -#define _check_numbers_template(arg_fmt, expect, str, fmt, n_args, ap) \ +#define _check_numbers_template(test, arg_fmt, expect, str, fmt, n_args, ap) \ do { \ pr_debug("\"%s\", \"%s\" ->\n", str, fmt); \ for (; n_args > 0; n_args--, expect++) { \ typeof(*expect) got = *va_arg(ap, typeof(expect)); \ pr_debug("\t" arg_fmt "\n", got); \ - if (got != *expect) { \ - pr_warn("vsscanf(\"%s\", \"%s\", ...) expected " arg_fmt " got " arg_fmt "\n", \ - str, fmt, *expect, got); \ - return 1; \ - } \ + KUNIT_EXPECT_EQ_MSG(test, got, *expect, "vsscanf(\"%s\", \"%s\", ...)", str, fmt); \ } \ - return 0; \ } while (0) -static int __init check_ull(const void *check_data, const char *string, +static void check_ull(struct kunit *test, const void *check_data, const char *string, const char *fmt, int n_args, va_list ap) { const unsigned long long *pval = check_data; - _check_numbers_template("%llu", pval, string, fmt, n_args, ap); + _check_numbers_template(test, "%llu", pval, string, fmt, n_args, ap); } -static int __init check_ll(const void *check_data, const char *string, +static void check_ll(struct kunit *test, const void *check_data, const char *string, const char *fmt, int n_args, va_list ap) { const long long *pval = check_data; - _check_numbers_template("%lld", pval, string, fmt, n_args, ap); + _check_numbers_template(test, "%lld", pval, string, fmt, n_args, ap); } -static int __init check_ulong(const void *check_data, const char *string, +static void check_ulong(struct kunit *test, const void *check_data, const char *string, const char *fmt, int n_args, va_list ap) { const unsigned long *pval = check_data; - _check_numbers_template("%lu", pval, string, fmt, n_args, ap); + _check_numbers_template(test, "%lu", pval, string, fmt, n_args, ap); } -static int __init check_long(const void *check_data, const char *string, +static void check_long(struct kunit *test, const void *check_data, const char *string, const char *fmt, int n_args, va_list ap) { const long *pval = check_data; - _check_numbers_template("%ld", pval, string, fmt, n_args, ap); + _check_numbers_template(test, "%ld", pval, string, fmt, n_args, ap); } -static int __init check_uint(const void *check_data, const char *string, +static void check_uint(struct kunit *test, const void *check_data, const char *string, const char *fmt, int n_args, va_list ap) { const unsigned int *pval = check_data; - _check_numbers_template("%u", pval, string, fmt, n_args, ap); + _check_numbers_template(test, "%u", pval, string, fmt, n_args, ap); } -static int __init check_int(const void *check_data, const char *string, +static void check_int(struct kunit *test, const void *check_data, const char *string, const char *fmt, int n_args, va_list ap) { const int *pval = check_data; - _check_numbers_template("%d", pval, string, fmt, n_args, ap); + _check_numbers_template(test, "%d", pval, string, fmt, n_args, ap); } -static int __init check_ushort(const void *check_data, const char *string, +static void check_ushort(struct kunit *test, const void *check_data, const char *string, const char *fmt, int n_args, va_list ap) { const unsigned short *pval = check_data; - _check_numbers_template("%hu", pval, string, fmt, n_args, ap); + _check_numbers_template(test, "%hu", pval, string, fmt, n_args, ap); } -static int __init check_short(const void *check_data, const char *string, +static void check_short(struct kunit *test, const void *check_data, const char *string, const char *fmt, int n_args, va_list ap) { const short *pval = check_data; - _check_numbers_template("%hd", pval, string, fmt, n_args, ap); + _check_numbers_template(test, "%hd", pval, string, fmt, n_args, ap); } -static int __init check_uchar(const void *check_data, const char *string, +static void check_uchar(struct kunit *test, const void *check_data, const char *string, const char *fmt, int n_args, va_list ap) { const unsigned char *pval = check_data; - _check_numbers_template("%hhu", pval, string, fmt, n_args, ap); + _check_numbers_template(test, "%hhu", pval, string, fmt, n_args, ap); } -static int __init check_char(const void *check_data, const char *string, +static void check_char(struct kunit *test, const void *check_data, const char *string, const char *fmt, int n_args, va_list ap) { const signed char *pval = check_data; - _check_numbers_template("%hhd", pval, string, fmt, n_args, ap); + _check_numbers_template(test, "%hhd", pval, string, fmt, n_args, ap); } /* Selection of interesting numbers to test, copied from test-kstrtox.c */ -static const unsigned long long numbers[] __initconst = { +static const unsigned long long numbers[] = { 0x0ULL, 0x1ULL, 0x7fULL, @@ -190,76 +165,76 @@ static const unsigned long long numbers[] __initconst = { : ((unsigned long long)(val) <= type_max(T))) -#define test_one_number(T, gen_fmt, scan_fmt, val, fn) \ -do { \ - const T expect_val = (T)(val); \ - T result = ~expect_val; /* should be overwritten */ \ - \ - snprintf(test_buffer, BUF_SIZE, gen_fmt, expect_val); \ - _test(fn, &expect_val, test_buffer, "%" scan_fmt, 1, &result); \ +#define test_one_number(test, T, gen_fmt, scan_fmt, val, fn) \ +do { \ + const T expect_val = (T)(val); \ + T result = ~expect_val; /* should be overwritten */ \ + \ + snprintf(test_buffer, BUF_SIZE, gen_fmt, expect_val); \ + _test(test, fn, &expect_val, test_buffer, "%" scan_fmt, 1, &result); \ } while (0) -#define simple_numbers_loop(T, gen_fmt, scan_fmt, fn) \ +#define simple_numbers_loop(test, T, gen_fmt, scan_fmt, fn) \ do { \ int i; \ \ for (i = 0; i < ARRAY_SIZE(numbers); i++) { \ if (value_representable_in_type(T, numbers[i])) \ - test_one_number(T, gen_fmt, scan_fmt, \ + test_one_number(test, T, gen_fmt, scan_fmt, \ numbers[i], fn); \ \ if (value_representable_in_type(T, -numbers[i])) \ - test_one_number(T, gen_fmt, scan_fmt, \ + test_one_number(test, T, gen_fmt, scan_fmt, \ -numbers[i], fn); \ } \ } while (0) -static void __init numbers_simple(void) -{ - simple_numbers_loop(unsigned long long, "%llu", "llu", check_ull); - simple_numbers_loop(long long, "%lld", "lld", check_ll); - simple_numbers_loop(long long, "%lld", "lli", check_ll); - simple_numbers_loop(unsigned long long, "%llx", "llx", check_ull); - simple_numbers_loop(long long, "%llx", "llx", check_ll); - simple_numbers_loop(long long, "0x%llx", "lli", check_ll); - simple_numbers_loop(unsigned long long, "0x%llx", "llx", check_ull); - simple_numbers_loop(long long, "0x%llx", "llx", check_ll); - - simple_numbers_loop(unsigned long, "%lu", "lu", check_ulong); - simple_numbers_loop(long, "%ld", "ld", check_long); - simple_numbers_loop(long, "%ld", "li", check_long); - simple_numbers_loop(unsigned long, "%lx", "lx", check_ulong); - simple_numbers_loop(long, "%lx", "lx", check_long); - simple_numbers_loop(long, "0x%lx", "li", check_long); - simple_numbers_loop(unsigned long, "0x%lx", "lx", check_ulong); - simple_numbers_loop(long, "0x%lx", "lx", check_long); - - simple_numbers_loop(unsigned int, "%u", "u", check_uint); - simple_numbers_loop(int, "%d", "d", check_int); - simple_numbers_loop(int, "%d", "i", check_int); - simple_numbers_loop(unsigned int, "%x", "x", check_uint); - simple_numbers_loop(int, "%x", "x", check_int); - simple_numbers_loop(int, "0x%x", "i", check_int); - simple_numbers_loop(unsigned int, "0x%x", "x", check_uint); - simple_numbers_loop(int, "0x%x", "x", check_int); - - simple_numbers_loop(unsigned short, "%hu", "hu", check_ushort); - simple_numbers_loop(short, "%hd", "hd", check_short); - simple_numbers_loop(short, "%hd", "hi", check_short); - simple_numbers_loop(unsigned short, "%hx", "hx", check_ushort); - simple_numbers_loop(short, "%hx", "hx", check_short); - simple_numbers_loop(short, "0x%hx", "hi", check_short); - simple_numbers_loop(unsigned short, "0x%hx", "hx", check_ushort); - simple_numbers_loop(short, "0x%hx", "hx", check_short); - - simple_numbers_loop(unsigned char, "%hhu", "hhu", check_uchar); - simple_numbers_loop(signed char, "%hhd", "hhd", check_char); - simple_numbers_loop(signed char, "%hhd", "hhi", check_char); - simple_numbers_loop(unsigned char, "%hhx", "hhx", check_uchar); - simple_numbers_loop(signed char, "%hhx", "hhx", check_char); - simple_numbers_loop(signed char, "0x%hhx", "hhi", check_char); - simple_numbers_loop(unsigned char, "0x%hhx", "hhx", check_uchar); - simple_numbers_loop(signed char, "0x%hhx", "hhx", check_char); +static void numbers_simple(struct kunit *test) +{ + simple_numbers_loop(test, unsigned long long, "%llu", "llu", check_ull); + simple_numbers_loop(test, long long, "%lld", "lld", check_ll); + simple_numbers_loop(test, long long, "%lld", "lli", check_ll); + simple_numbers_loop(test, unsigned long long, "%llx", "llx", check_ull); + simple_numbers_loop(test, long long, "%llx", "llx", check_ll); + simple_numbers_loop(test, long long, "0x%llx", "lli", check_ll); + simple_numbers_loop(test, unsigned long long, "0x%llx", "llx", check_ull); + simple_numbers_loop(test, long long, "0x%llx", "llx", check_ll); + + simple_numbers_loop(test, unsigned long, "%lu", "lu", check_ulong); + simple_numbers_loop(test, long, "%ld", "ld", check_long); + simple_numbers_loop(test, long, "%ld", "li", check_long); + simple_numbers_loop(test, unsigned long, "%lx", "lx", check_ulong); + simple_numbers_loop(test, long, "%lx", "lx", check_long); + simple_numbers_loop(test, long, "0x%lx", "li", check_long); + simple_numbers_loop(test, unsigned long, "0x%lx", "lx", check_ulong); + simple_numbers_loop(test, long, "0x%lx", "lx", check_long); + + simple_numbers_loop(test, unsigned int, "%u", "u", check_uint); + simple_numbers_loop(test, int, "%d", "d", check_int); + simple_numbers_loop(test, int, "%d", "i", check_int); + simple_numbers_loop(test, unsigned int, "%x", "x", check_uint); + simple_numbers_loop(test, int, "%x", "x", check_int); + simple_numbers_loop(test, int, "0x%x", "i", check_int); + simple_numbers_loop(test, unsigned int, "0x%x", "x", check_uint); + simple_numbers_loop(test, int, "0x%x", "x", check_int); + + simple_numbers_loop(test, unsigned short, "%hu", "hu", check_ushort); + simple_numbers_loop(test, short, "%hd", "hd", check_short); + simple_numbers_loop(test, short, "%hd", "hi", check_short); + simple_numbers_loop(test, unsigned short, "%hx", "hx", check_ushort); + simple_numbers_loop(test, short, "%hx", "hx", check_short); + simple_numbers_loop(test, short, "0x%hx", "hi", check_short); + simple_numbers_loop(test, unsigned short, "0x%hx", "hx", check_ushort); + simple_numbers_loop(test, short, "0x%hx", "hx", check_short); + + simple_numbers_loop(test, unsigned char, "%hhu", "hhu", check_uchar); + simple_numbers_loop(test, signed char, "%hhd", "hhd", check_char); + simple_numbers_loop(test, signed char, "%hhd", "hhi", check_char); + simple_numbers_loop(test, unsigned char, "%hhx", "hhx", check_uchar); + simple_numbers_loop(test, signed char, "%hhx", "hhx", check_char); + simple_numbers_loop(test, signed char, "0x%hhx", "hhi", check_char); + simple_numbers_loop(test, unsigned char, "0x%hhx", "hhx", check_uchar); + simple_numbers_loop(test, signed char, "0x%hhx", "hhx", check_char); } /* @@ -267,14 +242,14 @@ static void __init numbers_simple(void) * the raw prandom*() functions (Not mathematically rigorous!!). * Variabilty of length and value is more important than perfect randomness. */ -static u32 __init next_test_random(u32 max_bits) +static u32 next_test_random(u32 max_bits) { u32 n_bits = hweight32(prandom_u32_state(&rnd_state)) % (max_bits + 1); return prandom_u32_state(&rnd_state) & GENMASK(n_bits, 0); } -static unsigned long long __init next_test_random_ull(void) +static unsigned long long next_test_random_ull(void) { u32 rand1 = prandom_u32_state(&rnd_state); u32 n_bits = (hweight32(rand1) * 3) % 64; @@ -311,7 +286,7 @@ do { \ * updating buf_pos and returning the number of characters appended. * On error buf_pos is not changed and return value is 0. */ -static int __init __printf(4, 5) +static int __printf(4, 5) append_fmt(char *buf, int *buf_pos, int buf_len, const char *val_fmt, ...) { va_list ap; @@ -333,7 +308,7 @@ append_fmt(char *buf, int *buf_pos, int buf_len, const char *val_fmt, ...) * Convenience function to append the field delimiter string * to both the value string and format string buffers. */ -static void __init append_delim(char *str_buf, int *str_buf_pos, int str_buf_len, +static void append_delim(char *str_buf, int *str_buf_pos, int str_buf_len, char *fmt_buf, int *fmt_buf_pos, int fmt_buf_len, const char *delim_str) { @@ -341,15 +316,15 @@ static void __init append_delim(char *str_buf, int *str_buf_pos, int str_buf_len append_fmt(fmt_buf, fmt_buf_pos, fmt_buf_len, delim_str); } -#define test_array_8(fn, check_data, string, fmt, arr) \ +#define test_array_8(test, fn, check_data, string, fmt, arr) \ do { \ BUILD_BUG_ON(ARRAY_SIZE(arr) != 8); \ - _test(fn, check_data, string, fmt, 8, \ + _test(test, fn, check_data, string, fmt, 8, \ &(arr)[0], &(arr)[1], &(arr)[2], &(arr)[3], \ &(arr)[4], &(arr)[5], &(arr)[6], &(arr)[7]); \ } while (0) -#define numbers_list_8(T, gen_fmt, field_sep, scan_fmt, fn) \ +#define numbers_list_8(test, T, gen_fmt, field_sep, scan_fmt, fn) \ do { \ int i, pos = 0, fmt_pos = 0; \ T expect[8], result[8]; \ @@ -366,18 +341,18 @@ do { \ append_fmt(fmt_buffer, &fmt_pos, BUF_SIZE, "%%%s", scan_fmt); \ } \ \ - test_array_8(fn, expect, test_buffer, fmt_buffer, result); \ + test_array_8(test, fn, expect, test_buffer, fmt_buffer, result); \ } while (0) -#define numbers_list_fix_width(T, gen_fmt, field_sep, width, scan_fmt, fn) \ +#define numbers_list_fix_width(test, T, gen_fmt, field_sep, width, scan_fmt, fn)\ do { \ char full_fmt[16]; \ \ snprintf(full_fmt, sizeof(full_fmt), "%u%s", width, scan_fmt); \ - numbers_list_8(T, gen_fmt, field_sep, full_fmt, fn); \ + numbers_list_8(test, T, gen_fmt, field_sep, full_fmt, fn); \ } while (0) -#define numbers_list_val_width(T, gen_fmt, field_sep, scan_fmt, fn) \ +#define numbers_list_val_width(test, T, gen_fmt, field_sep, scan_fmt, fn) \ do { \ int i, val_len, pos = 0, fmt_pos = 0; \ T expect[8], result[8]; \ @@ -395,201 +370,201 @@ do { \ "%%%u%s", val_len, scan_fmt); \ } \ \ - test_array_8(fn, expect, test_buffer, fmt_buffer, result); \ + test_array_8(test, fn, expect, test_buffer, fmt_buffer, result); \ } while (0) -static void __init numbers_list_ll(const char *delim) +static void numbers_list_ll(struct kunit *test, const char *delim) { - numbers_list_8(unsigned long long, "%llu", delim, "llu", check_ull); - numbers_list_8(long long, "%lld", delim, "lld", check_ll); - numbers_list_8(long long, "%lld", delim, "lli", check_ll); - numbers_list_8(unsigned long long, "%llx", delim, "llx", check_ull); - numbers_list_8(unsigned long long, "0x%llx", delim, "llx", check_ull); - numbers_list_8(long long, "0x%llx", delim, "lli", check_ll); + numbers_list_8(test, unsigned long long, "%llu", delim, "llu", check_ull); + numbers_list_8(test, long long, "%lld", delim, "lld", check_ll); + numbers_list_8(test, long long, "%lld", delim, "lli", check_ll); + numbers_list_8(test, unsigned long long, "%llx", delim, "llx", check_ull); + numbers_list_8(test, unsigned long long, "0x%llx", delim, "llx", check_ull); + numbers_list_8(test, long long, "0x%llx", delim, "lli", check_ll); } -static void __init numbers_list_l(const char *delim) +static void numbers_list_l(struct kunit *test, const char *delim) { - numbers_list_8(unsigned long, "%lu", delim, "lu", check_ulong); - numbers_list_8(long, "%ld", delim, "ld", check_long); - numbers_list_8(long, "%ld", delim, "li", check_long); - numbers_list_8(unsigned long, "%lx", delim, "lx", check_ulong); - numbers_list_8(unsigned long, "0x%lx", delim, "lx", check_ulong); - numbers_list_8(long, "0x%lx", delim, "li", check_long); + numbers_list_8(test, unsigned long, "%lu", delim, "lu", check_ulong); + numbers_list_8(test, long, "%ld", delim, "ld", check_long); + numbers_list_8(test, long, "%ld", delim, "li", check_long); + numbers_list_8(test, unsigned long, "%lx", delim, "lx", check_ulong); + numbers_list_8(test, unsigned long, "0x%lx", delim, "lx", check_ulong); + numbers_list_8(test, long, "0x%lx", delim, "li", check_long); } -static void __init numbers_list_d(const char *delim) +static void numbers_list_d(struct kunit *test, const char *delim) { - numbers_list_8(unsigned int, "%u", delim, "u", check_uint); - numbers_list_8(int, "%d", delim, "d", check_int); - numbers_list_8(int, "%d", delim, "i", check_int); - numbers_list_8(unsigned int, "%x", delim, "x", check_uint); - numbers_list_8(unsigned int, "0x%x", delim, "x", check_uint); - numbers_list_8(int, "0x%x", delim, "i", check_int); + numbers_list_8(test, unsigned int, "%u", delim, "u", check_uint); + numbers_list_8(test, int, "%d", delim, "d", check_int); + numbers_list_8(test, int, "%d", delim, "i", check_int); + numbers_list_8(test, unsigned int, "%x", delim, "x", check_uint); + numbers_list_8(test, unsigned int, "0x%x", delim, "x", check_uint); + numbers_list_8(test, int, "0x%x", delim, "i", check_int); } -static void __init numbers_list_h(const char *delim) +static void numbers_list_h(struct kunit *test, const char *delim) { - numbers_list_8(unsigned short, "%hu", delim, "hu", check_ushort); - numbers_list_8(short, "%hd", delim, "hd", check_short); - numbers_list_8(short, "%hd", delim, "hi", check_short); - numbers_list_8(unsigned short, "%hx", delim, "hx", check_ushort); - numbers_list_8(unsigned short, "0x%hx", delim, "hx", check_ushort); - numbers_list_8(short, "0x%hx", delim, "hi", check_short); + numbers_list_8(test, unsigned short, "%hu", delim, "hu", check_ushort); + numbers_list_8(test, short, "%hd", delim, "hd", check_short); + numbers_list_8(test, short, "%hd", delim, "hi", check_short); + numbers_list_8(test, unsigned short, "%hx", delim, "hx", check_ushort); + numbers_list_8(test, unsigned short, "0x%hx", delim, "hx", check_ushort); + numbers_list_8(test, short, "0x%hx", delim, "hi", check_short); } -static void __init numbers_list_hh(const char *delim) +static void numbers_list_hh(struct kunit *test, const char *delim) { - numbers_list_8(unsigned char, "%hhu", delim, "hhu", check_uchar); - numbers_list_8(signed char, "%hhd", delim, "hhd", check_char); - numbers_list_8(signed char, "%hhd", delim, "hhi", check_char); - numbers_list_8(unsigned char, "%hhx", delim, "hhx", check_uchar); - numbers_list_8(unsigned char, "0x%hhx", delim, "hhx", check_uchar); - numbers_list_8(signed char, "0x%hhx", delim, "hhi", check_char); + numbers_list_8(test, unsigned char, "%hhu", delim, "hhu", check_uchar); + numbers_list_8(test, signed char, "%hhd", delim, "hhd", check_char); + numbers_list_8(test, signed char, "%hhd", delim, "hhi", check_char); + numbers_list_8(test, unsigned char, "%hhx", delim, "hhx", check_uchar); + numbers_list_8(test, unsigned char, "0x%hhx", delim, "hhx", check_uchar); + numbers_list_8(test, signed char, "0x%hhx", delim, "hhi", check_char); } -static void __init numbers_list(const char *delim) +static void numbers_list(struct kunit *test, const char *delim) { - numbers_list_ll(delim); - numbers_list_l(delim); - numbers_list_d(delim); - numbers_list_h(delim); - numbers_list_hh(delim); + numbers_list_ll(test, delim); + numbers_list_l(test, delim); + numbers_list_d(test, delim); + numbers_list_h(test, delim); + numbers_list_hh(test, delim); } -static void __init numbers_list_field_width_ll(const char *delim) +static void numbers_list_field_width_ll(struct kunit *test, const char *delim) { - numbers_list_fix_width(unsigned long long, "%llu", delim, 20, "llu", check_ull); - numbers_list_fix_width(long long, "%lld", delim, 20, "lld", check_ll); - numbers_list_fix_width(long long, "%lld", delim, 20, "lli", check_ll); - numbers_list_fix_width(unsigned long long, "%llx", delim, 16, "llx", check_ull); - numbers_list_fix_width(unsigned long long, "0x%llx", delim, 18, "llx", check_ull); - numbers_list_fix_width(long long, "0x%llx", delim, 18, "lli", check_ll); + numbers_list_fix_width(test, unsigned long long, "%llu", delim, 20, "llu", check_ull); + numbers_list_fix_width(test, long long, "%lld", delim, 20, "lld", check_ll); + numbers_list_fix_width(test, long long, "%lld", delim, 20, "lli", check_ll); + numbers_list_fix_width(test, unsigned long long, "%llx", delim, 16, "llx", check_ull); + numbers_list_fix_width(test, unsigned long long, "0x%llx", delim, 18, "llx", check_ull); + numbers_list_fix_width(test, long long, "0x%llx", delim, 18, "lli", check_ll); } -static void __init numbers_list_field_width_l(const char *delim) +static void numbers_list_field_width_l(struct kunit *test, const char *delim) { #if BITS_PER_LONG == 64 - numbers_list_fix_width(unsigned long, "%lu", delim, 20, "lu", check_ulong); - numbers_list_fix_width(long, "%ld", delim, 20, "ld", check_long); - numbers_list_fix_width(long, "%ld", delim, 20, "li", check_long); - numbers_list_fix_width(unsigned long, "%lx", delim, 16, "lx", check_ulong); - numbers_list_fix_width(unsigned long, "0x%lx", delim, 18, "lx", check_ulong); - numbers_list_fix_width(long, "0x%lx", delim, 18, "li", check_long); + numbers_list_fix_width(test, unsigned long, "%lu", delim, 20, "lu", check_ulong); + numbers_list_fix_width(test, long, "%ld", delim, 20, "ld", check_long); + numbers_list_fix_width(test, long, "%ld", delim, 20, "li", check_long); + numbers_list_fix_width(test, unsigned long, "%lx", delim, 16, "lx", check_ulong); + numbers_list_fix_width(test, unsigned long, "0x%lx", delim, 18, "lx", check_ulong); + numbers_list_fix_width(test, long, "0x%lx", delim, 18, "li", check_long); #else - numbers_list_fix_width(unsigned long, "%lu", delim, 10, "lu", check_ulong); - numbers_list_fix_width(long, "%ld", delim, 11, "ld", check_long); - numbers_list_fix_width(long, "%ld", delim, 11, "li", check_long); - numbers_list_fix_width(unsigned long, "%lx", delim, 8, "lx", check_ulong); - numbers_list_fix_width(unsigned long, "0x%lx", delim, 10, "lx", check_ulong); - numbers_list_fix_width(long, "0x%lx", delim, 10, "li", check_long); + numbers_list_fix_width(test, unsigned long, "%lu", delim, 10, "lu", check_ulong); + numbers_list_fix_width(test, long, "%ld", delim, 11, "ld", check_long); + numbers_list_fix_width(test, long, "%ld", delim, 11, "li", check_long); + numbers_list_fix_width(test, unsigned long, "%lx", delim, 8, "lx", check_ulong); + numbers_list_fix_width(test, unsigned long, "0x%lx", delim, 10, "lx", check_ulong); + numbers_list_fix_width(test, long, "0x%lx", delim, 10, "li", check_long); #endif } -static void __init numbers_list_field_width_d(const char *delim) +static void numbers_list_field_width_d(struct kunit *test, const char *delim) { - numbers_list_fix_width(unsigned int, "%u", delim, 10, "u", check_uint); - numbers_list_fix_width(int, "%d", delim, 11, "d", check_int); - numbers_list_fix_width(int, "%d", delim, 11, "i", check_int); - numbers_list_fix_width(unsigned int, "%x", delim, 8, "x", check_uint); - numbers_list_fix_width(unsigned int, "0x%x", delim, 10, "x", check_uint); - numbers_list_fix_width(int, "0x%x", delim, 10, "i", check_int); + numbers_list_fix_width(test, unsigned int, "%u", delim, 10, "u", check_uint); + numbers_list_fix_width(test, int, "%d", delim, 11, "d", check_int); + numbers_list_fix_width(test, int, "%d", delim, 11, "i", check_int); + numbers_list_fix_width(test, unsigned int, "%x", delim, 8, "x", check_uint); + numbers_list_fix_width(test, unsigned int, "0x%x", delim, 10, "x", check_uint); + numbers_list_fix_width(test, int, "0x%x", delim, 10, "i", check_int); } -static void __init numbers_list_field_width_h(const char *delim) +static void numbers_list_field_width_h(struct kunit *test, const char *delim) { - numbers_list_fix_width(unsigned short, "%hu", delim, 5, "hu", check_ushort); - numbers_list_fix_width(short, "%hd", delim, 6, "hd", check_short); - numbers_list_fix_width(short, "%hd", delim, 6, "hi", check_short); - numbers_list_fix_width(unsigned short, "%hx", delim, 4, "hx", check_ushort); - numbers_list_fix_width(unsigned short, "0x%hx", delim, 6, "hx", check_ushort); - numbers_list_fix_width(short, "0x%hx", delim, 6, "hi", check_short); + numbers_list_fix_width(test, unsigned short, "%hu", delim, 5, "hu", check_ushort); + numbers_list_fix_width(test, short, "%hd", delim, 6, "hd", check_short); + numbers_list_fix_width(test, short, "%hd", delim, 6, "hi", check_short); + numbers_list_fix_width(test, unsigned short, "%hx", delim, 4, "hx", check_ushort); + numbers_list_fix_width(test, unsigned short, "0x%hx", delim, 6, "hx", check_ushort); + numbers_list_fix_width(test, short, "0x%hx", delim, 6, "hi", check_short); } -static void __init numbers_list_field_width_hh(const char *delim) +static void numbers_list_field_width_hh(struct kunit *test, const char *delim) { - numbers_list_fix_width(unsigned char, "%hhu", delim, 3, "hhu", check_uchar); - numbers_list_fix_width(signed char, "%hhd", delim, 4, "hhd", check_char); - numbers_list_fix_width(signed char, "%hhd", delim, 4, "hhi", check_char); - numbers_list_fix_width(unsigned char, "%hhx", delim, 2, "hhx", check_uchar); - numbers_list_fix_width(unsigned char, "0x%hhx", delim, 4, "hhx", check_uchar); - numbers_list_fix_width(signed char, "0x%hhx", delim, 4, "hhi", check_char); + numbers_list_fix_width(test, unsigned char, "%hhu", delim, 3, "hhu", check_uchar); + numbers_list_fix_width(test, signed char, "%hhd", delim, 4, "hhd", check_char); + numbers_list_fix_width(test, signed char, "%hhd", delim, 4, "hhi", check_char); + numbers_list_fix_width(test, unsigned char, "%hhx", delim, 2, "hhx", check_uchar); + numbers_list_fix_width(test, unsigned char, "0x%hhx", delim, 4, "hhx", check_uchar); + numbers_list_fix_width(test, signed char, "0x%hhx", delim, 4, "hhi", check_char); } /* * List of numbers separated by delim. Each field width specifier is the * maximum possible digits for the given type and base. */ -static void __init numbers_list_field_width_typemax(const char *delim) +static void numbers_list_field_width_typemax(struct kunit *test, const char *delim) { - numbers_list_field_width_ll(delim); - numbers_list_field_width_l(delim); - numbers_list_field_width_d(delim); - numbers_list_field_width_h(delim); - numbers_list_field_width_hh(delim); + numbers_list_field_width_ll(test, delim); + numbers_list_field_width_l(test, delim); + numbers_list_field_width_d(test, delim); + numbers_list_field_width_h(test, delim); + numbers_list_field_width_hh(test, delim); } -static void __init numbers_list_field_width_val_ll(const char *delim) +static void numbers_list_field_width_val_ll(struct kunit *test, const char *delim) { - numbers_list_val_width(unsigned long long, "%llu", delim, "llu", check_ull); - numbers_list_val_width(long long, "%lld", delim, "lld", check_ll); - numbers_list_val_width(long long, "%lld", delim, "lli", check_ll); - numbers_list_val_width(unsigned long long, "%llx", delim, "llx", check_ull); - numbers_list_val_width(unsigned long long, "0x%llx", delim, "llx", check_ull); - numbers_list_val_width(long long, "0x%llx", delim, "lli", check_ll); + numbers_list_val_width(test, unsigned long long, "%llu", delim, "llu", check_ull); + numbers_list_val_width(test, long long, "%lld", delim, "lld", check_ll); + numbers_list_val_width(test, long long, "%lld", delim, "lli", check_ll); + numbers_list_val_width(test, unsigned long long, "%llx", delim, "llx", check_ull); + numbers_list_val_width(test, unsigned long long, "0x%llx", delim, "llx", check_ull); + numbers_list_val_width(test, long long, "0x%llx", delim, "lli", check_ll); } -static void __init numbers_list_field_width_val_l(const char *delim) +static void numbers_list_field_width_val_l(struct kunit *test, const char *delim) { - numbers_list_val_width(unsigned long, "%lu", delim, "lu", check_ulong); - numbers_list_val_width(long, "%ld", delim, "ld", check_long); - numbers_list_val_width(long, "%ld", delim, "li", check_long); - numbers_list_val_width(unsigned long, "%lx", delim, "lx", check_ulong); - numbers_list_val_width(unsigned long, "0x%lx", delim, "lx", check_ulong); - numbers_list_val_width(long, "0x%lx", delim, "li", check_long); + numbers_list_val_width(test, unsigned long, "%lu", delim, "lu", check_ulong); + numbers_list_val_width(test, long, "%ld", delim, "ld", check_long); + numbers_list_val_width(test, long, "%ld", delim, "li", check_long); + numbers_list_val_width(test, unsigned long, "%lx", delim, "lx", check_ulong); + numbers_list_val_width(test, unsigned long, "0x%lx", delim, "lx", check_ulong); + numbers_list_val_width(test, long, "0x%lx", delim, "li", check_long); } -static void __init numbers_list_field_width_val_d(const char *delim) +static void numbers_list_field_width_val_d(struct kunit *test, const char *delim) { - numbers_list_val_width(unsigned int, "%u", delim, "u", check_uint); - numbers_list_val_width(int, "%d", delim, "d", check_int); - numbers_list_val_width(int, "%d", delim, "i", check_int); - numbers_list_val_width(unsigned int, "%x", delim, "x", check_uint); - numbers_list_val_width(unsigned int, "0x%x", delim, "x", check_uint); - numbers_list_val_width(int, "0x%x", delim, "i", check_int); + numbers_list_val_width(test, unsigned int, "%u", delim, "u", check_uint); + numbers_list_val_width(test, int, "%d", delim, "d", check_int); + numbers_list_val_width(test, int, "%d", delim, "i", check_int); + numbers_list_val_width(test, unsigned int, "%x", delim, "x", check_uint); + numbers_list_val_width(test, unsigned int, "0x%x", delim, "x", check_uint); + numbers_list_val_width(test, int, "0x%x", delim, "i", check_int); } -static void __init numbers_list_field_width_val_h(const char *delim) +static void numbers_list_field_width_val_h(struct kunit *test, const char *delim) { - numbers_list_val_width(unsigned short, "%hu", delim, "hu", check_ushort); - numbers_list_val_width(short, "%hd", delim, "hd", check_short); - numbers_list_val_width(short, "%hd", delim, "hi", check_short); - numbers_list_val_width(unsigned short, "%hx", delim, "hx", check_ushort); - numbers_list_val_width(unsigned short, "0x%hx", delim, "hx", check_ushort); - numbers_list_val_width(short, "0x%hx", delim, "hi", check_short); + numbers_list_val_width(test, unsigned short, "%hu", delim, "hu", check_ushort); + numbers_list_val_width(test, short, "%hd", delim, "hd", check_short); + numbers_list_val_width(test, short, "%hd", delim, "hi", check_short); + numbers_list_val_width(test, unsigned short, "%hx", delim, "hx", check_ushort); + numbers_list_val_width(test, unsigned short, "0x%hx", delim, "hx", check_ushort); + numbers_list_val_width(test, short, "0x%hx", delim, "hi", check_short); } -static void __init numbers_list_field_width_val_hh(const char *delim) +static void numbers_list_field_width_val_hh(struct kunit *test, const char *delim) { - numbers_list_val_width(unsigned char, "%hhu", delim, "hhu", check_uchar); - numbers_list_val_width(signed char, "%hhd", delim, "hhd", check_char); - numbers_list_val_width(signed char, "%hhd", delim, "hhi", check_char); - numbers_list_val_width(unsigned char, "%hhx", delim, "hhx", check_uchar); - numbers_list_val_width(unsigned char, "0x%hhx", delim, "hhx", check_uchar); - numbers_list_val_width(signed char, "0x%hhx", delim, "hhi", check_char); + numbers_list_val_width(test, unsigned char, "%hhu", delim, "hhu", check_uchar); + numbers_list_val_width(test, signed char, "%hhd", delim, "hhd", check_char); + numbers_list_val_width(test, signed char, "%hhd", delim, "hhi", check_char); + numbers_list_val_width(test, unsigned char, "%hhx", delim, "hhx", check_uchar); + numbers_list_val_width(test, unsigned char, "0x%hhx", delim, "hhx", check_uchar); + numbers_list_val_width(test, signed char, "0x%hhx", delim, "hhi", check_char); } /* * List of numbers separated by delim. Each field width specifier is the * exact length of the corresponding value digits in the string being scanned. */ -static void __init numbers_list_field_width_val_width(const char *delim) +static void numbers_list_field_width_val_width(struct kunit *test, const char *delim) { - numbers_list_field_width_val_ll(delim); - numbers_list_field_width_val_l(delim); - numbers_list_field_width_val_d(delim); - numbers_list_field_width_val_h(delim); - numbers_list_field_width_val_hh(delim); + numbers_list_field_width_val_ll(test, delim); + numbers_list_field_width_val_l(test, delim); + numbers_list_field_width_val_d(test, delim); + numbers_list_field_width_val_h(test, delim); + numbers_list_field_width_val_hh(test, delim); } /* @@ -598,67 +573,67 @@ static void __init numbers_list_field_width_val_width(const char *delim) * of digits. For example the hex values c0,3,bf01,303 would have a * string representation of "c03bf01303" and extracted with "%2x%1x%4x%3x". */ -static void __init numbers_slice(void) +static void numbers_slice(struct kunit *test) { - numbers_list_field_width_val_width(""); + numbers_list_field_width_val_width(test, ""); } -#define test_number_prefix(T, str, scan_fmt, expect0, expect1, n_args, fn) \ +#define test_number_prefix(test, T, str, scan_fmt, expect0, expect1, n_args, fn)\ do { \ const T expect[2] = { expect0, expect1 }; \ T result[2] = { (T)~expect[0], (T)~expect[1] }; \ \ - _test(fn, &expect, str, scan_fmt, n_args, &result[0], &result[1]); \ + _test(test, fn, &expect, str, scan_fmt, n_args, &result[0], &result[1]);\ } while (0) /* * Number prefix is >= field width. * Expected behaviour is derived from testing userland sscanf. */ -static void __init numbers_prefix_overflow(void) +static void numbers_prefix_overflow(struct kunit *test) { /* * Negative decimal with a field of width 1, should quit scanning * and return 0. */ - test_number_prefix(long long, "-1 1", "%1lld %lld", 0, 0, 0, check_ll); - test_number_prefix(long, "-1 1", "%1ld %ld", 0, 0, 0, check_long); - test_number_prefix(int, "-1 1", "%1d %d", 0, 0, 0, check_int); - test_number_prefix(short, "-1 1", "%1hd %hd", 0, 0, 0, check_short); - test_number_prefix(signed char, "-1 1", "%1hhd %hhd", 0, 0, 0, check_char); - - test_number_prefix(long long, "-1 1", "%1lli %lli", 0, 0, 0, check_ll); - test_number_prefix(long, "-1 1", "%1li %li", 0, 0, 0, check_long); - test_number_prefix(int, "-1 1", "%1i %i", 0, 0, 0, check_int); - test_number_prefix(short, "-1 1", "%1hi %hi", 0, 0, 0, check_short); - test_number_prefix(signed char, "-1 1", "%1hhi %hhi", 0, 0, 0, check_char); + test_number_prefix(test, long long, "-1 1", "%1lld %lld", 0, 0, 0, check_ll); + test_number_prefix(test, long, "-1 1", "%1ld %ld", 0, 0, 0, check_long); + test_number_prefix(test, int, "-1 1", "%1d %d", 0, 0, 0, check_int); + test_number_prefix(test, short, "-1 1", "%1hd %hd", 0, 0, 0, check_short); + test_number_prefix(test, signed char, "-1 1", "%1hhd %hhd", 0, 0, 0, check_char); + + test_number_prefix(test, long long, "-1 1", "%1lli %lli", 0, 0, 0, check_ll); + test_number_prefix(test, long, "-1 1", "%1li %li", 0, 0, 0, check_long); + test_number_prefix(test, int, "-1 1", "%1i %i", 0, 0, 0, check_int); + test_number_prefix(test, short, "-1 1", "%1hi %hi", 0, 0, 0, check_short); + test_number_prefix(test, signed char, "-1 1", "%1hhi %hhi", 0, 0, 0, check_char); /* * 0x prefix in a field of width 1: 0 is a valid digit so should * convert. Next field scan starts at the 'x' which isn't a digit so * scan quits with one field converted. */ - test_number_prefix(unsigned long long, "0xA7", "%1llx%llx", 0, 0, 1, check_ull); - test_number_prefix(unsigned long, "0xA7", "%1lx%lx", 0, 0, 1, check_ulong); - test_number_prefix(unsigned int, "0xA7", "%1x%x", 0, 0, 1, check_uint); - test_number_prefix(unsigned short, "0xA7", "%1hx%hx", 0, 0, 1, check_ushort); - test_number_prefix(unsigned char, "0xA7", "%1hhx%hhx", 0, 0, 1, check_uchar); - test_number_prefix(long long, "0xA7", "%1lli%llx", 0, 0, 1, check_ll); - test_number_prefix(long, "0xA7", "%1li%lx", 0, 0, 1, check_long); - test_number_prefix(int, "0xA7", "%1i%x", 0, 0, 1, check_int); - test_number_prefix(short, "0xA7", "%1hi%hx", 0, 0, 1, check_short); - test_number_prefix(char, "0xA7", "%1hhi%hhx", 0, 0, 1, check_char); + test_number_prefix(test, unsigned long long, "0xA7", "%1llx%llx", 0, 0, 1, check_ull); + test_number_prefix(test, unsigned long, "0xA7", "%1lx%lx", 0, 0, 1, check_ulong); + test_number_prefix(test, unsigned int, "0xA7", "%1x%x", 0, 0, 1, check_uint); + test_number_prefix(test, unsigned short, "0xA7", "%1hx%hx", 0, 0, 1, check_ushort); + test_number_prefix(test, unsigned char, "0xA7", "%1hhx%hhx", 0, 0, 1, check_uchar); + test_number_prefix(test, long long, "0xA7", "%1lli%llx", 0, 0, 1, check_ll); + test_number_prefix(test, long, "0xA7", "%1li%lx", 0, 0, 1, check_long); + test_number_prefix(test, int, "0xA7", "%1i%x", 0, 0, 1, check_int); + test_number_prefix(test, short, "0xA7", "%1hi%hx", 0, 0, 1, check_short); + test_number_prefix(test, char, "0xA7", "%1hhi%hhx", 0, 0, 1, check_char); /* * 0x prefix in a field of width 2 using %x conversion: first field * converts to 0. Next field scan starts at the character after "0x". * Both fields will convert. */ - test_number_prefix(unsigned long long, "0xA7", "%2llx%llx", 0, 0xa7, 2, check_ull); - test_number_prefix(unsigned long, "0xA7", "%2lx%lx", 0, 0xa7, 2, check_ulong); - test_number_prefix(unsigned int, "0xA7", "%2x%x", 0, 0xa7, 2, check_uint); - test_number_prefix(unsigned short, "0xA7", "%2hx%hx", 0, 0xa7, 2, check_ushort); - test_number_prefix(unsigned char, "0xA7", "%2hhx%hhx", 0, 0xa7, 2, check_uchar); + test_number_prefix(test, unsigned long long, "0xA7", "%2llx%llx", 0, 0xa7, 2, check_ull); + test_number_prefix(test, unsigned long, "0xA7", "%2lx%lx", 0, 0xa7, 2, check_ulong); + test_number_prefix(test, unsigned int, "0xA7", "%2x%x", 0, 0xa7, 2, check_uint); + test_number_prefix(test, unsigned short, "0xA7", "%2hx%hx", 0, 0xa7, 2, check_ushort); + test_number_prefix(test, unsigned char, "0xA7", "%2hhx%hhx", 0, 0xa7, 2, check_uchar); /* * 0x prefix in a field of width 2 using %i conversion: first field @@ -666,124 +641,112 @@ static void __init numbers_prefix_overflow(void) * which will convert if can be interpreted as decimal but will fail * if it contains any hex digits (since no 0x prefix). */ - test_number_prefix(long long, "0x67", "%2lli%lli", 0, 67, 2, check_ll); - test_number_prefix(long, "0x67", "%2li%li", 0, 67, 2, check_long); - test_number_prefix(int, "0x67", "%2i%i", 0, 67, 2, check_int); - test_number_prefix(short, "0x67", "%2hi%hi", 0, 67, 2, check_short); - test_number_prefix(char, "0x67", "%2hhi%hhi", 0, 67, 2, check_char); - - test_number_prefix(long long, "0xA7", "%2lli%lli", 0, 0, 1, check_ll); - test_number_prefix(long, "0xA7", "%2li%li", 0, 0, 1, check_long); - test_number_prefix(int, "0xA7", "%2i%i", 0, 0, 1, check_int); - test_number_prefix(short, "0xA7", "%2hi%hi", 0, 0, 1, check_short); - test_number_prefix(char, "0xA7", "%2hhi%hhi", 0, 0, 1, check_char); -} - -#define _test_simple_strtoxx(T, fn, gen_fmt, expect, base) \ -do { \ - T got; \ - char *endp; \ - int len; \ - bool fail = false; \ - \ - total_tests++; \ - len = snprintf(test_buffer, BUF_SIZE, gen_fmt, expect); \ - got = (fn)(test_buffer, &endp, base); \ - pr_debug(#fn "(\"%s\", %d) -> " gen_fmt "\n", test_buffer, base, got); \ - if (got != (expect)) { \ - fail = true; \ - pr_warn(#fn "(\"%s\", %d): got " gen_fmt " expected " gen_fmt "\n", \ - test_buffer, base, got, expect); \ - } else if (endp != test_buffer + len) { \ - fail = true; \ - pr_warn(#fn "(\"%s\", %d) startp=0x%px got endp=0x%px expected 0x%px\n", \ - test_buffer, base, test_buffer, \ - test_buffer + len, endp); \ - } \ - \ - if (fail) \ - failed_tests++; \ + test_number_prefix(test, long long, "0x67", "%2lli%lli", 0, 67, 2, check_ll); + test_number_prefix(test, long, "0x67", "%2li%li", 0, 67, 2, check_long); + test_number_prefix(test, int, "0x67", "%2i%i", 0, 67, 2, check_int); + test_number_prefix(test, short, "0x67", "%2hi%hi", 0, 67, 2, check_short); + test_number_prefix(test, char, "0x67", "%2hhi%hhi", 0, 67, 2, check_char); + + test_number_prefix(test, long long, "0xA7", "%2lli%lli", 0, 0, 1, check_ll); + test_number_prefix(test, long, "0xA7", "%2li%li", 0, 0, 1, check_long); + test_number_prefix(test, int, "0xA7", "%2i%i", 0, 0, 1, check_int); + test_number_prefix(test, short, "0xA7", "%2hi%hi", 0, 0, 1, check_short); + test_number_prefix(test, char, "0xA7", "%2hhi%hhi", 0, 0, 1, check_char); +} + +#define _test_simple_strtoxx(test, T, fn, gen_fmt, expect, base) \ +do { \ + T got; \ + char *endp; \ + int len; \ + \ + len = snprintf(test_buffer, BUF_SIZE, gen_fmt, expect); \ + got = (fn)(test_buffer, &endp, base); \ + pr_debug(#fn "(\"%s\", %d) -> " gen_fmt "\n", test_buffer, base, got); \ + KUNIT_EXPECT_EQ_MSG(test, got, expect, #fn "(\"%s\", %d)", test_buffer, base); \ + KUNIT_EXPECT_PTR_EQ_MSG(test, endp, test_buffer + len, \ + #fn "(\"%s\", %d)", test_buffer, base); \ } while (0) -#define test_simple_strtoxx(T, fn, gen_fmt, base) \ +#define test_simple_strtoxx(test, T, fn, gen_fmt, base) \ do { \ int i; \ \ for (i = 0; i < ARRAY_SIZE(numbers); i++) { \ - _test_simple_strtoxx(T, fn, gen_fmt, (T)numbers[i], base); \ + _test_simple_strtoxx(test, T, fn, gen_fmt, (T)numbers[i], base);\ \ if (is_signed_type(T)) \ - _test_simple_strtoxx(T, fn, gen_fmt, \ + _test_simple_strtoxx(test, T, fn, gen_fmt, \ -(T)numbers[i], base); \ } \ } while (0) -static void __init test_simple_strtoull(void) +static void test_simple_strtoull(struct kunit *test) { - test_simple_strtoxx(unsigned long long, simple_strtoull, "%llu", 10); - test_simple_strtoxx(unsigned long long, simple_strtoull, "%llu", 0); - test_simple_strtoxx(unsigned long long, simple_strtoull, "%llx", 16); - test_simple_strtoxx(unsigned long long, simple_strtoull, "0x%llx", 16); - test_simple_strtoxx(unsigned long long, simple_strtoull, "0x%llx", 0); + test_simple_strtoxx(test, unsigned long long, simple_strtoull, "%llu", 10); + test_simple_strtoxx(test, unsigned long long, simple_strtoull, "%llu", 0); + test_simple_strtoxx(test, unsigned long long, simple_strtoull, "%llx", 16); + test_simple_strtoxx(test, unsigned long long, simple_strtoull, "0x%llx", 16); + test_simple_strtoxx(test, unsigned long long, simple_strtoull, "0x%llx", 0); } -static void __init test_simple_strtoll(void) +static void test_simple_strtoll(struct kunit *test) { - test_simple_strtoxx(long long, simple_strtoll, "%lld", 10); - test_simple_strtoxx(long long, simple_strtoll, "%lld", 0); - test_simple_strtoxx(long long, simple_strtoll, "%llx", 16); - test_simple_strtoxx(long long, simple_strtoll, "0x%llx", 16); - test_simple_strtoxx(long long, simple_strtoll, "0x%llx", 0); + test_simple_strtoxx(test, long long, simple_strtoll, "%lld", 10); + test_simple_strtoxx(test, long long, simple_strtoll, "%lld", 0); + test_simple_strtoxx(test, long long, simple_strtoll, "%llx", 16); + test_simple_strtoxx(test, long long, simple_strtoll, "0x%llx", 16); + test_simple_strtoxx(test, long long, simple_strtoll, "0x%llx", 0); } -static void __init test_simple_strtoul(void) +static void test_simple_strtoul(struct kunit *test) { - test_simple_strtoxx(unsigned long, simple_strtoul, "%lu", 10); - test_simple_strtoxx(unsigned long, simple_strtoul, "%lu", 0); - test_simple_strtoxx(unsigned long, simple_strtoul, "%lx", 16); - test_simple_strtoxx(unsigned long, simple_strtoul, "0x%lx", 16); - test_simple_strtoxx(unsigned long, simple_strtoul, "0x%lx", 0); + test_simple_strtoxx(test, unsigned long, simple_strtoul, "%lu", 10); + test_simple_strtoxx(test, unsigned long, simple_strtoul, "%lu", 0); + test_simple_strtoxx(test, unsigned long, simple_strtoul, "%lx", 16); + test_simple_strtoxx(test, unsigned long, simple_strtoul, "0x%lx", 16); + test_simple_strtoxx(test, unsigned long, simple_strtoul, "0x%lx", 0); } -static void __init test_simple_strtol(void) +static void test_simple_strtol(struct kunit *test) { - test_simple_strtoxx(long, simple_strtol, "%ld", 10); - test_simple_strtoxx(long, simple_strtol, "%ld", 0); - test_simple_strtoxx(long, simple_strtol, "%lx", 16); - test_simple_strtoxx(long, simple_strtol, "0x%lx", 16); - test_simple_strtoxx(long, simple_strtol, "0x%lx", 0); + test_simple_strtoxx(test, long, simple_strtol, "%ld", 10); + test_simple_strtoxx(test, long, simple_strtol, "%ld", 0); + test_simple_strtoxx(test, long, simple_strtol, "%lx", 16); + test_simple_strtoxx(test, long, simple_strtol, "0x%lx", 16); + test_simple_strtoxx(test, long, simple_strtol, "0x%lx", 0); } /* Selection of common delimiters/separators between numbers in a string. */ -static const char * const number_delimiters[] __initconst = { +static const char * const number_delimiters[] = { " ", ":", ",", "-", "/", }; -static void __init test_numbers(void) +static void test_numbers(struct kunit *test) { int i; /* String containing only one number. */ - numbers_simple(); + numbers_simple(test); /* String with multiple numbers separated by delimiter. */ for (i = 0; i < ARRAY_SIZE(number_delimiters); i++) { - numbers_list(number_delimiters[i]); + numbers_list(test, number_delimiters[i]); /* Field width may be longer than actual field digits. */ - numbers_list_field_width_typemax(number_delimiters[i]); + numbers_list_field_width_typemax(test, number_delimiters[i]); /* Each field width exactly length of actual field digits. */ - numbers_list_field_width_val_width(number_delimiters[i]); + numbers_list_field_width_val_width(test, number_delimiters[i]); } /* Slice continuous sequence of digits using field widths. */ - numbers_slice(); + numbers_slice(test); - numbers_prefix_overflow(); + numbers_prefix_overflow(test); } -static void __init selftest(void) +static void scanf_test(struct kunit *test) { test_buffer = kmalloc(BUF_SIZE, GFP_KERNEL); if (!test_buffer) @@ -797,18 +760,29 @@ static void __init selftest(void) prandom_seed_state(&rnd_state, 3141592653589793238ULL); - test_numbers(); + test_numbers(test); - test_simple_strtoull(); - test_simple_strtoll(); - test_simple_strtoul(); - test_simple_strtol(); + test_simple_strtoull(test); + test_simple_strtoll(test); + test_simple_strtoul(test); + test_simple_strtol(test); kfree(fmt_buffer); kfree(test_buffer); } -KSTM_MODULE_LOADERS(test_scanf); +static struct kunit_case scanf_test_cases[] = { + KUNIT_CASE(scanf_test), + {} +}; + +static struct kunit_suite scanf_test_suite = { + .name = "scanf", + .test_cases = scanf_test_cases, +}; + +kunit_test_suite(scanf_test_suite); + MODULE_AUTHOR("Richard Fitzgerald <rf(a)opensource.cirrus.com>"); MODULE_DESCRIPTION("Test cases for sscanf facility"); MODULE_LICENSE("GPL v2"); diff --git a/tools/testing/selftests/lib/Makefile b/tools/testing/selftests/lib/Makefile index c52fe3ad8e98..4afda556151f 100644 --- a/tools/testing/selftests/lib/Makefile +++ b/tools/testing/selftests/lib/Makefile @@ -4,5 +4,5 @@ # No binaries, but make sure arg-less "make" doesn't trigger "run_tests" all: -TEST_PROGS := printf.sh bitmap.sh prime_numbers.sh scanf.sh +TEST_PROGS := printf.sh bitmap.sh prime_numbers.sh include ../lib.mk diff --git a/tools/testing/selftests/lib/config b/tools/testing/selftests/lib/config index dc15aba8d0a3..80b55a504868 100644 --- a/tools/testing/selftests/lib/config +++ b/tools/testing/selftests/lib/config @@ -1,5 +1,4 @@ CONFIG_TEST_PRINTF=m -CONFIG_TEST_SCANF=m CONFIG_TEST_BITMAP=m CONFIG_PRIME_NUMBERS=m CONFIG_TEST_BITOPS=m diff --git a/tools/testing/selftests/lib/scanf.sh b/tools/testing/selftests/lib/scanf.sh deleted file mode 100755 index b59b8ba561c3..000000000000 --- a/tools/testing/selftests/lib/scanf.sh +++ /dev/null @@ -1,4 +0,0 @@ -#!/bin/sh -# SPDX-License-Identifier: GPL-2.0 -# Tests the scanf infrastructure using test_scanf kernel module. -$(dirname $0)/../kselftest/module.sh "scanf" test_scanf --- base-commit: 18fe18c99c8d90d77c7ed6b42f48fa5b4e5c99c3 change-id: 20250131-scanf-kunit-convert-f70dc33bb34c Best regards, -- Tamir Duberstein <tamird(a)gmail.com>

2 months, 1 week

3
9
0 0

[PATCH 0/2] tools/nolibc: add support for directory access

by Thomas Weißschuh

Add support opendir(), readdir(), closedir() and friends. Signed-off-by: Thomas Weißschuh <linux(a)weissschuh.net> --- Thomas Weißschuh (2): tools/nolibc: add support for sys_llseek() tools/nolibc: add support for directory access tools/include/nolibc/stdio.h | 76 ++++++++++++++++++++++++++++ tools/include/nolibc/sys.h | 29 ++++++++++- tools/include/nolibc/types.h | 5 ++ tools/testing/selftests/nolibc/nolibc-test.c | 37 ++++++++++++++ 4 files changed, 146 insertions(+), 1 deletion(-) --- base-commit: d3d90cc2891c9cf4ecba7b85c0af716ab755c7e5 change-id: 20250130-nolibc-dir-980c2e2b661a Best regards, -- Thomas Weißschuh <linux(a)weissschuh.net>

2 months, 1 week

2
6
0 0

[PATCH net-next 0/1] selftests: net: Add support for testing SO_RCVMARK and SO_RCVPRIORITY

by Anna Emese Nyiri

After submitting the patch implementing the SO_RCVPRIORITY socket option (https://lore.kernel.org/netdev/20241213084457.45120-5-annaemesenyiri@gmail.…), it was requested to include a test for the functionality. As a first step, write a test that also validates the SO_RCVMARK value, since no existing test covers it. If this combined test is not suitable, I will provide a standalone test specifically for SO_RCVPRIORITY and submit it separately. Anna Emese Nyiri (1): add support for testing SO_RCVMARK and SO_RCVPRIORITY tools/testing/selftests/net/Makefile | 1 + tools/testing/selftests/net/so_rcv_listener.c | 147 ++++++++++++++++++ tools/testing/selftests/net/test_so_rcv.sh | 56 +++++++ 3 files changed, 204 insertions(+) create mode 100644 tools/testing/selftests/net/so_rcv_listener.c create mode 100755 tools/testing/selftests/net/test_so_rcv.sh -- 2.43.0

2 months, 2 weeks

5
6
0 0

[PATCH bpf-next v7 0/5] Support eliding map lookup nullness

by Daniel Xu

This patch allows progs to elide a null check on statically known map lookup keys. In other words, if the verifier can statically prove that the lookup will be in-bounds, allow the prog to drop the null check. This is useful for two reasons: 1. Large numbers of nullness checks (especially when they cannot fail) unnecessarily pushes prog towards BPF_COMPLEXITY_LIMIT_JMP_SEQ. 2. It forms a tighter contract between programmer and verifier. For (1), bpftrace is starting to make heavier use of percpu scratch maps. As a result, for user scripts with large number of unrolled loops, we are starting to hit jump complexity verification errors. These percpu lookups cannot fail anyways, as we only use static key values. Eliding nullness probably results in less work for verifier as well. For (2), percpu scratch maps are often used as a larger stack, as the currrent stack is limited to 512 bytes. In these situations, it is desirable for the programmer to express: "this lookup should never fail, and if it does, it means I messed up the code". By omitting the null check, the programmer can "ask" the verifier to double check the logic. === Changelog === Changes in v7: * Use more accurate frame number when marking precise * Add test for non-stack key * Test for marking stack slot precise Changes in v6: * Use is_spilled_scalar_reg() helper and remove unnecessary comment * Add back deleted selftest with different helper to dirty dst buffer * Check size of spill is exactly key_size and update selftests * Read slot_type from correct offset into the spi * Rewrite selftests in C where possible * Mark constant map keys as precise Changes in v5: * Dropped all acks * Use s64 instead of long for const_map_key * Ensure stack slot contains spilled reg before accessing spilled_ptr * Ensure spilled reg is a scalar before accessing tnum const value * Fix verifier selftest for 32-bit write to write at 8 byte alignment to ensure spill is tracked * Introduce more precise tracking of helper stack accesses * Do constant map key extraction as part of helper argument processing and then remove duplicated stack checks * Use ret_flag instead of regs[BPF_REG_0].type * Handle STACK_ZERO * Fix bug in bpf_load_hdr_opt() arg annotation Changes in v4: * Only allow for CAP_BPF * Add test for stack growing upwards * Improve comment about stack growing upwards Changes in v3: * Check if stack is (erroneously) growing upwards * Mention in commit message why existing tests needed change Changes in v2: * Added a check for when R2 is not a ptr to stack * Added a check for when stack is uninitialized (no stack slot yet) * Updated existing tests to account for null elision * Added test case for when R2 can be both const and non-const Daniel Xu (5): bpf: verifier: Add missing newline on verbose() call bpf: tcp: Mark bpf_load_hdr_opt() arg2 as read-write bpf: verifier: Refactor helper access type tracking bpf: verifier: Support eliding map lookup nullness bpf: selftests: verifier: Add nullness elision tests kernel/bpf/verifier.c | 139 ++++++++++--- net/core/filter.c | 2 +- .../testing/selftests/bpf/progs/dynptr_fail.c | 6 +- tools/testing/selftests/bpf/progs/iters.c | 14 +- .../selftests/bpf/progs/map_kptr_fail.c | 2 +- .../selftests/bpf/progs/test_global_func10.c | 2 +- .../selftests/bpf/progs/uninit_stack.c | 5 +- .../bpf/progs/verifier_array_access.c | 188 ++++++++++++++++++ .../bpf/progs/verifier_basic_stack.c | 2 +- .../selftests/bpf/progs/verifier_const_or.c | 4 +- .../progs/verifier_helper_access_var_len.c | 12 +- .../selftests/bpf/progs/verifier_int_ptr.c | 2 +- .../selftests/bpf/progs/verifier_map_in_map.c | 2 +- .../selftests/bpf/progs/verifier_mtu.c | 2 +- .../selftests/bpf/progs/verifier_raw_stack.c | 4 +- .../selftests/bpf/progs/verifier_unpriv.c | 2 +- .../selftests/bpf/progs/verifier_var_off.c | 8 +- tools/testing/selftests/bpf/verifier/calls.c | 2 +- .../testing/selftests/bpf/verifier/map_kptr.c | 2 +- 19 files changed, 331 insertions(+), 69 deletions(-) -- 2.47.1

2 months, 2 weeks

4
11
0 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror January 2025