August 2025 - Linux-kselftest-mirror

[PATCH] selftests/futex: Skip futex_waitv tests if ENOSYS

by Wake Liu

The futex_waitv() syscall was introduced in Linux 5.16. The existing test in futex_wait_timeout.c will fail on kernels older than 5.16 due to the syscall not being implemented. Modify the test_timeout() function to check if the error returned is ENOSYS. If it is, skip the test and report it as such, rather than failing. This ensures the selftests can be run on a wider range of kernel versions without false negatives. Signed-off-by: Wake Liu <wakel(a)google.com> --- .../selftests/futex/functional/futex_wait_timeout.c | 11 ++++++++--- .../testing/selftests/futex/functional/futex_waitv.c | 8 ++++++++ 2 files changed, 16 insertions(+), 3 deletions(-) diff --git a/tools/testing/selftests/futex/functional/futex_wait_timeout.c b/tools/testing/selftests/futex/functional/futex_wait_timeout.c index d183f878360b..323cab339814 100644 --- a/tools/testing/selftests/futex/functional/futex_wait_timeout.c +++ b/tools/testing/selftests/futex/functional/futex_wait_timeout.c @@ -64,9 +64,14 @@ void *get_pi_lock(void *arg) static void test_timeout(int res, int *ret, char *test_name, int err) { if (!res || errno != err) { - ksft_test_result_fail("%s returned %d\n", test_name, - res < 0 ? errno : res); - *ret = RET_FAIL; + if (errno == ENOSYS) { + ksft_test_result_skip("%s: %s\n", + test_name, strerror(errno)); + } else { + ksft_test_result_fail("%s returned %d\n", test_name, + res < 0 ? errno : res); + *ret = RET_FAIL; + } } else { ksft_test_result_pass("%s succeeds\n", test_name); } diff --git a/tools/testing/selftests/futex/functional/futex_waitv.c b/tools/testing/selftests/futex/functional/futex_waitv.c index 034dbfef40cb..2a86fd3ea657 100644 --- a/tools/testing/selftests/futex/functional/futex_waitv.c +++ b/tools/testing/selftests/futex/functional/futex_waitv.c @@ -59,6 +59,14 @@ void *waiterfn(void *arg) int main(int argc, char *argv[]) { + if (!ksft_min_kernel_version(5, 16)) { + ksft_print_header(); + ksft_set_plan(0); + ksft_print_msg("%s: FUTEX_WAITV not implemented until 5.16\n", + basename(argv[0])); + ksft_print_cnts(); + return KSFT_SKIP; + } pthread_t waiter; int res, ret = RET_PASS; struct timespec to; -- 2.50.1.703.g449372360f-goog

3 months, 1 week

2
3
0 0

[PATCH v3] selftests/futex: Check for shmget support at runtime

by Wake Liu

The futex tests `futex_wait.c` and `futex_waitv.c` rely on the `shmget()` syscall, which may not be available if the kernel is built without System V IPC support (CONFIG_SYSVIPC=n). This can lead to test failures on such systems. This patch modifies the tests to check for `shmget()` support at runtime by calling it and checking for an `ENOSYS` error. If `shmget()` is not supported, the tests are skipped with a clear message, improving the user experience and preventing false negatives. This approach is more robust than relying on compile-time checks and ensures that the tests run only when the required kernel features are present. Signed-off-by: Wake Liu <wakel(a)google.com> --- .../selftests/futex/functional/futex_wait.c | 57 ++++++++------- .../selftests/futex/functional/futex_waitv.c | 73 ++++++++++++------- 2 files changed, 78 insertions(+), 52 deletions(-) diff --git a/tools/testing/selftests/futex/functional/futex_wait.c b/tools/testing/selftests/futex/functional/futex_wait.c index 685140d9b93d..2a834f074959 100644 --- a/tools/testing/selftests/futex/functional/futex_wait.c +++ b/tools/testing/selftests/futex/functional/futex_wait.c @@ -48,7 +48,7 @@ static void *waiterfn(void *arg) int main(int argc, char *argv[]) { int res, ret = RET_PASS, fd, c, shm_id; - u_int32_t f_private = 0, *shared_data; + u_int32_t f_private = 0, *shared_data = NULL; unsigned int flags = FUTEX_PRIVATE_FLAG; pthread_t waiter; void *shm; @@ -96,32 +96,37 @@ int main(int argc, char *argv[]) /* Testing an anon page shared memory */ shm_id = shmget(IPC_PRIVATE, 4096, IPC_CREAT | 0666); if (shm_id < 0) { - perror("shmget"); - exit(1); - } - - shared_data = shmat(shm_id, NULL, 0); - - *shared_data = 0; - futex = shared_data; - - info("Calling shared (page anon) futex_wait on futex: %p\n", futex); - if (pthread_create(&waiter, NULL, waiterfn, NULL)) - error("pthread_create failed\n", errno); - - usleep(WAKE_WAIT_US); - - info("Calling shared (page anon) futex_wake on futex: %p\n", futex); - res = futex_wake(futex, 1, 0); - if (res != 1) { - ksft_test_result_fail("futex_wake shared (page anon) returned: %d %s\n", - errno, strerror(errno)); - ret = RET_FAIL; + if (errno == ENOSYS) { + ksft_test_result_skip("Kernel does not support System V shared memory\n"); + } else { + ksft_test_result_fail("shmget() failed with error: %s\n", strerror(errno)); + ret = RET_FAIL; + } } else { - ksft_test_result_pass("futex_wake shared (page anon) succeeds\n"); + shared_data = shmat(shm_id, NULL, 0); + + *shared_data = 0; + futex = shared_data; + + info("Calling shared (page anon) futex_wait on futex: %p\n", futex); + if (pthread_create(&waiter, NULL, waiterfn, NULL)) + error("pthread_create failed\n", errno); + + usleep(WAKE_WAIT_US); + + info("Calling shared (page anon) futex_wake on futex: %p\n", futex); + res = futex_wake(futex, 1, 0); + if (res != 1) { + if (res < 0) + ksft_test_result_fail("futex_wake shared (page anon) failed with res=%d: %m\n", res); + else + ksft_test_result_fail("futex_wake shared (page anon) returned %d, expected 1\n", res); + ret = RET_FAIL; + } else { + ksft_test_result_pass("futex_wake shared (page anon) succeeds\n"); + } } - /* Testing a file backed shared memory */ fd = open(SHM_PATH, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR); if (fd < 0) { @@ -161,7 +166,8 @@ int main(int argc, char *argv[]) } /* Freeing resources */ - shmdt(shared_data); + if (shared_data) + shmdt(shared_data); munmap(shm, sizeof(f_private)); remove(SHM_PATH); close(fd); @@ -169,3 +175,4 @@ int main(int argc, char *argv[]) ksft_print_cnts(); return ret; } + diff --git a/tools/testing/selftests/futex/functional/futex_waitv.c b/tools/testing/selftests/futex/functional/futex_waitv.c index a94337f677e1..034dbfef40cb 100644 --- a/tools/testing/selftests/futex/functional/futex_waitv.c +++ b/tools/testing/selftests/futex/functional/futex_waitv.c @@ -110,40 +110,58 @@ int main(int argc, char *argv[]) } /* Shared waitv */ - for (i = 0; i < NR_FUTEXES; i++) { - int shm_id = shmget(IPC_PRIVATE, 4096, IPC_CREAT | 0666); - - if (shm_id < 0) { - perror("shmget"); - exit(1); + bool shm_supported = true; + int shm_id = shmget(IPC_PRIVATE, 4096, IPC_CREAT | 0666); + + if (shm_id < 0) { + if (errno == ENOSYS) { + shm_supported = false; + ksft_test_result_skip("Kernel does not support System V shared memory\n"); + } else { + ksft_test_result_fail("shmget() failed with error: %s\n", strerror(errno)); + ret = RET_FAIL; + shm_supported = false; } + } else { + shmctl(shm_id, IPC_RMID, NULL); + } - unsigned int *shared_data = shmat(shm_id, NULL, 0); + if (shm_supported) { + for (i = 0; i < NR_FUTEXES; i++) { + int shm_id = shmget(IPC_PRIVATE, 4096, IPC_CREAT | 0666); - *shared_data = 0; - waitv[i].uaddr = (uintptr_t)shared_data; - waitv[i].flags = FUTEX_32; - waitv[i].val = 0; - waitv[i].__reserved = 0; - } + if (shm_id < 0) { + perror("shmget"); + exit(1); + } - if (pthread_create(&waiter, NULL, waiterfn, NULL)) - error("pthread_create failed\n", errno); + unsigned int *shared_data = shmat(shm_id, NULL, 0); - usleep(WAKE_WAIT_US); + *shared_data = 0; + waitv[i].uaddr = (uintptr_t)shared_data; + waitv[i].flags = FUTEX_32; + waitv[i].val = 0; + waitv[i].__reserved = 0; + } - res = futex_wake(u64_to_ptr(waitv[NR_FUTEXES - 1].uaddr), 1, 0); - if (res != 1) { - ksft_test_result_fail("futex_wake shared returned: %d %s\n", - res ? errno : res, - res ? strerror(errno) : ""); - ret = RET_FAIL; - } else { - ksft_test_result_pass("futex_waitv shared\n"); - } + if (pthread_create(&waiter, NULL, waiterfn, NULL)) + error("pthread_create failed\n", errno); - for (i = 0; i < NR_FUTEXES; i++) - shmdt(u64_to_ptr(waitv[i].uaddr)); + usleep(WAKE_WAIT_US); + + res = futex_wake(u64_to_ptr(waitv[NR_FUTEXES - 1].uaddr), 1, 0); + if (res != 1) { + ksft_test_result_fail("futex_wake shared returned: %d %s\n", + res ? errno : res, + res ? strerror(errno) : ""); + ret = RET_FAIL; + } else { + ksft_test_result_pass("futex_waitv shared\n"); + } + + for (i = 0; i < NR_FUTEXES; i++) + shmdt(u64_to_ptr(waitv[i].uaddr)); + } /* Testing a waiter without FUTEX_32 flag */ waitv[0].flags = FUTEX_PRIVATE_FLAG; @@ -235,3 +253,4 @@ int main(int argc, char *argv[]) ksft_print_cnts(); return ret; } + -- 2.50.1.703.g449372360f-goog

3 months, 1 week

1
0
0 0

[PATCH RFC v2 0/2] KVM: arm64: PMU: Use multiple host PMUs

by Akihiko Odaki

On heterogeneous arm64 systems, KVM's PMU emulation is based on the features of a single host PMU instance. When a vCPU is migrated to a pCPU with an incompatible PMU, counters such as PMCCNTR_EL0 stop incrementing. Although this behavior is permitted by the architecture, Windows does not handle it gracefully and may crash with a division-by-zero error. The current workaround requires VMMs to pin vCPUs to a set of pCPUs that share a compatible PMU. This is difficult to implement correctly in QEMU/libvirt, where pinning occurs after vCPU initialization, and it also restricts the guest to a subset of available pCPUs. This patch introduces the KVM_ARM_VCPU_PMU_V3_COMPOSITION attribute to create a "composite" PMU. When set, KVM exposes a PMU that is compatible with all pCPUs by advertising only a single cycle counter, a feature common to all PMUs. This allows Windows guests to run reliably on heterogeneous systems without crashing, even without vCPU pinning, and enables VMMs to schedule vCPUs across all available pCPUs, making full use of the host hardware. A QEMU patch that demonstrates the usage of the new attribute is available at: https://lore.kernel.org/qemu-devel/20250806-kvm-v1-1-d1d50b7058cd@rsg.ci.i.… ("[PATCH RFC] target/arm/kvm: Choose PMU backend") Signed-off-by: Akihiko Odaki <odaki(a)rsg.ci.i.u-tokyo.ac.jp> --- Changes in v2: - Added the KVM_ARM_VCPU_PMU_V3_COMPOSITION attribute to opt in the feature. - Added code to handle overflow. - Link to v1: https://lore.kernel.org/r/20250319-hybrid-v1-1-4d1ada10e705@daynix.com --- Akihiko Odaki (2): KVM: arm64: PMU: Introduce KVM_ARM_VCPU_PMU_V3_COMPOSITION KVM: arm64: selftests: Test guest PMUv3 composition Documentation/virt/kvm/devices/vcpu.rst | 30 ++ arch/arm64/include/asm/kvm_host.h | 2 + arch/arm64/include/uapi/asm/kvm.h | 1 + arch/arm64/kvm/arm.c | 5 +- arch/arm64/kvm/pmu-emul.c | 495 +++++++++++++-------- arch/arm64/kvm/sys_regs.c | 2 +- include/kvm/arm_pmu.h | 12 +- .../selftests/kvm/arm64/vpmu_counter_access.c | 148 ++++-- 8 files changed, 461 insertions(+), 234 deletions(-) --- base-commit: 8ec6d99a41e3d1dbdff2bdb3aa42951681e1e76c change-id: 20250224-hybrid-01d5ff47edd2 Best regards, -- Akihiko Odaki <odaki(a)rsg.ci.i.u-tokyo.ac.jp>

3 months, 1 week

2
8
0 0

[PATCH v12 iproute2-next 0/3] DUALPI2 iproute2 patch

by chia-yu.chang＠nokia-bell-labs.com

From: Chia-Yu Chang <chia-yu.chang(a)nokia-bell-labs.com> Hello, Please find DUALPI2 iproute2 patch v12. For more details of DualPI2, please refer IETF RFC9332 (https://datatracker.ietf.org/doc/html/rfc9332). Best Regards, Chia-Yu --- v12 (04-Aug-2025) - Split into 3 patches: one move get_float(), one add get_float_min_max(), one for dualpi2 (David Ahern <dsahern(a)kernel.org>) - Repalce matches() with strcmp() within get_packets() (David Ahern <dsahern(a)kernel.org>) - Apply reverse xmas tree listing of variables (David Ahern <dsahern(a)kernel.org>) v11 (18-Jul-2025) - Replace TCA_DUALPI2 prefix with TC_DUALPI2 prefix for enums (Jakub Kicinski <kuba(a)kernel.org>) v10 (02-Jul-2025) - Replace STEP_THRESH and STEP_PACKETS w/ STEP_THRESH_PKTS and STEP_THRESH_US of net-next patch (Jakub Kicinski <kuba(a)kernel.org>) v9 (13-Jun-2025) - Fix space issue and typos (ALOK TIWARI <alok.a.tiwari(a)oracle.com>) - Change 'rtt_typical' to 'typical_rtt' in tc/q_dualpi2.c (ALOK TIWARI <alok.a.tiwari(a)oracle.com>) - Add the num of enum used by DualPI2 in pkt_sched.h v8 (09-May-2025) - Update pkt_sched.h with the one in nex-next - Correct a typo in the comment within pkt_sched.h (ALOK TIWARI <alok.a.tiwari(a)oracle.com>) - Update manual content in man/man8/tc-dualpi2.8 (ALOK TIWARI <alok.a.tiwari(a)oracle.com>) - Update tc/q_dualpi2.c to fix missing blank lines and add missing case (ALOK TIWARI <alok.a.tiwari(a)oracle.com>) v7 (05-May-2025) - Align pkt_sched.h with the v14 version of net-next due to spec modification in tc.yaml - Reorganize dualpi2_print_opt() to match the order in tc.yaml - Remove credit-queue in PRINT_JSON v6 (26-Apr-2025) - Update JSON file output due to spec modification in tc.yaml of net-next v5 (25-Mar-2025) - Use matches() to replace current strcmp() (Stephen Hemminger <stephen(a)networkplumber.org>) - Use general parse_percent() for handling scaled percentage values (Stephen Hemminger <stephen(a)networkplumber.org>) - Add print function for JSON of dualpi2 stats (Stephen Hemminger <stephen(a)networkplumber.org>) v4 (16-Mar-2025) - Add min_qlen_step to the dualpi2 attribute as the minimum queue length in number of packets in the L-queue to start step marking. v3 (21-Feb-2025) - Add memlimit to the dualpi2 attribute, and add memory_used, max_memory_used, and memory_limit in dualpi2 stats (Dave Taht <dave.taht(a)gmail.com>) - Update the manual to align with the latest implementation and clarify the queue naming and default unit - Use common "get_scaled_alpha_beta" and clean print_opt for Dualpi2 v2 (23-Oct-2024) - Rename get_float in dualpi2 to get_float_min_max in utils.c - Move get_float from iplink_can.c in utils.c (Stephen Hemminger <stephen(a)networkplumber.org>) - Add print function for JSON of dualpi2 (Stephen Hemminger <stephen(a)networkplumber.org>) --- Chia-Yu Chang (3): Move get_float() from ip/iplink_can.c to lib/utils.c Add get_float_min_max() in lib/utils.c tc: add dualpi2 scheduler module bash-completion/tc | 11 +- include/utils.h | 2 + ip/iplink_can.c | 14 -- lib/utils.c | 30 +++ man/man8/tc-dualpi2.8 | 249 ++++++++++++++++++++ tc/Makefile | 1 + tc/q_dualpi2.c | 535 ++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 827 insertions(+), 15 deletions(-) create mode 100644 man/man8/tc-dualpi2.8 create mode 100644 tc/q_dualpi2.c -- 2.34.1

3 months, 1 week

2
4
0 0

[RFC PATCH 00/18] cgroup/cpuset: Enable runtime modification of

by Waiman Long

The "nohz_full" and "rcu_nocbs" boot command parameters can be used to remove a lot of kernel overhead on a specific set of isolated CPUs which can be used to run some latency/bandwidth sensitive workloads with as little kernel disturbance/noise as possible. The problem with this mode of operation is the fact that it is a static configuration which cannot be changed after boot to adjust for changes in application loading. There is always a desire to enable runtime modification of the number of isolated CPUs that can be dedicated to this type of demanding workloads. This patchset is an attempt to do just that with an amount of CPU isolation close to what can be done with the nohz_full and rcu_nocbs boot kernel parameters. This patch series provides the ability to change the set of housekeeping CPUs at run time via the cpuset isolated partition functionality. Currently, the cpuset isolated partition is able to disable scheduler load balancing and the CPU affinity of the unbound workqueue to avoid the isolated CPUs. This patch series will extend that with other kernel noises associated with the nohz_full boot command line parameter which has the following sub-categories: - tick - timer - RCU - MISC - WQ - kthread The rcu_nocbs is actually a subset of nohz_full focusing just on the RCU part of the kernel noises. The WQ part has already been handled by the current cpuset code. This series focuses on the tick and RCU part of the kernel noises by actively changing their internal data structures to track changes in the list of isolated CPUs used by cpuset isolated partitions. The dynamic update of the lists of housekeeping CPUs at run time will also have impact on the other part of the kernel noises that reference the lists of housekeeping CPUs at run time. The pending patch series on timer migration[1], when properly integrated will support the timer part too. The CPU hotplug functionality of the Linux kernel is used to facilitate the runtime change of the nohz_full isolated CPUs with minimal code changes. The CPUs that need to be switched from non-isolated to isolated or vice versa will be brought offline first, making the necessary changes and then brought back online afterward. The use of CPU hotplug, however, does have a slight drawback of freezing all the other CPUs in part of the offlining process using the stop machine feature of the kernel. That will cause a noticeable latency spikes in other running applications which may be significant to sensitive applications running on isolated CPUs in other isolated partitions at the time. Hopefully we can find a way to solve this problem in the future. One possible workaround for this is to reserve a set of nohz_full isolated CPUs at boot time using the nohz_full boot command parameter. The bringing of those nohz_full reserved CPUs into and out of isolated partitions will not invoke CPU hotplug and hence will not cause unexpected latency spikes. These reserved CPUs will only be needed if there are other existing isolated partitions running critical applications at the time when an isolated partition needs to be created. Patches 1-4 updates the CPU isolation code at kernel/sched/isolation.c to enable dynamic update of the lists of housekeeping CPUs. Patch 5 introduces a new cpuhp_offline_cb() API for shutting down the given set of CPUs, running the given callback method and then bringing those CPUs back online again. This new API will block any incoming hotplug events from interfering this operation. Patches 6-9 updates the cpuset partition code to use the new cpuhp API to shut down the affect CPUs, making changes to the housekeeping cpumasks and then bring those CPUs online afterward. Patch 10 works around an issue in the DL server code that block the hotplug operation under certain configurations. Patch 11-14 updates the timer tick and related code to enable proper updates to the set of CPUs requiring nohz_full dynticks support. Patch 15 enables runtime modification to the set of isolated CPUs requiring RCU NO-CB CPU support with minor changes to the RCU code. Patches 16-18 includes other miscellaneous updates to cpuset code and documentation. This patch series is applied on top of some other cpuset patches[1] posted upstream recently. [1] https://lore.kernel.org/lkml/20250806093855.86469-1-gmonaco@redhat.com/ [2] https://lore.kernel.org/lkml/20250806172430.1155133-1-longman@redhat.com/ Waiman Long (18): sched/isolation: Enable runtime update of housekeeping cpumasks sched/isolation: Call sched_tick_offload_init() when HK_FLAG_KERNEL_NOISE is first set sched/isolation: Use RCU to delay successive housekeeping cpumask updates sched/isolation: Add a debugfs file to dump housekeeping cpumasks cpu/hotplug: Add a new cpuhp_offline_cb() API cgroup/cpuset: Introduce a new top level isolcpus_update_mutex cgroup/cpuset: Allow overwriting HK_TYPE_DOMAIN housekeeping cpumask cgroup/cpuset: Use CPU hotplug to enable runtime nohz_full modification cgroup/cpuset: Revert "Include isolated cpuset CPUs in cpu_is_isolated() check" sched/core: Ignore DL BW deactivation error if in cpuhp_offline_cb_mode tick/nohz: Make nohz_full parameter optional tick/nohz: Introduce tick_nohz_full_update_cpus() to update tick_nohz_full_mask tick/nohz: Allow runtime changes in full dynticks CPUs tick: Pass timer tick job to an online HK CPU in tick_cpu_dying() cgroup/cpuset: Enable RCU NO-CB CPU offloading of newly isolated CPUs cgroup/cpuset: Don't set have_boot_nohz_full without any boot time nohz_full CPU cgroup/cpuset: Documentation updates & don't use CPU 0 for isolated partition cgroup/cpuset: Add pr_debug() statements for cpuhp_offline_cb() call Documentation/admin-guide/cgroup-v2.rst | 33 +- .../admin-guide/kernel-parameters.txt | 19 +- include/linux/context_tracking.h | 8 +- include/linux/cpuhplock.h | 9 + include/linux/cpuset.h | 6 - include/linux/rcupdate.h | 2 + include/linux/sched/isolation.h | 9 +- include/linux/tick.h | 2 + kernel/cgroup/cpuset.c | 344 ++++++++++++------ kernel/context_tracking.c | 21 +- kernel/cpu.c | 47 +++ kernel/rcu/tree_nocb.h | 7 +- kernel/sched/core.c | 8 +- kernel/sched/debug.c | 32 ++ kernel/sched/isolation.c | 151 +++++++- kernel/sched/sched.h | 2 +- kernel/time/tick-common.c | 15 +- kernel/time/tick-sched.c | 24 +- .../selftests/cgroup/test_cpuset_prs.sh | 15 +- 19 files changed, 583 insertions(+), 171 deletions(-) -- 2.50.0

3 months, 1 week

3
20
0 0

[PATCH 0/4] Better split_huge_page_test result check

by Zi Yan

David asked me if there is a way of checking split_huge_page_test results instead of the existing smap check[1]. This patchset uses kpageflags to get after-split folio orders for a better split_huge_page_test result check. The added gather_folio_orders() scans through a VPN range and collects the numbers of folios at different orders. check_folio_orders() compares the result of gather_folio_orders() to a given list of numbers of different orders. split_huge_page_test needs the FORCE_READ fix in [2] to work correctly. This patchset also: 1. added new order and in folio offset to the split huge page debugfs's pr_debug()s; 2. changed split_huge_pages_pid() to skip the rest of a folio if it is split by folio_split() (not changing split_folio_to_order() part since split_pte_mapped_thp test relies on its behavior). [1] https://lore.kernel.org/linux-mm/e2f32bdb-e4a4-447c-867c-31405cbba151@redha… [2] https://lore.kernel.org/linux-mm/20250805175140.241656-1-ziy@nvidia.com/ Zi Yan (4): mm/huge_memory: add new_order and offset to split_huge_pages*() pr_debug. mm/huge_memory: move to next folio after folio_split() succeeds. selftests/mm: add check_folio_orders() helper. selftests/mm: check after-split folio orders in split_huge_page_test. mm/huge_memory.c | 22 +-- .../selftests/mm/split_huge_page_test.c | 67 ++++++--- tools/testing/selftests/mm/vm_util.c | 139 ++++++++++++++++++ tools/testing/selftests/mm/vm_util.h | 2 + 4 files changed, 200 insertions(+), 30 deletions(-) -- 2.47.2

3 months, 1 week

6
20
0 0

[PATCH net 1/2] tls: handle data disappearing from under the TLS ULP

by Jakub Kicinski

TLS expects that it owns the receive queue of the TCP socket. This cannot be guaranteed in case the reader of the TCP socket entered before the TLS ULP was installed, or uses some non-standard read API (eg. zerocopy ones). Make sure that the TCP sequence numbers match between ->data_ready and ->recvmsg, otherwise don't trust the work that ->data_ready has done. Signed-off-by: William Liu <will(a)willsroot.io> Signed-off-by: Savino Dicanosa <savy(a)syst3mfailure.io> Link: https://lore.kernel.org/tFjq_kf7sWIG3A7CrCg_egb8CVsT_gsmHAK0_wxDPJXfIzxFAMx… Fixes: 84c61fe1a75b ("tls: rx: do not use the standard strparser") Signed-off-by: Jakub Kicinski <kuba(a)kernel.org> --- include/net/tls.h | 1 + net/tls/tls.h | 2 +- net/tls/tls_strp.c | 17 ++++++++++++++--- net/tls/tls_sw.c | 3 ++- 4 files changed, 18 insertions(+), 5 deletions(-) diff --git a/include/net/tls.h b/include/net/tls.h index 857340338b69..37344a39e4c9 100644 --- a/include/net/tls.h +++ b/include/net/tls.h @@ -117,6 +117,7 @@ struct tls_strparser { bool msg_ready; struct strp_msg stm; + u32 copied_seq; struct sk_buff *anchor; struct work_struct work; diff --git a/net/tls/tls.h b/net/tls/tls.h index 774859b63f0d..4e077068e6d9 100644 --- a/net/tls/tls.h +++ b/net/tls/tls.h @@ -196,7 +196,7 @@ void tls_strp_msg_done(struct tls_strparser *strp); int tls_rx_msg_size(struct tls_strparser *strp, struct sk_buff *skb); void tls_rx_msg_ready(struct tls_strparser *strp); -void tls_strp_msg_load(struct tls_strparser *strp, bool force_refresh); +bool tls_strp_msg_load(struct tls_strparser *strp, bool force_refresh); int tls_strp_msg_cow(struct tls_sw_context_rx *ctx); struct sk_buff *tls_strp_msg_detach(struct tls_sw_context_rx *ctx); int tls_strp_msg_hold(struct tls_strparser *strp, struct sk_buff_head *dst); diff --git a/net/tls/tls_strp.c b/net/tls/tls_strp.c index 095cf31bae0b..4bac58174cc3 100644 --- a/net/tls/tls_strp.c +++ b/net/tls/tls_strp.c @@ -473,9 +473,11 @@ static void tls_strp_load_anchor_with_queue(struct tls_strparser *strp, int len) strp->anchor->destructor = NULL; strp->stm.offset = offset; + + strp->copied_seq = tp->copied_seq; } -void tls_strp_msg_load(struct tls_strparser *strp, bool force_refresh) +bool tls_strp_msg_load(struct tls_strparser *strp, bool force_refresh) { struct strp_msg *rxm; struct tls_msg *tlm; @@ -484,8 +486,15 @@ void tls_strp_msg_load(struct tls_strparser *strp, bool force_refresh) DEBUG_NET_WARN_ON_ONCE(!strp->stm.full_len); if (!strp->copy_mode && force_refresh) { - if (WARN_ON(tcp_inq(strp->sk) < strp->stm.full_len)) - return; + struct tcp_sock *tp = tcp_sk(strp->sk); + + if (unlikely(strp->copied_seq != tp->copied_seq || + WARN_ON(tcp_inq(strp->sk) < strp->stm.full_len))) { + + WRITE_ONCE(strp->msg_ready, 0); + memset(&strp->stm, 0, sizeof(strp->stm)); + return false; + } tls_strp_load_anchor_with_queue(strp, strp->stm.full_len); } @@ -495,6 +504,8 @@ void tls_strp_msg_load(struct tls_strparser *strp, bool force_refresh) rxm->offset = strp->stm.offset; tlm = tls_msg(strp->anchor); tlm->control = strp->mark; + + return true; } /* Called with lock held on lower socket */ diff --git a/net/tls/tls_sw.c b/net/tls/tls_sw.c index 549d1ea01a72..51c98a007dda 100644 --- a/net/tls/tls_sw.c +++ b/net/tls/tls_sw.c @@ -1384,7 +1384,8 @@ tls_rx_rec_wait(struct sock *sk, struct sk_psock *psock, bool nonblock, return sock_intr_errno(timeo); } - tls_strp_msg_load(&ctx->strp, released); + if (unlikely(!tls_strp_msg_load(&ctx->strp, released))) + return tls_rx_rec_wait(sk, psock, nonblock, false); return 1; } -- 2.50.1

3 months, 1 week

2
6
0 0

[PATCH v3 0/2] fscontext: do not consume log entries when returning -EMSGSIZE

by Aleksa Sarai

Userspace generally expects APIs that return -EMSGSIZE to allow for them to adjust their buffer size and retry the operation. However, the fscontext log would previously clear the message even in the -EMSGSIZE case. Given that it is very cheap for us to check whether the buffer is too small before we remove the message from the ring buffer, let's just do that instead. While we're at it, refactor some fscontext_read() into a separate helper to make the ring buffer logic a bit easier to read. Fixes: 007ec26cdc9f ("vfs: Implement logging through fs_context") Signed-off-by: Aleksa Sarai <cyphar(a)cyphar.com> --- Changes in v3: - selftests: use EXPECT_STREQ() - v2: <https://lore.kernel.org/r/20250806-fscontext-log-cleanups-v2-0-88e9d34d142f…> Changes in v2: - Refactor message fetching to fetch_message_locked() which returns ERR_PTR() in error cases. [Al Viro] - v1: <https://lore.kernel.org/r/20250806-fscontext-log-cleanups-v1-0-880597d42a5a…> --- Aleksa Sarai (2): fscontext: do not consume log entries when returning -EMSGSIZE selftests/filesystems: add basic fscontext log tests fs/fsopen.c | 54 +++++----- tools/testing/selftests/filesystems/.gitignore | 1 + tools/testing/selftests/filesystems/Makefile | 2 +- tools/testing/selftests/filesystems/fclog.c | 130 +++++++++++++++++++++++++ 4 files changed, 162 insertions(+), 25 deletions(-) --- base-commit: 66639db858112bf6b0f76677f7517643d586e575 change-id: 20250806-fscontext-log-cleanups-50f0143674ae Best regards, -- Aleksa Sarai <cyphar(a)cyphar.com>

3 months, 1 week

3
7
0 0

[PATCH 0/2] open_tree_attr: do not allow id-mapping changes without OPEN_TREE_CLONE

by Aleksa Sarai

As described in commit 7a54947e727b ('Merge patch series "fs: allow changing idmappings"'), open_tree_attr(2) was necessary in order to allow for a detached mount to be created and have its idmappings changed without the risk of any racing threads operating on it. For this reason, mount_setattr(2) still does not allow for id-mappings to be changed. However, there was a bug in commit 2462651ffa76 ("fs: allow changing idmappings") which allowed users to bypass this restriction by calling open_tree_attr(2) *without* OPEN_TREE_CLONE. can_idmap_mount() prevented this bug from allowing an attached mountpoint's id-mapping from being modified (thanks to an is_anon_ns() check), but this still allows for detached (but visible) mounts to have their be id-mapping changed. This risks the same UAF and locking issues as described in the merge commit, and was likely unintentional. For what it's worth, I found this while working on the open_tree_attr(2) man page, and was trying to figure out what open_tree_attr(2)'s behaviour was in the (slightly fruity) ~OPEN_TREE_CLONE case. Signed-off-by: Aleksa Sarai <cyphar(a)cyphar.com> --- Aleksa Sarai (2): open_tree_attr: do not allow id-mapping changes without OPEN_TREE_CLONE selftests/mount_setattr: add smoke tests for open_tree_attr(2) bug fs/namespace.c | 3 +- .../selftests/mount_setattr/mount_setattr_test.c | 77 ++++++++++++++++++---- 2 files changed, 66 insertions(+), 14 deletions(-) --- base-commit: 66639db858112bf6b0f76677f7517643d586e575 change-id: 20250808-open_tree_attr-bugfix-idmap-bb741166dc04 Best regards, -- Aleksa Sarai <cyphar(a)cyphar.com>

3 months, 1 week

2
3
0 0

[PATCH 0/9] kunit: Refactor and extend KUnit's

by Marie Zhussupova

Hello! KUnit offers a parameterized testing framework, where tests can be run multiple times with different inputs. Currently, the same `struct kunit` is used for each parameter execution. After each run, the test instance gets cleaned up. This creates the following limitations: a. There is no way to store resources that are accessible across the individual parameter test executions. b. It's not possible to pass additional context besides the previous parameter to `generate_params()` to get the next parameter. c. Test users are restricted to using pre-defined static arrays of parameter objects or `generate_params()` to define their parameters. There is no flexibility to pass a custom dynamic array without using `generate_params()`, which can be complex if generating the next parameter depends on more than just the single previous parameter (e.g., two or more previous parameters). This patch series resolves these limitations by: 1. [P 1] Giving each parameterized test execution its own `struct kunit`. This aligns more with the definition of a `struct kunit` as a running instance of a test. It will also remove the need to manage state, such as resetting the `test->priv` field or the `test->status_comment` after every parameter run. 2. [P 1] Introducing a parent pointer of type `struct kunit`. Behind the scenes, a parent instance for the parameterized tests will be created. It won't be used to execute any test logic, but will instead be used as a context for shared resources. Each individual running instance of a test will now have a reference to that parent instance and thus, have access to those resources. 3. [P 2] Introducing `param_init()` and `param_exit()` functions that can set up and clean up the parent instance of the parameterized tests. They will run once before and after the parameterized series and provide a way for the user to access the parent instance to add the parameter array or any other resources to it, including custom ones to the `test->parent->priv` field or to `test->parent->resources` via the Resource API (link below). https://elixir.bootlin.com/linux/v6.16-rc7/source/include/kunit/resource.h 4. [P 3, 4 & 5] Passing the parent `struct kunit` as an additional parameter to `generate_params()`. This provides `generate_params()` with more available context, making parameter generation much more flexible. The `generate_params()` implementations in the KCSAN and drm/xe tests have been adapted to match the new function pointer signature. 5. [P 6] Introducing a `params_data` field in `struct kunit`. This will allow the parent instance of a test to have direct storage of the parameter array, enabling features like using dynamic parameter arrays or using context beyond just the previous parameter. Thank you! -Marie Marie Zhussupova (9): kunit: Add parent kunit for parameterized test context kunit: Introduce param_init/exit for parameterized test shared context management kunit: Pass additional context to generate_params for parameterized testing kcsan: test: Update parameter generator to new signature drm/xe: Update parameter generator to new signature kunit: Enable direct registration of parameter arrays to a KUnit test kunit: Add example parameterized test with shared resources and direct static parameter array setup kunit: Add example parameterized test with direct dynamic parameter array setup Documentation: kunit: Document new parameterized test features Documentation/dev-tools/kunit/usage.rst | 455 +++++++++++++++++++++++- drivers/gpu/drm/xe/tests/xe_pci.c | 2 +- include/kunit/test.h | 98 ++++- kernel/kcsan/kcsan_test.c | 2 +- lib/kunit/kunit-example-test.c | 207 +++++++++++ lib/kunit/test.c | 82 ++++- 6 files changed, 818 insertions(+), 28 deletions(-) -- 2.50.1.552.g942d659e1b-goog

3 months, 1 week

7
40
0 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror August 2025