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

[PATCH v3 0/7] selftests/mm: Fix false positives and skip unsupported tests

by Aboorva Devarajan

Hi all, This patch series addresses false positives in the generic mm selftests and skips tests that cannot run correctly due to missing features or system limitations. v2: https://lore.kernel.org/all/20250703060656.54345-1-aboorvad@linux.ibm.com/ Changes in v3: - Rebased onto the latest mm-new branch, top commit of the base is commit 0709ddf8951f ("mm: add zblock allocator"). - Minor refactor based on the review comments. - Included the tags from the previous version. --- v1: https://lore.kernel.org/all/20250616160632.35250-1-aboorvad@linux.ibm.com/ Changes in v2: - Rebased onto the mm-new branch, top commit of the base is commit 3b4a8ad89f7e ("mm: add zblock allocator"). - Split some patches for clarity. - Updated virtual_address_range test to support testing 4PB VA on PPC64. - Added proper Fixes: tags. - Included a patch to skip a failing userfaultfd test when unsupported, instead of reporting a failure. --- Please let us know if you have any further comments. Thanks, Aboorva Aboorva Devarajan (3): selftests/mm: Fix child process exit codes in ksm_functional_tests selftests/mm: Skip thuge-gen test if system is not setup properly selftests/mm: Skip hugepage-mremap test if userfaultfd unavailable Donet Tom (4): mm/selftests: Fix incorrect pointer being passed to mark_range() selftests/mm: Add support to test 4PB VA on PPC64 selftest/mm: Fix ksm_funtional_test failures mm/selftests: Fix split_huge_page_test failure on systems with 64KB page size tools/testing/selftests/mm/hugepage-mremap.c | 16 +++++++++-- .../selftests/mm/ksm_functional_tests.c | 28 +++++++++++++------ .../selftests/mm/split_huge_page_test.c | 23 +++++++++------ tools/testing/selftests/mm/thuge-gen.c | 11 +++++--- .../selftests/mm/virtual_address_range.c | 13 ++++++++- 5 files changed, 67 insertions(+), 24 deletions(-) -- 2.47.1

3 months

4
20
0 0

[PATCH v2 0/1] selftests/futex: Check for shmget support at runtime

by Wake Liu

Changes in v2: - Restore RET_FAIL assignments in error paths to ensure the test's exit code accurately reflects the failure status. Wake Liu (1): selftests/futex: Check for shmget support at runtime .../selftests/futex/functional/futex_wait.c | 49 +++++++------ .../selftests/futex/functional/futex_waitv.c | 73 ++++++++++++------- 2 files changed, 73 insertions(+), 49 deletions(-) -- 2.50.1.703.g449372360f-goog

3 months

2
3
0 0

[PATCH] selftests/filesystems/binderfs: Skip tests if user namespaces are unavailable

by Wake Liu

The binderfs selftests, specifically `binderfs_stress` and `binderfs_test_unprivileged`, depend on user namespaces to run. On kernels built without user namespace support (CONFIG_USER_NS=n), these tests will fail. To prevent these failures, add a check for the availability of user namespaces by testing for the existence of "/proc/self/ns/user". If the check fails, skip the tests and print an informative message. Signed-off-by: Wake Liu <wakel(a)google.com> --- .../selftests/filesystems/binderfs/binderfs_test.c | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/tools/testing/selftests/filesystems/binderfs/binderfs_test.c b/tools/testing/selftests/filesystems/binderfs/binderfs_test.c index 81db85a5cc16..e77ed34ebd06 100644 --- a/tools/testing/selftests/filesystems/binderfs/binderfs_test.c +++ b/tools/testing/selftests/filesystems/binderfs/binderfs_test.c @@ -291,6 +291,11 @@ static int write_id_mapping(enum idmap_type type, pid_t pid, const char *buf, return 0; } +static bool has_userns(void) +{ + return (access("/proc/self/ns/user", F_OK) == 0); +} + static void change_userns(struct __test_metadata *_metadata, int syncfds[2]) { int ret; @@ -378,6 +383,9 @@ static void *binder_version_thread(void *data) */ TEST(binderfs_stress) { + if (!has_userns()) + SKIP(return, "%s: user namespace not supported\n", __func__); + int fds[1000]; int syncfds[2]; pid_t pid; @@ -502,6 +510,8 @@ TEST(binderfs_test_privileged) TEST(binderfs_test_unprivileged) { + if (!has_userns()) + SKIP(return, "%s: user namespace not supported\n", __func__); int ret; int syncfds[2]; pid_t pid; -- 2.50.1.703.g449372360f-goog

3 months

2
2
0 0

[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

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
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

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

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

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

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

2
6
0 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror