perf jitdump: Input validation hardening
Arnaldo Carvalho de Melo
maintainerv4 cover perf jitdump: Input validation hardening
Hi,
Please consider merging,
This series addresses twelve classes of input validation and resource handling bugs in the jitdump file format parser that could cause OOB memory access or memory leaks when processing maliciously crafted or corrupted jitdump files.
All issues were discovered by sashiko-bot during automated review of the jitdump code path. The bugs affect both the native-endian and byte-swap code paths, with some checks previously only enforced during byte-swapping.
Critical fix:
code_size validation was bypassable via int truncation. A record with code_size in [2^31, record_size - 56] passed the existing bounds check in jit_repipe_code_load() but truncated to a negative int when sent to jit_process_code_load(), so the code pointer landed ~2GiB past the record buffer, defeating the memchr() NUL scan and corrupting the injected ELF.
Before: code_size = 0x80000010 passes the range check, then truncates
to a negative offset
After: code_size > INT_MAX is rejected up front; all subsequent code
size arithmetic stays within the record buffer
- Arnaldo
Changes since v3:
- Address some issues about PATH_MAX
Changes since v2 (fe3ab00d55aa56b4), series reordered:
- Reordered the series so that the leak plug for debug_data and unwinding_data (now patch 2/12) comes before the code_size validation patch that introduces the early-return path flagged by sashiko-bot during review of v2. With the fix in place first, the early return no longer introduces a leak that would only have been plugged later in the series.
- Otherwise the series is unchanged: the end result is byte-identical to v2 (tree diff between the v2 and v3 tips is empty).
- The pre-existing issues reported by sashiko-bot that are outside the scope of this series were recorded in a TODO list for the next series (tools/perf/TODO.hardening), which is now in production.
Changes since v1 ([email protected]):
- Rebased onto the current perf-tools-next head (fe3ab00d55aa56b4).
- All 12 patches now carry a Reviewed-by: Ian Rogers <[email protected]>.
- Applied the code-convention suggestions from Ian's review of v1:
- Patch "perf jitdump: Check snprintf return before computing header size": the clamp now uses sizeof(event->mmap2.filename) instead of PATH_MAX in both jit_repipe_code_load() and jit_repipe_code_move(), tying the bound to the actual destination buffer.
- Patch "perf jitdump: Use dirname() return value in jit_open()":
the strlcpy() bound uses sizeof(jd->dir) instead of PATH_MAX.
- A cosmetics-only remark about the include order of <limits.h> was deliberately not applied.
Issues fixed:
Validation and bounds checks:
- Validate code_size against both the record size and INT_MAX in jit_repipe_code_load()
- Prevent integer underflow in the debug info size calculation
- Bounds-check the debug entry byte-swap loop
- Validate debug entries on the native (non-swap) path, matching the existing byte-swap path checks
- Validate sym string NUL-termination in code load, bounding the strlen() scan to the code blob
- Validate unwinding sizes against the record payload before allocating
- Check the snprintf() return before computing the header size, and clamp against the actual buffer size
Stream and record handling:
- Fix the extended header read that always failed, causing records to be misparsed
- Use dirname()'s return value in jit_open(), fixing ENOTDIR failures
- Fix funlockfile() being called on an unlocked stream in the jit_open() error path
Resource management:
- Free the event in jit_repipe_code_move()
- Fix debug_data and unwinding_data leaks when records are overwritten
Each patch includes a Fixes: tag pointing to the offending commit, dating back to jitdump mmap injection support (9b07e27f88b9cd78), source line info support (598b7c6919c7bbcc), and unwinding support (0284fecd13b6db3e), all from the original 2016 jitdump work.
Testing: Built and tested on x86_64. No existing tests cover jitdump parsing with malformed input; test suite expansion is left for future work. The final series was re-reviewed after the fixes and the v1 review (build-checked, Fixes: tags verified); no regressions found.
Arnaldo Carvalho de Melo (12):
perf jitdump: Fix extended header read that always fails
perf jitdump: Fix debug_data and unwinding_data leaks
perf jitdump: Validate code_size against total_size in code load perf jitdump: Prevent integer underflow in debug info size calculation perf jitdump: Bounds-check debug entry byte-swap loop
perf jitdump: Check snprintf return before computing header size perf jitdump: Fix funlockfile on unlocked stream in jit_open() error path perf jitdump: Free event in jit_repipe_code_move()
perf jitdump: Use dirname() return value in jit_open()
perf jitdump: Validate debug entries on native (non-swap) path perf jitdump: Validate sym string NUL-termination in code load perf jitdump: Validate unwinding sizes against record payload
tools/perf/util/jitdump.c | 126 +++++++++++++++++++++++++++++++++++++++------- 1 file changed, 108 insertions(+), 18 deletions(-)
base-commit: fe3ab00d55aa56b4d55cbc1150448f0aadd6732c
Arnaldo Carvalho de Melo
maintainerPATCH v4 1/12 perf jitdump: Fix extended header read that always fails
From: Arnaldo Carvalho de Melo <[email protected]>
jit_open() sets bsz = bs before the fread() that uses bs - bsz as the read size, making the expression always evaluate to zero. fread() with size 0 returns 0, which triggers the ret != 1 error path — so extended jitdump headers (total_size > sizeof(header)) have been silently broken since the original implementation.
Additionally, when 0 < bs <= bsz the if (bs > bsz) block is skipped entirely, leaving extended header bytes unread in the stream. Subsequent jit_get_next_entry() calls then parse those leftover bytes as a jr_prefix, corrupting the record stream.
Fix by separating the buffer growth from the read: realloc only when bs > bsz, then unconditionally fread bs bytes when bs > 0.
--- tools/perf/util/jitdump.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-)
tools/perf/util/jitdump.c +5 -3
@@ -224,10 +224,12 @@ jit_open(struct jit_buf_desc *jd, const char *name) n =realloc (buf, bs);if (!n) goto error; - bsz = bs; buf = n; -/* read extra we do not know about */ - ret =fread (buf, bs - bsz,1 , jd->in); + bsz = bs; + } +if (bs >0 ) { +/* consume extended header bytes from the stream */ + ret =fread (buf, bs,1 , jd->in);if (ret !=1 ) goto error; }
Signature · 1 line
2.55.0
[email protected]
AI reviewRe: [PATCH 01/12] perf jitdump: Fix extended header read that always fails
Sashiko has reviewed this patch and found no issues. It looks great!
Quoted 16 lines
From: Arnaldo Carvalho de Melo <[email protected]>
jit_open()sets bsz = bs before thefread()that uses bs - bsz as the read size, making the expression always evaluate to zero.fread()with size 0 returns 0, which triggers the ret != 1 error path — so extended jitdump headers (total_size> sizeof(header)) have been silently broken since the original implementation.Additionally, when 0 < bs <= bsz the if (bs > bsz) block is skipped entirely, leaving extended header bytes unread in the stream. Subsequent
jit_get_next_entry()calls then parse those leftover bytes as ajr_prefix, corrupting the record stream.Fix by separating the buffer growth from the read: realloc only when bs > bsz, then unconditionally fread bs bytes when bs > 0.
Quoted 8 lines
Fixes 9b07e27f88b9cd78 ("perf inject: Add jitdump mmap injection support")Reported-by sashiko-bot <[email protected]>Reviewed-by Ian Rogers <[email protected]>Cc Stephane Eranian <[email protected]>Cc Ian Rogers <[email protected]>Cc Namhyung Kim <[email protected]>Assisted-by LLMSigned-off-by Arnaldo Carvalho de Melo <[email protected]>
Sashiko has reviewed this patch and found no issues. It looks great!
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
Arnaldo Carvalho de Melo
maintainerPATCH v4 2/12 perf jitdump: Fix debug_data and unwinding_data leaks
In reply to Arnaldo Carvalho de MeloFrom: Arnaldo Carvalho de Melo <[email protected]>
jit_repipe_debug_info() overwrites jd->debug_data without freeing the previous allocation. If two consecutive JIT_CODE_DEBUG_INFO records appear without an intervening LOAD record consuming the data, the first allocation leaks.
The sibling jit_repipe_unwinding_info() already frees the old jd->unwinding_data before reassignment — add the same pattern to jit_repipe_debug_info() using zfree().
Also add cleanup of both buffers in jit_close() so they are freed when the jitdump session ends, even if no LOAD record consumed them.
--- tools/perf/util/jitdump.c | 3 +++ 1 file changed, 3 insertions(+)
tools/perf/util/jitdump.c +3 -0
@@ -117,6 +117,8 @@ jit_close(struct jit_buf_desc *jd)funlockfile (jd->in);fclose (jd->in); jd->in =NULL ; +zfree (&jd->debug_data); +zfree (&jd->unwinding_data); } static int
@@ -665,6 +667,7 @@ static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr)memcpy (data, &jr->info.entries, sz); +zfree (&jd->debug_data); jd->debug_data = data;/*
Signature · 1 line
2.55.0
[email protected]
AI reviewRe: [PATCH 02/12] perf jitdump: Fix debug_data and unwinding_data leaks
Sashiko has reviewed this patch and found no issues. It looks great!
Quoted 14 lines
From: Arnaldo Carvalho de Melo <[email protected]>
jit_repipe_debug_info()overwritesjd->debug_datawithout freeing the previous allocation. If two consecutiveJIT_CODE_DEBUG_INFOrecords appear without an intervening LOAD record consuming the data, the first allocation leaks.The sibling
jit_repipe_unwinding_info()already frees the oldjd->unwinding_databefore reassignment — add the same pattern tojit_repipe_debug_info()usingzfree().Also add cleanup of both buffers in
jit_close()so they are freed when the jitdump session ends, even if no LOAD record consumed them.
Quoted 6 lines
Fixes 9b07e27f88b9 ("perf inject: Add jitdump mmap injection support")Reported-by sashiko-bot <[email protected]>Reviewed-by Ian Rogers <[email protected]>Cc Stephane Eranian <[email protected]>Assisted-by LLMSigned-off-by Arnaldo Carvalho de Melo <[email protected]>
Sashiko has reviewed this patch and found no issues. It looks great!
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
Arnaldo Carvalho de Melo
maintainerPATCH v4 3/12 perf jitdump: Validate code_size against total_size in code load
In reply to Arnaldo Carvalho de MeloFrom: Arnaldo Carvalho de Melo <[email protected]>
jit_repipe_code_load() reads code_size from the jitdump record and uses it to compute a pointer to the code blob:
code = (unsigned long)jr + jr->load.p.total_size - csize;
An oversized code_size underflows the pointer arithmetic, causing OOB reads into earlier heap memory. Validate that code_size fits within the record (total_size - sizeof(jr->load)) before the pointer computation.
code_size is uint64_t but csize is int; values above INT_MAX wrap negative when narrowed into csize, which defeats the bounds check and sends the code pointer past the end of the record. Reject those too.
--- tools/perf/util/jitdump.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
tools/perf/util/jitdump.c +11 -0
@@ -9,6 +9,7 @@#include <fcntl.h> #include <unistd.h> #include <inttypes.h> +#include <limits.h> #include <byteswap.h> #include <sys/stat.h> #include <sys/mman.h>
@@ -452,6 +453,16 @@ static int jit_repipe_code_load(struct jit_buf_desc *jd, union jr_entry *jr) csize = jr->load.code_size; usize = jd->unwinding_mapped_size; addr = jr->load.code_addr; + +/* code blob lives at the end of the record, validate it fits */ +if (jr->load.p.total_size <sizeof (jr->load) || + jr->load.code_size > jr->load.p.total_size -sizeof (jr->load) || + jr->load.code_size >INT_MAX ) { +pr_warning ("jitdump: invalid code_size %" PRIu64" (total_size=%u) in code_load record\n" , + (uint64_t )jr->load.code_size, jr->load.p.total_size); +return -1 ; + } + sym = (void *)((unsigned long )jr +sizeof (jr->load)); code = (unsigned long )jr + jr->load.p.total_size - csize; count = jr->load.code_index;
Signature · 1 line
2.55.0
[email protected]
AI reviewRe: [PATCH 03/12] perf jitdump: Validate code_size against total_size in code load
Sashiko has reviewed this patch and found no issues. It looks great!
Quoted 15 lines
From: Arnaldo Carvalho de Melo <[email protected]>
jit_repipe_code_load()readscode_sizefrom the jitdump record and uses it to compute a pointer to the code blob:code = (unsigned long)jr + jr->load.p.total_size - csize;An oversized
code_sizeunderflows the pointer arithmetic, causing OOB reads into earlier heap memory. Validate thatcode_sizefits within the record (total_size-sizeof(jr->load)) before the pointer computation.
code_sizeisuint64_tbut csize is int; values aboveINT_MAXwrap negative when narrowed into csize, which defeats the bounds check and sends the code pointer past the end of the record. Reject those too.
Quoted 6 lines
Fixes 9b07e27f88b9 ("perf inject: Add jitdump mmap injection support")Reported-by sashiko-bot <[email protected]>Reviewed-by Ian Rogers <[email protected]>Cc Stephane Eranian <[email protected]>Assisted-by LLMSigned-off-by Arnaldo Carvalho de Melo <[email protected]>
Sashiko has reviewed this patch and found no issues. It looks great!
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3
Arnaldo Carvalho de Melo
maintainerPATCH v4 4/12 perf jitdump: Prevent integer underflow in debug info size calculation
In reply to Arnaldo Carvalho de MeloFrom: Arnaldo Carvalho de Melo <[email protected]>
jit_repipe_debug_info() and jit_repipe_unwinding_info() compute payload sizes by subtracting the fixed header size from total_size:
sz = jr->prefix.total_size - sizeof(jr->info);
When total_size is smaller than the header struct (from a truncated or corrupted jitdump record), the subtraction underflows to a massive value, causing an oversized allocation followed by an OOB memcpy.
Validate that total_size covers at least the fixed header before the subtraction in both functions.
--- tools/perf/util/jitdump.c | 8 ++++++++ 1 file changed, 8 insertions(+)
tools/perf/util/jitdump.c +8 -0
@@ -671,6 +671,10 @@ static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr)if (!(jd && jr))return -1 ; +/* total_size must cover at least the fixed header */ +if (jr->prefix.total_size <sizeof (jr->info)) +return -1 ; + sz = jr->prefix.total_size -sizeof (jr->info); data =malloc (sz);if (!data)
@@ -699,6 +703,10 @@ jit_repipe_unwinding_info(struct jit_buf_desc *jd, union jr_entry *jr)if (!(jd && jr))return -1 ; +/* total_size must cover at least the fixed header */ +if (jr->prefix.total_size <sizeof (jr->unwinding)) +return -1 ; + unwinding_data_size = jr->prefix.total_size -sizeof (jr->unwinding); unwinding_data =malloc (unwinding_data_size);if (!unwinding_data)
Signature · 1 line
2.55.0
[email protected]
AI reviewRe: [PATCH 04/12] perf jitdump: Prevent integer underflow in debug info size calculation
Sashiko has reviewed this patch and found no issues. It looks great!
Quoted 14 lines
From: Arnaldo Carvalho de Melo <[email protected]>
jit_repipe_debug_info()andjit_repipe_unwinding_info()compute payload sizes by subtracting the fixed header size fromtotal_size:sz = jr->prefix.total_size - sizeof(jr->info);When
total_sizeis smaller than the header struct (from a truncated or corrupted jitdump record), the subtraction underflows to a massive value, causing an oversized allocation followed by an OOB memcpy.Validate that
total_sizecovers at least the fixed header before the subtraction in both functions.
Quoted 8 lines
Fixes 598b7c6919c7 ("perf jit: add source line info support")Fixes 0284fecd13b6 ("perf jit: Add unwinding support")Reported-by sashiko-bot <[email protected]>Reviewed-by Ian Rogers <[email protected]>Cc Stephane Eranian <[email protected]>Cc Stefano Sanfilippo <[email protected]>Assisted-by LLMSigned-off-by Arnaldo Carvalho de Melo <[email protected]>
Sashiko has reviewed this patch and found no issues. It looks great!
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=4
Arnaldo Carvalho de Melo
maintainerPATCH v4 5/12 perf jitdump: Bounds-check debug entry byte-swap loop
In reply to Arnaldo Carvalho de MeloFrom: Arnaldo Carvalho de Melo <[email protected]>
The byte-swap loop for JIT_CODE_DEBUG_INFO uses array indexing (jr->info.entries[n]) to iterate debug entries. struct debug_entry has a flexible array member name[], so each entry has a different size. Array indexing computes offsets assuming fixed-size elements, landing inside variable-length name strings after the first entry and byte-swapping garbage.
Additionally, nr_entry is read from untrusted jitdump input without validation against total_size, so a crafted value causes OOB reads.
Replace the array indexing with debug_entry_next() pointer arithmetic (which correctly accounts for the variable-length name) and bounds-check each entry against the record's total_size before byte-swapping.
--- tools/perf/util/jitdump.c | 26 ++++++++++++++++++++++---- 1 file changed, 22 insertions(+), 4 deletions(-)
tools/perf/util/jitdump.c +22 -4
@@ -320,14 +320,32 @@ jit_get_next_entry(struct jit_buf_desc *jd)switch (id) {case JIT_CODE_DEBUG_INFO :if (jd->needs_bswap) { +void *end = (void *)jr + jr->prefix.total_size; +struct debug_entry *ent;uint64_t n; + jr->info.code_addr =bswap_64 (jr->info.code_addr); jr->info.nr_entry =bswap_64 (jr->info.nr_entry); -for (n =0 ; n < jr->info.nr_entry; n++) { - jr->info.entries[n].addr =bswap_64 (jr->info.entries[n].addr); - jr->info.entries[n].lineno =bswap_32 (jr->info.entries[n].lineno); - jr->info.entries[n].discrim =bswap_32 (jr->info.entries[n].discrim); + +/* +* debug_entry has a variable-length name[], so array +* indexing would compute wrong offsets — use +* debug_entry_next() and bounds-check each entry. +*/ + ent = &jr->info.entries[0 ]; +for (n =0 ; n < jr->info.nr_entry; n++) { +if ((void *)ent +sizeof (*ent) > end) +break ; +/* name must be NUL-terminated within the record */ +if (!memchr (ent->name,'\0' , (char *)end - ent->name)) +break ; + ent->addr =bswap_64 (ent->addr); + ent->lineno =bswap_32 (ent->lineno); + ent->discrim =bswap_32 (ent->discrim); + ent =debug_entry_next (ent); } +/* clamp so downstream consumers don't overrun */ + jr->info.nr_entry = n; }break ;case JIT_CODE_UNWINDING_INFO :
Signature · 1 line
2.55.0
[email protected]
AI reviewRe: [PATCH 05/12] perf jitdump: Bounds-check debug entry byte-swap loop
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] Unaligned memory accesses leading to SIGBUS crashes on strict-alignment architectures. --
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Unaligned memory accesses leading to SIGBUS crashes on strict-alignment architectures. --
commit 947f2eb889b5646cf554f70f7bd7ac567ceaa090
Author: Arnaldo Carvalho de Melo <[email protected]>
perf jitdump: Bounds-check debug entry byte-swap loop
This commit replaces fixed-size array indexing with pointer arithmetic using debug_entry_next to iterate variable-length debug entries in JIT_CODE_DEBUG_INFO records. It also adds bounds checking against the total record size to prevent out-of-bounds reads.
Quoted 4 lines
tools/perf/util/jitdump.c +0
-0
[ ... ]
Quoted 20 lines
tools/perf/util/jitdump.c +9
-4@@ -320,14 +320,32 @@ jit_get_next_entry(struct jit_buf_desc *jd)switch (id) {case JIT_CODE_DEBUG_INFO :if (jd->needs_bswap) { +void *end = (void *)jr + jr->prefix.total_size; +struct debug_entry *ent;uint64_t n; + jr->info.code_addr =bswap_64 (jr->info.code_addr); jr->info.nr_entry =bswap_64 (jr->info.nr_entry); -for (n =0 ; n < jr->info.nr_entry; n++) { - jr->info.entries[n].addr =bswap_64 (jr->info.entries[n].addr); - jr->info.entries[n].lineno =bswap_32 (jr->info.entries[n].lineno); - jr->info.entries[n].discrim =bswap_32 (jr->info.entries[n].discrim); + +/* +* debug_entry has a variable-length name[], so array +* indexing would compute wrong offsets — use +* debug_entry_next() and bounds-check each entry. +*/
tools/perf/util/jitdump.c jit_get_next_entry(struct jit_buf_desc *jd) · line 344
Quoted 10 lines
tools/perf/util/jitdump.c +10
-0+ ent = &jr->info.entries[0 ]; +for (n =0 ; n < jr->info.nr_entry; n++) { +if ((void *)ent +sizeof (*ent) > end) +break ; +/* name must be NUL-terminated within the record */ +if (!memchr (ent->name,'\0' , (char *)end - ent->name)) +break ; + ent->addr =bswap_64 (ent->addr); + ent->lineno =bswap_32 (ent->lineno); + ent->discrim =bswap_32 (ent->discrim);
[Severity: Medium]
Does this code risk triggering unaligned memory accesses and SIGBUS crashes on strict-alignment architectures?
In jitdump files, the debug_entry structure is packed with a variable-length name string without padding. The pointer arithmetic in debug_entry_next advances the ent pointer by the exact string length (including the NUL byte).
If the string has an odd length, subsequent ent pointers will no longer be aligned to an 8-byte boundary. Because the struct lacks the __packed attribute, the compiler assumes natural alignment.
When it emits standard aligned load and store instructions for the 64-bit addr and 32-bit lineno fields, they will trap when receiving an unaligned address while parsing cross-endian jitdump files in jit_get_next_entry.
Quoted 5 lines
tools/perf/util/jitdump.c +3
-0+ ent =debug_entry_next (ent); } +/* clamp so downstream consumers don't overrun */ + jr->info.nr_entry = n; }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=5
Arnaldo Carvalho de Melo
maintainerPATCH v4 6/12 perf jitdump: Check snprintf return before computing header size
In reply to Arnaldo Carvalho de MeloFrom: Arnaldo Carvalho de Melo <[email protected]>
snprintf() returns the would-have-been length on truncation. When the jitted filename exceeds PATH_MAX, the unclamped 'size' value inflates sizeof(event->mmap2.filename) - size into a massive underflow, causing the header.size computation to write an oversized header. The subsequent write to 'id = event + header.size - idr_size' then corrupts the heap.
Clamp size to PATH_MAX - 1 after snprintf in both jit_repipe_code_load() and jit_repipe_code_move().
--- tools/perf/util/jitdump.c | 6 ++++++ 1 file changed, 6 insertions(+)
tools/perf/util/jitdump.c +6 -0
@@ -495,6 +495,9 @@ static int jit_repipe_code_load(struct jit_buf_desc *jd, union jr_entry *jr) jd->dir, nspid, count); +/* snprintf returns would-be length on truncation, clamp to buffer */ +if (size >=sizeof (event->mmap2.filename)) + size =sizeof (event->mmap2.filename) -1 ; size++;/* for \0 */
@@ -625,6 +628,9 @@ static int jit_repipe_code_move(struct jit_buf_desc *jd, union jr_entry *jr) jd->dir, nspid, jr->move.code_index); +/* snprintf returns would-be length on truncation, clamp to buffer */ +if (size >=sizeof (event->mmap2.filename)) + size =sizeof (event->mmap2.filename) -1 ; size++;/* for \0 */
Signature · 1 line
2.55.0
[email protected]
AI reviewRe: [PATCH 06/12] perf jitdump: Check snprintf return before computing header size
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
Pre-existing issues:
- [High] Insufficient heap allocation in jit_repipe_code_move() leads to an out-of-bounds read and heap disclosure when writing the event to perf.data.
- [High] Heap out-of-bounds write due to brittle, hardcoded sample ID struct layout.
--
commit 9bf23bcb5ee8564df7189ee4fbf6479763732a6c
Author: Arnaldo Carvalho de Melo <[email protected]>
perf jitdump: Check snprintf return before computing header size
This commit clamps the string size returned by snprintf() to prevent an integer underflow when computing header.size in jit_repipe_code_load() and jit_repipe_code_move(). This fixes a heap corruption that occurs when jitted filenames exceed PATH_MAX.
tools/perf/util/jitdump.c static int jit_repipe_code_load(struct jit_buf_desc *jd, union jr_entry *jr) · line 500
Quoted 11 lines
tools/perf/util/jitdump.c +3
-0@@ -495,6 +495,9 @@ static int jit_repipe_code_load(struct jit_buf_desc *jd, union jr_entry *jr) jd->dir, nspid, count); +/* snprintf returns would-be length on truncation, clamp to buffer */ +if (size >=sizeof (event->mmap2.filename)) + size =sizeof (event->mmap2.filename) -1 ;
[Severity: High]
This is a pre-existing issue, but is it possible for the allocation of event earlier in this function to cause an out-of-bounds write?
In jit_repipe_code_load(), event is allocated with exactly idr_size trailing bytes:
event = calloc(1, sizeof(*event) + idr_size);
Later in the function, it writes to id->time based on a hardcoded struct layout:
struct {
u32 pid, tid;
u64 time;
} *id;
if (jd->sample_type & PERF_SAMPLE_TIME)
id->time = convert_timestamp(jd, jr->load.p.timestamp);If PERF_SAMPLE_TID is missing from the session but PERF_SAMPLE_TIME is present, idr_size may only be 8. Would writing to id->time at offset 8 strictly overflow the 8-byte dynamic allocation?
Quoted 3 lines
tools/perf/util/jitdump.c +0
-0size++;/* for \0 */
[ ... ]
tools/perf/util/jitdump.c static int jit_repipe_code_move(struct jit_buf_desc *jd, union jr_entry *jr) · line 633
Quoted 7 lines
tools/perf/util/jitdump.c +3
-0@@ -625,6 +628,9 @@ static int jit_repipe_code_move(struct jit_buf_desc *jd, union jr_entry *jr) jd->dir, nspid, jr->move.code_index); +/* snprintf returns would-be length on truncation, clamp to buffer */ +if (size >=sizeof (event->mmap2.filename)) + size =sizeof (event->mmap2.filename) -1 ;
[Severity: High]
This is a pre-existing issue, but can this lead to an out-of-bounds read and heap disclosure when the event is injected?
In jit_repipe_code_move(), the event buffer is allocated with a fixed 16-byte offset for the sample ID:
/*
* +16 to account for sample_id_all (hack)
*/
event = calloc(1, sizeof(*event) + 16);However, the total event size is calculated using the full dynamic idr_size:
event->mmap2.header.size = (sizeof(event->mmap2) -
(sizeof(event->mmap2.filename) - size) + idr_size);If idr_size > 16 (e.g. PERF_SAMPLE_CPU and PERF_SAMPLE_ID are set) and the filename length approaches PATH_MAX, could header.size strictly exceed the allocated buffer bounds? When jit_inject_event(jd, event) is called later, could the oversized header size cause it to read past the allocation and leak heap memory into the perf.data file?
Quoted 3 lines
tools/perf/util/jitdump.c +0
-0size++;/* for \0 */
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=6
Arnaldo Carvalho de Melo
maintainerPATCH v4 7/12 perf jitdump: Fix funlockfile on unlocked stream in jit_open() error path
In reply to Arnaldo Carvalho de MeloFrom: Arnaldo Carvalho de Melo <[email protected]>
If the malloc() for the initial read buffer fails, jit_open() jumps to the error label which calls funlockfile(jd->in). However, flockfile() is called later in the function, so at this point the stream was never locked. Calling funlockfile() on an unlocked stream is undefined behavior per POSIX.
Split the error path into two labels: 'error' (after flockfile) calls funlockfile before cleanup, 'error_noflock' (before flockfile) skips the unlock.
--- tools/perf/util/jitdump.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
tools/perf/util/jitdump.c +3 -2
@@ -157,7 +157,7 @@ jit_open(struct jit_buf_desc *jd, const char *name) buf =malloc (bsz);if (!buf) - goto error; + goto error_noflock;/* * protect from writer modifying the file while we are reading it
@@ -246,8 +246,9 @@ jit_open(struct jit_buf_desc *jd, const char *name)return 0 ; error: -free (buf);funlockfile (jd->in); +error_noflock: +free (buf);fclose (jd->in);return retval; }
Signature · 1 line
2.55.0
[email protected]
AI reviewRe: [PATCH 07/12] perf jitdump: Fix funlockfile on unlocked stream in jit_open() error path
Sashiko has reviewed this patch and found no issues. It looks great!
Quoted 12 lines
From: Arnaldo Carvalho de Melo <[email protected]>
If the
malloc()for the initial read buffer fails,jit_open()jumps to the error label which callsfunlockfile(jd->in). However,flockfile()is called later in the function, so at this point the stream was never locked. Callingfunlockfile()on an unlocked stream is undefined behavior per POSIX.Split the error path into two labels: 'error' (after flockfile) calls funlockfile before cleanup, '
error_noflock' (before flockfile) skips the unlock.
Quoted 6 lines
Fixes 9b07e27f88b9 ("perf inject: Add jitdump mmap injection support")Reported-by sashiko-bot <[email protected]>Reviewed-by Ian Rogers <[email protected]>Cc Stephane Eranian <[email protected]>Assisted-by LLMSigned-off-by Arnaldo Carvalho de Melo <[email protected]>
Sashiko has reviewed this patch and found no issues. It looks great!
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=7
Arnaldo Carvalho de Melo
maintainerPATCH v4 8/12 perf jitdump: Free event in jit_repipe_code_move()
In reply to Arnaldo Carvalho de MeloFrom: Arnaldo Carvalho de Melo <[email protected]>
jit_repipe_code_move() allocates a perf_event with calloc but never frees it — the 'out' label exits with only perf_sample__exit().
The sibling function jit_repipe_code_load() correctly calls free(event) at its out label. Add the same free(event) to jit_repipe_code_move().
--- tools/perf/util/jitdump.c | 1 + 1 file changed, 1 insertion(+)
tools/perf/util/jitdump.c +1 -0
@@ -685,6 +685,7 @@ static int jit_repipe_code_move(struct jit_buf_desc *jd, union jr_entry *jr)build_id__mark_dso_hit (tool, event, &sample, jd->machine); out:perf_sample__exit (&sample); +free (event);return ret; }
Signature · 1 line
2.55.0
[email protected]
AI reviewRe: [PATCH 08/12] perf jitdump: Free event in jit_repipe_code_move()
Sashiko has reviewed this patch and found no issues. It looks great!
Quoted 9 lines
From: Arnaldo Carvalho de Melo <[email protected]>
jit_repipe_code_move()allocates aperf_eventwith calloc but never frees it — the 'out' label exits with onlyperf_sample__exit().The sibling function
jit_repipe_code_load()correctly calls free(event) at its out label. Add the same free(event) tojit_repipe_code_move().
Quoted 6 lines
Fixes 9b07e27f88b9 ("perf inject: Add jitdump mmap injection support")Reported-by sashiko-bot <[email protected]>Reviewed-by Ian Rogers <[email protected]>Cc Stephane Eranian <[email protected]>Assisted-by LLMSigned-off-by Arnaldo Carvalho de Melo <[email protected]>
Sashiko has reviewed this patch and found no issues. It looks great!
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=8
Arnaldo Carvalho de Melo
maintainerPATCH v4 9/12 perf jitdump: Use dirname() return value in jit_open()
In reply to Arnaldo Carvalho de MeloFrom: Arnaldo Carvalho de Melo <[email protected]>
jit_open() calls dirname(jd->dir) but ignores the return value. POSIX says dirname() may return a pointer to internal static storage — glibc does this when the path has no '/', returning "." from a static buffer and leaving jd->dir unchanged with the original filename.
Capture the return value and copy it back to jd->dir when dirname() returns a different pointer.
--- tools/perf/util/jitdump.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
tools/perf/util/jitdump.c +4 -1
@@ -146,6 +146,7 @@ jit_open(struct jit_buf_desc *jd, const char *name)ssize_t bs, bsz =0 ;void *n, *buf =NULL ;int ret, retval =-1 ; +char *dname;nsinfo__mountns_enter (jd->nsi, &nsc); jd->in =fopen (name,"r" );
@@ -241,7 +242,9 @@ jit_open(struct jit_buf_desc *jd, const char *name)*/ strncpy (jd->dir, name,PATH_MAX -1 ); jd->dir[PATH_MAX -1 ] ='\0' ; -dirname (jd->dir); + dname =dirname (jd->dir); +if (dname != jd->dir) +strlcpy (jd->dir, dname,sizeof (jd->dir));free (buf);return 0 ;
Signature · 1 line
2.55.0
[email protected]
AI reviewRe: [PATCH 09/12] perf jitdump: Use dirname() return value in jit_open()
Sashiko has reviewed this patch and found no issues. It looks great!
Quoted 10 lines
From: Arnaldo Carvalho de Melo <[email protected]>
jit_open()callsdirname(jd->dir)but ignores the return value. POSIX saysdirname()may return a pointer to internal static storage — glibc does this when the path has no '/', returning "." from a static buffer and leavingjd->dirunchanged with the original filename.Capture the return value and copy it back to
jd->dirwhendirname()returns a different pointer.
Quoted 6 lines
Fixes 9b07e27f88b9 ("perf inject: Add jitdump mmap injection support")Reported-by sashiko-bot <[email protected]>Reviewed-by Ian Rogers <[email protected]>Cc Stephane Eranian <[email protected]>Assisted-by LLMSigned-off-by Arnaldo Carvalho de Melo <[email protected]>
Sashiko has reviewed this patch and found no issues. It looks great!
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=9
Arnaldo Carvalho de Melo
maintainerPATCH v4 10/12 perf jitdump: Validate debug entries on native (non-swap) path
In reply to Arnaldo Carvalho de MeloFrom: Arnaldo Carvalho de Melo <[email protected]>
The bounds-checking and nr_entry clamping added for the byte-swap path only runs when jd->needs_bswap is true. On native-endian files, nr_entry passes through unvalidated to jit_repipe_debug_info(), which stores it as jd->nr_debug_entries. Downstream, jit_process_debug_info() in genelf_debug.c iterates nr_debug_entries times via debug_entry_next(), which calls strlen() on each entry's name field — a crafted nr_entry causes OOB reads and writes.
Add bounds-checked iteration in jit_repipe_debug_info() that validates each debug_entry fits in the payload and its name is NUL-terminated before calling debug_entry_next(). Clamp nr_debug_entries to the count of valid entries.
--- tools/perf/util/jitdump.c | 27 ++++++++++++++++++++++----- 1 file changed, 22 insertions(+), 5 deletions(-)
tools/perf/util/jitdump.c +22 -5
@@ -694,8 +694,10 @@ static int jit_repipe_code_move(struct jit_buf_desc *jd, union jr_entry *jr)static int jit_repipe_debug_info (struct jit_buf_desc *jd,union jr_entry *jr) { -void *data; -size_t sz; +struct debug_entry *ent; +void *data, *end; +size_t sz, valid; +uint64_t i;if (!(jd && jr))return -1 ;
@@ -715,10 +717,25 @@ static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr) jd->debug_data = data;/* -* we must use nr_entry instead of size here because -* we cannot distinguish actual entry from padding otherwise +* Clamp nr_debug_entries to entries that actually fit in the +* payload. The byte-swap path already does this for cross-endian +* files; validate on the native path too, since downstream +* jit_process_debug_info() iterates via debug_entry_next() which +* calls strlen() on each entry's name field. */ - jd->nr_debug_entries = jr->info.nr_entry; + end = data + sz; + ent = data; + valid =0 ; +for (i =0 ; i < jr->info.nr_entry; i++) { +if ((void *)ent +sizeof (*ent) > end) +break ; +/* name must be NUL-terminated within the payload */ +if (!memchr (ent->name,'\0' , (char *)end - ent->name)) +break ; + ent =debug_entry_next (ent); + valid++; + } + jd->nr_debug_entries = valid;return 0 ; }
Signature · 1 line
2.55.0
[email protected]
AI reviewRe: [PATCH 10/12] perf jitdump: Validate debug entries on native (non-swap) path
Sashiko has reviewed this patch and found no issues. It looks great!
Quoted 15 lines
From: Arnaldo Carvalho de Melo <[email protected]>
The bounds-checking and
nr_entryclamping added for the byte-swap path only runs whenjd->needs_bswapis true. On native-endian files,nr_entrypasses through unvalidated tojit_repipe_debug_info(), which stores it asjd->nr_debug_entries. Downstream,jit_process_debug_info()ingenelf_debug.citeratesnr_debug_entriestimes viadebug_entry_next(), which callsstrlen()on each entry's name field — a craftednr_entrycauses OOB reads and writes.Add bounds-checked iteration in
jit_repipe_debug_info()that validates eachdebug_entryfits in the payload and its name is NUL-terminated before callingdebug_entry_next(). Clampnr_debug_entriesto the count of valid entries.
Quoted 6 lines
Fixes 598b7c6919c7bbcc ("perf jit: add source line info support")Reported-by sashiko-bot <[email protected]>Reviewed-by Ian Rogers <[email protected]>Cc Stephane Eranian <[email protected]>Assisted-by LLMSigned-off-by Arnaldo Carvalho de Melo <[email protected]>
Sashiko has reviewed this patch and found no issues. It looks great!
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=10
Arnaldo Carvalho de Melo
maintainerPATCH v4 11/12 perf jitdump: Validate sym string NUL-termination in code load
In reply to Arnaldo Carvalho de MeloFrom: Arnaldo Carvalho de Melo <[email protected]>
jit_repipe_code_load() computes sym = (void *)jr + sizeof(jr->load) and passes it to jit_emit_elf() which calls strlen(sym) via jit_write_elf(). If code_size equals total_size - sizeof(jr->load), the sym pointer aliases the code blob with no NUL terminator, and strlen() scans past the buffer into adjacent heap memory.
Add a memchr() check to verify the symbol name is NUL-terminated within the region between the load header and the code blob before use.
--- tools/perf/util/jitdump.c | 7 +++++++ 1 file changed, 7 insertions(+)
tools/perf/util/jitdump.c +7 -0
@@ -487,6 +487,13 @@ static int jit_repipe_code_load(struct jit_buf_desc *jd, union jr_entry *jr) sym = (void *)((unsigned long )jr +sizeof (jr->load)); code = (unsigned long )jr + jr->load.p.total_size - csize; + +/* sym string lives between the load header and the code blob */ +if (!memchr (sym,'\0' , code - (unsigned long )sym)) { +pr_warning ("jitdump: unterminated symbol name in code_load record\n" ); +return -1 ; + } + count = jr->load.code_index; idr_size = jd->machine->id_hdr_size;
Signature · 1 line
2.55.0
[email protected]
AI reviewRe: [PATCH 11/12] perf jitdump: Validate sym string NUL-termination in code load
Sashiko has reviewed this patch and found no issues. It looks great!
Quoted 11 lines
From: Arnaldo Carvalho de Melo <[email protected]>
jit_repipe_code_load()computes sym = (void *)jr +sizeof(jr->load)and passes it tojit_emit_elf()which calls strlen(sym) viajit_write_elf(). Ifcode_sizeequalstotal_size-sizeof(jr->load), the sym pointer aliases the code blob with no NUL terminator, andstrlen()scans past the buffer into adjacent heap memory.Add a
memchr()check to verify the symbol name is NUL-terminated within the region between the load header and the code blob before use.
Quoted 6 lines
Fixes 598b7c6919c7bbcc ("perf jit: add source line info support")Reported-by sashiko-bot <[email protected]>Reviewed-by Ian Rogers <[email protected]>Cc Stephane Eranian <[email protected]>Assisted-by LLMSigned-off-by Arnaldo Carvalho de Melo <[email protected]>
Sashiko has reviewed this patch and found no issues. It looks great!
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=11
Arnaldo Carvalho de Melo
maintainerPATCH v4 12/12 perf jitdump: Validate unwinding sizes against record payload
In reply to Arnaldo Carvalho de MeloFrom: Arnaldo Carvalho de Melo <[email protected]>
jit_repipe_unwinding_info() copies unwinding_size and eh_frame_hdr_size from the jitdump record into jd-> fields without checking them against the actual payload size. Downstream, jit_add_eh_frame_info() in genelf.c computes unwinding_table_size = unwinding_size - eh_frame_hdr_size, which underflows when eh_frame_hdr_size > unwinding_size. The result is passed as d->d_size to libelf, causing an OOB heap read into the output ELF file.
Validate that unwinding_size fits within the record payload and that eh_frame_hdr_size does not exceed unwinding_size before allocating or storing the values, so a bogus record cannot force a large allocation that is then discarded.
mapped_size is likewise taken from the record and was narrowed into an int for the mmap2 len computation in jit_repipe_code_load() and jit_repipe_code_move(); values above INT_MAX would turn negative, producing a wrong mmap2 length. Use uint64_t for usize so the value cannot truncate.
--- tools/perf/util/jitdump.c | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-)
tools/perf/util/jitdump.c +16 -3
@@ -462,7 +462,8 @@ static int jit_repipe_code_load(struct jit_buf_desc *jd, union jr_entry *jr)u16 idr_size;const char *sym;uint64_t count; -int ret, csize, usize; +int ret, csize; +uint64_t usize;pid_t nspid, pid, tid;struct {u32 pid, tid;
@@ -543,7 +544,7 @@ static int jit_repipe_code_load(struct jit_buf_desc *jd, union jr_entry *jr) event->mmap2.pgoff =GEN_ELF_TEXT_OFFSET ; event->mmap2.start = addr; - event->mmap2.len = usize ?ALIGN_8 (csize) + usize : csize; + event->mmap2.len = usize ?ALIGN_8 ((uint64_t )csize) + usize : (uint64_t )csize; event->mmap2.pid = pid; event->mmap2.tid = tid; event->mmap2.ino = st.st_ino;
@@ -612,7 +613,7 @@ static int jit_repipe_code_move(struct jit_buf_desc *jd, union jr_entry *jr)char *filename;size_t size;struct stat st; -int usize; +uint64_t usize;u16 idr_size;int ret;pid_t nspid, pid, tid;
@@ -761,6 +762,18 @@ jit_repipe_unwinding_info(struct jit_buf_desc *jd, union jr_entry *jr)return -1 ; unwinding_data_size = jr->prefix.total_size -sizeof (jr->unwinding); + +/* +* Validate sizes before allocating — jit_add_eh_frame_info() +* computes unwinding_size - eh_frame_hdr_size and uses the +* result as a buffer length for libelf. +*/ +if (jr->unwinding.unwinding_size > unwinding_data_size || + jr->unwinding.eh_frame_hdr_size > jr->unwinding.unwinding_size) { +pr_warning ("jitdump: invalid unwinding sizes in unwinding_info record\n" ); +return -1 ; + } + unwinding_data =malloc (unwinding_data_size);if (!unwinding_data)return -1 ;
Signature · 1 line
2.55.0
[email protected]
AI reviewRe: [PATCH 12/12] perf jitdump: Validate unwinding sizes against record payload
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
Pre-existing issues:
- [High] Stale unwinding data leak and corruption in subsequent JIT ELF files due to missing cleanup when eh_frame_hdr_size is zero.
- [High] Missing bounds check in jit_repipe_code_move leaks uninitialized heap memory into perf.data.
--
commit 606a51d613d656e670cf8772d98c0b537c8eb055
Author: Arnaldo Carvalho de Melo <[email protected]>
perf jitdump: Validate unwinding sizes against record payload
This commit validates unwinding sizes against the record payload to prevent out-of-bounds heap reads when eh_frame_hdr_size exceeds unwinding_size. It also updates mapped_size to use a uint64_t to avoid mmap2 length truncation.
Quoted 14 lines
tools/perf/util/jitdump.c +2
-1@@ -462,7 +462,8 @@ static int jit_repipe_code_load(struct jit_buf_desc *jd, union jr_entry *jr)u16 idr_size;const char *sym;uint64_t count; -int ret, csize, usize; +int ret, csize; +uint64_t usize;pid_t nspid, pid, tid;struct {u32 pid, tid;
tools/perf/util/jitdump.c
Quoted 2 lines
tools/perf/util/jitdump.c +0
-0u64 time; } *id;
[Severity: High]
This is a pre-existing issue, but does jit_repipe_code_load() leak stale unwinding data to subsequent JIT ELF files if eh_frame_hdr_size is zero?
A JIT dump can contain an unwinding record with unwinding_size > 0 but eh_frame_hdr_size == 0, which is valid and permitted by the new size validation.
When processing the subsequent code_load event, it correctly uses this unwinding data, but appears to skip the cleanup block because jd->eh_frame_hdr_size is zero:
if (jd->unwinding_data && jd->eh_frame_hdr_size) {
zfree(&jd->unwinding_data);
jd->eh_frame_hdr_size = 0;
...
}Could this cause all subsequent code_load events to erroneously embed the same stale unwinding table, corrupting the generated ELF files for unrelated JIT methods?
[ ... ]
tools/perf/util/jitdump.c static int jit_repipe_code_move(struct jit_buf_desc *jd, union jr_entry *jr) · line 619
Quoted 9 lines
tools/perf/util/jitdump.c +1
-1@@ -612,7 +613,7 @@ static int jit_repipe_code_move(struct jit_buf_desc *jd, union jr_entry *jr)char *filename;size_t size;struct stat st; -int usize; +uint64_t usize;u16 idr_size;int ret;pid_t nspid, pid, tid;
[Severity: High]
This is a pre-existing issue, but does jit_repipe_code_move() lack bounds checking for the record payload?
A malformed JIT dump could provide a JIT_CODE_MOVE record with a total_size smaller than sizeof(struct jr_code_move). jit_get_next_entry() reallocates the buffer to exactly total_size bytes, but jit_repipe_code_move() doesn't validate total_size before unconditionally accessing fields past the fixed record prefix:
nspid = jr->load.pid; ... event->mmap2.start = jr->move.new_code_addr; event->mmap2.len = usize ? ALIGN_8(jr->move.code_size) + usize : jr->move.code_size;
Could this result in uninitialized out-of-bounds heap memory being assigned to event fields that are subsequently written to the output perf.data stream?
[ ... ]
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=12