Direct naar de inhoud
⚡ Kritieke cyberalerts voor jouw sector & systemen — direct in je inbox. Aanmelden →
cybernieuws.nl Cybersecurity en informatiebeveiling nieuws alerts live · 2 min 123 bronnen 1 kritiek 8 vandaag
CVE's Videos Dagbriefing

← Terug naar CVE-database

CVE-2026-74568

NONE Gepubliceerd:

Beschrijving NL

In de Linux kernel is de volgende kwetsbaarheid verholpen:

KVM: arm64: vgic: Race repareren tussen LPI-release en herregistratie

Bevestig een potentiële race tussen het verlagen van een LPI's referentietelling en
die structuur uit de LPI-röntgenfoto te halen. LPI-structuren worden gehandhaafd in de VGIC LPI xarray (dist->lpi_xa). Wanneer de referentietelling van een LPI-structuur tot nul daalt,
vgic_release_lpi_locked() verwijdert de structuur uit de röntgen en
bevrijdt het onder het röntgenslot. De vrijgave van een LPI kan echter met een gelijktijdige LPI racen
herregistratie met dezelfde INTID via vgic_add_lpi() op een andere CPU,
aangezien de daling van de referentietelling en de ontruiming van de röntgenstraling niet worden uitgevoerd
in een enkele atomaire stap. Dit kan bijvoorbeeld gebeuren als de gast een
VERWIJDEREN terwijl er nog steeds naar de LPI wordt verwezen vanuit de actieve in afwachting van een vCPU
list (ap_list), en dezelfde INTID wordt opnieuw in kaart gebracht via MAPTI. Met name vgic_release_lpi_locked() wordt aangeroepen vanuit twee verschillende
paden: directe vrijgave via vgic_put_irq(), en uitgestelde vrijgave via
vgic_release_deleted_lpis(). Tijdens directe vrijgave kan het probleem het gevolg zijn
bij het verwijderen van een nieuw geregistreerde LPI uit de xarray:

CPU0 (LPI vrijgeven) CPU1 (Nieuwe LPI toevoegen)
==================== =====================
vgic_put_irq()
__vgic_put_irq()
refcount_dec_AND_test()
vgic_add_lpi()
xa_lock_irqsave()
old_irq = xa_l oad(.., intid)
vgic_try_get_irq_ref(old_irq) == false
nieuwe IRQ ingevoegd --> __xa_store(.., intid, ..)
xa_unlock_irqrestore()
xa_lock_irqsave();
vgic_release_lpi_locked()
__xa_erase(.., irq->intid) pending_release = true
vgic_add_lpi()
xa_lock_irqsave() old_irq = xa_load(.., intid)
vgic_try_get_irq_ref(oldirq) == false
BUG: oude IRQ overschreven --> __xa_store(.., intid, ..)
xa_unlock_irqrestore()

vgic_release_deleted_lpis()
xa_lock_irqsave()
xa_for_each() { .. } <-- oude IRQ met pending_release = true
is verdwenen, dus het kan niet worden vrijgegeven

Om het directe vrijgavepad vast te stellen, verplaatst u de referentietelling naar binnen
de xarray-vergrendeling, zodat vgic_add_lpi() nooit de
to-be-released LPI. In het uitgestelde vrijgavepad moet de refcount-daling plaatsvinden onder een ruwe
spinlock, zodat het röntgenslot niet kan worden vastgepakt, en dezelfde oplossing
werkt niet. Werk in plaats daarvan vgic_add_lpi() bij, zodat het
een LPI van de xarray, neemt het de verantwoordelijkheid op zich om het te bevrijden. Bijgevolg kan een LPI nu gelijktijdig worden vrijgegeven na een uitgestelde
release laat de refcount vallen, dus toegang tot het veld pending_release is nee
langer veilig voor gebruik-na-vrij. Verwijder alle toepassingen van de vlag en werk bij
vgic_release_deleted_lpis () om verweesde LPI's te identificeren puur op basis van
hun refcount.

Origineel (Engels) tonen

In the Linux kernel, the following vulnerability has been resolved:

KVM: arm64: vgic: Fix race between LPI release and re-registration

Fix a potential race between decrementing an LPI's reference count and
evicting that structure from the LPI xarray.

LPI structures are maintained in the VGIC LPI xarray (dist->lpi_xa).
When the reference count of an LPI structure drops to zero,
vgic_release_lpi_locked() removes the structure from the xarray and
frees it under the xarray lock.

However, the release of an LPI can race with a concurrent LPI
re-registration with the same INTID via vgic_add_lpi() on another CPU,
since the reference count drop and the xarray eviction are not performed
in a single atomic step. This can happen e.g. if the guest issues a
DISCARD while the LPI is still referenced from a vCPU's active-pending
list (ap_list), and the same INTID is re-mapped via MAPTI.

Particularly, vgic_release_lpi_locked() is called from two distinct
paths: direct release via vgic_put_irq(), and deferred release via
vgic_release_deleted_lpis(). During direct release, the issue can result
in deleting a newly registered LPI from the xarray:

CPU0 (Releasing LPI) CPU1 (Adding new LPI)
==================== =====================
vgic_put_irq()
__vgic_put_irq()
refcount_dec_and_test()
vgic_add_lpi()
xa_lock_irqsave()
old_irq = xa_load(.., intid)
vgic_try_get_irq_ref(old_irq) == false
new IRQ inserted --> __xa_store(.., intid, ..)
xa_unlock_irqrestore()
xa_lock_irqsave();
vgic_release_lpi_locked()
__xa_erase(.., irq->intid) pending_release = true
vgic_add_lpi()
xa_lock_irqsave()
old_irq = xa_load(.., intid)
vgic_try_get_irq_ref(oldirq) == false
BUG: old IRQ overwritten --> __xa_store(.., intid, ..)
xa_unlock_irqrestore()

vgic_release_deleted_lpis()
xa_lock_irqsave()
xa_for_each() { .. } <-- old IRQ with pending_release = true
is gone, so it cannot be released

To fix the direct release path, move the reference count drop inside
the xarray lock, making sure that vgic_add_lpi() never encounters the
to-be-released LPI.

In the deferred release path, the refcount drop must happen under a raw
spinlock, so the xarray lock cannot be grabbed, and the same solution
does not work. Instead, update vgic_add_lpi(), so that if it evicts
an LPI from the xarray, it takes on the responsibility of freeing it.
Consequently, an LPI may now be freed concurrently after a deferred
release drops the refcount, so accessing the pending_release field is no
longer safe from use-after-free. Delete all uses of the flag, and update
vgic_release_deleted_lpis() to identify orphaned LPIs purely based on
their refcount.

References