<feed xmlns='http://www.w3.org/2005/Atom'>
<title>linux-toradex.git/include/linux/sched, branch master</title>
<subtitle>Linux kernel for Apalis and Colibri modules</subtitle>
<link rel='alternate' type='text/html' href='https://git.toradex.cn/cgit/linux-toradex.git/'/>
<entry>
<title>Merge tag 'sched_ext-for-7.4-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/sched_ext</title>
<updated>2026-10-29T17:38:53+00:00</updated>
<author>
<name>Linus Torvalds</name>
<email>torvalds@linux-foundation.org</email>
</author>
<published>2026-10-29T17:38:53+00:00</published>
<link rel='alternate' type='text/html' href='https://git.toradex.cn/cgit/linux-toradex.git/commit/?id=729beb5aa80ce4bcf40f9ff74ed845269393a6ae'/>
<id>729beb5aa80ce4bcf40f9ff74ed845269393a6ae</id>
<content type='text'>
Pull sched_ext fixes from Tejun Heo:
 "This is a big pull for fixes, but much of it was in the works before
  the merge window.

  Most of these fixes are in sub-scheduler support, which nests BPF
  schedulers under a parent that hands them CPUs. It was heavily
  reworked over recent cycles and is now functionally complete. Porting
  real schedulers on it drove the latest additions and keeps finding
  corner cases.

  For example, once CPUs are shared and can be taken back, the kernel
  must keep every task moving when its scheduler can't run it or is
  failing, and those fallbacks interact subtly with each other and with
  other new core features.

   - The fallback paths meant to keep a task moving when its scheduler
     can't run it or is failing could themselves leave it stuck

   - The stall watchdog could blame a scheduler for time it wasn't
     responsible for, even taking down all of sched_ext

   - Sub-schedulers were told late, or not at all, which CPUs they could
     use

   - Deferred callbacks could stay queued or be dropped under core
     scheduling and proxy execution, with a sched/core fix to the
     duplicate check

   - Hardening: tracing programs can no longer call kfuncs that could
     deadlock the CPU"

* tag 'sched_ext-for-7.4-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/sched_ext: (34 commits)
  sched_ext: Reject scx_bpf_sub_grant/revoke() in tracing programs
  sched_ext: Fix the rescue overload pick ejecting the wrong sub under bypass
  sched_ext: Fix use-after-free of a NONE rescuee leaving its sched while running
  sched_ext: Fix a lone IMMED task waiting behind a kept prev
  sched_ext: Fix queued bypassed tasks stalling when the host loses SCX_CAP_BASE
  sched_ext: Let the bypass load balancer move tasks homed on other cpus
  sched_ext: Factor out bypass_lb_move() and insert with the donor DSQ unlocked
  sched_ext: Fix the bypass load balancer stranding tasks on cpus where the host lacks SCX_CAP_BASE
  sched_ext: Fix bypassed tasks stalling when the host lacks SCX_CAP_BASE
  sched_ext: Expire prev's slice in dispatch_one() under bypass
  sched_ext: Fix a cpu idling after put_prev_task_scx() queues its task on the local DSQ
  sched_ext: Refuse extending a kernel slice
  sched_ext: Mark the rescue grant as a kernel slice with SCX_TASK_KERNEL_SLICE
  sched_ext: Fix a cpu idling with a runnable rescuee
  sched_ext: Restore a rescuee's slice after ops.stopping()
  sched_ext: Fix rescue served time disagreeing with the slice under proxy execution
  sched_ext: Move refill_task_slice_dfl() below apply_slice_vtime()
  sched_ext: Fix bypassed tasks looping on a host without SCX_CAP_ENQ
  sched_ext: Fix bypassed tasks stranded by the reenqueue limit
  sched_ext: Clear holding_cpu where the claim is confirmed
  ...
</content>
<content type='xhtml'>
<div xmlns='http://www.w3.org/1999/xhtml'>
<pre>
Pull sched_ext fixes from Tejun Heo:
 "This is a big pull for fixes, but much of it was in the works before
  the merge window.

  Most of these fixes are in sub-scheduler support, which nests BPF
  schedulers under a parent that hands them CPUs. It was heavily
  reworked over recent cycles and is now functionally complete. Porting
  real schedulers on it drove the latest additions and keeps finding
  corner cases.

  For example, once CPUs are shared and can be taken back, the kernel
  must keep every task moving when its scheduler can't run it or is
  failing, and those fallbacks interact subtly with each other and with
  other new core features.

   - The fallback paths meant to keep a task moving when its scheduler
     can't run it or is failing could themselves leave it stuck

   - The stall watchdog could blame a scheduler for time it wasn't
     responsible for, even taking down all of sched_ext

   - Sub-schedulers were told late, or not at all, which CPUs they could
     use

   - Deferred callbacks could stay queued or be dropped under core
     scheduling and proxy execution, with a sched/core fix to the
     duplicate check

   - Hardening: tracing programs can no longer call kfuncs that could
     deadlock the CPU"

* tag 'sched_ext-for-7.4-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/sched_ext: (34 commits)
  sched_ext: Reject scx_bpf_sub_grant/revoke() in tracing programs
  sched_ext: Fix the rescue overload pick ejecting the wrong sub under bypass
  sched_ext: Fix use-after-free of a NONE rescuee leaving its sched while running
  sched_ext: Fix a lone IMMED task waiting behind a kept prev
  sched_ext: Fix queued bypassed tasks stalling when the host loses SCX_CAP_BASE
  sched_ext: Let the bypass load balancer move tasks homed on other cpus
  sched_ext: Factor out bypass_lb_move() and insert with the donor DSQ unlocked
  sched_ext: Fix the bypass load balancer stranding tasks on cpus where the host lacks SCX_CAP_BASE
  sched_ext: Fix bypassed tasks stalling when the host lacks SCX_CAP_BASE
  sched_ext: Expire prev's slice in dispatch_one() under bypass
  sched_ext: Fix a cpu idling after put_prev_task_scx() queues its task on the local DSQ
  sched_ext: Refuse extending a kernel slice
  sched_ext: Mark the rescue grant as a kernel slice with SCX_TASK_KERNEL_SLICE
  sched_ext: Fix a cpu idling with a runnable rescuee
  sched_ext: Restore a rescuee's slice after ops.stopping()
  sched_ext: Fix rescue served time disagreeing with the slice under proxy execution
  sched_ext: Move refill_task_slice_dfl() below apply_slice_vtime()
  sched_ext: Fix bypassed tasks looping on a host without SCX_CAP_ENQ
  sched_ext: Fix bypassed tasks stranded by the reenqueue limit
  sched_ext: Clear holding_cpu where the claim is confirmed
  ...
</pre>
</div>
</content>
</entry>
<entry>
<title>sched_ext: Refuse extending a kernel slice</title>
<updated>2026-10-27T19:40:56+00:00</updated>
<author>
<name>Tejun Heo</name>
<email>tj@kernel.org</email>
</author>
<published>2026-10-27T00:17:41+00:00</published>
<link rel='alternate' type='text/html' href='https://git.toradex.cn/cgit/linux-toradex.git/commit/?id=8197fa420ddd6cd9d3a023b63db34b798d163cc1'/>
<id>8197fa420ddd6cd9d3a023b63db34b798d163cc1</id>
<content type='text'>
A rescuee can keep running after its grant is served, on a cpu its scheduler
has lost. The write rules deny a slice extension only where the scheduler
lacks SCX_CAP_BASE on the cpu, and a scheduler holding BASE but not ENQ can
have a task under rescue there:

 1. the scheduler extends the rescuee's slice
 2. BASE is revoked. The cap-revoke eviction skips the rescuee.
 3. the grant is served and scx_rescue_charge() ends the rescue
 4. the task runs out the extension on the cpu its scheduler lost, outside
    the rescue's bandwidth

A scheduler shortens or zeroes a rescuee's slice to preempt it, and
scx_rescue_keep() resumes the grant afterwards. An extension serves no such
purpose.

Refuse extending a kernel slice in both scheduler write paths, the direct
write in scx_bpf_task_set_slice() and the out-of-band application, counted
in SCX_EV_SLICE_DENIED like an extension without BASE. Shortening stays
allowed.

