Changes in sub.h

11260c335ec6071af5543aef73000b28f041c124 - Merge tag 'sched_ext-for-7.3' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/sched_ext

Thu, 20 Aug 2026 20:01:37 +0200

Merge tag 'sched_ext-for-7.3' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/sched_extPull sched_ext updates from Tejun Heo: "Most of this cycle completes the enqueue-path support for hierarchical sub-scheduling, which makes sub-scheduler support feature complete: a root BPF scheduler can now hand a cgroup subtree over to a nested sub-scheduler together with revocable CPU grants, and the sub-scheduler owns all scheduling decisions for its tasks on those CPUs. Development volume was high and a number of changes plugging holes in the new support landed late in the cycle. Also included are core scheduling fixes that were completed too late for the v7.2 release and are routed through this pull request. Sub-scheduler CPU delegation: - Parent schedulers now grant and revoke per-CPU capabilities (enqueueing, preemption, CPU frequency control) on their children, enforced on every path a scheduler can reach a CPU through. Previously only dispatching could be delegated; this lets sub-schedulers fully schedule their CPUs. - Rescue execution: a task whose scheduler doesn't have access to the CPUs the task needs to run on starved until the watchdog ejected the whole scheduler. The kernel now runs such tasks directly on a small bandwidth budget, turning a scheduler-killing failure into bounded degradation. - Cgroup integration: tasks migrating across a sub-scheduler boundary weren't re-homed to the new owner, causing wrong-scheduler scheduling and a use-after-free. Sub-schedulers now take over their cgroup subtree and receive its cgroup callbacks. - Arena objects now cross the kernel/BPF boundary as typed pointer arguments, translated transparently by the BPF tree's new arena argument support, replacing untyped arguments with manual translation. - scx_qmap now demonstrates full hierarchical sub-scheduling. Other fixes and updates: - Robustness improvements: the abort path is now NMI-safe, fixing deadlocks when errors are raised from NMI context and making hardlockup recovery direct. Reenqueue loops that could monopolize a CPU ahead of the watchdog now eject the offending scheduler, and stalls are blamed on the scheduler actually responsible. - Hardening: BPF-writable arena memory is validated before kernel use, and task slice and vtime writes got explicit synchronization rules, closing corruption vectors open to buggy or malicious schedulers. - Core scheduling: sched_ext dispatching can drop the rq lock inside the core-wide pick, which let interleaving selections corrupt each other's state and hard-hang the machine. The selection now restarts when the lock was released. The task ordering callback was also invoked with its arguments swapped, and the default ordering is updated to work across sub-scheduler boundaries. The fixes are marked for stable. - Other fixes headed for stable: a task init leak on fork failure during enable, tooling compat macros that silently failed to detect newer kernels, and a crash on reenqueueing against a destroyed dispatch queue. - Tooling: scx_pair moves off deprecated callbacks, and the deprecated scx_bpf_cpu_rq() kfunc is removed"* tag 'sched_ext-for-7.3' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/sched_ext: (144 commits) sched_ext: Drop the dead SCX_DEQ_CORE_SCHED_EXEC test in dequeue_task_scx() sched_ext: Make core-sched task ordering hierarchy-aware sched_ext: Use runnable_at for the default core-sched task ordering sched_ext: Fix inverted ops.core_sched_before() invocation sched_ext: Move the config-off sub-cap kfunc stubs into sub.c sched_ext: Rename balance-era identifiers to dispatch terms sched_ext: Drop the stale keep_prev fixup in dispatch_pick() sched_ext: Keep kick_sync waiting on the rq's own CPU sched_ext: Make SCHED_CLASS_EXT select GENERIC_ALLOCATOR sched_ext/scx_flatcg: Fix cvtime true-up on slice expiry sched_ext: Don't BUG_ON a destroyed DSQ in process_deferred_reenq_users sched_ext: Fix scx_bpf_dsq_move_to_local___v2 compat detection sched_ext: Make scx_bpf_events() read the calling scheduler's counters sched_ext: Drop unlocked scx_rq_clock_invalidate() from scx_root_disable() selftests/sched_ext: Fix flaky ddsp failure tests on busy systems selftests/sched_ext: Make numa idle validation race-free sched_ext: Fix scx_bpf_dsq_reenq___compat kfunc extern prototype sched_ext/scx_flatcg: expire cached hweights on weight changes sched_ext: Fix exit_task leak on fork failure during enable sched_ext: fix stale references in doc comments ... List of files: /linux/kernel/sched/ext/sub.h

