summaryrefslogtreecommitdiff
AgeCommit message (Collapse)Author
2026-10-19dt-bindings: net: qcom,ipq9574-ppe: Split EDMA reset into sys and apbLuo Jie
The EDMA reset is described in the binding as a single reset, but the hardware has two separate EDMA resets, the system reset and the APB reset. The reset used in the example is a combined reset that covers both of them. Describe the EDMA resets as two separate entries named "sys" and "apb", in the same way as the EDMA clocks, and update the example accordingly. The EDMA driver has not been merged upstream yet, and no in-tree device tree uses the ethernet-dma node, so there is no existing user of this binding and it is safe to update it without breaking the ABI. Reviewed-by: Rob Herring (Arm) <robh@kernel.org> Signed-off-by: Luo Jie <jie.luo@oss.qualcomm.com> Link: https://patch.msgid.link/20261011-qcom_ipq5424_ppe-v2-1-8c7b057e2c43@oss.qualcomm.com Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2026-10-19net/dcb: Validate bandwidth for non-ETS traffic classesAlexei Lazar
The IEEE 802.1Qaz standard defines that bandwidth allocation percentages only apply to ETS traffic classes. Reject ETS configurations that specify non-zero bandwidth for non-ETS traffic classes. Placing this check in dcbnl_ieee_set() enforces the constraint uniformly for all drivers rather than relying on each driver to validate it independently. Drop the equivalent check from NFP's dcb_ets_check(). Keep ETS bandwidth-sum validation unchanged. Signed-off-by: Alexei Lazar <alazar@nvidia.com> Reviewed-by: Carolina Jubran <cjubran@nvidia.com> Signed-off-by: Tariq Toukan <tariqt@nvidia.com> Link: https://patch.msgid.link/20261011083929.739261-1-tariqt@nvidia.com Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2026-10-19Merge branch 'next' into for-linusDmitry Torokhov
Prepare input updates for 7.4 merge window.
2026-10-19watchdog: mediatek: Apply the driver's mode to a watchdog left runningRyan Brue
When the bootloader leaves the watchdog enabled, probe only marks it running and sets the timeout, so WDT_MODE keeps whatever the bootloader wrote. The Amazon Fire HD 10 (2017) bootloader leaves dual mode with the bark IRQ enabled, and no pretimeout is configured, so each timeout only raises the IRQ and restarts the count: with the 20 s timeout systemd sets, a hung system was reset after 37.95-39.76 s, and after 18.25-20.92 s once IRQ_EN was cleared by hand. Program the mode as mtk_wdt_start() does, which also applies mediatek,disable-extrst and mediatek,reset-by-toprgu to a running watchdog; read those two properties first. Fixes: bbece05c0d3a ("watchdog: mtk_wdt: Remove mtk_wdt_stop() in probe() to prevent the system freeze and it doesn't reboot by watchdog problem") Assisted-by: LLM Signed-off-by: Ryan Brue <ryanbrue.dev@gmail.com> Link: https://patch.msgid.link/20260923-rbrue-suez-upstreaming-mtk-wdt-dual-mode-v1-1-0970852315e4@gmail.com Signed-off-by: Guenter Roeck <linux@roeck-us.net>
2026-10-19Merge branch 'net-sched-cls_bpf-accept-dev-bound-programs-on-shared-blocks'Jakub Kicinski
Jamal Hadi Salim says: ==================== net/sched: cls_bpf: accept dev-bound programs on shared blocks This series fixes the regression where a device-bound SCHED_CLS program attached through a shared block is rejected even when it is bound to a netdev that owns the block, and closes the bind/reoffload replay hole a later-joining device would otherwise exploit. Patch 1 gives netdevsim's cls_bpf TC block callback the device-match check nfp already has; the callback is the authoritative per-device acceptance boundary and the defect there predates the cls_bpf core change. Patch 2 makes the core attach-time check derive the target device from the shared block's member set (block->q is NULL for a shared block) and require every member to match, mirroring the broadcast fan-out of the offload path. Patch 1 is a prerequisite of patch 2 on v7.2+ trees: commit 120977e2c096 ("net/sched: cls_bpf: reject dev-bound programs bound to a different device") made the replay path unreachable through shared blocks as a side effect, and patch 2 re-exposes it, so a stable tree must take both together. Patch 3 adds shared-block and late-join coverage to bpf_offload.py; it uses the existing sample_ret0.bpf.o with an explicit `type classifier` override instead of adding a new sample object. ==================== Link: https://patch.msgid.link/QDISC-PYC7.v2.20261010165947@mojatatu.com Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2026-10-19selftests: net: exercise dev-bound cls_bpf on shared blocksJamal Hadi Salim
The issue: bpf_offload.py only exercises per-device ingress qdiscs today, so neither the shared-block accept path nor the late-join replay is tested. The Fix: Add a test for a device-bound SCHED_CLS program attached through a shared block. It loads a dev-bound SCHED_CLS program for a netdevsim device and checks: - the program attaches to a shared block owned by its device, and the filter teardown leaves the device unloaded; - a block that also holds an independently backed device rejects the attach, because the offload path broadcasts the program to all members; - an independently backed device that joins a populated block is not loaded by the bind/replay path, and the driver's extack is asserted; - a second port of the same netdevsim device (same offload device) is accepted together with the bound port. The program is loaded from the existing sample_ret0.bpf.o with an explicit `type classifier` override, so no new sample object is needed. Reviewed-by: Victor Nogueira <victor@mojatatu.com> Signed-off-by: Jamal Hadi Salim <jhs@mojatatu.com> Reviewed-by: Simon Horman <horms@kernel.org> Link: https://patch.msgid.link/QDISC-PYC7.v2.20261010165947-4@mojatatu.com Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2026-10-19net/sched: cls_bpf: accept dev-bound programs on shared blocksJamal Hadi Salim
The issue: Follow-up to commit 120977e2c096 ("net/sched: cls_bpf: reject dev-bound programs bound to a different device"), which derived the target device from block->q: dev = block->q ? qdisc_dev(block->q) : NULL; tcf_block_create() leaves block->q NULL for shared blocks, so a device-bound program attached through a shared block is rejected with -EINVAL even when it is bound to a netdev that owns the block. The offload path (cls_bpf_offload_cmd()) never consults block->q and drives the per-device callbacks for shared blocks as before. The Fix: Accept the attach on a shared block when bpf_offload_dev_match() matches every netdev bound to the block, and reject an empty block. Every member must match because the offload path broadcasts the program to every callback registered on the block, so an any-member check would re-admit the wrong-device attach on a mixed block. Every dev-bound SCHED_CLS attach is skip_sw, which becomes err_stop and aborts the offload on the first failing callback, so the all-members rule is the offload path's own semantics. Iterate the public block->ports xarray (913b47d3424e, v6.8-rc1) rather than block->owner_list, which is private to cls_api.c. The shared-block rejection reports "Program is not bound to every device in the block", distinct from the non-shared message, because a member can exist without a registered callback (netdevsim registers its block callback ingress-only). Context note: This patch is not an independent fix: it re-exposes the shared-block replay path that commit 120977e2c096 ("net/sched: cls_bpf: reject dev-bound programs bound to a different device") had closed, so patch 1 must be applied first, including in stable. A stable tree taking this patch alone would re-enable shared-block attaches on a kernel whose netdevsim callback is still unchecked. Conditions to recreate the bug: - CONFIG_NETDEVSIM=y, CONFIG_NET_CLS_BPF=y - load a dev-bound SCHED_CLS program for netdevsim device B (prog_ifindex=B), pin it in bpffs - tc qdisc add dev B ingress_block 22 clsact - tc filter add block 22 ingress bpf da object-pinned <pin> skip_sw Unfixed, the filter add fails with -EINVAL ("Program is bound to a different device"); fixed, it succeeds. Adding a second, independently backed netdevsim device to the same block makes the attach fail again. Fixes: 120977e2c096 ("net/sched: cls_bpf: reject dev-bound programs bound to a different device") Reported-by: Sashiko (nipa) <sashiko-bot@kernel.org> Link: https://lore.kernel.org/netdev/20260809094418.901607-1-jhs@mojatatu.com/ Link: https://lore.kernel.org/netdev/QDISC-PYC7.v1.20261003103747@mojatatu.com/ Cc: stable@vger.kernel.org Reviewed-by: Victor Nogueira <victor@mojatatu.com> Signed-off-by: Jamal Hadi Salim <jhs@mojatatu.com> Reviewed-by: Simon Horman <horms@kernel.org> Link: https://patch.msgid.link/QDISC-PYC7.v2.20261010165947-3@mojatatu.com Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2026-10-19netdevsim: reject cls_bpf programs bound to another deviceJamal Hadi Salim
The issue: nsim_bpf_setup_tc_block_cb() installs any device-bound SCHED_CLS program without checking that its offload device matches the target netdev. The core cls_bpf attach path rejects a mismatching program, but a netdev that joins a shared block later is replayed the stored filter by cls_bpf_reoffload() before it is inserted into block->ports, so the attach-time check cannot see it. The driver callback is the authoritative per-device acceptance boundary and must enforce the match itself, as nfp already does in nfp_net_bpf_offload(). Without the check, replaying a device-bound program onto a different bpf_offload_dev installs it into that device's netdevsim state, which trips the WARN in nsim_bpf_uninit() (ns->bpf_offloaded set on a foreign device) and can dereference a NULL prog->aux->offload in nsim_prog_set_loaded(). The Fix: Reject a device-bound program whose offload device does not match the target netdev, with -EINVAL and an extack so the rejected replay is not silent. The check is intentionally narrower than nfp's: it fires only for a dev-bound program, so nsim's bpf_tc_non_bound_accept mode (which admits an unbound program onto the device) is unaffected. Teardown is never blocked: the guard is on the program being installed and an unbind passes cls_bpf.prog = NULL. Conditions to recreate the bug: - CONFIG_NETDEVSIM=y, CONFIG_NET_CLS_BPF=y - load and pin a dev-bound SCHED_CLS program for netdevsim device B - install the program on a shared block owned by B - add an independently backed netdevsim device C to that block; the bind replays the filter to C's callback, and C's ports/0/bpf_offloaded_id takes the B-bound program id. The reported Sashiko review is at https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20260809094418.901607-1-jhs@mojatatu.com Fixes: 31d3ad832948 ("netdevsim: add bpf offload support") Reported-by: Sashiko (nipa) <sashiko-bot@kernel.org> Link: https://lore.kernel.org/netdev/20260809094418.901607-1-jhs@mojatatu.com/ Link: https://lore.kernel.org/netdev/QDISC-PYC7.v1.20261003103747@mojatatu.com/ Cc: stable@vger.kernel.org Reviewed-by: Victor Nogueira <victor@mojatatu.com> Signed-off-by: Jamal Hadi Salim <jhs@mojatatu.com> Reviewed-by: Simon Horman <horms@kernel.org> Link: https://patch.msgid.link/QDISC-PYC7.v2.20261010165947-2@mojatatu.com Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2026-10-19ipe: update the project and test suite linksFan Wu
IPE now has a project website at https://ipe-lsm.org/, and its integration tests are maintained in the Integrity-Policy-Enforcement/ci repository. Point the admin guide to the website, and point the test suite link in the developer documentation to the new repository. Assisted-by: LLM Signed-off-by: Fan Wu <wufan@kernel.org>
2026-10-19ipe: fix enforcement auditFan Wu
ipe_audit_enforce() starts an audit buffer but writes the state change with audit_log(), which logs its own record. Ending the unused buffer then emits an extra empty AUDIT_MAC_STATUS record. Remove the unused buffer and log the state change with audit_log() alone. Fixes: a68916eaedcd ("ipe: add permissive toggle") Assisted-by: LLM Signed-off-by: Fan Wu <wufan@kernel.org>
2026-10-19ipe: correct policy text ownership commentFan Wu
Policy text is separately allocated only when p->pkcs7 is NULL. Correct the comment to match the existing free logic. No functional changes. Assisted-by: LLM Signed-off-by: Fan Wu <wufan@kernel.org>
2026-10-19ipe: check parser token table sizesFan Wu
The parser token tables contain one entry for each enum value followed by a terminator. Add static assertions so adding an enum value without a corresponding token fails the build. Assisted-by: LLM Signed-off-by: Fan Wu <wufan@kernel.org>
2026-10-19ipe: use designated initializers for audit name tablesFan Wu
The audit name tables are indexed by enum values but initialized positionally. Adding an enum value in the middle can associate the following names with the wrong values. Use designated initializers to bind each name to its enum value. No functional changes. Assisted-by: LLM Signed-off-by: Fan Wu <wufan@kernel.org>
2026-10-19ipe: constify token_default()Fan Wu
token_default() does not modify its argument, so make it const. Assisted-by: LLM Signed-off-by: Fan Wu <wufan@kernel.org>
2026-10-19ipe: fix invalid sgid value in audit event documentationManuel Ebner
The audit event example in the IPE documentation contains 'sgid=)', which is not a valid Set Group ID value. Fix it to use 'sgid=0'. Fixes: ac6731870ed9 ("documentation: add IPE documentation") Signed-off-by: Manuel Ebner <manuelebner@mailbox.org> Reviewed-by: Randy Dunlap <rdunlap@infradead.org> Signed-off-by: Fan Wu <wufan@kernel.org>
2026-10-20bpf: Annotate data races on bpf_lru_node typeNicholas Velten
KCSAN reports a data race on bpf_lru_node::type between the LRU list rotation and the free path of the common LRU: BUG: KCSAN: data-race in __bpf_lru_list_rotate / bpf_lru_push_free write to 0xffff88811b758022 of 1 bytes by task 4756 on cpu 1: __bpf_lru_node_move __bpf_lru_list_rotate_active __bpf_lru_list_rotate bpf_lru_list_pop_free_to_local bpf_common_lru_pop_free bpf_lru_pop_free htab_lru_map_update_elem read to 0xffff88811b758022 of 1 bytes by task 4752 on cpu 0: bpf_lru_list_push_free bpf_common_lru_push_free bpf_lru_push_free htab_lru_push_free htab_lru_map_update_elem value changed: 0x00 -> 0x01 bpf_lru_list_push_free() reads node->type for a WARN_ON_ONCE() sanity check before taking l->lock. __bpf_lru_node_move(), called right after under l->lock, does the same check, so drop the unlocked one. bpf_common_lru_push_free() re-checks node->type under loc_l->lock after the lockless READ_ONCE() at function entry. By then the node has been removed from the htab, so only flush and rotate can change its type, through __bpf_lru_node_move_in() and __bpf_lru_node_move() under l->lock. Mark that re-check with READ_ONCE() and those two writers with WRITE_ONCE(), following commit 6df8fb83301d ("bpf_lru_list: Read double-checked variable once without lock"). The remaining writers operate on a node with a single owner that nobody else reads and are left alone. Tested on bpf-next with CONFIG_KCSAN=y in a 4-vCPU virtme-ng guest, using a reproducer that runs 8 threads issuing BPF_MAP_UPDATE_BATCH on a 64-entry BPF_MAP_TYPE_LRU_HASH with overlapping keys. Reported-by: syzbot+1ea4f564bf6f1f3d1dc4@syzkaller.appspotmail.com Signed-off-by: Nicholas Velten <nicholasfvelten@gmail.com> Signed-off-by: Alexei Starovoitov <ast@kernel.org> Link: https://patch.msgid.link/20261019-fix-lru-node-type-kcsan-v2-1-c10a410b3565@gmail.com Closes: https://syzkaller.appspot.com/bug?extid=1ea4f564bf6f1f3d1dc4
2026-10-20Merge branch 'bpf-fix-arena-memory-incoherence'Alexei Starovoitov
Emil Tsalapatis says: ==================== bpf: Fix arena memory incoherence Arena memory is tracked in two places: the range tree, which records which addresses are allocated, and the kernel and user page tables. The two are updated under different locks, and that leaves two races: - Since b8467290edab ("bpf: arena: make arena kfuncs any context safe"), a free releases its range before the kernel TLB flush and the user zap complete. A concurrent allocation can then write through stale translations into pages that are about to be freed. - A user fault takes a reference to the page and installs the user PTE after dropping the arena lock. A free that runs in between leaves user space mapping a page that the arena has already released. In both cases BPF programs and user space can see different pages at the same arena address. - A free keeps its range allocated until the TLB flush and the user zap are complete, and only then releases it with range_tree_set(). User faults on the range get SIGBUS until then. Frees serialize on zap_mutex. - A user fault pins the page, locks its folio, and revalidates the kernel mapping before installing the user PTE, the way filemap_fault() synchronizes with truncate. The free waits for the folio lock of every page it removed before it zaps user mappings. Patches 1 and 2 fix the two races. Patch 3 adds selftests. Signed-off-by: Emil Tsalapatis <emil@etsalapatis.com> Cc: Puranjay Mohan <puranjay@kernel.org> v5 -> v6 (https://lore.kernel.org/bpf/20261016193703.9203-1-emil@etsalapatis.com/) - Return the locked page from arena_vm_fault() with VM_FAULT_LOCKED instead of installing the user PTE there with finish_fault(). The fault checks PageHWPoison() before it returns the page. (Alexei) - Give faults on a range that is being freed the same SIGBUS as faults on a reserved range. Drop the record of the range being freed and the fault-side wait. (Alexei) - Drop the trylock and deferral scheme. Frees serialize on zap_mutex and zap user mappings with zap_pages(), which takes mmap_read_lock() of each mapping process as in mainline. Keep the single-page zap shortcut. Sleepable frees are deferred only when the arena spinlock cannot be taken, and the worker retries such a free in place instead of requeueing itself. (Alexei) - Drop v5 patch 1. The worker no longer requeues itself, so the flush_work() in arena_map_free() waits for all of its work. (Alexei) - Drop v5 patch 4, which retried faults when the arena lock timed out. (Alexei) - Drop the immediate release of ranges without kernel PTEs; they go through the regular free path. - Selftests: map the page into user space before the paused free, and let the fault_free_realloc reader skip reads that raise SIGBUS. v4 -> v5 (https://lore.kernel.org/bpf/20261014233442.8392-1-emil@etsalapatis.com/) - Drop the third range-tree state and the is_range_tree_set() change (v4 patches 4 and 5). A free keeps its range allocated until the TLB flush and the user zap complete, then releases it with range_tree_set(). range_tree_clear() only allocates when the whole range is free, and then there is nothing to free. (Alexei) - Drop the per-arena mapping, page->mapping, the mapping-tree zap and the new bpf_map_ops callback (v4 patches 1 and 2). (Alexei) - Replace opref (v4 patch 7) with the folio lock. A fault rechecks the kernel PTE with the folio locked and installs the user PTE itself with finish_fault(), and a free waits for the folio lock of each page it removed before zapping (new patch 2). (Alexei) - Give faults on a reserved range the scratch_page error. Faults on the range being freed sleep until the free releases it, instead of spinning on VM_FAULT_RETRY. (Alexei) - Trylock arena->lock and the mmap read lock of every process that maps the arena before retiring a range, and defer the free if one is contended. The worker waits for the contended lock instead of requeueing itself. The deferred span, allocated with __GFP_RETRY_MAYFAIL when the caller can sleep, is the only allocation before the ptes are cleared. (Alexei) - Release a range without kernel ptes, such as a reserved one, right away without arena->lock or mmap_lock, so freeing and reallocating a reserved range is never deferred in sleepable context. - Retry faults when the arena lock times out, keeping SIGBUS for -EDEADLK (new patch 4). - Selftests: rename the subtests, and pause frees in zap_vma_range(), which arm64 can trace, instead of flush_tlb_kernel_range(). v3 -> v4 (https://lore.kernel.org/bpf/20260923191125.5311-1-emil@etsalapatis.com/) - Add per-arena anonymous mappings and associate pages with them - Return VM_FAULT_LOCKED and let generic MM install user PTEs; wait for locked fault pages before TLB flushing and zapping (Alexei). - Add mutual exclusion between arena free and fault operations to prevent incoherency. - Return VM_FAULT_NOPAGE for non-retryable GUP faults when progress is impossible. - Stop and drain self-requeueing deferred frees before map teardown. - Track ownership of unavailable ranges independently of free progress and retry worker reservations on -ENOMEM without starting teardown. - Make arena free span state machine explicit. v2 -> v3 (https://lore.kernel.org/bpf/20260923061425.7045-1-emil@etsalapatis.com/) - Rebase on bpf-next and resolve conflicts - Fold in the atomic mark_available range tree operation into initial fix patches v1 -> v2 (https://lore.kernel.org/bpf/20260902070239.16968-1-emil@etsalapatis.com/) - Use __range_iter_next() in is_range_tree_set() (bot-ci) - Move -EAGAIN handling to the patch where the errno is introduced (bot-ci) - Add refactoring patch for (Puranjay) - Avoid leaking unavailable range tree nodes with atomic mark_available operation() - Avoid retries on res spinlock locking for -EDEADLK (Puranjay) ==================== Link: https://patch.msgid.link/20261019201108.4552-1-emil@etsalapatis.com Signed-off-by: Alexei Starovoitov <ast@kernel.org>
2026-10-20selftests/bpf: Add arena allocation race testsEmil Tsalapatis
Add selftests for races between arena frees, reallocation and user faults: - realloc_during_free, realloc_during_deferred_free: a synchronous or deferred free keeps its range allocated until it completes. - fault_free_realloc: user and BPF views of a page stay coherent while it is repeatedly faulted, freed and reallocated. Pause frees in zap_vma_range(), after the range's kernel mappings are gone. Unlike flush_tlb_kernel_range(), which is inline on arm64, it is generic MM code that fentry can attach to. Map the page into user space first, so that the free has to zap it. Print why a subtest is skipped when a tracing target is missing. The reader in fault_free_realloc skips reads that raise SIGBUS, which a fault on a page that is being freed does. Signed-off-by: Emil Tsalapatis <emil@etsalapatis.com> Signed-off-by: Alexei Starovoitov <ast@kernel.org> Link: https://patch.msgid.link/20261019201108.4552-4-emil@etsalapatis.com
2026-10-20bpf: Fix arena race between page free and alloc leading to incoherencyEmil Tsalapatis
Existing arena kfunc code has an underlying race condition that can lead to writes being lost from the BPF program's point of view: a) A memory range gets freed by operation (1), and its range is added back to the arena range tree. b) A concurrent allocation (2) reallocates the range, and does writes to it. Writes from that CPU may follow the stale TLB entries into the pages that are about to be freed. c) (1) invalidates the TLB. The old pages, and any writes done to them, are now inaccessible. zap_pages() similarly removes the mappings for userspace threads. This can be triggered by particularly demanding BPF arena data structures that constantly allocate and deallocate memory, like hash table allocations. Solve this ABA problem by keeping the range allocated until TLB invalidation and unmapping are complete. Under the arena spinlock, claim any free pages in the range and clear its kernel PTEs. Then drop the spinlock, lock and unlock each cleared page to wait for faults that are still installing a user PTE, flush the kernel TLB and zap the user page tables. Finally, retake the spinlock to release the range. Frees serialize on zap_mutex, so an overlapping free cannot release the range early. Claiming the range only allocates a range tree node when the whole range is free, and then there is nothing to free. User faults on a range that is allocated without a page now raise SIGBUS instead of populating it. That covers a range reserved with bpf_arena_reserve_pages() and a range whose kernel PTEs a free has already cleared. Touching a page while a BPF program frees it is a user space bug, and in a BPF_F_SEGV_ON_FAULT arena it already raises SIGSEGV. Sleepable frees run synchronously and are deferred only when the arena spinlock cannot be taken. The deferred free worker retries such a free in place instead of requeueing itself, so the flush_work() in arena_map_free() waits for all of its work. Fixes: b8467290edab ("bpf: arena: make arena kfuncs any context safe") Reported-by: Mykola Lysenko <nickolay.lysenko@gmail.com> Suggested-by: Alexei Starovoitov <ast@kernel.org> Signed-off-by: Emil Tsalapatis <emil@etsalapatis.com> Signed-off-by: Alexei Starovoitov <ast@kernel.org> Link: https://patch.msgid.link/20261019201108.4552-3-emil@etsalapatis.com
2026-10-20bpf: Revalidate faulted arena pages before installing user mappingsEmil Tsalapatis
A user fault on an arena pins the page that the kernel arena maps, drops the arena spinlock and returns the page to the core fault code, which then locks the folio and installs the user PTE. A concurrent free can clear the kernel mapping in that window. The page reference prevents a use-after-free, but the fault can still install a user PTE for a page the arena has already released. User space and BPF programs then see different memory at the same arena offset. Close the window from the fault side. Lock the page, recheck that the kernel mapping still points to it, and return it with VM_FAULT_LOCKED so that it stays locked until the core fault code has installed the user PTE. If a free removed the page, drop it and return VM_FAULT_NOPAGE so that the fault starts over. Return VM_FAULT_HWPOISON for a poisoned page. This change alone does not close the race, because the free path does not yet wait for the page lock. The following change makes frees wait for in-flight faults before zapping user mappings. Fixes: 317460317a02 ("bpf: Introduce bpf_arena.") Suggested-by: Alexei Starovoitov <ast@kernel.org> Signed-off-by: Emil Tsalapatis <emil@etsalapatis.com> Signed-off-by: Alexei Starovoitov <ast@kernel.org> Link: https://patch.msgid.link/20261019201108.4552-2-emil@etsalapatis.com
2026-10-20Merge branch 'refuse-co-re-relocations-for-a-signed-program'Alexei Starovoitov
Kumar Kartikeya Dwivedi says: ==================== Refuse CO-RE relocations for a signed program The signature of a BPF program is checked over the insns as submitted, but the loader may also hand in CO-RE relocation records, which the kernel applies to those insns afterwards with values the loader picks through its BTF. Whoever holds a signed program can so change its constants once the signature has passed. Refuse relocations on a signed load, before the signature is examined, and test it. Found by Sashiko on the "Fix some arena paper cuts" series: https://lore.kernel.org/bpf/sashiko-outbox-176588@kernel.org/ ==================== Link: https://patch.msgid.link/20261019144851.4052056-1-memxor@gmail.com Signed-off-by: Alexei Starovoitov <ast@kernel.org>
2026-10-20selftests/bpf: Test that a signed program with CO-RE relocations is refusedKumar Kartikeya Dwivedi
Load a two insn program with a junk signature and one CO-RE relocation record, and check that the kernel refuses it with -EACCES and the message naming the relocations, before it examines the signature. Without the check the same load gets as far as the signature and fails on it with -EBADMSG. Signed-off-by: Kumar Kartikeya Dwivedi <memxor@gmail.com> Signed-off-by: Alexei Starovoitov <ast@kernel.org> Acked-by: Daniel Borkmann <daniel@iogearbox.net> Link: https://patch.msgid.link/20261019144851.4052056-3-memxor@gmail.com
2026-10-20bpf: Refuse CO-RE relocations for a signed programKumar Kartikeya Dwivedi
The signature of a program covers its insns as submitted, along with the frozen metadata maps of a signed loader, and bpf_prog_verify_signature() checks it before the verifier does anything else with the program. CO-RE relocations are the one input besides the insns that changes them: the loader hands them in with the program, and bpf_check_core_relo() applies them after the signature check, rewriting the immediate or the offset of every insn a record names with a value the loader chooses, a field offset, a type size or id or an enum value of the kernel BTF, or a type id of the BTF the loader supplies itself. Whoever holds a signed program can so change its constants once the signature has passed, the offsets a signed loader reads its metadata map with for instance, and run a program the signer never saw. The exclusive metadata map of a signed loader does not make up for it: the hash that binds the map to a program is chosen by whoever creates the map, so it can name the relocated program as well. Refuse a signed load that carries relocations, before the signature is examined, like the other checks on the shape of a signed load. A signed loader has none to lose: the programs it embeds are relocated by the loader itself through bpf_core_apply(), and nothing relocates the loader. The BTF of the program itself can stay: without relocations it steers only the verification, through func_info, line_info and the annotations of global function arguments, and rewrites nothing. Fixes: 349271568303 ("bpf: Implement signature verification for BPF programs") Signed-off-by: Kumar Kartikeya Dwivedi <memxor@gmail.com> Signed-off-by: Alexei Starovoitov <ast@kernel.org> Acked-by: Daniel Borkmann <daniel@iogearbox.net> Link: https://patch.msgid.link/20261019144851.4052056-2-memxor@gmail.com
2026-10-20Merge branch 'bpf-fix-builds-broken-by-fatal-resolve_btfids-warnings'Alexei Starovoitov
Sasha Levin says: ==================== bpf: Fix builds broken by fatal resolve_btfids warnings Commit 201a454df948 ("resolve_btfids: Fix the --fatal_warnings exit status") makes resolve_btfids warnings fail the build again with CONFIG_WERROR=y. That exposed BTF ID references to functions some configs don't build. KernelCI has been seeing i386 i386_defconfig+kselftest builds fail on linux-next since next-20261015: WARN: resolve_btfids: unresolved symbol bpf_arena_reserve_pages WARN: resolve_btfids: unresolved symbol bpf_arena_free_pages WARN: resolve_btfids: unresolved symbol bpf_arena_alloc_pages Failed to generate BTF for vmlinux Try to disable CONFIG_DEBUG_INFO_BTF https://files.kernelci.org/kbuild-gcc-14-i386-kselftest-6ad2315ca3f195e1aa930c8a/build.log.gz Patch 1 drops three special_kfunc_list entries that have no users, bpf_arena_reserve_pages among them. Patch 2 makes the remaining arena entries depend on the condition arena.o is built with. Patch 3 fixes the same problem for bpf_lsm_socket_sendmsg in bpf_ksock.c, which breaks x86_64 builds with CONFIG_BPF_LSM=y and CONFIG_SECURITY_NETWORK=n. The entries left in special_kfunc_list resolve to the same IDs as before, and the IDs that become BTF_ID_UNUSED were already zero. Tested by building vmlinux with CONFIG_DEBUG_INFO_BTF=y and CONFIG_WERROR=y for i386, x86_64, and x86_64 with CONFIG_BPF_LSM=y and both CONFIG_SECURITY_NETWORK=n and =y, and comparing special_kfunc_list and bpf_lsm_socket_sendmsg_id before and after the series. ==================== Link: https://patch.msgid.link/20261019211006.2574350-1-sashal@kernel.org Signed-off-by: Alexei Starovoitov <ast@kernel.org>
2026-10-20bpf: Fix ksock build with BPF_LSM=y and SECURITY_NETWORK=nSasha Levin
bpf_ksock.c references bpf_lsm_socket_sendmsg() whenever CONFIG_BPF_LSM=y, but the socket LSM hooks, and with them the BPF LSM socket_sendmsg hook, only exist with CONFIG_SECURITY_NETWORK=y. Without it resolve_btfids warns: WARN: resolve_btfids: unresolved symbol bpf_lsm_socket_sendmsg and since commit 201a454df948 ("resolve_btfids: Fix the --fatal_warnings exit status") that fails the build with CONFIG_WERROR=y. Only reference the hook with CONFIG_SECURITY_NETWORK=y, and use BTF_ID_UNUSED otherwise. The ID stays zero, as it was when unresolved, so bpf_ksock_kfunc_filter() keeps allowing LSM programs: none can be attached to socket_sendmsg without CONFIG_SECURITY_NETWORK. Fixes: 7ae4eb14c5f9 ("bpf: Add ksock kfuncs") Signed-off-by: Sasha Levin <sashal@kernel.org> Signed-off-by: Alexei Starovoitov <ast@kernel.org> Acked-by: Mahe Tardy <mahe.tardy@gmail.com> Link: https://patch.msgid.link/20261019211006.2574350-4-sashal@kernel.org
2026-10-20bpf: Don't reference arena kfuncs when arena isn't builtSasha Levin
kernel/bpf/Makefile builds arena.o only for CONFIG_MMU && CONFIG_64BIT, but special_kfunc_list references bpf_arena_alloc_pages() and bpf_arena_free_pages() unconditionally, so on 32-bit and !MMU kernels resolve_btfids can't resolve them: WARN: resolve_btfids: unresolved symbol bpf_arena_free_pages WARN: resolve_btfids: unresolved symbol bpf_arena_alloc_pages Since commit 201a454df948 ("resolve_btfids: Fix the --fatal_warnings exit status") these warnings fail the build with CONFIG_WERROR=y, which breaks i386 builds with CONFIG_DEBUG_INFO_BTF=y: Failed to generate BTF for vmlinux Try to disable CONFIG_DEBUG_INFO_BTF Only reference them under the condition arena.o is built with, and use BTF_ID_UNUSED otherwise to keep the list in sync with enum special_kfunc_type. An unresolved ID is zero, like BTF_ID_UNUSED, so the contents of the list don't change. Fixes: b8467290edab ("bpf: arena: make arena kfuncs any context safe") Signed-off-by: Sasha Levin <sashal@kernel.org> Signed-off-by: Alexei Starovoitov <ast@kernel.org> Link: https://patch.msgid.link/20261019211006.2574350-3-sashal@kernel.org
2026-10-20bpf: Drop unused entries from special_kfunc_list againSasha Levin
Commit 6f033615ef8f ("bpf: Trim special_kfunc_list in verifier") dropped bpf_arena_reserve_pages, bpf_stream_vprintk and bpf_stream_print_stack from special_kfunc_list once nothing used them anymore, but commit ab7fff217fd1 ("bpf: Check helper and kfunc arguments in one path") brought all three back without adding any users. Besides being dead, the bpf_arena_reserve_pages entry can't be resolved on 32-bit and !MMU kernels, which don't build arena.o, and since commit 201a454df948 ("resolve_btfids: Fix the --fatal_warnings exit status") the resulting resolve_btfids warning fails the build with CONFIG_WERROR=y: WARN: resolve_btfids: unresolved symbol bpf_arena_reserve_pages Drop the three entries again. Fixes: ab7fff217fd1 ("bpf: Check helper and kfunc arguments in one path") Signed-off-by: Sasha Levin <sashal@kernel.org> Signed-off-by: Alexei Starovoitov <ast@kernel.org> Link: https://patch.msgid.link/20261019211006.2574350-2-sashal@kernel.org
2026-10-19tracing/osnoise: Add __printf attribute to osnoise_print()Adrián García Casado
Building kernel/trace/trace_osnoise.o with W=1 triggers the following compiler warning: kernel/trace/trace_osnoise.c:96:17: warning: function 'osnoise_print' might be a candidate for 'gnu_printf' format attribute [-Wsuggest-attribute=format] osnoise_print() forwards its format string and va_list arguments to trace_array_vprintk(), which is annotated with __printf(3, 0). Add the __printf(1, 2) attribute to osnoise_print() to silence the W=1 warning and enable compile-time format string checking for its callers. Link: https://patch.msgid.link/20261019205344.190022-1-adriangarciacasado42@gmail.com Signed-off-by: Adrián García Casado <adriangarciacasado42@gmail.com> Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2026-10-19sched_ext: Queue the kick_sync wait from set_next_task_scx()Andrea Righi
The SCX_KICK_WAIT wait is deferred to rq->scx.kick_sync_bal_cb, which a final pick queues on the local rq. Under core scheduling, a pick that returns a task isn't final: pick_next_task() goes on to pick the SMT siblings, and their dispatch can release the shared rq lock with the callback still queued. A CPU acquiring the rq lock in that window then finds a pending balance callback and triggers the warning in rq_pin_lock(). Fix this by queuing the callback from set_next_task_scx() on SNT_PICK and SNT_REPICK. put_prev_set_next_task() calls it once the pick is final, after the core-wide selection, so the rq lock can't be dropped with the callback queued. If the CPU ends up running idle or a higher class task, no SCX task runs there and there's nothing to wait for: kick_sync_pending stays set and the next pick of an SCX task waits before running it. Also, proxy exec zaps the balance callbacks and picks again when find_proxy_task() fails, so clear kick_sync_pending when the callback runs rather than when it's queued. Fixes: 415cb193bb97 ("sched_ext: Fix SCX_KICK_WAIT deadlock by deferring wait to balance callback") Cc: stable@vger.kernel.org # v7.0+: c72945693b90: sched: Restart fair hrtick after same-task repicks Cc: stable@vger.kernel.org # v7.0+ Suggested-by: Tejun Heo <tj@kernel.org> Signed-off-by: Andrea Righi <arighi@nvidia.com> Signed-off-by: Tejun Heo <tj@kernel.org>
2026-10-19selftests: breakpoints: Skip step_after_suspend_test on systems without a ↵Anirudh Srinivasan
wakeup capable RTC This test puts a system into suspend state and uses CLOCK_BOOTTIME_ALARM to wake the system up. This alarm can only wake up systems that have a wakeup capable RTC source. On systems without such an RTC (for example, most RISC-V boards), this test puts the system into suspend and just hangs, requiring power cycling. clock_getres(CLOCK_BOOTTIME_ALARM) fails with EINVAL on such systems, so add a check based on that to skip this test on systems without a wakeup capable RTC source. Link: https://lore.kernel.org/r/20261002-breakpoints_rtc-v1-1-a3b6542a0fdf@oss.tenstorrent.com Signed-off-by: Anirudh Srinivasan <asrinivasan@oss.tenstorrent.com> Signed-off-by: Shuah Khan <skhan@linuxfoundation.org>
2026-10-19selftests/cgroup: test cgroup.kill with an exited thread group leaderKir Kolyshkin
Add two tests for cgroup.kill and a process whose thread group leader has exited while another thread is still running: - test_cgkill_exited_leader kills the cgroup the process is in; - test_cgkill_exited_leader_migrated moves the remaining thread to another cgroup, where the process is not listed in cgroup.procs, and kills that cgroup. Both check that the cgroup is no longer populated afterwards. Signed-off-by: Kir Kolyshkin <kolyshkin@gmail.com> Signed-off-by: Tejun Heo <tj@kernel.org>
2026-10-19cgroup: fix cgroup.kill for exited thread group leaderKir Kolyshkin
cgroup.kill does not work in case a process' thread group leader is gone but other threads are still running. This is because __cgroup_kill() only walks the thread group leaders and sends SIGKILL to each of them with send_sig(), which uses PIDTYPE_PID: 1. The exited leader is still listed by CSS_TASK_ITER_PROCS as long as the process has live threads, but a signal directed at a single exiting task never takes effect: complete_signal() does not look for another thread to deliver it to, and __send_signal_locked() now drops it altogether. The process keeps running. 2. The live threads of such a process can be migrated to another cgroup by writing any of their IDs to cgroup.procs, while the exited leader stays behind. The destination cgroup has no thread group leader to iterate, so writing to its cgroup.kill does nothing at all. In both cases the cgroup stays populated after cgroup.kill, and a process inside a container can use this to survive the container being killed. This also works with a private PID namespace when the init of the container is the process, as the PID namespace is not torn down while init has live threads. Case 1 can be fixed by using do_send_sig_info(..., PIDTYPE_TGID) instead of send_sig(), so that the signal is taken by a live thread even if the task found by the iterator is exiting. Note it was pointed out by Eric in [1] while reviewing v2 of cgroup.kill patchset, and v3 was meant to switch to it, but the change was only made in cgroup_post_fork(), leaving __cgroup_kill() with send_sig(). Case 2 can only be fixed by iterating over all threads, so this is what the fix also does. Once a thread group is being killed, its other threads are skipped since they already have a fatal signal pending. I ran some performance checks and the added cost is ~60 ns per every thread on my laptop (and less than a millisecond for 10K threads), which seems low. The time to "populated 0" seems unchanged. The issue was found in crun by Anthropic's OSS Scanner, and crun is getting a workaround for it [2] (which does what we needed to do before cgroup.kill was added). [1] https://lore.kernel.org/all/m1v97x6niq.fsf@fess.ebiederm.org/ [2] https://github.com/containers/crun/pull/2351 Fixes: 661ee6280931 ("cgroup: introduce cgroup.kill") Cc: stable@vger.kernel.org # v5.14+ Signed-off-by: Kir Kolyshkin <kolyshkin@gmail.com> Acked-by: Oleg Nesterov <oleg@redhat.com> Signed-off-by: Tejun Heo <tj@kernel.org>
2026-10-19selftests/cgroup: Skip test_cpuset_prs.sh test if some required CPUs are offlineWaiman Long
The test_cpuset_prs.sh test assumes that all the relevant CPUs being tested are online. If some of them are offline, some of the test cases may fail. So skip the test if the required CPUs are either offline or not present. While at it, the cleanup() and online_cpus() functions as well as the trap statement to run cleanup() on exit are moved earlier to make sure the cleanup function will be run if the test is somehow aborted early. Signed-off-by: Waiman Long <longman@redhat.com> Signed-off-by: Tejun Heo <tj@kernel.org>
2026-10-19selftests/cgroup: Add tests for nohz_full housekeeping checkWaiman Long
When a boot time nohz_full CPUs are present and they cover CPUs 0-7, some of the test cases may fail. So the test run will be skipped with a warning message in this case. On the other hand, if the boot time nohz_full CPUs cover all the CPUs except 0-7, a special set of nohz_full specific housekeeping check related tests could be run to make sure the housekeeping check are behaving properly. The test_cpuset_prs.sh test script is now updated to do exactly that. Signed-off-by: Waiman Long <longman@redhat.com> Signed-off-by: Tejun Heo <tj@kernel.org>
2026-10-19selftests/cgroup: Add tests for isolcpus housekeeping checkWaiman Long
Whenever a partition is enabled or the cpumask of a valid partition changes, a housekeeping check will be performed to ensure that the change won't violate the imposed housekeeping constraints. One of the constraints is that a boot-time isolated CPU will not be used to form a non-isolated root partition. This requires the presence of boot-time isolated CPUs when a test is run. The test_cpuset_prs.sh test script is now updated to run a set a special housekeeping check tests that will only be run if a suitable boot-time isolated CPU is present. This will enable us to detect bugs or regressions in the housekeeping checking code though a "isolcpus=" boot parameter with CPUs beyond CPU 8 must be present. This patch also includes a minor fix to the REMOTE_TEST_MATRIX to avoid test failure when the -v option is used. Reviewed-by: Guopeng Zhang <zhangguopeng@kylinos.cn> Signed-off-by: Waiman Long <longman@redhat.com> Signed-off-by: Tejun Heo <tj@kernel.org>
2026-10-19cgroup/cpuset: Don't allow a child root partition under an isolated parentWaiman Long
Although it is not typical for real users to create a complicated nested partition hierarchy, it is currently allowed to create nested root and isolated partitions. In addition, disabling or invalidating a partition should always be allowed especially when the cpuset is being deleted. With a nested root and isolated partition hierarchy, it is possible that all active housekeeping CPUs can be exhausted when disabling or invalidating a root partition and returning its CPUs to the isolated parent. One way to avoid this problem is to disallow the creation of a root partition under an isolated parent. It is indeed a new limitation imposed on the existing cpuset partition functionality. However an isolated partition is usually a left node where scheduling and some other kernel noises are disabled. It doesn't make much sense to create a child root partition under an isolated parent and remove some CPUs from the set of isolated CPUs again. Creation of a child isolated partition under a root or isolated parent is still allowed. If a partition with child root partitions is converted to isolated, the child root partitions will be invalidated. The cgroup-v2 documentation is also updated to reflect this new limitation. New test cases are added to test_cpuset_prs.sh to verify this new behavior. Some existing test cases are also updated accordingly. Signed-off-by: Waiman Long <longman@redhat.com> Signed-off-by: Tejun Heo <tj@kernel.org>
2026-10-19cgroup/cpuset: Properly disabling partition when partition state switching failsWaiman Long
Before commit 103b08709e8a ("cgroup/cpuset: Fail if isolated and nohz_full don't leave any housekeeping"), the partition state can be freely switched from "root" to "isolated" and vice versa. After that commit, the switch from "root" to "isolated" can fail if it exhausts all the housekeeping CPUs. Later on, the switch from "isolated" to "root" can also fail if some of the partition CPUs are boot-time isolated by "isolcpus". A local or remote partition is made invalid when the switch fails. However there are 2 problems with the existing invalidation code. 1) Both the subpartitions_cpus and isolated_cpus are not properly updated. 2) In the case of remote partition with remote_partition flag set, it is not cleared. Fix this by calling the proper partition disabling function in this case. On an x86 test system with boot option "isolcpus=10 cgroup_debug" set and more than 16 cores, the following commands were executed after boot. # cd /sys/fs/cgroup # echo +cpuset > cgroup.subtree_control # cat cpuset.cpus.isolated 10 # mkdir A # echo 10-12 > A/cpuset.cpus # echo isolated > A/cpuset.cpus.partition # cat A/cpuset.cpus.partition isolated Before the patch: # echo root > A/cpuset.cpus.partition # cat A/cpuset.cpus.partition root invalid (partition config conflicts with housekeeping setup) # cat cpuset.cpus.isolated .__DEBUG__.cpuset.cpus.subpartitions 10-12 10-12 After the patch: # echo root > A/cpuset.cpus.partition # cat A/cpuset.cpus.partition root invalid (partition config conflicts with housekeeping setup) # cat cpuset.cpus.isolated .__DEBUG__.cpuset.cpus.subpartitions 10 Reported-by: Tejun Heo <tj@kernel.org> Link: https://lore.kernel.org/lkml/7f4c57b26ad120ab30adf35653f1dd94@kernel.org/ Fixes: 4a74e418881f ("cgroup/cpuset: Check partition conflict with housekeeping setup") Fixes: 103b08709e8a ("cgroup/cpuset: Fail if isolated and nohz_full don't leave any housekeeping") Reviewed-by: Guopeng Zhang <zhangguopeng@kylinos.cn> Signed-off-by: Waiman Long <longman@redhat.com> Signed-off-by: Tejun Heo <tj@kernel.org>
2026-10-19cgroup/cpuset: Do housekeeping check before converting invalid partition to ↵Waiman Long
valid When a hotplug event happens or when update_cpumasks_hier() is called, an invalid partition may be converted back to valid. However check against housekeeping conflict isn't being done which can lead to a partition state that violates the housekeeping rules. Update the code to allow reviving an invalid partition only if it can pass the housekeeping check. Fixes: 4a74e418881f ("cgroup/cpuset: Check partition conflict with housekeeping setup") Reviewed-by: Guopeng Zhang <zhangguopeng@kylinos.cn> Signed-off-by: Waiman Long <longman@redhat.com> Signed-off-by: Tejun Heo <tj@kernel.org>
2026-10-19cgroup/cpuset: Consider all the exclusive CPUs when doing housekeeping checkWaiman Long
When prstate_housekeeping_conflict() is called to perform housekeeping check with cpumask changes, the cpumask changes are passed in via add_cpus and del_cpus parameters. With this arrangement, the exclusive CPUs owned by the child partitions and not affected by the cpumask change, if any, are excluded in the analysis. The only places where there are separate add and delete masks are when the cpuset.cpus or cpuset.cpus.exclusive is being changed. In both cases, partition_cpus_change() is a good place to perform the housekeeping check. If we allow a root partition to be created under an isolated partition, it is possible the cpumask change will still leave active housekeeping CPUs but then no housekeeping CPUs will be left when the child partitions are disabled or invalidated. As a first step to protect against this possibility, all the exclusive CPUs of the cpuset should be considered to be owned by the current cpuset when doing housekeeping check. At the same time, we do want to know if some housekeeping CPUs are going to be removed from the isolated partition that there will be no danger of losing all the active housekeeping CPUs. So the current add_cpus paremeter is renamed as new_cpus to indicate that it includes the complete set of effective xcpus. With the new check in partition_cpus_change(), the housekeeping check in update_parent_effective_cpumask() with partcmd_update and newmask is now duplicative and can be removed. The housekeeping check in remote_cpus_update(), however, will still be useful as this function can be called directly from update_cpumasks_hier() without going through partition_cpus_change(). The update_parent_effective_cpumask() call from update_cpumasks_hier() is partcmd_update with no cpumask which still have the housekeeping check and so is covered. Fixes: 103b08709e8a ("cgroup/cpuset: Fail if isolated and nohz_full don't leave any housekeeping") Signed-off-by: Waiman Long <longman@redhat.com> Signed-off-by: Tejun Heo <tj@kernel.org>
2026-10-19cgroup/cpuset: Consolidate isolated_cpus_can_update() into ↵Waiman Long
prstate_housekeeping_conflict() The isolated_cpus_can_update() and prstate_housekeeping_conflict() are checking different aspects of upcoming cpumask changes that may conflict with the current setting of the housekeeping cpumasks. There are places where both are called together. There are also places where only one of them is called. That inconsistency can contribute to missing check where invalid cpumask changes may be allowed to move forward. Fix that by consolidating isolated_cpus_can_update() into prstate_housekeeping_conflict() and call prstate_housekeeping_conflict() in all the places where either one of them or both are called. The exception is the validate_partition() function where the prstate_housekeeping_conflict() call is removed. It is because validate_partition() is called only from partition_cpus_change() where prstate_housekeeping_conflict() will be called from either remote_cpus_update() or update_parent_effective_cpumask() with partcmd_update if not for partition invalidatation or disablement. Now prstate_housekeeping_conflict() will be called in the following locations: - when a partition is enabled in remote_partition_enable() or in update_parent_effective_cpumask() with partcmd_enable*. - when a cpumask is updated in remote_cpus_update() or in update_parent_effective_cpumask() with partcmd_update. - when a partition state changes from root to isolated or vice versa in update_prstate(). Fixes: 4a74e418881f ("cgroup/cpuset: Check partition conflict with housekeeping setup") Fixes: 103b08709e8a ("cgroup/cpuset: Fail if isolated and nohz_full don't leave any housekeeping") Reviewed-by: Guopeng Zhang <zhangguopeng@kylinos.cn> Signed-off-by: Waiman Long <longman@redhat.com> Signed-off-by: Tejun Heo <tj@kernel.org>
2026-10-19cgroup/cpuset: Fix a missing isolated_cpus update in update_cpumasks_hier()Waiman Long
It is found that when a local isolated partition is being invalidated because its parent partition is no longer valid, the isolated_cpus cpumask may not be properly updated. Those isolated CPUs may or may not needed to be removed from isolated_cpus depending on if there is a local isolated partition ancestor that will now own those isolated CPUs instead. Fix that by calling a new ancestor_partition() helper to return the closeset valid partition root ancestor. If that ancestor is PRS_ROOT, the isolated CPUs will have to be removed from isolated_cpus. For a PRS_ISOLATED ancestor, the isolated CPUs are checked against the ancestor's ones to see if any of them should be removed as it is possible that the invalidation of the parent may be caused by change in the effective xcpus of that ancestor. If any of the isolated CPUs should be removed, isolated_cpus_update() will be called under callback_lock. An existing test case in test_cpuset_prs.sh is modifed and a new one added to test that. Fixes: 11e5f407b64a ("cgroup/cpuset: Keep track of CPUs in isolated partitions") Signed-off-by: Waiman Long <longman@redhat.com> Signed-off-by: Tejun Heo <tj@kernel.org>
2026-10-19cgroup/cpuset: use mems_allowed_seq when checking a policy nodemaskGregory Price (Meta)
A cpuset update changes the task's mems_allowed and rebinds its mempolicy in separate steps under mems_allowed_seq, but the check reads both without it. This can cause a spurious numa placement miss under some cpuset/mempolicy combinations. A reader that loads one mask before the update and the other after it can see a spurious empty intersection and drop the nodemask. For example, a task with cpuset.mems={0} and MPOL_BIND={0}. If the cpuset moves to mems={1,2}, the policy is rebound to {1}. The allocator can race and compare the old mems_allowed {0} against the new policy {1} - which will result in a dropped nodemask and a misplaced allocation on node 2. Simply retry the intersection until mems_allowed_seq is stable. This covers the task policy, which is rebound under mems_allowed_seq. VMA policies are rebound afterwards by mpol_rebind_mm(), outside mems_allowed_seq, and are not covered by this change. Fixes: cc9a6c877661 ("cpuset: mm: reduce large amounts of memory barrier related damage v3") Reviewed-by: Vlastimil Babka (SUSE) <vbabka@kernel.org> Reviewed-by: Waiman Long <longman@redhat.com> Signed-off-by: Gregory Price (Meta) <gourry@gourry.net> Signed-off-by: Tejun Heo <tj@kernel.org>
2026-10-19sched_ext: Reset runnable_at when a task leaves its schedulerMichal Blaszczyk
The watchdog measures how long a task has been waiting from p->scx.runnable_at, which set_task_runnable() resets when the task becomes runnable after it last ran. ops_dequeue() never asks for a reset, as the dequeue of a waiting task is temporary, e.g. for a migration or an attribute change. Leaving the scheduler isn't temporary. A task which is switched out of SCHED_EXT while it's waiting keeps its runnable_at. When it's switched back and becomes runnable, its wait appears to have started before it left, and the time it spent in another class counts towards the timeout. If the watchdog checks before the task runs, it aborts the scheduler: sched_ext: class_switch_stall: runner[418] failed to run for 3.010s Here, the task waited for a few milliseconds before it was switched to SCHED_OTHER, slept outside of SCHED_EXT for three seconds, and was charged for all of it as soon as it woke up on SCHED_EXT again. The same happens when scx_sub_enable_workfn() hands a waiting task over to a new sub-scheduler, which can then be blamed for time the task waited under the parent. scx_rehome_task() isn't affected, as it moves the task through SCX_TASK_INIT, which resets runnable_at. The stale runnable_at also skews the default core-sched ordering in scx_prio_less(). Reset runnable_at in scx_disable_task(), when the task leaves the control of its scheduler. Fixes: 8a010b81b3a5 ("sched_ext: Implement runnable task stall watchdog") Cc: stable@vger.kernel.org # v6.12+ Assisted-by: LLM Signed-off-by: Michal Blaszczyk <michalblk@google.com> Reviewed-by: Andrea Righi <arighi@nvidia.com> Signed-off-by: Tejun Heo <tj@kernel.org>
2026-10-19PCI/sysfs: Reject unaligned resource I/O port accessesDeepanshu Kartikey
pci_resource_io() validates that off+count stays within the BAR's range but never checks that the resulting port is aligned to the access size. A pwrite64()/pread64() on a resourceN file with an odd offset and count=2 or count=4 reaches outw()/outl() with a misaligned address. On arm64 this becomes a store/load to a Device-memory mapping (PCI_IOBASE + port), which architecturally requires natural alignment, causing an alignment fault and kernel oops. Reject misaligned accesses before they reach the low-level accessor. Reported-by: syzbot+7134530b25073b4ef373@syzkaller.appspotmail.com Closes: https://syzkaller.appspot.com/bug?extid=7134530b25073b4ef373 Signed-off-by: Deepanshu Kartikey <kartikey406@gmail.com> Signed-off-by: Bjorn Helgaas <bhelgaas@google.com> Tested-by: Rihyeon Kim <rihyeon8648@gmail.com> Acked-by: Manivannan Sadhasivam <manivannan.sadhasivam@oss.qualcomm.com> Link: https://patch.msgid.link/20260809045946.15638-1-kartikey406@gmail.com
2026-10-19Revert "Input: matrix_keypad - force switch rows to input mode"Alexander Kochetkov
This reverts commit 01c84b03d80aab9f04c4e3e1f9085f4202ff7c29. The commit makes every scan call gpiod_direction_input() on the row GPIOs. On pin controllers where GPIO input and interrupt are separate pinmux functions this switches the row pins out of interrupt mode, and enable_row_irqs() does not switch them back: it only unmasks the interrupts. Row interrupts then never arrive and the keypad stops working. Seen with a matrix keypad on an Allwinner A64 board (PINE A64-LTS); it works again with the commit reverted. The workaround is not needed on Ingenic either: the author of the reverted commit re-tested all available JZ47xx SoCs and they all report the live pin state in interrupt mode, see the thread in Link. Fixes: 01c84b03d80a ("Input: matrix_keypad - force switch rows to input mode") Link: https://lore.kernel.org/all/4130C026-2A83-408B-836A-ECA044491C47@gmail.com/ Cc: stable@vger.kernel.org Signed-off-by: Alexander Kochetkov <al.kochet@gmail.com> Acked-by: Siarhei Volkau <lis8215@gmail.com> Acked-by: Paul Cercueil <paul@crapouillou.net> Link: https://patch.msgid.link/20261002100935.449473-1-al.kochet@gmail.com Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
2026-10-19tcp: Add TCP ROCCET congestion control module.Tim Fuechsel
TCP ROCCET is a new congestion control algorithm based on TCP CUBIC that improves its overall performance in cellular networks. By its mode of function, CUBIC causes bufferbloat while it tries to detect the available throughput of a network path. This is particularly a problem with large buffers in mobile networks. A more detailed description and analysis of this problem caused by TCP CUBIC can be found in [1]. TCP ROCCET's main method of addressing the bufferbloat problem is by adding two additional metrics. The first metric is the relative increase in RTT from its minimum, the srRTT. Here, bufferbloat can be detected when RTTs increase due to buffer filling. The second metric is the acknowledgment arrival rate sampled over 100ms intervals and the bytes sent and received over 5 RTTs. If CUBIC increases the send rate or congestion window, and the acknowledgment arrival rate stays at the same level, the connection is limited by the bottleneck link's capacity. In such cases, ROCCET reduces the send rate to prevent bufferbloat. ROCCET uses a modified version of slow start rather than HyStart because HyStart is known to enter the congestion avoidance phase too early when used in cellular networks [2]. Therefore, ROCCET uses a combination of srRTT and the acknowledgment arrival rate to determine when to exit slow start. For the congestion avoidance phase, ROCCET relies on the srRTT and monitoring the sent and received bytes to detect the filling of the bottleneck buffer. To keep the minimum RTT updated, ROCCET performs minimum RTT probing if no new minimum RTT was found in the last 5 seconds. To this end ROCCET halves the cwnd and probes for 200ms but at least for one RTT, for a new minimum RTT. After probing, ROCCET refills the pipe carefully. In addition, ROCCET reacts to packet loss by adapting CUBIC's behavior. ECNs are handled as ROCCET congestion event, where the cwnd gets reduced and ROCCET enters a buffer drain state. In real-world mobile 5G NR measurements, TCP ROCCET achieves better performance than CUBIC, by maintaining similar throughput while reducing the latency. More information about TCP ROCCET and measurement evaluations can be found here [3]. For the version (2026-07-21), we provide additional performance evaluation regarding throughput, latency, and bandwidth share [4]. [1] https://doi.org/10.1109/VTC2023-Fall60731.2023.10333357 [2] https://doi.org/10.1109/WMNC.2016.7543932 [3] https://doi.org/10.23919/WONS68803.2026.11501781 [4] http://go.lu-h.de/roccet-2026-07-21 Co-developed-by: Lukas Prause <lukas.prause@ikt.uni-hannover.de> Signed-off-by: Lukas Prause <lukas.prause@ikt.uni-hannover.de> Signed-off-by: Tim Fuechsel <t.fuechsel@gmx.de> Link: https://patch.msgid.link/asdfdDIQb7Nhm692@volt-roccet-vm Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2026-10-19Merge branch 'r8169-add-rss-support-for-rtl8127'Jakub Kicinski
Javen Xu says: ==================== r8169: add RSS support for RTL8127 This patch series adds RSS (Receive Side Scaling) support for the r8169 ethernet driver, specifically for RTL8127 (RTL_GIGA_MAC_VER_80). RSS enables packet distribution across multiple receive queues, which can significantly improve network throughput on multi-core systems by allowing parallel processing of incoming packets. Key features: - Multi-queue RX support (up to 8 queues) - MSI-X interrupt with vector mapping - Dynamic queue configuration via ethtool (-L) - RSS hash computation for flow classification Experiments: Platform: AMD Ryzen Embedded R2514 with Radeon Graphics(4 Cores/8 Threads) Arch: x86_64 Test command: Server: iperf3 -s Client: iperf3 -c 192.168.2.1 -P 20 -t 3600 Monitor: mpstat -P ALL 1 Before this patch (Without RSS): Throughput: Unstable, fluctuating between 3.76 Gbits/sec and 8.2 Gbits/sec. CPU Usage: A single CPU core is fully occupied with softirq reaching up to 96%. After this patch (With RSS enabled): Throughput: Stable at 9.42 Gbits/sec. CPU Usage: The traffic load is evenly distributed across multiple CPU cores. The maximum softirq on a single core dropped to 63%. Other Experiments: Link: https://lore.kernel.org/netdev/0A5279953D81BB9C+f50c9b49-3e5d-467f-b69a-7e49ed223383@radxa.com/ ==================== Link: https://patch.msgid.link/20261008065722.1026-1-javen_xu@realsil.com.cn Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2026-10-19r8169: add get_channel support for ethtoolJaven Xu
Add get_channel support for ethtool. In multi-vector mode, it reports the active RX channel count and a single TX channel. Additionly, it reports one other channel to account for the dedicated link-change interrupt vector. In single-vector mode, where RX, TX, link-change events share the same interrupt, it reports a single combined channel. Signed-off-by: Javen Xu <javen_xu@realsil.com.cn> Link: https://patch.msgid.link/20261008065722.1026-8-javen_xu@realsil.com.cn Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2026-10-19r8169: move struct ethtool_opsJaven Xu
The patch moves the rtl8169_ethtool_ops definition further down in r8169_main.c so that subsequent additions of rtl8169_get_channels and can be referenced from the ops struct without needing forward declarations. Signed-off-by: Javen Xu <javen_xu@realsil.com.cn> Link: https://patch.msgid.link/20261008065722.1026-7-javen_xu@realsil.com.cn Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2026-10-19r8169: add support and enable rssJaven Xu
This patch adds support and enable rss for RTL8127. It requests 30 to 32 MSI-X vectors. To support RSS, this patch converts struct RxDesc into a union. Additionly, this patch fixes a potential skb overrun issue. Previously, with NETIF_F_RXALL enabled, a runt or CRC-error desc with a length below 4 would fall through to subtract ETH_FCS_LEN. This will lead to a memory overrun. Fix this by explicitly dropping packets smaller than ETH_HLEN + ETH_FCS_LEN. Note that this fix introduces a behavior change on non-RSS chips: with both RXALL and RXFCS enabled, runt frames of 14 to 17 bytes that used to be delivered are now dropped. Ethtool rss tools will be contained in another series patched instead of this patch. Signed-off-by: Javen Xu <javen_xu@realsil.com.cn> Link: https://patch.msgid.link/20261008065722.1026-6-javen_xu@realsil.com.cn Signed-off-by: Jakub Kicinski <kuba@kernel.org>