scx_rescue_keep()'s restore of the remainder raises the slice from zero.
Like the kernel's other slice writes, it goes through scx_set_task_slice()
and not the scheduler write paths.

v2:
- scx_rescue_admit()'s kerneldoc no longer mentions a served-time snapshot.
- SCX_EV_SLICE_DENIED's comment lists every refusal it counts.
- scx_bpf_task_set_slice()'s kerneldoc says that shortening is refused on a
  protected slice.

Fixes: 5fd501744b10 ("sched_ext: Add bandwidth-limited rescue execution for stranded tasks")
Signed-off-by: Tejun Heo &lt;tj@kernel.org&gt;
Reviewed-by: Andrea Righi &lt;arighi@nvidia.com&gt;
</content>
<content type='xhtml'>
<div xmlns='http://www.w3.org/1999/xhtml'>
<pre>
A rescuee can keep running after its grant is served, on a cpu its scheduler
has lost. The write rules deny a slice extension only where the scheduler
lacks SCX_CAP_BASE on the cpu, and a scheduler holding BASE but not ENQ can
have a task under rescue there:

 1. the scheduler extends the rescuee's slice
 2. BASE is revoked. The cap-revoke eviction skips the rescuee.
 3. the grant is served and scx_rescue_charge() ends the rescue
 4. the task runs out the extension on the cpu its scheduler lost, outside
    the rescue's bandwidth

A scheduler shortens or zeroes a rescuee's slice to preempt it, and
scx_rescue_keep() resumes the grant afterwards. An extension serves no such
purpose.

Refuse extending a kernel slice in both scheduler write paths, the direct
write in scx_bpf_task_set_slice() and the out-of-band application, counted
in SCX_EV_SLICE_DENIED like an extension without BASE. Shortening stays
allowed.

scx_rescue_keep()'s restore of the remainder raises the slice from zero.
Like the kernel's other slice writes, it goes through scx_set_task_slice()
and not the scheduler write paths.

v2:
- scx_rescue_admit()'s kerneldoc no longer mentions a served-time snapshot.
- SCX_EV_SLICE_DENIED's comment lists every refusal it counts.
- scx_bpf_task_set_slice()'s kerneldoc says that shortening is refused on a
  protected slice.

Fixes: 5fd501744b10 ("sched_ext: Add bandwidth-limited rescue execution for stranded tasks")
Signed-off-by: Tejun Heo &lt;tj@kernel.org&gt;
Reviewed-by: Andrea Righi &lt;arighi@nvidia.com&gt;
</pre>
</div>
</content>
</entry>
<entry>
<title>sched_ext: Mark the rescue grant as a kernel slice with SCX_TASK_KERNEL_SLICE</title>
<updated>2026-10-27T19:40:56+00:00</updated>
<author>
<name>Tejun Heo</name>
<email>tj@kernel.org</email>
</author>
<published>2026-10-27T00:17:40+00:00</published>
<link rel='alternate' type='text/html' href='https://git.toradex.cn/cgit/linux-toradex.git/commit/?id=98889f2cae365fda99b1664151bc7c9908156536'/>
<id>98889f2cae365fda99b1664151bc7c9908156536</id>
<content type='text'>
In the following patches, bypassed tasks run under rescue when their host
lacks SCX_CAP_BASE on the cpu. Under bypass the kernel zeroes the running
task's slice at every tick, as it does not trust the scheduler's slices.

A rescue grant has to survive that, or it is served a tick at a time with
the rescuee sent to the tail of the local DSQ each time. The generic slice
handling can't tell a kernel grant from a scheduler's slice.

Mark the grant as a kernel slice with SCX_TASK_KERNEL_SLICE, set at rescue
admission and cleared when the slice ends. The generic slice handling leaves
it alone. The default refill does nothing for it, and the three zeroings go
through the new expire_task_slice(), which skips it:

 - the bypass tick's zeroing of the running task
 - the eviction of a running task that can't stay on the cpu when bypass
   lifts
 - the cap-revoke eviction of a running task

Schedulers keep their control. Preemption and scx_bpf_task_set_slice() still
apply, and the rescue stays bounded by served time.

The sites that recognized the rescuee by identity, the reenqueue scan and
put_prev_task_scx()'s reinsert, test the flag instead.
scx_task_has_kernel_slice() hides the test behind the scx_has_subs() static
key, as only a sub-scheduler's task can carry the flag. The flag's entries
join the enum tables in tools/sched_ext.

No kernel slice reaches a zeroing until bypassed tasks run under rescue. The
cap-revoke eviction skipped the rescuee already, and bypass entry ends an
open rescue, so the bypass tick and the eviction at bypass lift see none.

The refill is the one behavior change. The pick refills a zero slice only
for a task that can stay on the cpu, so it concerns a rescuee whose
scheduler holds BASE there. A scheduler may zero such a queued rescuee's
slice, and the next pick used to refill it to the default.

Now the rescuee runs on the zero slice until the next tick. There
put_prev_task_scx() restores the remainder when another task is runnable.

When nothing else is runnable, dispatch_one() keeps the rescuee as the last
task. The pick then ends its zero slice, which ends the rescue, and refills
the default. A scheduler with SCX_OPS_ENQ_LAST skips the keep-last test.
scx_rescue_keep() restores the remainder there instead and the rescue goes
on.

v2:
- scx_rescue_admit()'s kerneldoc no longer mentions a served-time snapshot.
- The description covers a scheduler with SCX_OPS_ENQ_LAST, whose rescuee
  dispatch_one() keeps on the remainder.

Signed-off-by: Tejun Heo &lt;tj@kernel.org&gt;
Reviewed-by: Andrea Righi &lt;arighi@nvidia.com&gt;
</content>
<content type='xhtml'>
<div xmlns='http://www.w3.org/1999/xhtml'>
<pre>
In the following patches, bypassed tasks run under rescue when their host
lacks SCX_CAP_BASE on the cpu. Under bypass the kernel zeroes the running
task's slice at every tick, as it does not trust the scheduler's slices.

A rescue grant has to survive that, or it is served a tick at a time with
the rescuee sent to the tail of the local DSQ each time. The generic slice
handling can't tell a kernel grant from a scheduler's slice.

Mark the grant as a kernel slice with SCX_TASK_KERNEL_SLICE, set at rescue
admission and cleared when the slice ends. The generic slice handling leaves
it alone. The default refill does nothing for it, and the three zeroings go
through the new expire_task_slice(), which skips it:

 - the bypass tick's zeroing of the running task
 - the eviction of a running task that can't stay on the cpu when bypass
   lifts
 - the cap-revoke eviction of a running task

Schedulers keep their control. Preemption and scx_bpf_task_set_slice() still
apply, and the rescue stays bounded by served time.

The sites that recognized the rescuee by identity, the reenqueue scan and
put_prev_task_scx()'s reinsert, test the flag instead.
scx_task_has_kernel_slice() hides the test behind the scx_has_subs() static
key, as only a sub-scheduler's task can carry the flag. The flag's entries
join the enum tables in tools/sched_ext.

No kernel slice reaches a zeroing until bypassed tasks run under rescue. The
cap-revoke eviction skipped the rescuee already, and bypass entry ends an
open rescue, so the bypass tick and the eviction at bypass lift see none.

The refill is the one behavior change. The pick refills a zero slice only
for a task that can stay on the cpu, so it concerns a rescuee whose
scheduler holds BASE there. A scheduler may zero such a queued rescuee's
slice, and the next pick used to refill it to the default.

Now the rescuee runs on the zero slice until the next tick. There
put_prev_task_scx() restores the remainder when another task is runnable.

When nothing else is runnable, dispatch_one() keeps the rescuee as the last
task. The pick then ends its zero slice, which ends the rescue, and refills
the default. A scheduler with SCX_OPS_ENQ_LAST skips the keep-last test.
scx_rescue_keep() restores the remainder there instead and the rescue goes
on.