5fd501744b10814f5c12899ce86d223cee2c51ca - sched_ext: Add bandwidth-limited rescue execution for stranded tasks

Mon, 03 Aug 2026 23:01:29 +0200

sched_ext: Add bandwidth-limited rescue execution for stranded tasksA local DSQ insert lacking the needed caps is diverted to the reject DSQ andbounced back through ops.enqueue() so the scheduler can re-decide. Thatrecovery assumes the scheduler has somewhere legal to send the task. When itdoesn't, e.g. when the task's affinity is restricted to cids delegated away,the task starves until the stall watchdog ejects the scheduler. An exitingtask is worse - it skips ops.enqueue() and the rejection becomes aself-requeuing cycle that burns the CPU until the watchdog fires.Add SCX_ENQ_RESCUE, a fallback modifier on local DSQ inserts. When theinsert would be rejected for missing caps, the kernel takes over and runsthe task on the target CPU without consulting the owning scheduler. Thekernel sets the flag itself when enqueueing an exiting task.Rescue is a last-resort forward-progress backstop with a persistentdisadvantage, not a way around cap enforcement. A per-CPU token bucketaccrues rescue_bandwidth_ppt (default 2%) of CPU time and rescues run one ata time in arrival order. Each is granted a slice of the rescue_quantum_us(default 5ms) quantum divided across the waiters, waits at the tail of thelocal DSQ claiming no priority, and rejoins its scheduler as a fresh arrivalonce the slice is served.The schedulers keep their normal control over an admitted rescuee and maypreempt or reslice it. Service is measured on CPU time actually received, soneither shortens the rescue. Prolonged denial escalates - the remainingslice turns into protected execution (SCX_TASK_PROTECTED) and the rescueepreempts the current task. Escalation is paced by the same bucket, anddelivered service converges on the configured bandwidth no matter howaggressively the schedulers dispatch.Both knobs are root-only and SCX_RESCUE_DISABLE turns rescue off, makingSCX_ENQ_RESCUE inserts reject as usual.v2: - Add SCX_OPS_OPEN() fix-ups for the new ops fields so cpu-form schedulers setting them still load on older kernels. (Andrea)Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

78f8d726e62e0b72a4b11e5778d2d7e252b076c0 - sched_ext: Make SCX_ENQ_IGNORE_CAPS waive the preemption cap too

Mon, 03 Aug 2026 23:01:07 +0200

sched_ext: Make SCX_ENQ_IGNORE_CAPS waive the preemption cap tooSCX_ENQ_IGNORE_CAPS is kernel-internal and marks a placement the kernelforces. scx_caps_for_enq() waives the enqueue cap for it, but a PREEMPTinsert still picks up the preemption cap requirement fromscx_caps_for_preempt(). Update scx_caps_for_preempt() to take enq_flags andrequire nothing when SCX_ENQ_IGNORE_CAPS is set.Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

8b3b8522c9139c18b8dbbafbeb0c903609e5a27d - sched_ext: Rename scx_local_or_reject_dsq() to scx_resolve_local_dsq()

Mon, 03 Aug 2026 23:00:31 +0200

sched_ext: Rename scx_local_or_reject_dsq() to scx_resolve_local_dsq()The following rescue execution addition gives the function a third possibledestination, making a name that enumerates the outcomes a poor fit. Renameto the destination-neutral scx_resolve_local_dsq(). No functional changes.Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

7947442047cff1d296ab615b8c6ddbc7c9b7bf21 - sched_ext: Add scx_cgroup_sched() for cgrp->scx_sched reads

Fri, 24 Jul 2026 03:07:56 +0200

sched_ext: Add scx_cgroup_sched() for cgrp->scx_sched readscgrp->scx_sched is __rcu and published with rcu_assign_pointer() but everyreader loads it with a plain access, so sparse flags all of them. The readsare lock-protected: enable/disable paths rewrite the field under all ofscx_enable_mutex, scx_fork_rwsem and cgroup_mutex, and cgroup creationinherits the parent's sched under cgroup_mutex before the new cgroup isreachable, so holding any one of the three locks makes the read stable.Add scx_cgroup_sched() which states the protection withrcu_dereference_check() and convert the readers. No functional changes.Signed-off-by: Tejun Heo List of files: /linux/kernel/sched/ext/sub.h

8946dbd3aa91acfb75b1633859290ba248e313b2 - sched_ext: Add the scx_has_subs static key and gate sub-sched hot paths

