fork: don't create io threads once PF_POSTCOREDUMP is set
No exploitation in the wild has been reported. EPSS puts the chance of exploitation in the next 30 days at 0%. Fixed in Kernel 9dea2e237ffe2a325b9d42ed15ea9ee6561979c7, Kernel 026aa32c00b0b3ea849d0ae98313274c9d3c7e21, Kernel 1f978881ce6c9ac4f4d4a7b6a6e52339eadcd350 and 6 more.
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.
Affected
Vendors, products and packages with version ranges
| Vendor | Product | Versions | Fixed |
|---|---|---|---|
| Linux | Kernel | >=92307383082daff5df884a25df9e283efb7ef261 <9dea2e237ffe2a325b9d42ed15ea9ee6561979c7, >=92307383082daff5df884a25df9e283efb7ef261 <026aa32c00b0b3ea849d0ae98313274c9d3c7e21, >=92307383082daff5df884a25df9e283efb7ef261 <1f978881ce6c9ac4f4d4a7b6a6e52339eadcd350, >=92307383082daff5df884a25df9e283efb7ef261 <3a0cdf3eb9c3026b046efe32f01b9090ab4e2d73, >=92307383082daff5df884a25df9e283efb7ef261 <64f2a38a1658493d7a53d656bcc483ee4b837623, =5.16 | 9dea2e237ffe2a325b9d42ed15ea9ee6561979c7, 026aa32c00b0b3ea849d0ae98313274c9d3c7e21, 1f978881ce6c9ac4f4d4a7b6a6e52339eadcd350, 3a0cdf3eb9c3026b046efe32f01b9090ab4e2d73, 64f2a38a1658493d7a53d656bcc483ee4b837623 |
| linux-kernel: Kernel | >=6.13.0 <6.18.61, >=6.19.0 <7.2.15, >=7.3.0 <7.3.2, >=5.16.0 <6.12.117 | 6.18.61, 7.2.15, 7.3.2, 6.12.117 |
Timeline
Every event on this vulnerability
Related
Other vulnerabilities in Kernel, strongest first
Embed
A live severity badge for an advisory, README or ticket