CVE-2026-99561
What it is
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.
At a glance
- Fix
- No patch or advisory is linked yet. Look at mitigations or restrict exposure.
Timeline
- PublishedDisclosed publicly on CVE.org and NVD
- Last updatedMost recent change to the record
Why it ranks here
- Exploited in the wild: no, CISA does not list it.
- Exploit odds: not scored yet.
- Severity: not scored yet.
- Fix: none linked yet, which raises it.
Details
- Published
- Last modified
- Record status
- Received
Affected
- Linux < 3a0cdf3eb9c3026b046efe32f01b9090ab4e2d73
- Linux < 64f2a38a1658493d7a53d656bcc483ee4b837623
- Linux < 9dea2e237ffe2a325b9d42ed15ea9ee6561979c7
- Linux < 026aa32c00b0b3ea849d0ae98313274c9d3c7e21
- Linux < 1f978881ce6c9ac4f4d4a7b6a6e52339eadcd350
- Linux 5.16
Is it in your code?
Hand this to your coding agent. It searches your project for the affected products and checks versions. Nothing leaves your machine.
Read https://cve-list.com/agent/cve/CVE-2026-99561.md and follow it. Check whether this project is affected by CVE-2026-99561. Read only. Don't change anything and don't upload my code. Tell me yes, no or not sure, with the file as proof.
References
- https://git.kernel.org/stable/c/026aa32c00b0b3ea849d0ae98313274c9d3c7e21
- https://git.kernel.org/stable/c/1f978881ce6c9ac4f4d4a7b6a6e52339eadcd350
- https://git.kernel.org/stable/c/3a0cdf3eb9c3026b046efe32f01b9090ab4e2d73
- https://git.kernel.org/stable/c/64f2a38a1658493d7a53d656bcc483ee4b837623
- https://git.kernel.org/stable/c/9dea2e237ffe2a325b9d42ed15ea9ee6561979c7