Thu, 16 Jul 2026 01:37:59 +0200

sched_ext: Add the scx_has_subs static key and gate sub-sched hot pathsWith CONFIG_EXT_SUB_SCHED=y but no sub-scheduler attached - the common case- hot paths still pay for sub-sched bookkeeping. Gate it behind__scx_has_subs, a static key counting live sub-schedulers, so that aroot-only system stops paying.Most conversions are simple skip-if-no-sub tests. scx_idle_notify() isspecial - it's a hierarchy walk, so give it a fast path which notifies theroot directly using the same tests as the walk. A pendingSCX_RQ_SUB_IDLE_RENOTIFY can be ignored as no sub can be owed one and thecaller clears the flag either way.Suggested-by: Andrea Righi Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

7f480f34b78a0f482fbaa2aadece036aad275a74 - sched_ext: Move scx_dispatch_sched() to a new inlines.h

Thu, 16 Jul 2026 01:37:59 +0200

sched_ext: Move scx_dispatch_sched() to a new inlines.hscx_dispatch_sched() is common dispatch machinery and looks out of place insub.h, but it needs scx_cpu_arg() from cid.h and can't move into internal.hwithout creating a circular include. Add inlines.h on top of internal.h andcid.h, and move the function there. The function was sub.h's only cid.huser, so drop that include. Pure code move, no functional change.v2: Host the function in a new inlines.h instead of at internal.h's tail, which formed a circular include with cid.h. Drop sub.h's now-unused cid.h include. (sashiko AI)Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

75c268ed57f2197a4f1fd9259f42cb6065dd311b - sched_ext: Replay ecaps notifications suppressed by bypass

Tue, 14 Jul 2026 10:18:44 +0200

sched_ext: Replay ecaps notifications suppressed by bypassscx_process_sync_ecaps() consumes ecaps syncs while the sched is bypassingwithout delivering ops.sub_ecaps_updated(), leaving reported_ecaps stale.Nothing re-queued a sync when bypass lifted, so a cid whose caps neverchange again would never be notified. Attach-time initial grants hit thisevery time: they are consumed during the enable bypass window, so a schednever learned its initial effective caps through the callback.Re-queue a sync for every (sched, cpu) with an undelivered delta at theper-cpu bypass exit in scx_bypass(), next to the idle renotify catch-up. Thenext balance on the cpu then delivers the pending delta with proper dispatchcontext.Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

6ea3be36808100336dffb4b04a6e5a483a26a649 - sched_ext: Gate kicks on SCX_CAP_BASE and preemption on SCX_CAP_PREEMPT

Tue, 14 Jul 2026 10:18:44 +0200

sched_ext: Gate kicks on SCX_CAP_BASE and preemption on SCX_CAP_PREEMPTA kick forces a scheduling event on the target cpu, and a preemption alsoevicts the running task. Gate both on caps. Any kick requires baselineaccess on the cid, and preempting a task the sub-sched does not own -whether by a SCX_ENQ_PREEMPT insert or a SCX_KICK_PREEMPT kick - requiresthe new SCX_CAP_PREEMPT. Gating either alone would leave a hole - theweakest cap authorizing preempting kicks, or plain kicks disturbing cpus thekicker has no access to.Preempting the sched's own subtree is always allowed, and the cap extendsthe right to any task on the cid. PREEMPT implies ENQ, and so ENQ_IMMED.A preempting insert tests the running task under the target rq lock and isrejected and reenqueued unless the victim is in the inserter's subtree or itholds PREEMPT. A migration-disabled task is admitted regardless, but withSCX_ENQ_PREEMPT stripped.Kicks are enforced on the delivery path, where the effective caps can beread coherently under the target rq's lock. A kick from a sub-sched lackingSCX_CAP_BASE on the cid is dropped, and a SCX_KICK_PREEMPT kick withoutPREEMPT for a task outside the kicker's subtree degrades to a plainreschedule.Unlike the enqueue caps, PREEMPT is checked only at the instant of theinsert or kick, never as a standing property of a queued task.v2: Clear SCX_ENQ_PREEMPT on the offline and migration_pending force-admits.Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

701b7bcad8681b161de791579aeb3de285f9a20f - sched_ext: Add the SCX_CAP_ENQ cap

Tue, 14 Jul 2026 10:18:43 +0200