v2:
- scx_rescue_admit()'s kerneldoc no longer mentions a served-time snapshot.
- The description covers a scheduler with SCX_OPS_ENQ_LAST, whose rescuee
  dispatch_one() keeps on the remainder.

Signed-off-by: Tejun Heo &lt;tj@kernel.org&gt;
Reviewed-by: Andrea Righi &lt;arighi@nvidia.com&gt;
</pre>
</div>
</content>
</entry>
<entry>
<title>sched_ext: Pack scx_ent_flags' multi-bit fields at the top</title>
<updated>2026-10-27T19:40:56+00:00</updated>
<author>
<name>Tejun Heo</name>
<email>tj@kernel.org</email>
</author>
<published>2026-10-27T00:17:32+00:00</published>
<link rel='alternate' type='text/html' href='https://git.toradex.cn/cgit/linux-toradex.git/commit/?id=2e68cfad33faad70187df89b4c9f93ae439b7946'/>
<id>2e68cfad33faad70187df89b4c9f93ae439b7946</id>
<content type='text'>
The following patches add a flag for a kernel-owned slice to scx_ent_flags.
The two 3-bit fields, the task state at bits 8 to 10 and the reenqueue
reason at bits 12 to 14, sit right above the single-bit flags, so the new
flag would have to take bit 11 or 15, out of sequence with the rest.

Pack the fields at the top of the word, below SCX_TASK_CURSOR, the state at
bits 25 to 27 and the reason at bits 28 to 30, so that the single-bit flags
continue from bit 8.

The renumbering changes the values a BPF scheduler reads from p-&gt;scx.flags.
Nothing in the kernel or the in-tree schedulers hardcodes the numbers. The
enum ABI table in tools/sched_ext/include/scx/enums_abi.autogen.h, kept for
repairing enum values that a kernel's BTF truncates, is regenerated for the
two fields. In the scx repository, scx_eevdf tests SCX_TASK_REENQ_IMMED and
SCX_TASK_REENQ_PREEMPTED against SCX_TASK_REENQ_REASON_MASK. Those three
names belong in its load-time enum table, so that they follow the running
kernel. No behavior change.

Signed-off-by: Tejun Heo &lt;tj@kernel.org&gt;
Reviewed-by: Andrea Righi &lt;arighi@nvidia.com&gt;
</content>
<content type='xhtml'>
<div xmlns='http://www.w3.org/1999/xhtml'>
<pre>
The following patches add a flag for a kernel-owned slice to scx_ent_flags.
The two 3-bit fields, the task state at bits 8 to 10 and the reenqueue
reason at bits 12 to 14, sit right above the single-bit flags, so the new
flag would have to take bit 11 or 15, out of sequence with the rest.

Pack the fields at the top of the word, below SCX_TASK_CURSOR, the state at
bits 25 to 27 and the reason at bits 28 to 30, so that the single-bit flags
continue from bit 8.

The renumbering changes the values a BPF scheduler reads from p-&gt;scx.flags.
Nothing in the kernel or the in-tree schedulers hardcodes the numbers. The
enum ABI table in tools/sched_ext/include/scx/enums_abi.autogen.h, kept for
repairing enum values that a kernel's BTF truncates, is regenerated for the
two fields. In the scx repository, scx_eevdf tests SCX_TASK_REENQ_IMMED and
SCX_TASK_REENQ_PREEMPTED against SCX_TASK_REENQ_REASON_MASK. Those three
names belong in its load-time enum table, so that they follow the running
kernel. No behavior change.

Signed-off-by: Tejun Heo &lt;tj@kernel.org&gt;
Reviewed-by: Andrea Righi &lt;arighi@nvidia.com&gt;
</pre>
</div>
</content>
</entry>
<entry>
<title>Merge tag 'sched_ext-for-7.4' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/sched_ext</title>
<updated>2026-10-22T20:37:35+00:00</updated>
<author>
<name>Linus Torvalds</name>
<email>torvalds@linux-foundation.org</email>
</author>
<published>2026-10-22T20:37:35+00:00</published>
<link rel='alternate' type='text/html' href='https://git.toradex.cn/cgit/linux-toradex.git/commit/?id=98aec86f8c6bf2e1091fefb99eaba8b910e8eef1'/>
<id>98aec86f8c6bf2e1091fefb99eaba8b910e8eef1</id>
<content type='text'>
Pull sched_ext updates from Tejun Heo:

 - Proxy execution can now be enabled together with sched_ext. A BPF
   scheduler can opt in to receive mutex-blocked tasks that donate their
   scheduling context to the lock owner and place them itself.

 - Lazy preemption: a BPF scheduler can preempt or kick a CPU lazily,
   deferring the switch to the next return to user space or tick, as the
   fair class can.

 - Sub-schedulers: a parent now learns which child runs on each CPU it
   delegated and when a cap change takes effect. A detaching child loses
   its caps before the parent restores the CPUs.

 - New kfuncs re-enqueue single tasks from a dispatch queue iteration
   and report a cgroup's CPU count and a CID's NUMA node. The CID
   topology now includes clusters.

 - Hot path optimizations: dispatch queue and task lookups compare keys
   inline, remote task moves no longer take a dispatch queue lock twice,
   and sub-scheduler hooks cost nothing without sub-schedulers.

 - Kfuncs callable from tracing programs are hardened against NMI and
   IRQ nesting, which could hard-lock the CPU or pick a wrong idle CPU.

 - Built-in dispatch queues no longer allocate per-CPU state that grew
   with the square of the CPU count.

 - Header syncs with the scx repo, a BTF workaround for pahole 1.32, and
   selftest fixes and coverage.

* tag 'sched_ext-for-7.4' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/sched_ext: (69 commits)
  sched_ext: Drop the locks periodically while walking a user DSQ for re-enqueue
  sched_ext: scx_qmap: Also re-enqueue stranded tasks with scx_bpf_dsq_reenq_task()
  sched_ext: Add scx_bpf_dsq_reenq_task() to re-enqueue single tasks from a DSQ iteration
  sched_ext: Factor out the rq lock switch of scx_dsq_move()
  sched_ext: Don't queue balance callbacks from a core-sched pick
  sched_ext: Don't leave balance callbacks queued across a pick retry
  sched_ext: Fix a bypassed task stalling on a cpu its scheduler has no caps on
  sched_ext: Fix the running task keeping its protection into bypass
  sched_ext: Fix use-after-free of a local reenq node left on an inactive cpu
  sched_ext: Keep proxy donors with slice left on the local DSQ
  selftests/sched_ext: Report reload_loop attach failures
  selftests/sched_ext: Bound exit waits
  selftests/sched_ext: Add SCX_ASSERT_ALIVE and adopt it
  selftests/sched_ext: Fail loudly when EXIT_KIND is missing from BTF
  sched_ext: Add SCX_ECODE_RSN_CGROUP_OFFLINE to user_exit_info.h
  selftests/sched_ext: Fix reload_loop error-path use-after-free
  selftests/sched_ext: Fix build error in dequeue_remote selftest
  sched_ext: scx_qmap: Reset a child's cpuperf targets once its PERF revoke takes effect
  sched_ext: Add ops.sub_child_ecaps_updated() to report a child's effective cap changes
  sched_ext: scx_qmap: Show actual cid use per participant
  ...
</content>
<content type='xhtml'>
<div xmlns='http://www.w3.org/1999/xhtml'>
<pre>
Pull sched_ext updates from Tejun Heo:

 - Proxy execution can now be enabled together with sched_ext. A BPF
   scheduler can opt in to receive mutex-blocked tasks that donate their
   scheduling context to the lock owner and place them itself.

 - Lazy preemption: a BPF scheduler can preempt or kick a CPU lazily,
   deferring the switch to the next return to user space or tick, as the
   fair class can.

 - Sub-schedulers: a parent now learns which child runs on each CPU it
   delegated and when a cap change takes effect. A detaching child loses
   its caps before the parent restores the CPUs.

 - New kfuncs re-enqueue single tasks from a dispatch queue iteration
   and report a cgroup's CPU count and a CID's NUMA node. The CID
   topology now includes clusters.

 - Hot path optimizations: dispatch queue and task lookups compare keys
   inline, remote task moves no longer take a dispatch queue lock twice,
   and sub-scheduler hooks cost nothing without sub-schedulers.

 - Kfuncs callable from tracing programs are hardened against NMI and
   IRQ nesting, which could hard-lock the CPU or pick a wrong idle CPU.

 - Built-in dispatch queues no longer allocate per-CPU state that grew
   with the square of the CPU count.

 - Header syncs with the scx repo, a BTF workaround for pahole 1.32, and
   selftest fixes and coverage.

