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

iio: event: Fix event FIFO reset race

`iio_event_getfd()` creates the event file descriptor with
`anon_inode_getfd()`, which allocates a new fd, creates the anonymous
file and installs it in the process fd table before returning to the
caller.

The IIO code resets the event FIFO after `anon_inode_getfd()` has returned,
but before `IIO_GET_EVENT_FD_IOCTL` has copied the fd number to userspace.
But since fd tables are shared between threads, another thread can guess
the newly allocated fd number and issue a `read()` on it as soon as the fd
has been installed.

This means the `kfifo_to_user()` in `iio_event_chrdev_read()` can run in
parallel with the `kfifo_reset_out()` in `iio_event_getfd()`.

The kfifo documentation says that `kfifo_reset_out()` is only safe when it
is called from the reader thread and there is only one concurrent reader.
Otherwise it is dangerous and must be handled in the same way as
`kfifo_reset()`.

If that happens, `kfifo_to_user()` can advance the FIFO `out` index based
on state from before the reset, after the reset has already moved the `out`
index to the current `in` index. That can leave the FIFO with an `out`
index past the `in` index. A later `read()` can then see an underflowed
FIFO length and copy more data than the event FIFO buffer contains. This
can result in an out-of-bounds read and leak adjacent kernel memory to
userspace.

Move the FIFO reset before `anon_inode_getfd()`. At that point the event fd is
marked busy, but the new fd has not been installed yet, so userspace cannot
access it while the FIFO is reset.
Published: 2026-07-25
Score: 7.1 High
EPSS: < 1% Very Low
KEV: No
Impact: n/a
Action: n/a
AI Analysis

Impact

A race condition in the Linux kernel's Industrial I/O (IIO) event handling path allows a user thread to obtain a newly allocated file descriptor before the FIFO is reset. While the FIFO reset occurs, another thread can read from the file descriptor. The read path may advance the FIFO pointer using stale state, potentially leaving the output index past the input index. Subsequent reads can therefore copy more data than the buffer holds, leading to an out‑of‑bounds read of kernel memory which is then exposed to user space. The vulnerability enables information disclosure of kernel contents, including potentially sensitive data.

Affected Systems

The flaw is present in all versions of the Linux kernel that include the IIO event driver prior to the commit that reordered the FIFO reset and the file descriptor allocation. These include the current stable releases as well as all upstream kernels that had not yet incorporated the patch. Because the affected code is part of the generic IIO subsystem, any system that exposes the IIO event device nodes (/dev/iio/eventX) to a user process is susceptible. No specific vendor product list beyond the Linux kernel is enumerated, so all distributions shipping the vulnerable kernel code are impacted.

Risk and Exploitability

The CVSS base score of 7.1 classifies it as high severity, while the EPSS score of <1% implies a very low predicted probability of exploitation. The flaw requires a local user to race against the kernel’s FIFO reset, which is generally only possible when the user can open and read the IIO event file. No active exploits have been disclosed and the issue is not listed in CISA’s KEV catalog, suggesting limited threat activity. Nonetheless, systems that expose the IIO event interface to untrusted users or invite local users with elevated privileges face elevated risk; patching promptly mitigates any potential memory disclosure.

Generated by OpenCVE AI on August 3, 2026 at 18:28 UTC.

Remediation

No vendor fix or workaround currently provided.

OpenCVE Recommended Actions

  • Apply the latest Linux kernel release that contains the commit moving the FIFO reset before anon_inode_getfd in the IIO event handling code.
  • Restrict access to the IIO event device nodes (e.g., /dev/iio/eventX) by setting appropriate file permissions or enforcing SELinux/AppArmor rules so that only trusted users or processes can open the devices.
  • Configure kernel audit or trace logging to detect anomalous read attempts on the IIO event devices, and investigate any such events promptly.

Generated by OpenCVE AI on August 3, 2026 at 18:28 UTC.

Tracking

Sign in to view the affected projects.

Advisories
Source ID Title
Debian DLA Debian DLA DLA-4717-1 linux security update
Debian DLA Debian DLA DLA-4720-1 linux security update
Debian DLA Debian DLA DLA-4723-1 linux-6.1 security update
Debian DLA Debian DLA DLA-4724-1 linux-6.12 new package
History

Wed, 29 Jul 2026 12:15:00 +0000


Mon, 27 Jul 2026 05:15:00 +0000

Type Values Removed Values Added
Metrics cvssV3_1

{'score': 7.1, 'vector': 'CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:H'}


Sun, 26 Jul 2026 01:15:00 +0000

Type Values Removed Values Added
Weaknesses CWE-125

Sat, 25 Jul 2026 09:30:00 +0000

Type Values Removed Values Added
Description In the Linux kernel, the following vulnerability has been resolved: iio: event: Fix event FIFO reset race `iio_event_getfd()` creates the event file descriptor with `anon_inode_getfd()`, which allocates a new fd, creates the anonymous file and installs it in the process fd table before returning to the caller. The IIO code resets the event FIFO after `anon_inode_getfd()` has returned, but before `IIO_GET_EVENT_FD_IOCTL` has copied the fd number to userspace. But since fd tables are shared between threads, another thread can guess the newly allocated fd number and issue a `read()` on it as soon as the fd has been installed. This means the `kfifo_to_user()` in `iio_event_chrdev_read()` can run in parallel with the `kfifo_reset_out()` in `iio_event_getfd()`. The kfifo documentation says that `kfifo_reset_out()` is only safe when it is called from the reader thread and there is only one concurrent reader. Otherwise it is dangerous and must be handled in the same way as `kfifo_reset()`. If that happens, `kfifo_to_user()` can advance the FIFO `out` index based on state from before the reset, after the reset has already moved the `out` index to the current `in` index. That can leave the FIFO with an `out` index past the `in` index. A later `read()` can then see an underflowed FIFO length and copy more data than the event FIFO buffer contains. This can result in an out-of-bounds read and leak adjacent kernel memory to userspace. Move the FIFO reset before `anon_inode_getfd()`. At that point the event fd is marked busy, but the new fd has not been installed yet, so userspace cannot access it while the FIFO is reset.
Title iio: event: Fix event FIFO reset race
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-08-05T12:42:28.071Z

Reserved: 2026-07-19T15:36:31.792Z

Link: CVE-2026-64496

cve-icon Vulnrichment

No data.

cve-icon NVD

Status : Received

Published: 2026-07-25T10:17:35.490

Modified: 2026-07-27T05:16:54.923

Link: CVE-2026-64496

cve-icon Redhat

Severity : Moderate

Publid Date: 2026-07-25T00:00:00Z

Links: CVE-2026-64496 - Bugzilla

cve-icon OpenCVE Enrichment

Updated: 2026-08-03T18:30:06Z

Weaknesses