sched_ext: Add the SCX_CAP_ENQ capAdd SCX_CAP_ENQ, which gates inserting tasks onto a cid's local DSQ. UnlikeIMMED enqueue, plain enqueues can pile up, so ENQ is the stronger cap andimplies ENQ_IMMED. Losing ENQ also triggers the reenq scan. The scan testseach queued task and the running task against the cap each needs viascx_caps_for_task(), so an ENQ-only loss reenqueues plain tasks, evicting arunning one, while IMMED tasks, which need only ENQ_IMMED, stay put.Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

46a85ae6fe5b468107baa9f21f073a940208d9ff - sched_ext: Tie cpu occupancy to SCX_CAP_BASE through the task slice

Tue, 14 Jul 2026 10:18:43 +0200

sched_ext: Tie cpu occupancy to SCX_CAP_BASE through the task sliceA task's slice grants it cpu occupancy - how long it holds its cpu. In asub-scheduler hierarchy cpu access is delegated through revocablecapabilities, so a task's occupancy must follow them. Only its own schedulersets its slice, and extending the slice is allowed only while that schedulerholds baseline cpu access (SCX_CAP_BASE) on the cpu. Otherwise a schedulercould keep occupying a cpu it has been denied simply by handing out longslices.The cap check reads effective caps, which are coherent only under the task'srq lock, and the kernel decrements the slice under that lock as the taskruns, so a running task's slice can be changed only there while a queuedtask's can be set directly. Make scx_bpf_task_set_slice() apply the sliceunder the rq lock. Synchronously when the caller already holds it, otherwiseby stashing it in the new p->scx.slice_oob, tagged with the scheduler's idso a request that outlived a reassignment is dropped. Whether the callerholds @p's current rq lock is tested with p->scx.runnable_cpu.Revocation is enforced through the same grant. When a cpu's effective capslose SCX_CAP_BASE, the cap-revoke reenq scan also checks the running taskand zeroes its slice to evict it. The scan runs as a balance callback afterthe pick, so this catches both the task that was running when the revokelanded and a capless task the pick just promoted off the local DSQ. Thepaths that keep a task on its cpu - holding on to the last runnable task inbalance, the ENQ_LAST reinsertion and the slice refill on pick - skip taskslacking baseline access. A migration-disabled task is exempt, mirroring itscapless admission on insert.v4: Test rq ownership with p->scx.runnable_cpu, closing a remote-wakeup TOCTOU. (sashiko AI)v3: Keep a pending out-of-band slice request across refill and preserve. (sashiko AI)v2: Only write slice directly when @p is queued on the held rq. (sashiko AI)Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

147d1885f390bcfb929210814f86dc22b24c2631 - sched_ext: Add the SCX_CAP_ENQ_IMMED cap

Tue, 14 Jul 2026 10:18:43 +0200

sched_ext: Add the SCX_CAP_ENQ_IMMED capReplace the __SCX_CAP_DUMMY placeholder with SCX_CAP_ENQ_IMMED, which gatesinserting IMMED tasks onto a cid's local DSQ. An IMMED enqueue is guaranteedto either get its task running on the cpu at once or hand it back to thescheduler, so IMMED work can never pile up on the cpu's queue and a cpu canbe shared across sub-scheds through IMMED access without any of themswamping it.That makes ENQ_IMMED the natural baseline, the minimal cap to make any useof a cpu. SCX_CAP_BASE aliases it so gates on basic cpu access can state theintention instead of naming ENQ_IMMED.Enforcement covers inserts and queued tasks. An insert without the cap isdiverted to the reject DSQ, and queued tasks are reenqueued when the cap islost. scx_bpf_sub_dispatch() skips a child that lacks the cap on the cpu, asits inserts would only be rejected. Vacating the running task on cap losslands in a later patch.Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

8b17523479437fadb26f649e00a0d848c624c07e - sched_ext: Add SCX_ENQ_IGNORE_CAPS for in-place restore

Tue, 14 Jul 2026 10:18:43 +0200

sched_ext: Add SCX_ENQ_IGNORE_CAPS for in-place restoreA SAVE/RESTORE requeue re-inserts a running task in place and is immediatelyfollowed by set_next_task_scx(). It is not a real scheduling event: the taskis already admitted to its cid and must return to the local DSQunconditionally.scx_caps_for_enq() maps an enqueue to the cap its local-DSQ insert requires.Add SCX_ENQ_IGNORE_CAPS, set it on the RESTORE-in-place branch ofenqueue_task_scx(), and have scx_caps_for_enq() require no caps for it, sothe cid admission gate never diverts an in-place restore to the reject DSQ.Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

75a8c8202c918f567e7a7b16add40b0be02c2113 - sched_ext: Add reject DSQ for cap-rejected dispatches

