CVE-2026-90002
massUse-after-free race in Linux kernel ftrace trace-instance filter files
The Linux kernel's ftrace subsystem contains a use-after-free in the handling of per-instance set_ftrace_filter and set_ftrace_notrace files. When such a file is opened, the code dereferences an ftrace_ops pointer stored in the inode's private data to take a reference on the trace instance (trace_array); if an administrator removes the instance via rmdir during that window, the ftrace_ops may already have been freed, and touching it corrupts kernel memory and can crash the kernel. Triggering it requires local code execution and access to tracefs, plus a concurrent rmdir of a tracing instance while an instance filter file is opened — a narrow but scriptable race. On systems that grant low-privileged users access to tracefs, this is exploitable for denial of service (kernel crash) and, per the CVSS vector's high confidentiality/integrity/availability ratings, potentially for local privilege escalation. No public proof-of-concept is known and the flaw is not in the CISA KEV catalog, so exploitation has not been observed.
What to do: Patch kernels with the ftrace fix from the upstream commit (available via backports in distribution kernel updates; check your vendor's errata for CVE-2026-90002). As a mitigation, restrict /sys/kernel/tracing (tracefs) to root or fully trusted groups, and avoid concurrently removing trace instances while instance filter files are open. Verify exposure by checking whether tracefs is mounted and which users or groups have read/write access to it.
| Linux kernel (ftrace/tracefs subsystem, per-instance set_ftrace_filter and set_ftrace_notrace support) | — |
Order-of-magnitude estimate by the model from install counts, market share and public scan data it knows; verify before quoting.
In the Linux kernel, the following vulnerability has been resolved: ftrace: Take trace_array reference before accessing its ftrace_ops The trace instance files set_ftrace_filter and set_ftrace_notrace was updated to work with specific trace instances (trace_arrays). The issue is that when these files are opened, there is a small race window where it will use the ftrace_ops from the inode->private pointer to get a reference to the trace_array and then take its reference. The problem is that the ftrace_ops itself could be freed. If the rmdir on the instance happens at the same time the set_ftrace_filter file is opened, the rmdir could have also freed the ftrace_ops and referencing it will cause a use-after-free bug and crash the kernel. Instead, pass in the trace_array as the file private data (NULL for the top level instance), and then pass both the trace_array and the ftrace_ops to the ftrace_regex_open() function. If the trace_array is NULL, then it just uses the ftrace_ops without the need to take its reference (like normal). If the ftrace_ops is NULL, that is only the case for the top level instance and the global_ops can be used. This allows the trace_array to have its reference incremented before touching the ftrace_ops that could also be freed when the instance is.
- Vector
- CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
In the news0 stories
No ingested article mentions this CVE yet.