CVE-2026-46223: Linux Kernel Cgroup Deadlock During Container Teardown

Technical summary

The vulnerability stems from a synchronous blocking mechanism in cgroup_drain_dying() that was introduced to enforce the controller invariant requiring ->css_offline() to not execute while tasks remain in a cgroup. The problematic flow occurs when: (1) a task past exit_signals() remains linked to a cset due to earlier architectural changes that deferred task unlink; (2) rmdir() calls cgroup_drain_dying() to wait for these tasks; (3) if the rmdir caller is also the reaper of zombies (e.g., PID 1), a deadlock ensues because the reaper blocks in TASK_UNINTERRUPTIBLE, preventing zombie cleanup, which in turn prevents PID namespace teardown and task exit. The fix transforms css killing from a synchronous operation to an asynchronous one driven by percpu_ref_kill_and_confirm(), allowing rmdir to return after cgroup.procs empties while ->css_offline() runs post-drainage. This eliminates the lock-ordering deadlock by breaking the circular wait dependency.

Business impact

Production systems running containerized workloads are at risk of hung processes and system hangs during container lifecycle operations. A hung rmdir operation can cascade into application deployment failures, orchestration system timeouts, and potential system-wide availability degradation if multiple cgroup removals are queued. Systems using PID namespaces for container isolation—particularly Kubernetes nodes, systemd-managed systems, or custom container runtimes—face the highest exposure. The MEDIUM severity reflects local-only access requirements and the specific trigger conditions needed, though the impact of a hang can be severe for availability.

Affected systems

The vulnerability affects the Linux kernel across all supported versions impacted by the chain of commits dating back to v7.0 that introduced the problematic rmdir behavior. Any distribution shipping an affected kernel version is in scope, with particular risk in systems actively removing cgroups during container teardown or PID namespace cleanup. The vulnerability requires local access and the ability to trigger cgroup removal operations, limiting the attack surface to local users or container management systems.

Exploitability

Exploitation requires local access and the ability to trigger cgroup rmdir operations while conditions align to cause the deadlock—specifically, the rmdir caller must also be managing zombie processes undergoing reaping. This is not a trivial coincidence in uncontrolled environments but occurs reliably in PID namespace teardown scenarios involving re-parented orphan processes. The original vulnerability report includes a reproducible test case (pidns teardown with zombie reaper) that reliably triggers the hang. Weaponization would involve crafting PID namespace and container lifecycle scenarios to force the deadlock state, placing this at moderate exploitability for targeted local denial-of-service.

Remediation

Patch the Linux kernel to include the fix deferring css percpu_ref kill until after cgroup depopulation. The solution involves asynchronously scheduling css cleanup via percpu_ref_kill_and_confirm() rather than waiting synchronously in rmdir context. Verify that the patch includes explicit cgroup_get()/cgroup_put() reference pinning around the deferred work queue to avoid dependency on implicit ordering invariants. For stable backports, the change set is somewhat invasive but localized to cgroup management code; test thoroughly in your container runtime environment before rolling to production.

Patch guidance

Apply the kernel patch that implements the asynchronous css killing behavior. The fix should be verified against the vendor advisory for your specific Linux distribution to confirm the patch version and any dependent commits. Key aspects to verify: (1) cgroup_drain_dying() no longer blocks rmdir on task lingering; (2) css_offline() runs asynchronously via percpu_ref_kill_and_confirm() after cgroup drains; (3) rmdir returns promptly once cgroup.procs is empty; (4) explicit cgroup reference counting wraps the deferred work. Test the patch in a staging environment that exercises container creation and deletion cycles, particularly with namespace teardown scenarios.

Detection guidance

Monitor for hung rmdir processes using process state inspection (ps showing processes in TASK_UNINTERRUPTIBLE state within cgroup operations). Check kernel logs for timeouts or hangs during cgroup deletion, particularly in container orchestration or systemd teardown paths. Correlate rmdir hangs with active zombie reaping or PID namespace teardown operations. On vulnerable systems under specific trigger conditions, you may observe: systemctl/orchestrator delays during service/container shutdown, accumulated zombie processes unable to be reaped, or system-wide slowdowns during mass container termination. Implement timeout monitoring around container lifecycle operations as a temporary detection control.

Why prioritize this

While CVSS 5.5 (MEDIUM) reflects the local-only requirement and specificity of trigger conditions, the availability impact in production container environments warrants prioritization. This is not a widespread remote threat, but a targeted local denial-of-service affecting system stability during normal container lifecycle operations. Organizations running Kubernetes, Docker, or systemd-managed containers should prioritize patching to prevent availability incidents. The deadlock scenario is deterministic and reliably reproducible in PID namespace contexts, making it a realistic threat in multi-tenant or dynamic container environments. Balance this against your kernel update cycle; backport availability and testing effort may influence timing.

Risk score, explained

The CVSS 3.1 score of 5.5 (MEDIUM) reflects: Attack Vector Local (cannot be exploited remotely), Access Complexity Low (no special conditions beyond normal cgroup removal), Privilege Level Low (local user can trigger via container operations), User Interaction None, Scope Unchanged, Confidentiality None, Integrity None, Availability High (denial of service via hang). The score appropriately penalizes the local-only attack vector but acknowledges the complete availability impact. In container environments, the practical risk may feel higher due to the centrality of container lifecycle operations, but the scorer's requirement for local access and specific trigger alignment justifies MEDIUM classification.

Frequently asked questions