* tag 'sched_ext-for-7.4' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/sched_ext: (69 commits)
  sched_ext: Drop the locks periodically while walking a user DSQ for re-enqueue
  sched_ext: scx_qmap: Also re-enqueue stranded tasks with scx_bpf_dsq_reenq_task()
  sched_ext: Add scx_bpf_dsq_reenq_task() to re-enqueue single tasks from a DSQ iteration
  sched_ext: Factor out the rq lock switch of scx_dsq_move()
  sched_ext: Don't queue balance callbacks from a core-sched pick
  sched_ext: Don't leave balance callbacks queued across a pick retry
  sched_ext: Fix a bypassed task stalling on a cpu its scheduler has no caps on
  sched_ext: Fix the running task keeping its protection into bypass
  sched_ext: Fix use-after-free of a local reenq node left on an inactive cpu
  sched_ext: Keep proxy donors with slice left on the local DSQ
  selftests/sched_ext: Report reload_loop attach failures
  selftests/sched_ext: Bound exit waits
  selftests/sched_ext: Add SCX_ASSERT_ALIVE and adopt it
  selftests/sched_ext: Fail loudly when EXIT_KIND is missing from BTF
  sched_ext: Add SCX_ECODE_RSN_CGROUP_OFFLINE to user_exit_info.h
  selftests/sched_ext: Fix reload_loop error-path use-after-free
  selftests/sched_ext: Fix build error in dequeue_remote selftest
  sched_ext: scx_qmap: Reset a child's cpuperf targets once its PERF revoke takes effect
  sched_ext: Add ops.sub_child_ecaps_updated() to report a child's effective cap changes
  sched_ext: scx_qmap: Show actual cid use per participant
  ...
</pre>
</div>
</content>
</entry>
<entry>
<title>Merge tag 'timers-core-2026-10-20' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip</title>
<updated>2026-10-21T21:20:38+00:00</updated>
<author>
<name>Linus Torvalds</name>
<email>torvalds@linux-foundation.org</email>
</author>
<published>2026-10-21T21:20:38+00:00</published>
<link rel='alternate' type='text/html' href='https://git.toradex.cn/cgit/linux-toradex.git/commit/?id=aaf3d47e530616ed0cf9110ba8c537ace455dd90'/>
<id>aaf3d47e530616ed0cf9110ba8c537ace455dd90</id>
<content type='text'>
Pull timer core updates from Thomas Gleixner:
 "Updates for the core timekeeping and timers subsystem:

   - Futher cleanups for the POSIX timer exit/exec related code to
     simplify the code flow and to make it more robust against future
     changes.

   - Prevent tearing of timekeeper::ktime_sec which can be accessed
     without the sequence count protection.

     The timekeeper is updated by memcpy() with an uneven sequence count
     to force readers into the retry path. On 64-bit machine the
     ktime_sec member can be accessed atomically without the sequence
     count protection. That is only correct when the update side
     memcpy() guarantees atomicity at the 64-bit granularity. That's not
     guaranteed due to debug options, compilers and instruction
     availability. If the memcpy() does not provide the atomicity then
     the unprotected readers can observe store tearing.

     To prevent this write the ktime_sec member before the memcpy() so
     that a non-atomic memcpy() will write the same data. A similar fix
     has been done for the xtime_sec member, but the ktime_sec
     equivalent was missed.

   - Prevent time64_to_tm() day truncation on 32-bit kernels

     The function receives a 64-bit seconds value but stores the
     quotient of the computation in a long, which truncates the result
     for large input values. Cure this by using div_s64_rem() which
     stores the quotient in s64 and only leaves the seconds-within-day
     reminder in a long, which is guaranteed to fit. This fix comes with
     a corresponding kunit test to prevent further mishaps.

   - Mark data-racy accesses to the hrtimer_sleeper::task member.

     The recent updates to KCSAN flagged these benign races. Annotate
     them with new helper functions, convert all existing usage sites
     and mark the task member private after that so that future users
     which fail to use the helpers can be detected automatically.

   - Address similar benign KCSAN flagged issues in the hrtimer, timer
     and timer migration code.

   - Fixes for a few selftest issues"

* tag 'timers-core-2026-10-20' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (26 commits)
  selftests/timers: clocksource-switch: Fix unchecked open()/read()
  selftests: timers: Measure the CPU timers on the clock they count
  selftests: timers: Count what tick is worth in the drift estimate
  time/kunit: Add time64_to_tm() case beyond 32-bit day count
  time: Prevent time64_to_tm() day truncation on 32-bit
  timekeeping: Use READ_ONCE/WRITE_ONCE() for ktime_sec to prevent tearing
  timers/migration: Mark racy updates to tmigr_event::ignore field
  timers: Mark racy updates to hlist_node::pprev field
  hrtimer: Apply READ_ONCE() to lockless base-&gt;running loads
  hrtimer: Mark the hrtimer_sleeper structure's -&gt;task field __private
  hrtimer: Update hrtimer_resolution only if value changes
  futex: Use accessor for hrtimer_sleeper -&gt;task field in requeue
  rtmutex: Use accessor for hrtimer_sleeper -&gt;task field
  net: pktgen: Use accessor for hrtimer_sleeper -&gt;task field
  timers: Use accessor for hrtimer_sleeper -&gt;task field in sleep_timeout.c
  futex: Use accessor for hrtimer_sleeper -&gt;task field in waitwake.c
  io-uring/rw: Use accessor for hrtimer_sleeper -&gt;task field
  wait: Use accessor for hrtimer_sleeper -&gt;task field
  aio: Use accessor for hrtimer_sleeper -&gt;task field
  hrtimer: Mark data-racy accesses to hrtimer_sleeper -&gt;task field
  ...
</content>
<content type='xhtml'>
<div xmlns='http://www.w3.org/1999/xhtml'>
<pre>
Pull timer core updates from Thomas Gleixner:
 "Updates for the core timekeeping and timers subsystem:

   - Futher cleanups for the POSIX timer exit/exec related code to
     simplify the code flow and to make it more robust against future
     changes.

   - Prevent tearing of timekeeper::ktime_sec which can be accessed
     without the sequence count protection.

     The timekeeper is updated by memcpy() with an uneven sequence count
     to force readers into the retry path. On 64-bit machine the
     ktime_sec member can be accessed atomically without the sequence
     count protection. That is only correct when the update side
     memcpy() guarantees atomicity at the 64-bit granularity. That's not
     guaranteed due to debug options, compilers and instruction
     availability. If the memcpy() does not provide the atomicity then
     the unprotected readers can observe store tearing.

     To prevent this write the ktime_sec member before the memcpy() so
     that a non-atomic memcpy() will write the same data. A similar fix
     has been done for the xtime_sec member, but the ktime_sec
     equivalent was missed.

   - Prevent time64_to_tm() day truncation on 32-bit kernels

     The function receives a 64-bit seconds value but stores the
     quotient of the computation in a long, which truncates the result
     for large input values. Cure this by using div_s64_rem() which
     stores the quotient in s64 and only leaves the seconds-within-day
     reminder in a long, which is guaranteed to fit. This fix comes with
     a corresponding kunit test to prevent further mishaps.

   - Mark data-racy accesses to the hrtimer_sleeper::task member.

     The recent updates to KCSAN flagged these benign races. Annotate
     them with new helper functions, convert all existing usage sites
     and mark the task member private after that so that future users
     which fail to use the helpers can be detected automatically.

   - Address similar benign KCSAN flagged issues in the hrtimer, timer
     and timer migration code.

   - Fixes for a few selftest issues"