Tue, 14 Jul 2026 10:18:43 +0200

sched_ext: Add reject DSQ for cap-rejected dispatchesWhen a sub-scheduler dispatches a task to a CPU it lacks the requiredcapability on, the task must be rejected rather than allowed to run.Add the machinery for that. Each rq gets a reject DSQ, a kernel-internalholding queue that is never run and that the BPF scheduler cannot reach. Aninsert that must be refused is diverted there instead of the local DSQ, anda deferred requeue then hands the parked tasks back to the BPF scheduler tore-decide. A cap revoke extends this to already-queued tasks. When therevoke reaches the cpu's effective caps, the cpu scans its local DSQ andreenqueues the tasks that no longer qualify.A migration-disabled task must run on its cpu, so a capless one is admittedanyway and counted in the new SCX_EV_SUB_FORCED_ADMIT event.This is preparation for the actual sub-sched cap enforcement. The divert iswired but inert here.v2: Admit offline-rq and migration_pending inserts to local, not reject. (sashiko AI)Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

b81a6c018cdeb91897696489694653c56fa60eb5 - sched_ext: Add sub_ecaps_updated() effective-cap change notifier

Tue, 14 Jul 2026 10:18:43 +0200

sched_ext: Add sub_ecaps_updated() effective-cap change notifierA sub-scheduler that gains or loses effective caps on a cpu may want to acton it right away - e.g. place or preempt on a newly usable cpu. The existingops.sub_caps_updated() doesn't fit as it is delivered asynchronously toscheduling operations and can arrive before the per-cpu effective caps golive.Add ops.sub_ecaps_updated(cid, before, after), a cid-form callback firedfrom scx_process_sync_ecaps() when a sub-sched's effective caps on a cidchange. It runs in dispatch context so the sched can insert, kick or preempton the cid directly. @before is the caps as of the last delivery.Cpu hotplug rides the same machinery. Going down zeroes each sched's ecapson the cpu's cid, with queued syncs discarded at consumption while the cpuis inactive. Coming back up queues a sync for every sched. reported_ecaps iskept across the down/up cycle, so the resync fires the callback only ifownership actually changed while the cpu was down.v2: Compute cid below the active-cpu guard; discard queued syncs on !cpu_active(). (sashiko AI)Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

56fdc35b7471639bae66f2ce3885e59a4543b9dd - sched_ext: Maintain per-cpu effective cap copies for single-read checks

Tue, 14 Jul 2026 10:18:43 +0200

sched_ext: Maintain per-cpu effective cap copies for single-read checksChecking a sched's caps on a cid would need to test several cap bits againstcaps[] to account for implied caps. Also, caps[] modifications aren'tsynchronized against scheduling operations on each cpu, which can lead toawkward race conditions.Collect them per cpu instead. caps[] under pshard->lock stays the targetconfiguration. scx_sched_pcpu->ecaps is added, the transposed effectivecopy: the set of cap bits the sched holds on that cpu which can be accessedwith a single read. It is stable under the rq lock. It can also be readlocklessly with READ_ONCE().Grant and revoke only mutate caps[]. They queue a sync request on the targetcpu's rq->scx.ecaps_to_sync and kick it, and the cpu recomputes the queuedscheds' ecaps from caps[] in balance_one() under its own rq lock. A dyingsched runs the sync directly to retire its queued request before freeing. Asheld references can defer the freeing past the enclosing root scheduler'slifetime, root enable discards leftover sync requests before going live.Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

5f2a9a4c2e6c827eafa8491764125934c5466a84 - sched_ext: Add coalescing sub_caps_updated() notifier for sub-schedulers

Tue, 14 Jul 2026 10:18:43 +0200

sched_ext: Add coalescing sub_caps_updated() notifier for sub-schedulersWire up ops_cid.sub_caps_updated() to notify sub-scheds of cap changes.Three constraints shape the design: 1. Static memory. Deliveries use a fixed-size buffer, both for runtime efficiency and so notifications can't be lost under memory pressure. 2. High-frequency updates. Grant/revoke can mutate caps in bursts, and the notifier path must absorb that without amplifying it. 3. Recursive grant/revoke from the callback. A child receiving a notification can call grant/revoke on its own children, which can cascade recursively down its subtree.(1) and (2) lead to coalescing into a fixed payload. Each delivery carries asingle (cmask, caps) pair covering every change since the previous one.Direction (set vs cleared) isn't encoded as it doesn't fit in the fixed-sizesummary. The callback queries scx_bpf_sub_caps() for current state. Only onedelivery is in flight per shard. Further changes fold into the same bufferand ship as the next callback, so a shard's callbacks fire in order.(3) leads to deferred delivery. Events accumulate during grant/revoke andare delivered after the shard lock is released.v2:- Request a private stack for ops.sub_caps_updated(). (sashiko AI)- Build cmask_arena_out via scx_cmask_ref, not by re-reading its header.Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

