CVE-2026-99236 covers how the kernel parses an incomplete event filter: a tracing filter string that ends after a logical operator. Kernels from 4.17 onwards are affected, and each of the eight stable series listed on kernel.org now has a fixed release. On an unfixed kernel the filter parser reads one entry before the start of an array it has just allocated.
CVE-2026-99236 was published on 2 November 2026 by the Linux kernel CNA for the trace event filter parser, kernel/trace/trace_events_filter.c. It describes what happens when the parser receives an incomplete event filter, that is, an expression that ends after && or ||. Three questions decide whether it matters to your product: is your kernel between 4.17 and the fixed release of its series, does your image build event tracing and perf events, and can code that you do not control run on the device. The bug class is one that any driver author can write: a value that means “not yet resolved” is used as an array index, and the check that would reject it runs after the first use.
- Component:
kernel/trace/trace_events_filter.c, functionpredicate_parse(); built byCONFIG_EVENT_TRACING. The perf entry point also needsCONFIG_PERF_EVENTS. - Introduced in: mainline 4.17, by commit 80765597bc58 (“tracing: Rewrite filter logic to be simpler and faster”).
- Fixed in: mainline 7.4-rc1 (commit 1fdc4164e488) and stable 5.10.273, 5.15.224, 6.1.191, 6.6.161, 6.12.115, 6.18.60, 7.2.14 and 7.3.1. Unmaintained series from 4.17 onwards, such as 4.19, 5.4, 7.0 and 7.1, have no fix.
- Not affected: kernels older than 4.17.
- Severity: CVSS v3.1 base score 7.8, HIGH, vector
CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, assigned by the Linux kernel CNA. NVD has not published its own analysis; on 20 November 2026 it shows the record as “Received” and carries only the CNA score. - Reached by: a local user who sets a filter on a perf tracepoint event that the same process opened, with the
PERF_EVENT_IOC_SET_FILTERioctl. - Effect: an out-of-bounds read one entry before a heap array; the value read can become a branch target in the compiled filter.
- Exploitation: not listed in the CISA Known Exploited Vulnerabilities catalogue (version 2026.11.18, checked on 20 November 2026).
What the code does
A trace event can carry a filter, a boolean expression over its fields; events that do not match are discarded. A filter is set by writing to the filter file of an event in tracefs, or with the PERF_EVENT_IOC_SET_FILTER ioctl on a perf tracepoint event, which enters through ftrace_profile_set_filter(). Both reach predicate_parse().
predicate_parse() compiles the string into an array of struct prog_entry. Each entry holds one predicate, a target index and a when_to_branch flag. filter_match_preds() evaluates the predicate of the current entry and, if the result equals when_to_branch, continues at index target.
The function works in three passes. In the first, each predicate receives an entry whose target is set provisionally to the previous index, so the first entry starts with a target of -1, which the comment in the source calls undefined. After each predicate an inner loop reads the next token and calls update_preds() to replace provisional targets with real ones. The second pass shortens chains of branches, and the third checks that every target points forward.
The bug: an incomplete event filter leaves a target unresolved
The first pass has two ways to finish, and only one resolves the pending operators. At the end of the string, the inner loop calls update_preds() for any pending operator and jumps to the label out. When it reads && or ||, it only records the operator in a flag and returns to the outer loop, which expects another predicate.
With an incomplete event filter the string ends at that point. The outer loop condition, while (*ptr), is false, and execution reaches the same label with the operator not processed.
Before the fix, the code after out checked only that the parentheses balance and that at least one predicate was parsed. Both checks pass, so the function runs the second pass. This is that pass in the 7.3 source:
/* Second Pass */
for (i = N-1 ; i--; ) {
int target = prog[i].target;
if (prog[i].when_to_branch == prog[target].when_to_branch)
prog[i].target = prog[target].target;
}The commit message gives an example with two predicates in which the first entry still has a target of -1 here. With two predicates the body runs once, with i equal to 0. The loop reads prog[-1].when_to_branch, which lies before the start of the array. The third pass contains a check, WARN_ON(prog[i].target <= i), that rejects a target of -1, but it runs after this read.
Depending on the contents of the neighbouring slab memory, the loop can copy prog[-1].target into the first entry, and a positive value passes the forward-only check. The filter is then installed with a branch target that the parser never computed, and filter_match_preds() uses it as an array index for each event.
How it is reached
The commit message names one route for an incomplete event filter: “A self-targeted perf tracepoint counting event can reach this path through PERF_EVENT_IOC_SET_FILTER.” The CVSS vector from the CNA records the same conditions: local access, low privileges, and no action by another user.
The parser also serves the tracefs filter files, where the regression test in the fix writes its expressions.
CONFIG_EVENT_TRACING builds the file. The perf route also needs CONFIG_PERF_EVENTS.
For an embedded product, the practical question is who can run code on the device, because the route needs a local process. An image that keeps ftrace and perf enabled for field diagnostics, and that also runs third-party applications or gives users a shell, meets the conditions in the record.
The fix
Commit 1fdc4164e488 (“tracing: Reject incomplete event filter expressions”, dated 23 October 2026) adds six lines to predicate_parse(), between the end of the outer loop and the label:
/* before */
}
}
out:
if (top != op_stack) {
/* after */
}
}
/* Only the inner loop can complete a non-empty expression. */
if (N) {
ret = -EINVAL;
parse_error(pe, FILT_ERR_INVALID_FILTER, ptr - str);
goto out_free;
}
out:
if (top != op_stack) {The inner loop leaves through goto out, which jumps past the new lines, so a complete expression is not affected. The new lines run only when the outer loop ends because the string is finished. If a predicate has been parsed at that point (N is not zero), no predicate followed the last operator, and the function returns -EINVAL.
This is sufficient because a non-empty expression can now reach the second pass only through the path that calls update_preds(). Input with no predicate still receives the existing error. The commit also adds a selftest, event-filter-incomplete.tc, which expects the kernel to refuse every incomplete event filter it writes.
The fix has not been amended: on 20 November 2026 it is the newest change to the file in each of the eight stable branches.
Which kernels are fixed
| Series | First fixed release | Commit |
|---|---|---|
| Mainline | 7.4-rc1 | 1fdc4164e488 |
| 7.3.y | 7.3.1 | 5bcdf3c18c34 |
| 7.2.y | 7.2.14 (series now end of life) | 64993d970dde |
| 6.18.y | 6.18.60 | 1008e9e0b828 |
| 6.12.y | 6.12.115 | 5a999b5a1653 |
| 6.6.y | 6.6.161 | b205ff58e029 |
| 6.1.y | 6.1.191 | 15ff3cc7f2be |
| 5.15.y | 5.15.224 | 2a98f5d4913e |
| 5.10.y | 5.10.273 | 4a1a6d353599 |
The versions come from the CVE record; each commit was confirmed in the history of the file in its branch. The record marks every other version from 4.17 as affected, which includes 4.19, 5.4, 7.0, 7.1 and the 7.3 release itself.
The CVE was listed in the weekly round-up for 1 – 7 November 2026. A vendor BSP on an unmaintained series needs the six-line change backported.
Check your tree
With the kernel source in a directory named linux, search the history of the file for the subject of the fix:
raghu@techveda.org:~$ git -C linux log --oneline --grep="tracing: Reject incomplete event filter expressions" -- kernel/trace/trace_events_filter.cIf the command prints nothing and the tree is 4.17 or newer, the tree is affected.
For a BSP without history, search for the comment that the fix adds, and check the configuration:
raghu@techveda.org:~$ grep -n "Only the inner loop can complete a non-empty expression" linux/kernel/trace/trace_events_filter.c
raghu@techveda.org:~$ grep -n -E "CONFIG_EVENT_TRACING=|CONFIG_PERF_EVENTS=" linux/.configA match from the first command means that the fix is present. If CONFIG_EVENT_TRACING is not set, the file is not built and the CVE does not apply to your image. Without CONFIG_PERF_EVENTS, only the tracefs files reach the parser.
The lesson: validate a placeholder before it becomes an index
- List every exit from a loop. The first pass had two ways out, and only one completed the work that the later passes rely on.
- Treat a placeholder as invalid until it is replaced. A target of -1 meant “not yet resolved”. Code that uses such a field as an index must first be certain that it has been replaced.
- Place the check before the first use. The forward-only check was correct, but it ran one pass too late.
- Test input that stops early. Drivers that parse firmware headers, descriptors from an attached device, or strings written to sysfs have the same exposure as this parser had to an incomplete event filter. Add a test case for input that ends after each kind of token.
What was checked and what could not be verified
Read on 20 November 2026: the announcement on the linux-cve-announce list; the CVE record (state PUBLISHED, last updated on 3 November 2026); the NVD entry (last modified on 3 November 2026); the mainline fix commit and its 5.10.y backport, in full; the affected file and kernel/trace/Makefile at the 7.3 tag; the history of the file in mainline and in the eight stable branches; the kernel.org release list; and the CISA catalogue. The CVSS score appears in the announcement, in the CNA container of the record, and on NVD as a Secondary metric whose source is the kernel CNA.
Not verified: the fault was not reproduced, so no command output is shown. The seven other backports were confirmed by commit ID and subject only. The effect of tracefs permissions and of the perf_event_paranoid setting was not examined; the statement that low privileges are enough comes from the record. Vendor trees were not examined.
Key takeaways
- CVE-2026-99236 affects kernels from 4.17 that build
CONFIG_EVENT_TRACING; all eight stable series listed on kernel.org have a fixed release. - The kernel CNA scores the record 7.8 (HIGH) with a local vector; NVD has not analysed it, and it is not in the CISA catalogue.
- The fix is six lines that reject an incomplete event filter; a search for its comment shows whether a BSP has it.
Frequently asked questions
Which kernel versions are affected by CVE-2026-99236?
Kernels from 4.17 onwards that are older than the fixed release of their series. The fixed releases are 5.10.273, 5.15.224, 6.1.191, 6.6.161, 6.12.115, 6.18.60, 7.2.14, 7.3.1 and mainline 7.4-rc1.
Does the CVE apply if my image does not enable tracing?
No. The affected file is built only when CONFIG_EVENT_TRACING is set.
How do I check a BSP that has no git history?
Search kernel/trace/trace_events_filter.c for the comment “Only the inner loop can complete a non-empty expression”. A match means that the fix is present.
References
- CVE-2026-99236 announcement, linux-cve-announce list
- CVE-2026-99236 record, cve.org
- Fix commit 1fdc4164e488 (mainline 7.4-rc1)
- Stable backport 4a1a6d353599 (5.10.273)
- Introducing commit 80765597bc58 (mainline 4.17)
- kernel/trace/trace_events_filter.c in 7.3
- CVE-2026-99236, National Vulnerability Database
- CISA Known Exploited Vulnerabilities catalogue
- kernel.org release list