* tag 'timers-core-2026-10-20' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (26 commits)
  selftests/timers: clocksource-switch: Fix unchecked open()/read()
  selftests: timers: Measure the CPU timers on the clock they count
  selftests: timers: Count what tick is worth in the drift estimate
  time/kunit: Add time64_to_tm() case beyond 32-bit day count
  time: Prevent time64_to_tm() day truncation on 32-bit
  timekeeping: Use READ_ONCE/WRITE_ONCE() for ktime_sec to prevent tearing
  timers/migration: Mark racy updates to tmigr_event::ignore field
  timers: Mark racy updates to hlist_node::pprev field
  hrtimer: Apply READ_ONCE() to lockless base-&gt;running loads
  hrtimer: Mark the hrtimer_sleeper structure's -&gt;task field __private
  hrtimer: Update hrtimer_resolution only if value changes
  futex: Use accessor for hrtimer_sleeper -&gt;task field in requeue
  rtmutex: Use accessor for hrtimer_sleeper -&gt;task field
  net: pktgen: Use accessor for hrtimer_sleeper -&gt;task field
  timers: Use accessor for hrtimer_sleeper -&gt;task field in sleep_timeout.c
  futex: Use accessor for hrtimer_sleeper -&gt;task field in waitwake.c
  io-uring/rw: Use accessor for hrtimer_sleeper -&gt;task field
  wait: Use accessor for hrtimer_sleeper -&gt;task field
  aio: Use accessor for hrtimer_sleeper -&gt;task field
  hrtimer: Mark data-racy accesses to hrtimer_sleeper -&gt;task field
  ...
</pre>
</div>
</content>
</entry>
<entry>
<title>Merge tag 'sched-core-2026-10-18' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip</title>
<updated>2026-10-20T22:35:35+00:00</updated>
<author>
<name>Linus Torvalds</name>
<email>torvalds@linux-foundation.org</email>
</author>
<published>2026-10-20T22:35:35+00:00</published>
<link rel='alternate' type='text/html' href='https://git.toradex.cn/cgit/linux-toradex.git/commit/?id=cb95904b470d2d347012d5e360303cf478ca5362'/>
<id>cb95904b470d2d347012d5e360303cf478ca5362</id>
<content type='text'>
Pull scheduler updates from Ingo Molnar:
 "Kconfig updates:

   - Simplify PREEMPT_DYNAMIC (Mark Rutland)

  Fair scheduler updates:

   - Remove redundant RUN_TO_PARITY check (Elif Topuz)

   - Declare augmented callbacks per field, fix
     rb_add_augmented_cached() descent (Yiwei Lin, Peter Zijlstra)

   - Restart fair hrtick after same-task repicks (Shubhang Kaushik)

   - Improve the scheduling latency of short slice tasks (Vincent
     Guittot)

  Deadline/RT scheduler updates:

   - Check start_dl_timer expiry with ktime_before() (Liang Hao)

   - irq_work: CPU-hotplug improvements on PREEMPT_RT (Sebastian Andrzej
     Siewior)

  Energy-aware scheduling updates:

   - Implement the steal_governor, introduce preferred CPUs and
     steal-driven vCPU backoff (Shrikanth Hegde)

  Multi-processor load-balancing updates:

   - Enable preferred SMT siblings on NVIDIA Olympus (Andrea Righi)

   - Randomize equally shallow idle CPU picks (Christian Loehle)

   - Remove redundant core_sched_seq (Hui Su)

  Cache-aware scheduling updates:

   - Avoid publishing partial LLC utilization (Jemmy Wong)

  NUMA-balancing updates:

   - Reset NUMA fault locality after scan period update (Eric Kim)

  Proxy execution updates:

   - Ongoing work to implement sleeping owner handling for proxy
     execution (John Stultz, Vasily Gorbik)

   - Preparatory steps to make sched_ext compatible with proxy execution
     (Andrea Righi)

  Scheduler infrastructure updates &amp; fixes:

   - Remove the RCU wait from PSI trigger destruction (Shakeel Butt)

   - Avoid modifying wait-entry on failed priority registration
     (Hui Su)

   - Use the new static key API for sched_feat (Hongyan Xia)

   - Convert paravirt_steal to new static key APIs (Hongyan Xia)

   - cputime: Don't account idle time twice after dyntick-idle
     (Stian Halseth)

  Scheduler debugging updates:

   - Set TIF_NEED_RESCHED before calling __trace_set_need_resched()
     (Sechang Lim)

   - Fix context analysis errors in non-preferred CPU push (Shrikanth
     Hegde)

  Misc cleanups and fixes by Christian Loehle, Shubhang Kaushik,
  Thomas Huth and Vladimir Zapolskiy"

* tag 'sched-core-2026-10-18' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (64 commits)
  sched: Replace nr_iowait_cpu() with a bool accessor
  Revert "sched/fair: Remove dead code on enqueue_task_fair()"
  sched/cache: Avoid publishing partial LLC utilization
  sched/cputime: Don't account idle time twice after dyntick-idle
  sched/psi: Remove the RCU wait from trigger destruction
  sched/eevdf: Remove redundant RUN_TO_PARITY check
  sched/wait: Avoid modifying entry on failed priority registration
  rbtree_test: Use rb_add_augmented_cached() for the cached augmented test
  rbtree: Update augmented data on the way down in rb_add_augmented_cached()
  rbtree: Declare augmented callbacks per field with RB_AUG()
  rbtree_test: Use rb_add() and rb_add_cached() for the basic tests
  smpboot: Don't park the thread if work is pending
  irq_work: Flush lazy work CPU down on PREEMPT_RT
  irq_work: Update a comment regarding CPU hotplug invocation
  sched/topology: Add asymmetric SMT packing override
  sched/fair: Honor asymmetric SMT priority in idle selection
  sched: Set TIF_NEED_RESCHED before calling __trace_set_need_resched()
  sched/core: Fix context analysis errors in non-preferred CPU push
  virt/steal_governor: Enable the driver
  virt/steal_governor: Implement steal_governor policy loop
  ...
</content>
<content type='xhtml'>
<div xmlns='http://www.w3.org/1999/xhtml'>
<pre>
Pull scheduler updates from Ingo Molnar:
 "Kconfig updates:

   - Simplify PREEMPT_DYNAMIC (Mark Rutland)

  Fair scheduler updates:

   - Remove redundant RUN_TO_PARITY check (Elif Topuz)

   - Declare augmented callbacks per field, fix
     rb_add_augmented_cached() descent (Yiwei Lin, Peter Zijlstra)

   - Restart fair hrtick after same-task repicks (Shubhang Kaushik)

   - Improve the scheduling latency of short slice tasks (Vincent
     Guittot)

  Deadline/RT scheduler updates:

   - Check start_dl_timer expiry with ktime_before() (Liang Hao)

   - irq_work: CPU-hotplug improvements on PREEMPT_RT (Sebastian Andrzej
     Siewior)

  Energy-aware scheduling updates:

   - Implement the steal_governor, introduce preferred CPUs and
     steal-driven vCPU backoff (Shrikanth Hegde)

  Multi-processor load-balancing updates:

   - Enable preferred SMT siblings on NVIDIA Olympus (Andrea Righi)

   - Randomize equally shallow idle CPU picks (Christian Loehle)

   - Remove redundant core_sched_seq (Hui Su)

  Cache-aware scheduling updates:

   - Avoid publishing partial LLC utilization (Jemmy Wong)

  NUMA-balancing updates:

   - Reset NUMA fault locality after scan period update (Eric Kim)

  Proxy execution updates:

   - Ongoing work to implement sleeping owner handling for proxy
     execution (John Stultz, Vasily Gorbik)

   - Preparatory steps to make sched_ext compatible with proxy execution
     (Andrea Righi)

  Scheduler infrastructure updates &amp; fixes:

   - Remove the RCU wait from PSI trigger destruction (Shakeel Butt)

   - Avoid modifying wait-entry on failed priority registration
     (Hui Su)

   - Use the new static key API for sched_feat (Hongyan Xia)

   - Convert paravirt_steal to new static key APIs (Hongyan Xia)

   - cputime: Don't account idle time twice after dyntick-idle
     (Stian Halseth)

  Scheduler debugging updates:

   - Set TIF_NEED_RESCHED before calling __trace_set_need_resched()
     (Sechang Lim)

   - Fix context analysis errors in non-preferred CPU push (Shrikanth
     Hegde)

  Misc cleanups and fixes by Christian Loehle, Shubhang Kaushik,
  Thomas Huth and Vladimir Zapolskiy"