86094b95efcf747c80930a2a675c5b14505a19b1 - sched_ext: Add per-shard cap delegation for sub-schedulers

Tue, 14 Jul 2026 10:18:43 +0200

sched_ext: Add per-shard cap delegation for sub-schedulersCaps are per-cid permissions parents delegate to direct children viascx_bpf_sub_grant() / scx_bpf_sub_revoke(). A child's cap set is always asubset of its parent's. Sub-scheds check their caps locally, and cross-schedcommunication is needed only when the delegation set itself changes.Caps will be used to implement sub-sched scheduling on the enqueue path.Picking a cid for a task at a leaf depends on which cids the leaf is allowedto use, and resolving that programmatically on every enqueue would mean across-sched round-trip call chain, possibly retrying if the request can't begranted as-is. The dispatch path is different - it runs as top-downrecursion via scx_bpf_sub_dispatch().Locking is per shard. cid space is split into shards, and each sub-sched hasits own pshard->lock for each shard. Operations are broken up on shardboundaries. Different shards never contend. Shards are expected to betopology-aligned and likely to serve as the locality unit when cids areallocated to schedulers, so per-shard lock granularity scales naturally withthe allocation pattern.This patch adds the framework with a single dummy cap. Real caps land inlater patches.The enable path is reordered for pshards. scx_arena_pool_init() moves aheadof scx_link_sched() so the pshards are allocated before the sched becomesreachable - scx_alloc_pshards() skips allocation when the arena pool isn'tinitialized.- scx_bpf_sub_grant(): Per-cid all-or-nothing grant to direct child.- scx_bpf_sub_revoke(): Clear caps on @cmask across @child and its subtree.- scx_bpf_sub_caps(): Lockless snapshot of caps on a cid range./sys/kernel/sched_ext/SCHED/caps shows the caps each scheduler currentlyholds.v4: Move the pshard[] full build/publish and the err_disable scx_error() recording to earlier patches. (sashiko AI)v3: Build pshard[] fully before publishing it, read it with READ_ONCE. (sashiko AI)v2: Validate ops before scx_link_sched() publishes the sub. (sashiko AI)Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

bbda59d85341d6d4d957596233646c84d9d9a451 - sched_ext: Add scx_skip_subtree_pre()

Tue, 14 Jul 2026 10:18:43 +0200

sched_ext: Add scx_skip_subtree_pre()Factor the sibling/ancestor portion of scx_next_descendant_pre() out asscx_skip_subtree_pre(), a pre-order walk primitive that skips @pos'ssubtree, and call it from scx_next_descendant_pre(). Same locking rules asthe existing primitive.Used in a follow-up to fast-skip subtrees that have nothing to do during adescendant walk.Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h

70f8b1785327f233d667d8fc0751a7d2ec231597 - sched_ext: RCU-protect the sub-sched tree's children/sibling lists

Tue, 14 Jul 2026 10:18:43 +0200

sched_ext: RCU-protect the sub-sched tree's children/sibling listsFuture kfuncs need to walk descendants without scx_sched_lock. Make thewalker RCU-safe so that they can. A sub-sched's fields are initializedbefore it is linked, so a walk that observes a linked node also observes itssetup. In-place changes after linking carry their own ordering.Switch the children/sibling list ops to RCU and expand the descendant walkerto accept rcu_read_lock as a valid read-side context. Walkers that mutatekeep scx_sched_lock.A sub-sched can be linked while an ancestor is bypassing, after the bypasswalk that propagates the depth has passed its parent. Bypass state is aper-cpu flag plus a depth count and can't be established atomically at linktime, so refuse to link under a bypassing ancestor. Take scx_bypass_lockacross linking to check the parent's bypass state coherently.v3: Reject linking under a bypassing ancestor instead of inheriting bypass_depth. (sashiko AI)v2: Inherit bypass_depth before publishing @sch on the RCU sibling list.Signed-off-by: Tejun Heo Reviewed-by: Andrea Righi List of files: /linux/kernel/sched/ext/sub.h