Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDrive sustained Tx load on ice NIC
-
DeliveryDriver writes doorbell via writel_relaxed on arm64
-
ExploitDQL num_queued update not yet globally visible
-
ExecutionNIC completes descriptors, dql_completed sees invalid count
-
ImpactBUG_ON panics kernel (DoS)
Vulnerability Assessment
| Exploitation Conditions | Exploitation (a kernel panic/DoS) requires all of: an arm64 machine (the writel_relaxed() ordering weakness does not affect architectures where relaxed writes are already ordered relative to MMIO), the ice driver bound to an Intel E810/E830-class NIC, a kernel containing commit ccde82e90946 ('ice: add E830 Earliest TxTime First Offload support') - i.e. 6.18 and the affected stable backports before the fix - and sustained Tx network load sufficient to hit the race window between the DQL accounting write and the doorbell MMIO write. Limiting factors: there is no attacker-controlled crafted input; the condition is a timing race observed only under heavy load, it is architecture-specific to arm64, and it is confined to the ice driver code path, so non-arm64 systems and non-ice NICs are unaffected. Updating to a fixed kernel is the remedy stated in the sources. |
| Impact | The CVSS 3.1 base score of 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) frames this as a network-reachable, low-complexity, unauthenticated availability issue, but that framing overstates attacker control. The description makes clear this is a CPU/MMIO memory-ordering race on arm64: the ice driver's Tx doorbell was changed to writel_relaxed() (by commit ccde82e90946), which on arm64 does not order the normal-memory DQL accounting write (dql->num_queued) before the MMIO doorbell write, so dql_completed() can observe more bytes completed than queued and hit BUG_ON at lib/dynamic_queue_limits.c:99, panicking the kernel. There is no crafted packet or attacker input that deterministically triggers this - it manifests under sustained legitimate network load, so AV:N/AC:L is a poor fit and the realistic complexity is high and platform-dependent. Supporting signals point to low real-world urgency: EPSS is 0.21% (10th percentile), the CVE is not in CISA KEV, and no exploit/PoC reference is present (the three git.kernel.org links are the fix commits, not exploit code). The vendor priority label is 'this_week' and a patch is available. Net: a genuine availability/stability regression worth patching on affected arm64 fleets, but not an actively exploited or weaponizable remote DoS; treat as a reliability fix rather than an emergency. Key caveat to verify: the CVSS network vector conflicts with the description's load-induced, non-attacker-controlled race - the A:H impact is real but the exploitability metrics are not. |
| Exploit ScenarioDerived | An arm64 server using the Intel E810-XXV NIC with the ice driver runs under sustained network load; the relaxed doorbell write lets the NIC begin transmitting and complete descriptors before the DQL byte-accounting update becomes globally visible, so dql_completed() sees an impossible state and the BUG_ON panics the kernel, causing a denial of service. No attacker-crafted input is required - heavy legitimate traffic reproduces it reliably per the reporter. No public exploit identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 24, 2026
Kernel panic and denial of service can affect arm64 Linux systems using the ice driver with Intel E810/E830-class NICs under sustained transmit load, where relaxed MMIO doorbell writes may be reordered before the DQL byte-accounting update and trip a BUG_ON in dql_completed(). The assessed severity is CVSS 3.1 7.5 with AC:H, reflecting that this is a timing race requiring a specific architecture, driver, NIC and heavy Tx traffic rather than attacker-controlled input; EPSS is 0.21% (10th percentile) and no public exploit was identified at time of analysis. Fixed kernels are available (6.18.57, 7.2.11 and 7.3), and the priority label is this_week.
RemediationAI
Update to a fixed kernel release: Linux 6.18.57, 7.2.11, or 7.3, each containing the corresponding stable fix commit (b7725acf9c574debb97ae1613569ac9e148438be, f94ab1fffd009250d72c6dc1662cb84467ac5365, or 7a579dec8423bba7bec96fcfcb2e30838b0858ee). The sources state that updating to a fixed kernel is the remedy; no separate workaround is documented in the supplied references. Advisory links: https://git.kernel.org/stable/c/b7725acf9c574debb97ae1613569ac9e148438be, https://git.kernel.org/stable/c/f94ab1fffd009250d72c6dc1662cb84467ac5365, https://git.kernel.org/stable/c/7a579dec8423bba7bec96fcfcb2e30838b0858ee, and https://nvd.nist.gov/vuln/detail/CVE-2026-98965.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The ice driver Tx path updates dql->num_queued through __netdev_tx_sent_queue() and then rings the hardware queue tail doorbell so the NIC can begin transmitting descriptors. Commit ccde82e90946 ('ice: add E830 Earliest TxTime First Offload support') changed the doorbell notification from writel() to writel_relaxed(); on arm64, writel_relaxed() does not guarantee the same ordering between normal-memory writes and MMIO writes as writel(), so the NIC can observe the doorbell before the DQL accounting update is globally visible. If the NIC completes transmission before dql_completed() observes the update, dynamic queue limits detects more completed bytes than queued bytes and the BUG_ON at lib/dynamic_queue_limits.c:99 fires, producing a kernel panic. The trigger is a timing race under sustained network load on arm64 with an Intel E810-XXV or E830-class controller; there is no attacker-controlled crafted input, and non-arm64 systems or non-ice NICs are unaffected. CPE data identifies linux:linux, and no CWE is assigned in the supplied data.
Know when Intel gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Triggered only by a timing race under sustained load on arm64 with specific NICs and no attacker-controlled input, so AC:H; impact is availability-only (kernel panic), hence C:N/I:N/A:H.
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
4DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
ice: Restore Ordered MMIO Writes for Tx Doorbells
The DQL accounting state which tracks the number of bytes queued for the NIC to transmit, namely dql->num_queued, is updated by the ICE driver when it invokes __netdev_tx_sent_queue(). Subsequently the driver updates the hardware queue tail allowing the NIC to begin processing the work queue. The queue accounting update should be ordered before the NIC begins transmitting descriptors.
The transmit path currently updates the hardware doorbell using writel_relaxed(), which (on arm64) does not provide the same ordering guarantees between writes to normal memory and writes to MMIO registers that writel() does. This introduces a potential race where the NIC begins transmitting descriptors before the dql->num_queued update is globally visible. If the NIC finishes before the update is observed by dql_completed(), it detects an invalid state where more bytes have been completed than have been queued. When this happens the following BUG_ON is triggered.
BUG_ON(count > num_queued - dql->num_completed);
This has been observed and manifests as the following crash (note that the trace has been trimmed) in an environment with sustained network load that uses an Intel Corporation Ethernet Controller E810-XXV for SFP (rev 02) on an arm64 machine. Replacing writel_relaxed() with writel() in a test kernel eliminated the crash in the user's workload, which previously reproduced the issue reliably.
kernel BUG at lib/dynamic_queue_limits.c:99
Internal error: Oops - BUG: 00000000f2000800 [#1] SMP pc : dql_completed+0x268/0x2a0 lr : ice_clean_tx_irq+0x1d4/0x620 [ice] Call trace: dql_completed+0x268/0x2a0 (P) ice_napi_poll+0x94/0x520 [ice] __napi_poll+0x48/0x3f0 net_rx_action+0x194/0x420
This restores the behaviour prior to commit ccde82e90946 ("ice: add E830 Earliest TxTime First Offload support"), which changed the notification mechanism from writel() to writel_relaxed().
Executive ViewAI
A high-severity kernel vulnerability (CVE-2026-98965) can cause kernel panics and denial of service on arm64 Linux systems equipped with Intel E810/E830 network cards when handling sustained transmit loads. Production services relying on these systems may experience unplanned outages, impacting availability and operational continuity. Leadership should prioritize patching because while exploitation requires specific conditions, the business impact of service disruptions can be significant.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Apache Log4j2 contains a critical JNDI injection vulnerability known as 'Log4Shell' that allows unauthenticated remote c
An unprivileged network attacker could gain system privileges to provisioned Intel manageability SKUs: Intel Active Mana
Stack-based buffer overflow in the unique_service_name function in ssdp/ssdp_server.c in the SSDP parser in the portable
The x86-64 kernel system-call functionality in Xen 4.1.2 and earlier, as used in Citrix XenServer 6.0.2 and earlier and
Stack-based buffer overflow in the unique_service_name function in ssdp/ssdp_server.c in the SSDP parser in the portable
Stack-based buffer overflow in the unique_service_name function in ssdp/ssdp_server.c in the SSDP parser in the portable
Stack-based buffer overflow in the unique_service_name function in ssdp/ssdp_server.c in the SSDP parser in the portable
Stack-based buffer overflow in the unique_service_name function in ssdp/ssdp_server.c in the SSDP parser in the portable
Systems with microprocessors utilizing speculative execution and branch prediction may allow unauthorized disclosure of
Stack-based buffer overflow in the unique_service_name function in ssdp/ssdp_server.c in the SSDP parser in the portable
Stack-based buffer overflow in the unique_service_name function in ssdp/ssdp_server.c in the SSDP parser in the portable
Stack-based buffer overflow in the unique_service_name function in ssdp/ssdp_server.c in the SSDP parser in the portable
EUVD-2026-108759
GHSA-272r-g6c6-94w3
NVD
CVE.org
EPSS
Exploit-DB