* tag 'sched-core-2026-10-18' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (64 commits)
  sched: Replace nr_iowait_cpu() with a bool accessor
  Revert "sched/fair: Remove dead code on enqueue_task_fair()"
  sched/cache: Avoid publishing partial LLC utilization
  sched/cputime: Don't account idle time twice after dyntick-idle
  sched/psi: Remove the RCU wait from trigger destruction
  sched/eevdf: Remove redundant RUN_TO_PARITY check
  sched/wait: Avoid modifying entry on failed priority registration
  rbtree_test: Use rb_add_augmented_cached() for the cached augmented test
  rbtree: Update augmented data on the way down in rb_add_augmented_cached()
  rbtree: Declare augmented callbacks per field with RB_AUG()
  rbtree_test: Use rb_add() and rb_add_cached() for the basic tests
  smpboot: Don't park the thread if work is pending
  irq_work: Flush lazy work CPU down on PREEMPT_RT
  irq_work: Update a comment regarding CPU hotplug invocation
  sched/topology: Add asymmetric SMT packing override
  sched/fair: Honor asymmetric SMT priority in idle selection
  sched: Set TIF_NEED_RESCHED before calling __trace_set_need_resched()
  sched/core: Fix context analysis errors in non-preferred CPU push
  virt/steal_governor: Enable the driver
  virt/steal_governor: Implement steal_governor policy loop
  ...
</pre>
</div>
</content>
</entry>
<entry>
<title>Merge tag 'vfs-7.4-rc1.sync_close' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs</title>
<updated>2026-10-20T07:03:21+00:00</updated>
<author>
<name>Linus Torvalds</name>
<email>torvalds@linux-foundation.org</email>
</author>
<published>2026-10-20T07:03:21+00:00</published>
<link rel='alternate' type='text/html' href='https://git.toradex.cn/cgit/linux-toradex.git/commit/?id=f47d223627f80cb7a1eb14c585fe6cb35de5e984'/>
<id>f47d223627f80cb7a1eb14c585fe6cb35de5e984</id>
<content type='text'>
Pull file closing updates from Christian Brauner:
 "This makes closing files synchronous for close_range(), exec and exit.

  Since fput() was switched to task work every final __fput() of an
  exiting task is queued on task work and run from exit_task_work().
  exec and close_range() do the same. For a task with a large descriptor
  table that is a cmpxchg() and a TIF_NOTIFY_RESUME test-and-set per
  file plus a list entry for any later task_work_cancel() to search
  under pi_lock, and then a second pass over every struct file that
  isn't cache hot anymore by then. Oleg and Neil have pointed this out
  over the years.

  close_files(), close_range() and close-on-exec now flush and put each
  file inline the way close(2) does. Kernel threads aren't affected.
  They share init_files which init_task pins forever so their
  exit_files() never drops the last reference, and their fput() keeps
  punting to a workqueue. The one place that could put a table from a
  kthread context, a failing copy_process(), can't hold the last
  reference while the source table is alive.

  On a 64 vCPU KVM guest tearing down 4096, 65536 and 1M descriptors
  scattered at random positions in the table:

                           4096 fds        65536 fds        1M fds
    exit                   1045 -&gt; 895 us  18.9 -&gt; 14.9 ms  429 -&gt; 306 ms
    execve, close-on-exec  1393 -&gt; 1190 us 21.4 -&gt; 16.9 ms  471 -&gt; 325 ms
    close_range()          1179 -&gt; 988 us  21.9 -&gt; 17.4 ms  484 -&gt; 337 ms

  So that is 16-21% or 40-150 ns per closed file, largest at 1M
  descriptors. With eight processes tearing down 65536 descriptors each
  at once it stays at 16-21% because the second pass over 16 MB of
  struct file is what gets expensive when CPUs compete for the cache.

  With 32 or 64 processes both kernels are bound by pushing millions of
  files through slab and rcu and the difference shrinks to 4-8%. Files
  whose own release dominates gain less, 13% for eventfds, 11% for
  pipes, 6% for AF_UNIX sockets. close(2) is untouched and will-it-scale
  is within 2%.

  The spufs coredump support is removed. It was the only reason
  do_coredump() unshared the descriptor table. gdb dropped Cell
  debugging in 9.1 and binutils in 2.34, the Cell blades are gone and
  nothing on the PlayStation 3 produces or reads these notes. With that
  unshare_files() goes away, exec installs its private table through the
  new switch_files_struct() and the coredump startup completion becomes
  a plain thread count waited on with the new wait_var_event_state().

  Three fixes for the synchronous close are included. A failed fork
  released its files under scx_fork_rwsem and deadlocked against the bpf
  link's release. A session leader's exit released its tty before
  disassociate_ctty() ran and the foreground job lost its SIGHUP, so the
  tty is hung up before the files are closed now. And descriptor tables
  are walked from the highest descriptor down which restores the order
  the deferred puts had and keeps a few long-standing release ordering
  bugs from deadlocking exit"

* tag 'vfs-7.4-rc1.sync_close' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs:
  fs: close files from the highest descriptor down
  coredump: factor out coredump_wait_inactive()
  exit: hang up the tty before closing the files
  fork: release the files of a failed fork after sched_cancel_fork()
  coredump: replace the startup completion with a thread count
  sched: add wait_var_event_state()
  coredump: drop core_state-&gt;dumper
  fs: make close_cloexec_files() synchronous
  fs: rename do_close_on_exec() to close_cloexec_files()
  fs: make close_range() synchronous
  fs: make close_files() synchronous
  fs: add filp_close_sync()
  fs: remove unshare_files()
  fs: move unshare_fd() to fs/file.c
  fs: add switch_files_struct()
  coredump: stop unsharing the file descriptor table
  fs: don't open-code file_close_fd() in close_fd()
  powerpc: remove coredump support
</content>
<content type='xhtml'>
<div xmlns='http://www.w3.org/1999/xhtml'>
<pre>
Pull file closing updates from Christian Brauner:
 "This makes closing files synchronous for close_range(), exec and exit.

  Since fput() was switched to task work every final __fput() of an
  exiting task is queued on task work and run from exit_task_work().
  exec and close_range() do the same. For a task with a large descriptor
  table that is a cmpxchg() and a TIF_NOTIFY_RESUME test-and-set per
  file plus a list entry for any later task_work_cancel() to search
  under pi_lock, and then a second pass over every struct file that
  isn't cache hot anymore by then. Oleg and Neil have pointed this out
  over the years.

  close_files(), close_range() and close-on-exec now flush and put each
  file inline the way close(2) does. Kernel threads aren't affected.
  They share init_files which init_task pins forever so their
  exit_files() never drops the last reference, and their fput() keeps
  punting to a workqueue. The one place that could put a table from a
  kthread context, a failing copy_process(), can't hold the last
  reference while the source table is alive.

  On a 64 vCPU KVM guest tearing down 4096, 65536 and 1M descriptors
  scattered at random positions in the table:

                           4096 fds        65536 fds        1M fds
    exit                   1045 -&gt; 895 us  18.9 -&gt; 14.9 ms  429 -&gt; 306 ms
    execve, close-on-exec  1393 -&gt; 1190 us 21.4 -&gt; 16.9 ms  471 -&gt; 325 ms
    close_range()          1179 -&gt; 988 us  21.9 -&gt; 17.4 ms  484 -&gt; 337 ms

  So that is 16-21% or 40-150 ns per closed file, largest at 1M
  descriptors. With eight processes tearing down 65536 descriptors each
  at once it stays at 16-21% because the second pass over 16 MB of
  struct file is what gets expensive when CPUs compete for the cache.

  With 32 or 64 processes both kernels are bound by pushing millions of
  files through slab and rcu and the difference shrinks to 4-8%. Files
  whose own release dominates gain less, 13% for eventfds, 11% for
  pipes, 6% for AF_UNIX sockets. close(2) is untouched and will-it-scale
  is within 2%.

  The spufs coredump support is removed. It was the only reason
  do_coredump() unshared the descriptor table. gdb dropped Cell
  debugging in 9.1 and binutils in 2.34, the Cell blades are gone and
  nothing on the PlayStation 3 produces or reads these notes. With that
  unshare_files() goes away, exec installs its private table through the
  new switch_files_struct() and the coredump startup completion becomes
  a plain thread count waited on with the new wait_var_event_state().

  Three fixes for the synchronous close are included. A failed fork
  released its files under scx_fork_rwsem and deadlocked against the bpf
  link's release. A session leader's exit released its tty before
  disassociate_ctty() ran and the foreground job lost its SIGHUP, so the
  tty is hung up before the files are closed now. And descriptor tables
  are walked from the highest descriptor down which restores the order
  the deferred puts had and keeps a few long-standing release ordering
  bugs from deadlocking exit"

