CVE-2026-98070
CVE-2026-98070 is a high-severity vulnerability in Linux Linux Kernel with a CVSS 3.x base score of 8.1. It is not currently listed as actively exploited by CISA, and its EPSS exploit-prediction score is low. The underlying weakness is classified as CWE-667.
Key facts
- Severity: High (CVSS 3.x base score 8.1)
- EPSS exploit prediction: 0% (31st percentile)
- Actively exploited: Not listed in CISA KEV
- Weakness: CWE-667
- Affected product: Linux Linux Kernel
- Published:
- Last modified:
Description
In the Linux kernel, the following vulnerability has been resolved: net/rds: acquire RDS_IN_XMIT in rds_tcp_reset_callbacks() rds_tcp_reset_callbacks() quiesces the transmit path by setting the path state to RDS_CONN_RESETTING and then waiting for RDS_IN_XMIT to be sampled clear before swapping the underlying socket and calling rds_send_path_reset(). Sampling the bit clear is not the same as owning it: rds_send_xmit() can re-acquire RDS_IN_XMIT right after the wait_event() returns. Its state recheck after taking the lock is a store-buffering pattern (the resetter writes the state and reads the bit, the sender writes the bit and reads the state) and acquire_in_xmit() is only an acquire operation, so on weakly ordered architectures both sides can miss each other's write and the transmit path then runs concurrently with rds_send_path_reset() rewriting cp_xmit_* state - which is exactly what the comment above rds_send_path_reset() tells its callers to prevent. Take the lock instead, hold it across the socket swap and rds_send_path_reset(), and release it with a wake-up at the end. The lock-ordering constraint documented above the wait still holds: the lock is acquired before lock_sock(), so a sender inside tcp_sendmsg() can never be waited on while we hold the socket lock. Two details of the old code go away with the same change: - t_sock is now read only after the lock is acquired. The old code cached it before waiting; the teardown in rds_conn_shutdown() releases that socket and clears t_sock, so a pointer cached before the wait can be stale by the time the accept path resumes. Reading it under RDS_IN_XMIT is what makes the exclusion complete once the teardown owns the same lock, which the next patch arranges; until then the teardown still only samples the bit, and the two paths remain as exposed to each other as they are today. - The old !osock early path called rds_send_path_reset() with no serialization at all. It now runs under the lock like the normal path. The conditional RDS_CONN_RESETTING transition of the previous patch happens before the socket check either way: a path found without a socket is either still connecting (its reconnect worker blocked on t_conn_path_lock) and legitimately goes RESETTING -> UP on the new socket, or it has been torn down meanwhile and is dropped. The in-function comment describing the old wait-based quiesce is rewritten to describe the lock-based one, and the stale block comment above the function (which still described a return value and an incomplete list of t_sock writers) is refreshed to name all four writers - the connect, accept, teardown and swap paths - and what serializes each of them.
Frequently asked questions
- What is CVE-2026-98070?
- In the Linux kernel, the following vulnerability has been resolved: net/rds: acquire RDS_IN_XMIT in rds_tcp_reset_callbacks() rds_tcp_reset_callbacks() quiesces the transmit path by setting the path state to RDS_CONN_RESETTING and then waiting for RDS_IN_XMIT to be sampled clear before swapping the underlying socket and calling rds_send_path_reset(). Sampling the bit clear is not the same as owning it: rds_send_xmit() can re-acquire RDS_IN_XMIT right after the wait_event() returns. Its state recheck after taking the lock is a store-buffering pattern (the resetter writes the state and reads the bit, the sender writes the bit and reads the state) and acquire_in_xmit() is only an acquire operation, so on weakly ordered architectures both sides can miss each other's write and the transmit path then runs concurrently with rds_send_path_reset() rewriting cp_xmit_* state - which is exactly what the comment above rds_send_path_reset() tells its callers to prevent. Take the lock instead, hold it across the socket swap and rds_send_path_reset(), and release it with a wake-up at the end. The lock-ordering constraint documented above the wait still holds: the lock is acquired before lock_sock(), so a sender inside tcp_sendmsg() can never be waited on while we hold the socket lock. Two details of the old code go away with the same change: - t_sock is now read only after the lock is acquired. The old code cached it before waiting; the teardown in rds_conn_shutdown() releases that socket and clears t_sock, so a pointer cached before the wait can be stale by the time the accept path resumes. Reading it under RDS_IN_XMIT is what makes the exclusion complete once the teardown owns the same lock, which the next patch arranges; until then the teardown still only samples the bit, and the two paths remain as exposed to each other as they are today. - The old !osock early path called rds_send_path_reset() with no serialization at all. It now runs under the lock like the normal path. The conditional RDS_CONN_RESETTING transition of the previous patch happens before the socket check either way: a path found without a socket is either still connecting (its reconnect worker blocked on t_conn_path_lock) and legitimately goes RESETTING -> UP on the new socket, or it has been torn down meanwhile and is dropped. The in-function comment describing the old wait-based quiesce is rewritten to describe the lock-based one, and the stale block comment above the function (which still described a return value and an incomplete list of t_sock writers) is refreshed to name all four writers - the connect, accept, teardown and swap paths - and what serializes each of them.
- How severe is CVE-2026-98070?
- CVE-2026-98070 has a CVSS 3.x base score of 8.1, rated high severity. It is exploitable over network with high attack complexity, requires no privileges and no user interaction. Impact on confidentiality is high, integrity high, and availability high.
- Is CVE-2026-98070 being actively exploited?
- It is not currently listed in CISA's KEV catalog. Its EPSS exploit-prediction score is 0% (31st percentile), an estimate of the probability of exploitation in the next 30 days.
- What products are affected by CVE-2026-98070?
- CVE-2026-98070 primarily affects Linux Linux Kernel. In total, 8 product configurations (CPEs) are listed as vulnerable; see the affected-products list for the exact versions.
- How do I fix CVE-2026-98070?
- Review the linked vendor and NVD advisories for patched versions and mitigations, then upgrade or apply the recommended workaround. Given its high severity, prioritise patching exposed systems.
- When was CVE-2026-98070 published?
- CVE-2026-98070 was published on 2026-09-25 and last updated on 2026-11-18.
References
- https://git.kernel.org/stable/c/02c5f9dc2efd823e061954d564ce00bacd1bebeb
- https://git.kernel.org/stable/c/062d9e008c67289e8e1b221ecdd8f9d60566d012
- https://git.kernel.org/stable/c/670af4e4a4de5e6bb5daee3838485571a0caa5fa
- https://git.kernel.org/stable/c/830a2e21b200c6b6fdccc63dd3f23932bf7a894b
- https://git.kernel.org/stable/c/8e4c3b7844c906c7097b4cfedd9dd1f48c9a6a92
- https://git.kernel.org/stable/c/a05790cb4ff03f797d76906990b148d83f63e7a3
- https://git.kernel.org/stable/c/d184e6dd4b8f3c20c018595fd09795a66b46c8ef
- https://git.kernel.org/stable/c/d625112564c3e980e02504270222b49b82690cee
Affected products (8)
- cpe:2.3:o:linux:linux_kernel:*:*:*:*:*:*:*:*
- cpe:2.3:o:linux:linux_kernel:4.7:-:*:*:*:*:*:*
- cpe:2.3:o:linux:linux_kernel:4.7:rc3:*:*:*:*:*:*
- cpe:2.3:o:linux:linux_kernel:4.7:rc4:*:*:*:*:*:*
- cpe:2.3:o:linux:linux_kernel:4.7:rc5:*:*:*:*:*:*
- cpe:2.3:o:linux:linux_kernel:4.7:rc6:*:*:*:*:*:*
- cpe:2.3:o:linux:linux_kernel:4.7:rc7:*:*:*:*:*:*
- cpe:2.3:o:linux:linux_kernel:7.3:rc1:*:*:*:*:*:*
More vulnerabilities in Linux Linux Kernel
- CVE-2026-63795 — Critical (CVSS 10.0): In the Linux kernel, the following vulnerability has been resolved: 9p: avoid putting oldfid in p9_client_walk() error…
- CVE-2025-38429 — Critical (CVSS 10.0): In the Linux kernel, the following vulnerability has been resolved: bus: mhi: ep: Update read pointer only after…
- CVE-2025-22021 — Critical (CVSS 10.0): In the Linux kernel, the following vulnerability has been resolved: netfilter: socket: Lookup orig tuple for IPv6…
- CVE-2025-21663 — Critical (CVSS 10.0): In the Linux kernel, the following vulnerability has been resolved: net: stmmac: dwmac-tegra: Read iommu stream id…
- CVE-2024-56719 — Critical (CVSS 10.0): In the Linux kernel, the following vulnerability has been resolved: net: stmmac: fix TSO DMA API usage causing…
- CVE-2024-44984 — Critical (CVSS 10.0): In the Linux kernel, the following vulnerability has been resolved: bnxt_en: Fix double DMA unmapping for…
All CVEs affecting Linux Linux Kernel →
Other CWE-667 (Improper Locking) vulnerabilities
- CVE-2026-64534 — Critical (CVSS 9.8): In the Linux kernel, the following vulnerability has been resolved: nvmet-tcp: check INIT_FAILED before…
- CVE-2026-64232 — Critical (CVSS 9.8): In the Linux kernel, the following vulnerability has been resolved: block: recompute nr_integrity_segments in…
- CVE-2026-64068 — Critical (CVSS 9.8): In the Linux kernel, the following vulnerability has been resolved: netfs: Fix missing locking around retry adding new…
- CVE-2026-64067 — Critical (CVSS 9.8): In the Linux kernel, the following vulnerability has been resolved: netfs: Fix missing barriers when accessing…
- CVE-2026-53049 — Critical (CVSS 9.8): In the Linux kernel, the following vulnerability has been resolved: gfs2: add some missing log locking Function…
- CVE-2025-22077 — Critical (CVSS 9.8): In the Linux kernel, the following vulnerability has been resolved: Revert "smb: client: fix TCP timers deadlock after…