Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.
Sources: National Vulnerability Database, CISA KEV, Exploit-DB
CVE-2026-93233 Overview
CVE-2026-93233 is a counter underflow vulnerability in the Linux kernel's Nouveau Direct Rendering Manager (DRM) device memory (dmem) subsystem. The flaw affects accounting of compound device-private folios in NVIDIA GPU memory management when those folios are split by the memory management core.
The nouveau_dmem_folio_split() hook updates sub-folio metadata but fails to increment chunk->callocated for the new sub-folios. Each sub-folio is later freed individually, decrementing the counter once per free. The result is an unsigned counter underflow that prevents chunk reclamation and triggers kernel warnings.
Critical Impact
The underflow wraps chunk->callocated to a very large value, leaking the GPU memory chunk permanently and preventing reclamation by nouveau_dmem_fini().
Affected Products
- Linux kernel versions containing the Nouveau DRM device-private memory implementation
- Systems using NVIDIA GPUs with the Nouveau open-source driver and HMM device-private memory
- Linux stable branches prior to the fix commit 0163b92946d0a7c816f619c57a4d9867954dd106
Discovery Timeline
- 2026-09-24 - CVE-2026-93233 published to NVD
- 2026-09-24 - Last updated in NVD database
Technical Details for CVE-2026-93233
Vulnerability Analysis
The vulnerability resides in the Nouveau DRM device memory subsystem, which manages device-private pages backing NVIDIA GPU memory. The subsystem tracks allocated device-private folios per chunk using a callocated counter. Large (compound) folios are counted as a single allocation when first allocated.
When the memory management core splits a large folio into smaller sub-folios, it invokes the driver's ->folio_split() callback once per new sub-folio. The Nouveau implementation, nouveau_dmem_folio_split(), updates per-folio metadata but does not increment chunk->callocated to reflect the newly tracked sub-folios.
Each resulting sub-folio is later released independently through nouveau_dmem_folio_free(), which decrements chunk->callocated once per free. One allocation increment is therefore matched by N decrements, leaving the counter short by N-1.
Root Cause
The root cause is an accounting asymmetry between allocation, split, and free paths. The allocation path increments once per compound folio. The free path decrements once per freed folio. The split path neglects to add the N-1 missing increments for the newly created sub-folios, breaking the invariant that allocations and frees must balance.
Attack Vector
This is a local kernel resource-accounting bug rather than a direct code-execution primitive. Triggering the condition requires workloads that allocate large device-private folios on Nouveau and cause them to be split by the mm core. On the first split/free cycle, WARN_ON(!chunk->callocated) fires and the unsigned counter wraps. The chunk can no longer be reclaimed, producing a persistent GPU memory leak and additional warnings at driver teardown in nouveau_dmem_fini().
The vulnerability manifests in the Nouveau DRM device memory split and free paths. See the upstream fix at Kernel Git Commit Details and the related Kernel Git Commit Overview for the full patch context.
Detection Methods for CVE-2026-93233
Indicators of Compromise
- Kernel log entries containing WARN_ON triggered inside nouveau_dmem_folio_free() referencing chunk->callocated.
- Warnings emitted by nouveau_dmem_fini() on module unload or driver teardown reporting leaked allocation counts.
- Progressive growth of unreleased Nouveau device-private memory chunks on hosts running GPU workloads that split large folios.
Detection Strategies
- Monitor dmesg and /var/log/kern.log for Nouveau DRM warnings referencing dmem, callocated, or folio accounting.
- Correlate GPU workload lifecycles with kernel warning timestamps to identify split-induced underflows.
- Track running kernel versions against the upstream fix commit to identify unpatched hosts.
Monitoring Recommendations
- Centralize kernel ring buffer logs from Linux hosts with NVIDIA GPUs using the Nouveau driver.
- Alert on repeated WARN_ON events originating from drivers/gpu/drm/nouveau/nouveau_dmem.c.
- Baseline Nouveau device-private memory usage over time to surface non-reclaimable chunks.
How to Mitigate CVE-2026-93233
Immediate Actions Required
- Identify Linux hosts running the Nouveau driver with device-private memory enabled and compare kernel versions against patched stable releases.
- Apply vendor-supplied kernel updates that include the upstream fix commit 0163b92946d0a7c816f619c57a4d9867954dd106.
- Reboot affected systems after patching to clear any already-leaked callocated state in the running kernel.
Patch Information
The upstream fix accounts for the new sub-folio inside nouveau_dmem_folio_split() under the same lock used by nouveau_dmem_folio_free(), keeping allocation and free counts balanced. Patch details are available in the Kernel Git Commit Details and Kernel Git Commit Overview. Distribution maintainers backport the fix into supported stable kernel branches.
Workarounds
- Switch affected GPU workloads to the proprietary NVIDIA driver stack where feasible until the kernel patch is deployed.
- Avoid workloads that allocate and subsequently split large device-private folios on Nouveau on unpatched kernels.
- Schedule periodic reboots on long-running Nouveau hosts to reset leaked callocated accounting until patches are applied.
# Verify running kernel version and Nouveau module status
uname -r
lsmod | grep nouveau
# Inspect kernel log for Nouveau dmem warnings
dmesg | grep -iE 'nouveau.*(dmem|callocated|WARNING)'
Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.
Sources: National Vulnerability Database, CISA KEV, Exploit-DB

