CVE-2026-99561 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
fork: don't create io threads once PF_POSTCOREDUMP is set
zap_process() skips every thread that already has PF_POSTCOREDUMP set. Such a thread is past synchronize_group_exit(), so a coredump can't catch it anymore. It isn't counted in core_state->threads_remaining and it isn't sent SIGKILL.
do_exit() sets PF_POSTCOREDUMP in synchronize_group_exit() and calls io_uring_files_cancel() right after that. The cancellation runs task work and a create_worker_cb() that io-wq queued before the exit creates a new io-wq worker from there. If another thread started a coredump in the meantime that worker joins a thread-group which is already being dumped. zap_process() never saw it so it was never counted. But when it exits it sees signal->core_state in synchronize_group_exit() and decrements threads_remaining like any other thread.
So the count reaches zero one thread early and the dumper leaves coredump_wait_inactive() while a thread it counted is still running.
The task has no fatal signal pending because zap_process() deliberately didn't send it one, and it never went through get_signal() so it doesn't have PF_SIGNALED either.
Refuse to create an io thread when the creator has PF_POSTCOREDUMP. That costs nothing. io_uring_files_cancel() raises IO_WQ_BIT_EXIT before it runs any task work, so a worker created from there only ever gets to exit again, and io_should_retry_thread() doesn't retry -EINTR.
Clearing PF_POSTCOREDUMP for the new thread in copy_process() was the other option. It makes the worker a thread like any other, but it only helps while the dump hasn't started. A worker born after zap_process() has run is invisible to it whatever its flags say and still decrements threads_remaining on the way out. Refusing to create it covers both, and then no task is ever born with the flag, so there is nothing to clear.
Moving io_uring_files_cancel() ahead of synchronize_group_exit() closes the same window. It runs the cancellation, and whatever that can block on, before the thread announces itself to the dumper. A thread that blocks there never reaches coredump_task_exit() at all, so the dumper ends up waiting for a thread that never parks. Refusing the creation leaves the cancellation where it is. But it's very ugly to run io_uring work even before we did all the generic exit work.
If you want to get best quality of vulnerability data, you may have to visit VulDB.
Analysis
by VulDB Data Team • 11/19/2026
The Linux kernel contains a race condition vulnerability within the interaction between process termination, coredump generation, and the io_uring subsystem that can lead to incorrect thread counting during core dump operations. This issue specifically affects scenarios where a multi-threaded process is undergoing a coredump while one of its threads initiates an exit sequence involving io_uring file cancellation. The root cause lies in the timing of when new worker threads are created by the io-wq subsystem relative to the state tracking performed by the kernel's coredump logic. When a thread exits, it may trigger io_uring_files_cancel which can queue task work including callbacks that create new io-wq workers. If this creation occurs after another thread in the same process group has already started generating a core dump, the newly created worker joins a thread group that is actively being dumped but remains invisible to the zap_process function responsible for tracking active threads during the coredump.
The operational impact of this flaw stems from how the kernel manages synchronization between exiting threads and the dumping thread. The zap_process function iterates through all threads in a process, skipping those with the PF_POSTCOREDUMP flag set because they are considered past the synchronize_group_exit point and thus unable to be caught by the coredump mechanism. These skipped threads are not counted in core_state->threads_remaining nor do they receive SIGKILL signals intended to force their termination during the dump. However, if a new io-wq worker is created after zap_process has completed its scan but before the exiting thread fully completes its exit sequence, this new thread will eventually reach synchronize_group_exit upon its own eventual termination. At that point it observes signal->core_state and decrements threads_remaining as expected for any other thread in the group. Because this specific thread was never included in the initial count by zap_process due to being created after the scan window closed, the decrement causes threads_remaining to reach zero prematurely.
This premature decrement triggers a critical synchronization failure where the dumping process believes all relevant threads have exited and leaves coredump_wait_inactive while one of its counted threads is still running. The affected task does not have any fatal signal pending because zap_process deliberately avoided sending it such signals, nor does it possess PF_SIGNALED since it never went through get_signal processing. Consequently, the thread continues to execute potentially causing data corruption or incomplete core dumps depending on what operations were in progress at the time of premature exit detection. This represents a significant reliability issue for applications relying on accurate coredump generation for debugging purposes and could theoretically be exploited if an attacker can control timing conditions to force specific race states during process termination sequences involving io_uring work items.
The resolution involves refusing to create new io threads when the creator thread has PF_POSTCOREDUMP set, effectively closing the window where invisible workers could be spawned during active coredump operations. This approach is preferred over alternative solutions such as clearing PF_POSTCOREDUMP for newly created threads in copy_process because that method only helps while the dump has not yet started and fails to address cases where workers are born after zap_process has already run regardless of their flag states. By preventing creation entirely, no task ever inherits the problematic flag state requiring cleanup later. Another considered alternative was moving io_uring_files_cancel ahead of synchronize_group_exit but this was rejected as it would cause cancellation work including blocking operations to execute before generic exit procedures are completed which introduces undesirable side effects and complexity into the process termination flow.
From a vulnerability classification perspective, this issue aligns with CWE-362 Concurrent Execution using Shared Resource with Improper Synchronization since multiple threads access shared state without proper coordination during critical sections of coredump handling. It also relates to CWE-410 Missing Double Check in some interpretations regarding the race between thread creation and visibility checks though primarily it is a synchronization logic error rather than a simple missing check. In terms of MITRE ATT&CK framework, this could be categorized under T1562 Impair Defenses specifically within the context of disrupting forensic capabilities through coredump manipulation although practical exploitation would require precise timing control over process exit and io_uring work submission which is generally difficult to achieve reliably in most environments.
Mitigation strategies for system administrators involve ensuring systems are updated with kernel patches that include this fix as it addresses a fundamental logic error in the kernel's handling of thread lifecycle during coredump scenarios. For organizations running custom kernels or older versions without immediate patch availability, monitoring io_uring usage patterns and avoiding complex multi-threaded applications that generate frequent core dumps may reduce exposure risk though complete mitigation requires code-level fixes since the vulnerability exists deep within kernel synchronization primitives. Developers utilizing io_uring should be aware of these timing constraints when designing exit handlers to avoid triggering worker creation during potential coredump windows if running unpatched systems.