* tag 'vfs-7.4-rc1.sync_close' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs:
  fs: close files from the highest descriptor down
  coredump: factor out coredump_wait_inactive()
  exit: hang up the tty before closing the files
  fork: release the files of a failed fork after sched_cancel_fork()
  coredump: replace the startup completion with a thread count
  sched: add wait_var_event_state()
  coredump: drop core_state-&gt;dumper
  fs: make close_cloexec_files() synchronous
  fs: rename do_close_on_exec() to close_cloexec_files()
  fs: make close_range() synchronous
  fs: make close_files() synchronous
  fs: add filp_close_sync()
  fs: remove unshare_files()
  fs: move unshare_fd() to fs/file.c
  fs: add switch_files_struct()
  coredump: stop unsharing the file descriptor table
  fs: don't open-code file_close_fd() in close_fd()
  powerpc: remove coredump support
</pre>
</div>
</content>
</entry>
<entry>
<title>Merge tag 'vfs-7.4-rc1.shared.net-next.pidfd' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs</title>
<updated>2026-10-20T06:32:52+00:00</updated>
<author>
<name>Linus Torvalds</name>
<email>torvalds@linux-foundation.org</email>
</author>
<published>2026-10-20T06:32:52+00:00</published>
<link rel='alternate' type='text/html' href='https://git.toradex.cn/cgit/linux-toradex.git/commit/?id=a6656aefd328d544420ecec121fc898b7f067827'/>
<id>a6656aefd328d544420ecec121fc898b7f067827</id>
<content type='text'>
Pull pidfd updates from Christian Brauner:
 "This adds thread specific pidfds to af_unix sockets.

  SO_PASSPIDFD and SO_PEERPIDFD hand out a pidfd for the thread-group
  leader. A coredump server on the coredump socket can't get a handle on
  the thread that took the signal and is writing the dump, and anything
  doing per-thread authentication has the same problem. The sending and
  the connecting thread are recorded in addition to the thread-group
  leader and sk_peer_pid becomes an array indexed by pid type.

  SO_PASSPIDFD_THREAD works like SO_PASSPIDFD but delivers an
  SCM_PIDFD_THREAD cmsg for the sending thread. Both options are
  independent so a receiver can ask for both. On SOCK_STREAM sockets
  recvmsg() only stops merging data at a thread boundary when the
  receiver asked for a thread pidfd. SO_PEERPIDFD_THREAD returns a pidfd
  for the thread that called connect(), listen() or socketpair(). pidfs
  records the coredump on the dumping thread's struct pid too so its
  pidfd reports it like the leader's does. Selftests for af_unix and the
  coredump socket are included"

* tag 'vfs-7.4-rc1.shared.net-next.pidfd' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs:
  selftests/coredump: check the dumping thread's pidfd
  pidfs: record the coredump on the dumping thread's pid too
  selftests/net: SO_PEERPIDFD_THREAD
  net: add SO_PEERPIDFD_THREAD to get a thread-specific pidfd
  af_unix: record the pid of the connecting thread
  net: turn sk_peer_pid into an array indexed by pid type
  selftests/net: SO_PASSPIDFD_THREAD
  net: add SO_PASSPIDFD_THREAD to get a thread-specific SCM_PIDFD
  af_unix: record the pid of the sending thread
  pid: add helpers to operate on a struct pid array
</content>
<content type='xhtml'>
<div xmlns='http://www.w3.org/1999/xhtml'>
<pre>
Pull pidfd updates from Christian Brauner:
 "This adds thread specific pidfds to af_unix sockets.

  SO_PASSPIDFD and SO_PEERPIDFD hand out a pidfd for the thread-group
  leader. A coredump server on the coredump socket can't get a handle on
  the thread that took the signal and is writing the dump, and anything
  doing per-thread authentication has the same problem. The sending and
  the connecting thread are recorded in addition to the thread-group
  leader and sk_peer_pid becomes an array indexed by pid type.

  SO_PASSPIDFD_THREAD works like SO_PASSPIDFD but delivers an
  SCM_PIDFD_THREAD cmsg for the sending thread. Both options are
  independent so a receiver can ask for both. On SOCK_STREAM sockets
  recvmsg() only stops merging data at a thread boundary when the
  receiver asked for a thread pidfd. SO_PEERPIDFD_THREAD returns a pidfd
  for the thread that called connect(), listen() or socketpair(). pidfs
  records the coredump on the dumping thread's struct pid too so its
  pidfd reports it like the leader's does. Selftests for af_unix and the
  coredump socket are included"

* tag 'vfs-7.4-rc1.shared.net-next.pidfd' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs:
  selftests/coredump: check the dumping thread's pidfd
  pidfs: record the coredump on the dumping thread's pid too
  selftests/net: SO_PEERPIDFD_THREAD
  net: add SO_PEERPIDFD_THREAD to get a thread-specific pidfd
  af_unix: record the pid of the connecting thread
  net: turn sk_peer_pid into an array indexed by pid type
  selftests/net: SO_PASSPIDFD_THREAD
  net: add SO_PASSPIDFD_THREAD to get a thread-specific SCM_PIDFD
  af_unix: record the pid of the sending thread
  pid: add helpers to operate on a struct pid array
