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

fuse: publish io-uring queues with release semantics

fuse_uring_create_queue() initializes a fuse_ring_queue and then
publishes the pointer into ring->queues[qid] with WRITE_ONCE() under the
fch->lock. There are several readers that may concurrently be fetching
that pointer locklessly and then deferencing it.

WRITE_ONCE() doesn't ensure ordering of the queue's field
initialization before the ring->queues[qid] pointer assignment. The
queue must be published with smp_store_release() so the field
initialization is guaranteed to happen before.

Readers in paths where the read may happen concurrently with the store
need to use READ_ONCE() because any race involving a plain access is
undefined.
Published: 2026-09-04
Score: n/a
EPSS: < 1% Very Low
KEV: No
Impact: Potential kernel crash or memory corruption due to an unsynchronised race condition in the FUSE io-uring queue publishing logic
Action: Immediate Patch
AI Analysis

Impact

The vulnerability is a data race caused by using WRITE_ONCE instead of a proper release store (smp_store_release) when publishing a fuse_ring_queue pointer. The publication occurs while other readers may locklessly fetch and dereference the pointer before the queue’s fields are fully initialised, leading to undefined behaviour, including possible kernel memory corruption or a panic. This race can break kernel stability and potentially expose sensitive kernel data if an attacker can read or influence the incorrectly initialised structure.

Affected Systems

The flaw resides in the Linux kernel, affecting all builds that include the FUSE io‑uring code path. The specific kernel versions impacted are not enumerated in the advisory, so any system running a kernel with this FUSE implementation is potentially vulnerable until the patch is applied.

Risk and Exploitability

The CVSS and EPSS metrics are not provided, and the vulnerability is not listed in CISA’s KEV catalog, indicating that it has not been confirmed as actively exploited. However, because the race occurs in kernel mode and requires concurrent access to the FUSE io‑uring queues, exploitation would generally need local privileged access to a FUSE mount. The absence of a documented exploit limits the immediate threat level, but a local attacker could induce a crash or leverage the race to gain higher privileges if coupled with additional vulnerabilities. The attack would most likely be executed by mounting a vulnerable FUSE filesystem and performing concurrent operations that trigger the unsynchronised read.

Generated by OpenCVE AI on September 4, 2026 at 19:17 UTC.

Remediation

No vendor fix or workaround currently provided.

OpenCVE Recommended Actions

  • Apply the latest Linux kernel update that includes the fix for the FUSE io‑uring race condition
  • If the system cannot be immediately updated, isolate or restrict FUSE mounts to trusted users only and avoid exposing untrusted FUSE filesystems from unprivileged accounts
  • As a temporary measure, disable the io‑uring feature for FUSE by setting a module parameter or rebuilding the kernel with io‑uring support for FUSE disabled if the patch is not yet available

Generated by OpenCVE AI on September 4, 2026 at 19:17 UTC.

Tracking

Sign in to view the affected projects.

Advisories

No advisories yet.

History

Fri, 11 Sep 2026 10:15:00 +0000


Fri, 04 Sep 2026 19:45:00 +0000

Type Values Removed Values Added
Weaknesses CWE-362
CWE-758

Fri, 04 Sep 2026 16:00:00 +0000

Type Values Removed Values Added
Description In the Linux kernel, the following vulnerability has been resolved: fuse: publish io-uring queues with release semantics fuse_uring_create_queue() initializes a fuse_ring_queue and then publishes the pointer into ring->queues[qid] with WRITE_ONCE() under the fch->lock. There are several readers that may concurrently be fetching that pointer locklessly and then deferencing it. WRITE_ONCE() doesn't ensure ordering of the queue's field initialization before the ring->queues[qid] pointer assignment. The queue must be published with smp_store_release() so the field initialization is guaranteed to happen before. Readers in paths where the read may happen concurrently with the store need to use READ_ONCE() because any race involving a plain access is undefined.
Title fuse: publish io-uring queues with release semantics
First Time appeared Linux
Linux linux Kernel
CPEs cpe:2.3:o:linux:linux_kernel:*:*:*:*:*:*:*:*
Vendors & Products Linux
Linux linux Kernel
References

Subscriptions

Linux Linux Kernel
cve-icon MITRE

Status: PUBLISHED

Assigner: Linux

Published:

Updated: 2026-09-11T09:57:11.882Z

Reserved: 2026-08-26T14:34:25.797Z

Link: CVE-2026-80858

cve-icon Vulnrichment

No data.

cve-icon NVD

Status : Received

Published: 2026-09-04T16:18:14.940

Modified: 2026-09-11T10:16:51.933

Link: CVE-2026-80858

cve-icon Redhat

No data.

cve-icon OpenCVE Enrichment

Updated: 2026-09-05T01:15:14Z

Weaknesses
  • CWE-362

    Concurrent Execution using Shared Resource with Improper Synchronization ('Race Condition')

  • CWE-758

    Reliance on Undefined, Unspecified, or Implementation-Defined Behavior