</pre>
</div>
</content>
</entry>
<entry>
<title>Merge tag 'kernel-7.4-rc1.signal' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs</title>
<updated>2026-10-20T02:22:15+00:00</updated>
<author>
<name>Linus Torvalds</name>
<email>torvalds@linux-foundation.org</email>
</author>
<published>2026-10-20T02:22:15+00:00</published>
<link rel='alternate' type='text/html' href='https://git.toradex.cn/cgit/linux-toradex.git/commit/?id=018cf9bf786d501a27963dca6777f169f978e2a5'/>
<id>018cf9bf786d501a27963dca6777f169f978e2a5</id>
<content type='text'>
Pull signal handling updates from Christian Brauner:
 "This stops TIF_NOTIFY_SIGNAL from interrupting work that can't be
  restarted and fixes a bunch of coredump and signal bugs.

  TIF_NOTIFY_SIGNAL kicks a task out of an uninterruptible sleep so it
  returns to userspace, runs its task work and goes back to sleep. That
  breaks coredumps: dump_interrupted() only lets fatal signals interrupt
  a dump and writes to a regular file ignore TIF_NOTIFY_SIGNAL. But the
  pipe and the socket paths check signal_pending() Adeep down in code
  that is shared with regular syscalls and bail. So a crashing process
  with io_uring requests in flight loses most of its coredump.

  In the selftest an unfixed kernel delivers 357324 of at least 5111808
  bytes. And io_uring isn't the only source. klp_send_signals(),
  bpf_task_work_schedule_signal(), landlock's tsync, kthread_stop() and
  the printk kunit test raise the bit as well, some of them from irq
  context against any task. So this can't be fixed per subsystem and the
  state has to be per-task and ambient.

  Add PF_NO_NOTIFY_SIGNAL and no_notify_signal_save()/restore() helpers
  modelled on memalloc_nofs_save(). Inside such a section
  signal_pending() ignores TIF_NOTIFY_SIGNAL. Coredumps, the smb send
  path, which hand-rolled its own version of this, and the pid namespace
  reaper, which busy-looped when the bit kept getting raised, are
  converted.

  The second part is a set of fixes that fell out of looking at the
  coredump code with kres and modelling it in TLA+:

  - coredump_finish() woke the parked threads without holding rcu. A
    parked thread can exit on a spurious wakeup and be freed before
    wake_up_process() takes its pi_lock.

  - Only SIGKILL and the freezers interrupt a dump now and the three
    freezers agree. Power management and cgroup v1 freezing aborted a
    dump while a cgroup v2 freeze either waited for the dump or cut it
    short depending on where the core went.

  - io-wq set its exit bit without a barrier against the task work that
    creates workers. On weakly ordered architectures exit could hang on
    worker_done.

  - retarget_shared_pending() slingshotted a shared signal to the dumper
    when a zapped sibling restored its signal mask. That set
    TIF_SIGPENDING on the dumper and truncated the core.

  - A tracer could clear the signal mask of a user worker with
    PTRACE_SETSIGMASK and inject a coredump signal. An io-wq worker of
    an SQPOLL ring dumping core deadlocks the whole group.
    PTRACE_SETSIGMASK is refused for user workers now and
    __set_task_blocked() enforces the fork-time mask.

  - exec cancels io_uring requests before de_thread() so a worker
    creation queued as task work can't add a thread to a thread group
    that de_thread() just took down.

  - No io threads are created from a PF_SIGNALED or PF_POSTCOREDUMP
    creator anymore. Such a worker was invisible to zap_process() but
    still decremented threads_remaining on exit so the dumper could
    leave coredump_wait_inactive() early.

  Also included are a comment that do_each_pid_task() needs
  tasklist_lock, a READ_ONCE() in pid_alive() and a regression test for
  fork() into a pid namespace whose ancestor lost its init"

* tag 'kernel-7.4-rc1.signal' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs: (21 commits)
  pid: use READ_ONCE() in pid_alive()
  selftests: pid_namespace: test fork with dead ancestor
  pid: document that do_each_pid_task() needs tasklist_lock
  signal: enforce the user worker signal mask in __set_task_blocked()
  fork: use SIG_KERNEL_ONLY_MASK for the user worker signal mask
  fork: don't create io threads once PF_POSTCOREDUMP is set
  fork: move the coredump and exec checks into create_io_thread()
  exec: cancel io_uring requests before de_thread()
  selftests/coredump: expect PTRACE_SETSIGMASK to be refused on a user worker
  selftests/coredump: test a user worker as the coredumping thread
  ptrace: refuse to change the signal mask of a user worker
  selftests/coredump: test shared signal retargeting during a dump
  signal: only SIGKILL and the freezers interrupt a coredumping task
  signal: don't retarget shared signals in a dying thread group
  io-wq: order the exit bit against worker creation task work
  coredump: hold RCU while releasing parked threads
  pid_namespace: prevent TIF_NOTIFY_SIGNAL from interrupting the reaper
  smb: prevent TIF_NOTIFY_SIGNAL from interrupting
  selftests/coredump: test that TIF_NOTIFY_SIGNAL doesn't truncate a coredump
  coredump: prevent TIF_NOTIFY_SIGNAL from interrupting coredumps
  ...
</content>
<content type='xhtml'>
<div xmlns='http://www.w3.org/1999/xhtml'>
<pre>
Pull signal handling updates from Christian Brauner:
 "This stops TIF_NOTIFY_SIGNAL from interrupting work that can't be
  restarted and fixes a bunch of coredump and signal bugs.

  TIF_NOTIFY_SIGNAL kicks a task out of an uninterruptible sleep so it
  returns to userspace, runs its task work and goes back to sleep. That
  breaks coredumps: dump_interrupted() only lets fatal signals interrupt
  a dump and writes to a regular file ignore TIF_NOTIFY_SIGNAL. But the
  pipe and the socket paths check signal_pending() Adeep down in code
  that is shared with regular syscalls and bail. So a crashing process
  with io_uring requests in flight loses most of its coredump.

  In the selftest an unfixed kernel delivers 357324 of at least 5111808
  bytes. And io_uring isn't the only source. klp_send_signals(),
  bpf_task_work_schedule_signal(), landlock's tsync, kthread_stop() and
  the printk kunit test raise the bit as well, some of them from irq
  context against any task. So this can't be fixed per subsystem and the
  state has to be per-task and ambient.

  Add PF_NO_NOTIFY_SIGNAL and no_notify_signal_save()/restore() helpers
  modelled on memalloc_nofs_save(). Inside such a section
  signal_pending() ignores TIF_NOTIFY_SIGNAL. Coredumps, the smb send
  path, which hand-rolled its own version of this, and the pid namespace
  reaper, which busy-looped when the bit kept getting raised, are
  converted.

  The second part is a set of fixes that fell out of looking at the
  coredump code with kres and modelling it in TLA+:

  - coredump_finish() woke the parked threads without holding rcu. A
    parked thread can exit on a spurious wakeup and be freed before
    wake_up_process() takes its pi_lock.

  - Only SIGKILL and the freezers interrupt a dump now and the three
    freezers agree. Power management and cgroup v1 freezing aborted a
    dump while a cgroup v2 freeze either waited for the dump or cut it
    short depending on where the core went.

  - io-wq set its exit bit without a barrier against the task work that
    creates workers. On weakly ordered architectures exit could hang on
    worker_done.

  - retarget_shared_pending() slingshotted a shared signal to the dumper
    when a zapped sibling restored its signal mask. That set
    TIF_SIGPENDING on the dumper and truncated the core.

  - A tracer could clear the signal mask of a user worker with
    PTRACE_SETSIGMASK and inject a coredump signal. An io-wq worker of
    an SQPOLL ring dumping core deadlocks the whole group.
    PTRACE_SETSIGMASK is refused for user workers now and
    __set_task_blocked() enforces the fork-time mask.

  - exec cancels io_uring requests before de_thread() so a worker
    creation queued as task work can't add a thread to a thread group
    that de_thread() just took down.

  - No io threads are created from a PF_SIGNALED or PF_POSTCOREDUMP
    creator anymore. Such a worker was invisible to zap_process() but
    still decremented threads_remaining on exit so the dumper could
    leave coredump_wait_inactive() early.

  Also included are a comment that do_each_pid_task() needs
  tasklist_lock, a READ_ONCE() in pid_alive() and a regression test for
  fork() into a pid namespace whose ancestor lost its init"

* tag 'kernel-7.4-rc1.signal' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs: (21 commits)
  pid: use READ_ONCE() in pid_alive()
  selftests: pid_namespace: test fork with dead ancestor
  pid: document that do_each_pid_task() needs tasklist_lock
  signal: enforce the user worker signal mask in __set_task_blocked()
  fork: use SIG_KERNEL_ONLY_MASK for the user worker signal mask
  fork: don't create io threads once PF_POSTCOREDUMP is set
  fork: move the coredump and exec checks into create_io_thread()
  exec: cancel io_uring requests before de_thread()
  selftests/coredump: expect PTRACE_SETSIGMASK to be refused on a user worker
  selftests/coredump: test a user worker as the coredumping thread
  ptrace: refuse to change the signal mask of a user worker
  selftests/coredump: test shared signal retargeting during a dump
  signal: only SIGKILL and the freezers interrupt a coredumping task
  signal: don't retarget shared signals in a dying thread group
  io-wq: order the exit bit against worker creation task work
  coredump: hold RCU while releasing parked threads
  pid_namespace: prevent TIF_NOTIFY_SIGNAL from interrupting the reaper
  smb: prevent TIF_NOTIFY_SIGNAL from interrupting
  selftests/coredump: test that TIF_NOTIFY_SIGNAL doesn't truncate a coredump
  coredump: prevent TIF_NOTIFY_SIGNAL from interrupting coredumps
  ...
</pre>
</div>
</content>
</entry>
</feed>
