Skip to contentSkip to conversation

perf annotate-data: Support flexible array types

PATCH Superseded Namhyung Kim 2 participants 13 messages Sep 12 – Sep 14 perf events

v1 of 5 Superseded Latest is v5 →

lore
Share & tools
lore

Namhyung Kim

author maintainer
#0 lore raw

cover perf annotate-data: Support flexible array types

Hello,

The flexible arrays are dynamically allocated with different size. So checking with the original type size won't match and cannot match the sample. This patch series detects those flex-arrays and allows accesses beyond the original size.

I'm not sure what's the best way to add test codes for data type profiling as it seems we need to add a lot more workloads for different cases. Probably we may want to split the workloads as separate binaries.

Thanks,
Namhyung

Cc Zecheng Li <[email protected]>
Cc Yanbo Zhao <[email protected]>
Cc Tengda Wu <[email protected]>
Cc Shuai Xue <[email protected]>

Namhyung Kim (4):
perf annotate-data: Convert type histogram to hashmap perf dwarf-aux: Add die_has_flex_array() helper
perf annotate-date: Allow out-of-size access for flex-array types perf annotate-data: Adjust type offset for flex-array

 tools/perf/ui/browsers/annotate-data.c |  11 +-
 tools/perf/util/annotate-data.c        | 167 +++++++++++++++++++------
 tools/perf/util/annotate-data.h        |  10 +-
 tools/perf/util/dwarf-aux.c            |  57 +++++++++
 tools/perf/util/dwarf-aux.h            |   3 +
 5 files changed, 202 insertions(+), 46 deletions(-)
Signature · 1 line
2.55.0.1032.g73a4cd73de-goog
author maintainer
#1 lore raw

PATCH 1/4 perf annotate-data: Convert type histogram to hashmap

The type histogram maintains sample counts and periods per offset. Use a hashmap instead of an array to reduce the memory overhead.

No functional changes intended.

---
 tools/perf/ui/browsers/annotate-data.c | 11 ++--
 tools/perf/util/annotate-data.c        | 72 ++++++++++++++++----------
 tools/perf/util/annotate-data.h        |  8 +--
 3 files changed, 58 insertions(+), 33 deletions(-)
tools/perf/ui/browsers/annotate-data.c +8 -3
index aa8c89fe2e82c1c5..82667c6ae2e746c6 100644
@@ -62,12 +62,17 @@ static int get_member_overhead(struct annotated_data_type *adt,
 
 		k = 0;
 		for_each_group_evsel(evsel, leader) {
+			struct type_hist_entry *hist;
+
 			if (symbol_conf.skip_empty &&
 			    evsel__hists(evsel)->stats.nr_samples == 0)
 				continue;
 
-			h = adt->histograms[evsel->core.idx];
-			update_hist_entry(&entry->hists[k++], &h->addr[offset]);
+			h = &adt->histograms[evsel->core.idx];
+			if (!hashmap__find(&h->samples, offset, &hist))
+				continue;
+
+			update_hist_entry(&entry->hists[k++], hist);
 		}
 	}
 	return 0;
@@ -416,7 +421,7 @@ static void browser__write(struct ui_browser *uib, void *entry, int row)
 
 	/* print the number */
 	for_each_group_evsel(evsel, leader) {
-		struct type_hist *h = adt->histograms[evsel->core.idx];
+		struct type_hist *h = &adt->histograms[evsel->core.idx];
 
 		if (symbol_conf.skip_empty &&
 		    evsel__hists(evsel)->stats.nr_samples == 0)
tools/perf/util/annotate-data.c +46 -26

128 lines not on this page · raw message

tools/perf/util/annotate-data.h +4 -4
index c26130744260955f..ca2096a9ee62cbfe 100644
@@ -73,12 +73,12 @@ struct type_hist_entry {
  * struct type_hist - Type histogram for each event
  * @nr_samples: Total number of samples in this data type
  * @period: Total count of the event in this data type
- * @offset: Array of histogram entry
+ * @samples: Hashmap of (offset, type_hist_entry)
  */
 struct type_hist {
 	u64			nr_samples;
 	u64			period;
-	struct type_hist_entry	addr[];
+	struct hashmap		samples;
 };
 
 /**
@@ -86,7 +86,7 @@ struct type_hist {
  * @node: RB-tree node for dso->type_tree
  * @self: Actual type information
  * @nr_histogram: Number of histogram entries
- * @histograms: An array of pointers to histograms
+ * @histograms: An array of histograms
  *
  * This represents a data type accessed by samples in the profile data.
  */
@@ -94,7 +94,7 @@ struct annotated_data_type {
 	struct rb_node node;
 	struct annotated_member self;
 	int nr_histograms;
-	struct type_hist **histograms;
+	struct type_hist *histograms;
 };
 
 extern struct annotated_data_type unknown_type;
Signature · 1 line
2.55.0.1032.g73a4cd73de-goog
#2 lore raw

Re: [PATCH 1/4] perf annotate-data: Convert type histogram to hashmap

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] Missing index increment when hashmap lookup fails in `get_member_overhead` causes histogram…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Missing index increment when hashmap lookup fails in get_member_overhead causes histogram columns to be scrambled across events. --

commit 4840a8fb0b1911e5130194633a0b05e4bf3e21fe
Author: Namhyung Kim <[email protected]>

perf annotate-data: Convert type histogram to hashmap

This commit converts the type histogram from an array to a hashmap to reduce memory overhead. It replaces direct array accesses with hashmap lookups across the annotation components.

Quoted 11 lines
tools/perf/ui/browsers/annotate-data.c +2 -0
index aa8c89fe2e82c..82667c6ae2e74 100644
@@ -62,12 +62,17 @@ static int get_member_overhead(struct annotated_data_type *adt,
 
 		k = 0;
 		for_each_group_evsel(evsel, leader) {
+			struct type_hist_entry *hist;
+
 			if (symbol_conf.skip_empty &&

tools/perf/ui/browsers/annotate-data.c static int get_member_overhead(struct annotated_data_type *adt, · line 75

Quoted 10 lines
tools/perf/ui/browsers/annotate-data.c +5 -2
 			    evsel__hists(evsel)->stats.nr_samples == 0)
 				continue;
 
-			h = adt->histograms[evsel->core.idx];
-			update_hist_entry(&entry->hists[k++], &h->addr[offset]);
+			h = &adt->histograms[evsel->core.idx];
+			if (!hashmap__find(&h->samples, offset, &hist))
+				continue;
+
+			update_hist_entry(&entry->hists[k++], hist);

[Severity: Medium]
When hashmap__find() fails (indicating an event has no samples at this byte offset), the continue statement skips the k++ increment.

Will this cause subsequent events in the group to write their stats into the skipped event's entry->hists[k] bucket?

If k is not advanced for the skipped event, it appears the histogram columns for multi-event annotation data could shift and display in the wrong event columns in the UI.

Could we ensure k is incremented even when the hashmap lookup fails to preserve the correct column alignment?

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
author maintainer
#3 lore raw

Re: [PATCH 1/4] perf annotate-data: Convert type histogram to hashmap

Quoted 42 lines · On Sat, Sep 12, 2026 at 05:56:45AM +0000, [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Missing index increment when hashmap lookup fails in get_member_overhead causes histogram columns to be scrambled across events. --

commit 4840a8fb0b1911e5130194633a0b05e4bf3e21fe
Author: Namhyung Kim <[email protected]>

perf annotate-data: Convert type histogram to hashmap

This commit converts the type histogram from an array to a hashmap to reduce memory overhead. It replaces direct array accesses with hashmap lookups across the annotation components.

Quoted 11 lines
tools/perf/ui/browsers/annotate-data.c +2 -0
index aa8c89fe2e82c..82667c6ae2e74 100644
@@ -62,12 +62,17 @@ static int get_member_overhead(struct annotated_data_type *adt,
 
 		k = 0;
 		for_each_group_evsel(evsel, leader) {
+			struct type_hist_entry *hist;
+
 			if (symbol_conf.skip_empty &&

tools/perf/ui/browsers/annotate-data.c static int get_member_overhead(struct annotated_data_type *adt, · line 75

Quoted 10 lines
tools/perf/ui/browsers/annotate-data.c +5 -2
 			    evsel__hists(evsel)->stats.nr_samples == 0)
 				continue;
 
-			h = adt->histograms[evsel->core.idx];
-			update_hist_entry(&entry->hists[k++], &h->addr[offset]);
+			h = &adt->histograms[evsel->core.idx];
+			if (!hashmap__find(&h->samples, offset, &hist))
+				continue;
+
+			update_hist_entry(&entry->hists[k++], hist);

[Severity: Medium]
When hashmap__find() fails (indicating an event has no samples at this byte offset), the continue statement skips the k++ increment.

Will this cause subsequent events in the group to write their stats into the skipped event's entry->hists[k] bucket?

Quoted 6 lines

If k is not advanced for the skipped event, it appears the histogram columns for multi-event annotation data could shift and display in the wrong event columns in the UI.

Could we ensure k is incremented even when the hashmap lookup fails to preserve the correct column alignment?

Right, will fix in v2.

Thanks,
Namhyung

author maintainer
#4 lore raw

PATCH 2/4 perf dwarf-aux: Add die_has_flex_array() helper

In reply to Namhyung Kim

The die_has_flex_array() returns true when the given type is a struct and contains an array at the end of the struct.

Cc Masami Hiramatsu <[email protected]>
---
 tools/perf/util/dwarf-aux.c | 57 +++++++++++++++++++++++++++++++++++++
 tools/perf/util/dwarf-aux.h |  3 ++
 2 files changed, 60 insertions(+)
tools/perf/util/dwarf-aux.c +57 -0
index d7160f87ac7d7ab3..98d018798fa750ae 100644
@@ -2180,3 +2180,60 @@ Dwarf_Die *die_deref_ptr_type(Dwarf_Die *ptr_die, int offset,
 
 	return die_get_member_type(&type_die, offset, die_mem);
 }
+
+static bool __die_find_last_member(Dwarf_Die *parent_die, Dwarf_Die *die_mem)
+{
+	Dwarf_Die tmp_die;
+	bool found = false;
+
+	if (dwarf_child(parent_die, &tmp_die))
+		return false;
+
+	do {
+		if (dwarf_tag(&tmp_die) == DW_TAG_member) {
+			memcpy(die_mem, &tmp_die, sizeof(tmp_die));
+			found = true;
+		}
+	} while (dwarf_siblingof(&tmp_die, &tmp_die) == 0);
+
+	return found;
+}
+
+/**
+ * die_has_flex_array - Check if the given type has a flex-array at the end
+ * @parent_die: a pointer to type DIE
+ *
+ * This function returns %true iff @parent_die is a struct type and has an
+ * array at the end.  Note that the flex-array has no element, it should have
+ * no size and the parent size doesn't include the flex-array.  So it should
+ * locate at the offset of the parent size.
+ *
+ * For simplicity, it assumes the parent size of aligned with the flex-array.
+ */
+bool die_has_flex_array(Dwarf_Die *parent_die)
+{
+	Dwarf_Die die_mem, type_die;
+	Dwarf_Word size, loc;
+
+	if (dwarf_tag(parent_die) != DW_TAG_structure_type)
+		return false;
+
+	if (dwarf_aggregate_size(parent_die, &size) < 0)
+		return false;
+
+	/* get the member field at the end of the struct */
+	if (!__die_find_last_member(parent_die, &die_mem))
+		return false;
+
+	/* get the type of the member */
+	if (die_get_real_type(&die_mem, &type_die) == NULL)
+		return false;
+
+	if (dwarf_tag(&type_die) == DW_TAG_array_type)
+		return die_get_data_member_location(&die_mem, &loc) == 0 && loc == size;
+
+	if (dwarf_tag(&type_die) == DW_TAG_structure_type)
+		return die_has_flex_array(&type_die);
+
+	return false;
+}
tools/perf/util/dwarf-aux.h +3 -0
index 161f0bf980b6ee6a..9b662db710220522 100644
@@ -189,4 +189,7 @@ void die_collect_global_vars(Dwarf_Die *cu_die, struct die_var_type **var_types)
 /* Get the frame base information from CFA */
 int die_get_cfa(Dwarf *dwarf, u64 pc, int *preg, int *poffset);
 
+/* Check whether given type has a flex array */
+bool die_has_flex_array(Dwarf_Die *parent_die);
+
 #endif /* _DWARF_AUX_H */
Signature · 1 line
2.55.0.1032.g73a4cd73de-goog
#5 lore raw

Re: [PATCH 2/4] perf dwarf-aux: Add die_has_flex_array() helper

Thank you for your contribution! Sashiko AI review found 4 potential issue(s) to consider: - [High] die_has_flex_array() uses a flawed heuristic (`loc == size`) to identify flexible arrays, which…

Thank you for your contribution! Sashiko AI review found 4 potential issue(s) to consider:
- [High] die_has_flex_array() uses a flawed heuristic (loc == size) to identify flexible arrays, which falsely rejects standard C structs with trailing alignment padding.
- [Medium] Nested structures bypass the bounds and padding validation for flexible arrays, creating inconsistent logic compared to direct array members.
- [Medium] The function fails to detect flexible arrays that are embedded inside a trailing anonymous union.
- [Medium] Infinite recursion in die_has_flex_array() when parsing maliciously crafted cyclic DWARF structures, leading to stack exhaustion.
--

commit 8b9b8180d24f8e4da056fe22e70f6b84446a7257
Author: Namhyung Kim <[email protected]>

perf dwarf-aux: Add die_has_flex_array() helper

The die_has_flex_array() returns true when the given type is a struct and contains an array at the end of the struct.

Quoted 4 lines
tools/perf/util/dwarf-aux.c +0 -0
index d7160f87ac7d7..98d018798fa75 100644

[ ... ]

tools/perf/util/dwarf-aux.c Dwarf_Die *die_deref_ptr_type(Dwarf_Die *ptr_die, int offset, · line 2219

Quoted 7 lines
tools/perf/util/dwarf-aux.c +7 -0
+bool die_has_flex_array(Dwarf_Die *parent_die)
+{
+	Dwarf_Die die_mem, type_die;
+	Dwarf_Word size, loc;
+
+	if (dwarf_tag(parent_die) != DW_TAG_structure_type)
+		return false;

[Severity: Medium]
Does this rigid check against DW_TAG_structure_type fail to detect valid flexible arrays embedded inside trailing anonymous unions, which are frequently used in the kernel?

[ ... ]

tools/perf/util/dwarf-aux.c Dwarf_Die *die_deref_ptr_type(Dwarf_Die *ptr_die, int offset, · line 2233

Quoted 2 lines
tools/perf/util/dwarf-aux.c +2 -0
+	if (dwarf_tag(&type_die) == DW_TAG_array_type)
+		return die_get_data_member_location(&die_mem, &loc) == 0 && loc == size;

[Severity: High]
Does this strict loc == size equality accurately detect flexible arrays when standard C structs contain trailing alignment padding?

When preceding members do not perfectly align with the struct's maximum alignment, the compiler pads the total struct size. For example, if a struct has an 8-byte long, a 4-byte int, and a trailing flexible array, its total size is padded to 16 bytes. However, the data member location (loc) of the flexible array is 12.

Could this cause perf annotate to falsely reject legitimate samples targeting flexible array members in padded structs by evaluating as PERF_TMR_BAD_OFFSET?

tools/perf/util/dwarf-aux.c Dwarf_Die *die_deref_ptr_type(Dwarf_Die *ptr_die, int offset, · line 2236

Quoted 3 lines
tools/perf/util/dwarf-aux.c +3 -0
+
+	if (dwarf_tag(&type_die) == DW_TAG_structure_type)
+		return die_has_flex_array(&type_die);

[Severity: Medium]
Does this recursive call bypass bounds and padding validation for flexible arrays nested inside structures, making the logic inconsistent compared to direct array members?

If the last member is a nested struct with no padding, it returns true, completely ignoring any padding that may exist between the nested struct and the end of the parent struct.

[Severity: Medium]
Is there a risk of infinite recursion and stack exhaustion when parsing maliciously crafted cyclic DWARF structures?

If an untrusted DWARF file defines a struct A whose last member is struct B, and struct B's last member is struct A, this recursion could overflow the stack since it lacks depth limits or cycle tracking.

tools/perf/util/dwarf-aux.c

Quoted 2 lines
tools/perf/util/dwarf-aux.c +2 -0
+
+	return false;

[Severity: Medium]
Is this fall-through where DW_TAG_union_type is unhandled, dropping support for flexible arrays wrapped in trailing unions?

Quoted 1 line

+}

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
author maintainer
#6 lore raw

Re: [PATCH 2/4] perf dwarf-aux: Add die_has_flex_array() helper

Quoted 20 lines · On Sat, Sep 12, 2026 at 05:58:36AM +0000, [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 4 potential issue(s) to consider:
- [High] die_has_flex_array() uses a flawed heuristic (loc == size) to identify flexible arrays, which falsely rejects standard C structs with trailing alignment padding.
- [Medium] Nested structures bypass the bounds and padding validation for flexible arrays, creating inconsistent logic compared to direct array members.
- [Medium] The function fails to detect flexible arrays that are embedded inside a trailing anonymous union.
- [Medium] Infinite recursion in die_has_flex_array() when parsing maliciously crafted cyclic DWARF structures, leading to stack exhaustion.
--

commit 8b9b8180d24f8e4da056fe22e70f6b84446a7257
Author: Namhyung Kim <[email protected]>

perf dwarf-aux: Add die_has_flex_array() helper

The die_has_flex_array() returns true when the given type is a struct and contains an array at the end of the struct.

Quoted 4 lines
tools/perf/util/dwarf-aux.c +0 -0
index d7160f87ac7d7..98d018798fa75 100644

[ ... ]

Quoted 12 lines

tools/perf/util/dwarf-aux.c Dwarf_Die *die_deref_ptr_type(Dwarf_Die *ptr_die, int offset, · line 2219

Quoted 7 lines
tools/perf/util/dwarf-aux.c +7 -0
+bool die_has_flex_array(Dwarf_Die *parent_die)
+{
+	Dwarf_Die die_mem, type_die;
+	Dwarf_Word size, loc;
+
+	if (dwarf_tag(parent_die) != DW_TAG_structure_type)
+		return false;

[Severity: Medium]
Does this rigid check against DW_TAG_structure_type fail to detect valid flexible arrays embedded inside trailing anonymous unions, which are frequently used in the kernel?

Hmm.. ok. I'll add union type support.

Quoted 9 lines

[ ... ]

tools/perf/util/dwarf-aux.c Dwarf_Die *die_deref_ptr_type(Dwarf_Die *ptr_die, int offset, · line 2233

Quoted 2 lines
tools/perf/util/dwarf-aux.c +2 -0
+	if (dwarf_tag(&type_die) == DW_TAG_array_type)
+		return die_get_data_member_location(&die_mem, &loc) == 0 && loc == size;

[Severity: High]
Does this strict loc == size equality accurately detect flexible arrays when standard C structs contain trailing alignment padding?

Quoted 5 lines

When preceding members do not perfectly align with the struct's maximum alignment, the compiler pads the total struct size. For example, if a struct has an 8-byte long, a 4-byte int, and a trailing flexible array, its total size is padded to 16 bytes. However, the data member location (loc) of the flexible array is 12.

Right.

Quoted 3 lines

Could this cause perf annotate to falsely reject legitimate samples targeting flexible array members in padded structs by evaluating as PERF_TMR_BAD_OFFSET?

Ok, I'll change the logic to check the last member being an array and its size is not specified or zero.

Quoted 10 lines

tools/perf/util/dwarf-aux.c Dwarf_Die *die_deref_ptr_type(Dwarf_Die *ptr_die, int offset, · line 2236

Quoted 4 lines
tools/perf/util/dwarf-aux.c +3 -0
+
+	if (dwarf_tag(&type_die) == DW_TAG_structure_type)
+		return die_has_flex_array(&type_die);

[Severity: Medium]
Does this recursive call bypass bounds and padding validation for flexible arrays nested inside structures, making the logic inconsistent compared to direct array members?

Quoted 3 lines

If the last member is a nested struct with no padding, it returns true, completely ignoring any padding that may exist between the nested struct and the end of the parent struct.

I'll add a check for the offset too.

Quoted 8 lines

[Severity: Medium]
Is there a risk of infinite recursion and stack exhaustion when parsing maliciously crafted cyclic DWARF structures?

If an untrusted DWARF file defines a struct A whose last member is struct B, and struct B's last member is struct A, this recursion could overflow the stack since it lacks depth limits or cycle tracking.

I'm not sure if it's possible but anyway I can add a recursion check just in case.

Quoted 7 lines

tools/perf/util/dwarf-aux.c

Quoted 3 lines
tools/perf/util/dwarf-aux.c +2 -0
+
+	return false;

[Severity: Medium]
Is this fall-through where DW_TAG_union_type is unhandled, dropping support for flexible arrays wrapped in trailing unions?

Will handle that as well.

Thanks,
Namhyung

author maintainer
#7 lore raw

PATCH 3/4 perf annotate-date: Allow out-of-size access for flex-array types

In reply to Namhyung Kim

Structs that have a flex array will have accesses beyond its original size as the array was declared as 0 sized. For now, it just allow any offset bigger than the size. It could be refined later.

---
 tools/perf/util/annotate-data.c | 22 +++++++++++++++-------
 tools/perf/util/annotate-data.h |  2 ++
 2 files changed, 17 insertions(+), 7 deletions(-)
tools/perf/util/annotate-data.c +15 -7
index aff60a630fd05b01..ad043403ced58d98 100644
@@ -248,8 +248,15 @@ static int __add_member_cb(Dwarf_Die *die, void *arg)
 	else
 		die_mem = member_type;
 
-	if (dwarf_aggregate_size(&die_mem, &size) < 0)
-		size = 0;
+	if (dwarf_aggregate_size(&die_mem, &size) < 0) {
+		if (dwarf_tag(&die_mem) == DW_TAG_array_type) { /* flex-array? */
+			__die_get_real_type(&die_mem, &die_mem);
+			if (dwarf_aggregate_size(&die_mem, &size) < 0)
+				size = 0;
+		} else {
+			size = 0;
+		}
+	}
 
 	if (dwarf_attr_integrate(die, DW_AT_data_member_location, &attr)) {
 		if (dwarf_formudata(&attr, &loc) != 0) {
@@ -399,6 +406,7 @@ static struct annotated_data_type *dso__findnew_data_type(struct dso *dso,
 	result->self.type_name = type_name;
 	result->self.size = size;
 	INIT_LIST_HEAD(&result->self.children);
+	result->flex_array = die_has_flex_array(type_die);
 
 	if (symbol_conf.annotate_data_member)
 		add_member_types(result, type_die);
@@ -559,7 +567,7 @@ static enum type_match_result check_variable(struct data_loc_info *dloc,
 		return PERF_TMR_NO_SIZE;
 
 	/* Minimal sanity check */
-	if ((unsigned)offset >= size)
+	if ((unsigned)offset >= size && !die_has_flex_array(&sized_type))
 		return PERF_TMR_BAD_OFFSET;
 
 	return PERF_TMR_OK;
@@ -1168,7 +1176,7 @@ static enum type_match_result check_matching_type(struct type_state *state,
 
 		/* Get the size of the actual type */
 		if (dwarf_aggregate_size(&sized_type, &size) < 0 ||
-		    (unsigned)dloc->type_offset >= size)
+		    ((unsigned)dloc->type_offset >= size && !die_has_flex_array(&sized_type)))
 			return PERF_TMR_BAD_OFFSET;
 
 		return PERF_TMR_OK;
@@ -1192,7 +1200,7 @@ static enum type_match_result check_matching_type(struct type_state *state,
 
 		/* Get the size of the actual type */
 		if (dwarf_aggregate_size(type_die, &size) < 0 ||
-		    (unsigned)dloc->type_offset >= size)
+		    ((unsigned)dloc->type_offset >= size && !die_has_flex_array(type_die)))
 			return PERF_TMR_BAD_OFFSET;
 
 		return PERF_TMR_OK;
@@ -1211,7 +1219,7 @@ static enum type_match_result check_matching_type(struct type_state *state,
 
 		/* Get the size of the actual type */
 		if (dwarf_aggregate_size(type_die, &size) < 0 ||
-		    (unsigned)dloc->type_offset >= size)
+		    ((unsigned)dloc->type_offset >= size && !die_has_flex_array(type_die)))
 			return PERF_TMR_BAIL_OUT;
 
 		return PERF_TMR_OK;
@@ -1839,7 +1847,7 @@ int annotated_data_type__update_samples(struct annotated_data_type *adt,
 			return -1;
 	}
 
-	if (offset < 0 || offset >= adt->self.size)
+	if (offset < 0 || (offset >= adt->self.size && !adt->flex_array))
 		return -1;
 
 	h = &adt->histograms[evsel->core.idx];
tools/perf/util/annotate-data.h +2 -0
index ca2096a9ee62cbfe..27b7148b64f60350 100644
@@ -85,6 +85,7 @@ struct type_hist {
  * struct annotated_data_type - Data type to profile
  * @node: RB-tree node for dso->type_tree
  * @self: Actual type information
+ * @flex_array: Whethere it has a flex array
  * @nr_histogram: Number of histogram entries
  * @histograms: An array of histograms
  *
@@ -93,6 +94,7 @@ struct type_hist {
 struct annotated_data_type {
 	struct rb_node node;
 	struct annotated_member self;
+	bool flex_array;
 	int nr_histograms;
 	struct type_hist *histograms;
 };
Signature · 1 line
2.55.0.1032.g73a4cd73de-goog
#8 lore raw

Re: [PATCH 3/4] perf annotate-date: Allow out-of-size access for flex-array types

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:

New issues:
- [Low] The patch breaks the negative bounds check for variables containing flexible arrays, allowing invalid negative offsets to be falsely accepted.
- [Low] Failure to expand flexible array elements if the element type is a typedef.

Pre-existing issues:
- [Low] Missing explicit inclusion of <string.h> for libc string functions, violating musl compatibility subsystem guidelines. --

commit 71730adfd191d6d7dd60b7b99d73c9bc2ede7031
Author: Namhyung Kim <[email protected]>

perf annotate-date: Allow out-of-size access for flex-array types

Structs that have a flex array will have accesses beyond its original size as the array was declared as 0 sized. For now, it just allow any offset bigger than the size. It could be refined later.

tools/perf/util/annotate-data.c line 12

Quoted 10 lines
tools/perf/util/annotate-data.c +0 -0
index aff60a630fd05..ad043403ced58 100644
@@ -8,5 +8,5 @@
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <inttypes.h>
 #include <linux/zalloc.h>

[Severity: Low]
This is a pre-existing issue, but is there a missing include for <string.h> in tools/perf/util/annotate-data.c? The file uses libc string functions like strcmp and strdup, and failing to explicitly include <string.h> violates the subsystem guidelines for musl libc compatibility, which could lead to build failures.

[ ... ]

tools/perf/util/annotate-data.c static int __add_member_cb(Dwarf_Die *die, void *arg) · line 253

Quoted 9 lines
tools/perf/util/annotate-data.c +3 -2
@@ -248,8 +248,15 @@ static int __add_member_cb(Dwarf_Die *die, void *arg)
 	else
 		die_mem = member_type;
 
-	if (dwarf_aggregate_size(&die_mem, &size) < 0)
-		size = 0;
+	if (dwarf_aggregate_size(&die_mem, &size) < 0) {
+		if (dwarf_tag(&die_mem) == DW_TAG_array_type) { /* flex-array? */
+			__die_get_real_type(&die_mem, &die_mem);

[Severity: Low]
Will __add_member_cb() fail to resolve typedefs here? Using __die_get_real_type instead of die_get_real_type strips const and volatile qualifiers but stops at DW_TAG_typedef. This prevents the subsequent struct expansion if the flexible array element type is a typedef of a struct.

Quoted 8 lines
tools/perf/util/annotate-data.c +6 -0
+			if (dwarf_aggregate_size(&die_mem, &size) < 0)
+				size = 0;
+		} else {
+			size = 0;
+		}
+	}
 
 	if (dwarf_attr_integrate(die, DW_AT_data_member_location, &attr)) {

[ ... ]

tools/perf/util/annotate-data.c static enum type_match_result check_variable(struct data_loc_info *dloc, · line 570

Quoted 6 lines
tools/perf/util/annotate-data.c +1 -1
@@ -559,7 +567,7 @@ static enum type_match_result check_variable(struct data_loc_info *dloc,
 		return PERF_TMR_NO_SIZE;
 
 	/* Minimal sanity check */
-	if ((unsigned)offset >= size)
+	if ((unsigned)offset >= size && !die_has_flex_array(&sized_type))

[Severity: Low]
Does check_variable() allow invalid negative offsets to bypass the check? Since offset is cast to unsigned, a negative offset evaluates to a large positive number. If the type has a flexible array, the negative bounds check is now broken and the offset will be falsely accepted.

Quoted 3 lines
tools/perf/util/annotate-data.c +0 -0
 		return PERF_TMR_BAD_OFFSET;
 
 	return PERF_TMR_OK;

[ ... ]

tools/perf/util/annotate-data.c static enum type_match_result check_matching_type(struct type_state *state, · line 1179

Quoted 6 lines
tools/perf/util/annotate-data.c +1 -1
@@ -1168,7 +1176,7 @@ static enum type_match_result check_matching_type(struct type_state *state,
 
 		/* Get the size of the actual type */
 		if (dwarf_aggregate_size(&sized_type, &size) < 0 ||
-		    (unsigned)dloc->type_offset >= size)
+		    ((unsigned)dloc->type_offset >= size && !die_has_flex_array(&sized_type)))

[Severity: Low]
Could this logic in check_matching_type() lead to negative offsets bypassing the check as well? Similar to check_variable(), casting dloc->type_offset to unsigned causes negative values to appear as large positive numbers, bypassing the bounds check if there is a flexible array. This flaw is repeated multiple times in the pointer tracking logic.

Quoted 3 lines
tools/perf/util/annotate-data.c +0 -0
 			return PERF_TMR_BAD_OFFSET;
 
 		return PERF_TMR_OK;
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3
author maintainer
#9 lore raw

Re: [PATCH 3/4] perf annotate-date: Allow out-of-size access for flex-array types

Quoted 28 lines · On Sat, Sep 12, 2026 at 06:02:24AM +0000, [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:

New issues:
- [Low] The patch breaks the negative bounds check for variables containing flexible arrays, allowing invalid negative offsets to be falsely accepted.
- [Low] Failure to expand flexible array elements if the element type is a typedef.

Pre-existing issues:
- [Low] Missing explicit inclusion of <string.h> for libc string functions, violating musl compatibility subsystem guidelines. --

commit 71730adfd191d6d7dd60b7b99d73c9bc2ede7031
Author: Namhyung Kim <[email protected]>

perf annotate-date: Allow out-of-size access for flex-array types

Structs that have a flex array will have accesses beyond its original size as the array was declared as 0 sized. For now, it just allow any offset bigger than the size. It could be refined later.

Quoted 9 lines
tools/perf/util/annotate-data.c +0 -0
index aff60a630fd05..ad043403ced58 100644
@@ -8,5 +8,5 @@
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <inttypes.h>
Quoted 8 lines

tools/perf/util/annotate-data.c line 12

Quoted 1 line
tools/perf/util/annotate-data.c +0 -0
 #include <linux/zalloc.h>

[Severity: Low]
This is a pre-existing issue, but is there a missing include for <string.h> in tools/perf/util/annotate-data.c? The file uses libc string functions like strcmp and strdup, and failing to explicitly include <string.h> violates the subsystem guidelines for musl libc compatibility, which could lead to build failures.

Will add.

Quoted 7 lines

[ ... ]

Quoted 4 lines
tools/perf/util/annotate-data.c +0 -0
@@ -248,8 +248,15 @@ static int __add_member_cb(Dwarf_Die *die, void *arg)
 	else
 		die_mem = member_type;
 
Quoted 11 lines

tools/perf/util/annotate-data.c static int __add_member_cb(Dwarf_Die *die, void *arg) · line 253

Quoted 5 lines
tools/perf/util/annotate-data.c +3 -2
-	if (dwarf_aggregate_size(&die_mem, &size) < 0)
-		size = 0;
+	if (dwarf_aggregate_size(&die_mem, &size) < 0) {
+		if (dwarf_tag(&die_mem) == DW_TAG_array_type) { /* flex-array? */
+			__die_get_real_type(&die_mem, &die_mem);

[Severity: Low]
Will __add_member_cb() fail to resolve typedefs here? Using __die_get_real_type instead of die_get_real_type strips const and volatile qualifiers but stops at DW_TAG_typedef. This prevents the subsequent struct expansion if the flexible array element type is a typedef of a struct.

Ok, I can change it to die_get_read_type() to handle tyepdef.

Quoted 15 lines
Quoted 9 lines
tools/perf/util/annotate-data.c +6 -0
+			if (dwarf_aggregate_size(&die_mem, &size) < 0)
+				size = 0;
+		} else {
+			size = 0;
+		}
+	}
 
 	if (dwarf_attr_integrate(die, DW_AT_data_member_location, &attr)) {

[ ... ]

Quoted 3 lines
tools/perf/util/annotate-data.c +0 -0
@@ -559,7 +567,7 @@ static enum type_match_result check_variable(struct data_loc_info *dloc,
 		return PERF_TMR_NO_SIZE;
 
Quoted 9 lines

tools/perf/util/annotate-data.c static enum type_match_result check_variable(struct data_loc_info *dloc, · line 570

Quoted 3 lines
tools/perf/util/annotate-data.c +1 -1
 	/* Minimal sanity check */
-	if ((unsigned)offset >= size)
+	if ((unsigned)offset >= size && !die_has_flex_array(&sized_type))

[Severity: Low]
Does check_variable() allow invalid negative offsets to bypass the check? Since offset is cast to unsigned, a negative offset evaluates to a large positive number. If the type has a flexible array, the negative bounds check is now broken and the offset will be falsely accepted.

Right, I'll add a separate negative value check.

Quoted 9 lines
Quoted 4 lines
tools/perf/util/annotate-data.c +0 -0
 		return PERF_TMR_BAD_OFFSET;
 
 	return PERF_TMR_OK;

[ ... ]

Quoted 2 lines
tools/perf/util/annotate-data.c +0 -0
@@ -1168,7 +1176,7 @@ static enum type_match_result check_matching_type(struct type_state *state,
 
Quoted 11 lines

tools/perf/util/annotate-data.c static enum type_match_result check_matching_type(struct type_state *state, · line 1179

Quoted 4 lines
tools/perf/util/annotate-data.c +1 -1
 		/* Get the size of the actual type */
 		if (dwarf_aggregate_size(&sized_type, &size) < 0 ||
-		    (unsigned)dloc->type_offset >= size)
+		    ((unsigned)dloc->type_offset >= size && !die_has_flex_array(&sized_type)))

[Severity: Low]
Could this logic in check_matching_type() lead to negative offsets bypassing the check as well? Similar to check_variable(), casting dloc->type_offset to unsigned causes negative values to appear as large positive numbers, bypassing the bounds check if there is a flexible array. This flaw is repeated multiple times in the pointer tracking logic.

Will fix them all. Probably with a helper function.

Thanks,
Namhyung

Quoted 7 lines
Quoted 4 lines
tools/perf/util/annotate-data.c +0 -0
 			return PERF_TMR_BAD_OFFSET;
 
 		return PERF_TMR_OK;
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3
author maintainer
#10 lore raw

PATCH 4/4 perf annotate-data: Adjust type offset for flex-array

In reply to Namhyung Kim

The flex array members are located beyond the original type size. Also it needs to adjust the offset in an array to find a corresponding element using module operation. Note that we focus on access to type and field, so array index is not important.

Make sure to find a field name for flex arrays.

---
 tools/perf/util/annotate-data.c | 73 ++++++++++++++++++++++++++++++---
 1 file changed, 67 insertions(+), 6 deletions(-)
tools/perf/util/annotate-data.c +67 -6
index ad043403ced58d98..0789a8cbea7c0355 100644
@@ -332,19 +332,40 @@ static void delete_members(struct annotated_member *member)
 }
 
 static int fill_member_name(char *buf, size_t sz, struct annotated_member *m,
-			    int offset, bool first)
+			    int offset, bool first, bool has_flex_array)
 {
 	struct annotated_member *child;
+	bool found = false;
+	int len;
 
 	if (list_empty(&m->children))
 		return 0;
 
 	list_for_each_entry(child, &m->children, node) {
-		int len;
-
 		if (offset < child->offset || offset >= child->offset + child->size)
 			continue;
 
+		found = true;
+		break;
+	}
+
+	if (!found && has_flex_array) {
+		/*
+		 * It may have an intermediate struct that has another struct that
+		 * contains a flex array.  In that case, the outer struct itself is
+		 * has no array and the size is less than the offset so the above
+		 * logic won't find the outer struct at the offset.  Let's use the
+		 * last struct if it couldn't find a member for the flex array.
+		 */
+		child = list_last_entry(&m->children, struct annotated_member, node);
+
+		if (!strstr(child->type_name, "struct "))
+			return 0;
+
+		found = true;
+	}
+
+	if (found) {
 		/* It can have anonymous struct/union members */
 		if (child->var_name) {
 			len = scnprintf(buf, sz, "%s%s",
@@ -354,15 +375,37 @@ static int fill_member_name(char *buf, size_t sz, struct annotated_member *m,
 			len = 0;
 		}
 
-		return fill_member_name(buf + len, sz - len, child, offset, first) + len;
+		return fill_member_name(buf + len, sz - len, child, offset, first,
+					has_flex_array) + len;
 	}
+
 	return 0;
 }
 
 int annotated_data_type__get_member_name(struct annotated_data_type *adt,
 					 char *buf, size_t sz, int member_offset)
 {
-	return fill_member_name(buf, sz, &adt->self, member_offset, /*first=*/true);
+	return fill_member_name(buf, sz, &adt->self, member_offset, /*first=*/true,
+				adt->flex_array);
+}
+
+static struct annotated_member *find_flex_array(struct annotated_member *m, int offset)
+{
+	struct annotated_member *child;
+
+	if (list_empty(&m->children))
+		return NULL;
+
+	child = list_last_entry(&m->children, struct annotated_member, node);
+	if (offset == child->offset && strstr(child->type_name, "[]"))
+		return child;
+
+	return find_flex_array(child, offset);
+}
+
+static struct annotated_member *get_flex_array_member(struct annotated_data_type *adt)
+{
+	return find_flex_array(&adt->self, adt->self.size);
 }
 
 static struct annotated_data_type *dso__findnew_data_type(struct dso *dso,
@@ -1743,6 +1786,7 @@ struct annotated_data_type *find_data_type(struct data_loc_info *dloc)
 {
 	struct dso *dso = map__dso(dloc->ms->map);
 	Dwarf_Die type_die;
+	struct annotated_data_type *result;
 
 	/*
 	 * The type offset is the same as instruction offset by default.
@@ -1755,7 +1799,24 @@ struct annotated_data_type *find_data_type(struct data_loc_info *dloc)
 	if (find_data_type_die(dloc, &type_die) < 0)
 		return NULL;
 
-	return dso__findnew_data_type(dso, &type_die);
+	result = dso__findnew_data_type(dso, &type_die);
+	if (result == NULL)
+		return NULL;
+
+	if (result->flex_array && dloc->type_offset > result->self.size) {
+		struct annotated_member *flex_array = get_flex_array_member(result);
+		if (flex_array) {
+			int offset = dloc->type_offset;
+
+			/* adjust offset in the flex array */
+			offset -= result->self.size;
+			offset %= flex_array->size;
+			offset += result->self.size;
+
+			dloc->type_offset = offset;
+		}
+	}
+	return result;
 }
 
 static size_t data_type_hash(long key, void *ctx __maybe_unused)
Signature · 1 line
2.55.0.1032.g73a4cd73de-goog
#11 lore raw

Re: [PATCH 4/4] perf annotate-data: Adjust type offset for flex-array

Thank you for your contribution! Sashiko AI review found 4 potential issue(s) to consider: - [High] Division by zero when calculating the adjusted offset for a flexible array member if the array…

Thank you for your contribution! Sashiko AI review found 4 potential issue(s) to consider:
- [High] Division by zero when calculating the adjusted offset for a flexible array member if the array element size is zero.
- [Medium] find_flex_array() fails to find the flex array member if the outer struct has trailing padding.
- [Medium] Fallback struct matching fails for typedefs and unions.
- [Medium] Struct padding holes are incorrectly annotated as the last member.
--

commit 29427abf6848041f9bb5e65c33e21982de9656cd
Author: Namhyung Kim <[email protected]>

perf annotate-data: Adjust type offset for flex-array

The flex array members are located beyond the original type size. Also it needs to adjust the offset in an array to find a corresponding element using module operation. Note that we focus on access to type and field, so array index is not important.

Make sure to find a field name for flex arrays.

Quoted 4 lines
tools/perf/util/annotate-data.c +0 -0
index ad043403ced58..0789a8cbea7c0 100644

[ ... ]

Quoted 7 lines
tools/perf/util/annotate-data.c +1 -1
@@ -332,19 +332,40 @@ static void delete_members(struct annotated_member *member)
 }
 
 static int fill_member_name(char *buf, size_t sz, struct annotated_member *m,
-			    int offset, bool first)
+			    int offset, bool first, bool has_flex_array)
 {

[ ... ]

tools/perf/util/annotate-data.c static void delete_members(struct annotated_member *member) · line 360

Quoted 9 lines
tools/perf/util/annotate-data.c +9 -0
+	if (!found && has_flex_array) {
+		/*
+		 * It may have an intermediate struct that has another struct that
+		 * contains a flex array.  In that case, the outer struct itself is
+		 * has no array and the size is less than the offset so the above
+		 * logic won't find the outer struct at the offset.  Let's use the
+		 * last struct if it couldn't find a member for the flex array.
+		 */
+		child = list_last_entry(&m->children, struct annotated_member, node);

[Severity: Medium]
In fill_member_name() in tools/perf/util/annotate-data.c, if the requested offset doesn't fall into any member's bounds (which occurs for accesses to padding bytes between fields), found remains false. If has_flex_array is true, this block unconditionally assigns child to the last member and sets found to true.

Will this cause random memory accesses to padding bytes to be erroneously annotated as valid accesses to the flexible array's parent struct?

tools/perf/util/annotate-data.c static void delete_members(struct annotated_member *member) · line 363

Quoted 3 lines
tools/perf/util/annotate-data.c +3 -0
+
+		if (!strstr(child->type_name, "struct "))
+			return 0;

[Severity: Medium]
In fill_member_name() in tools/perf/util/annotate-data.c, can this fallback struct matching fail for valid nested flexible arrays declared with a typedef or a union?

If the nested intermediate member was declared using a typedef (e.g., typedef struct { ... } foo_t;), the DWARF type name will be foo_t, lacking the substring "struct ". If it is a union, its type name begins with "union ". In these cases, this check fails, causing the function to incorrectly return 0 and drop the annotation.

Quoted 3 lines
tools/perf/util/annotate-data.c +3 -0
+
+		found = true;
+	}

[ ... ]

tools/perf/util/annotate-data.c static int fill_member_name(char *buf, size_t sz, struct annotated_member *m, · line 401

Quoted 10 lines
tools/perf/util/annotate-data.c +10 -0
+static struct annotated_member *find_flex_array(struct annotated_member *m, int offset)
+{
+	struct annotated_member *child;
+
+	if (list_empty(&m->children))
+		return NULL;
+
+	child = list_last_entry(&m->children, struct annotated_member, node);
+	if (offset == child->offset && strstr(child->type_name, "[]"))
+		return child;

[Severity: Medium]
In find_flex_array() in tools/perf/util/annotate-data.c, will this strict offset equality check fail if the outer struct has trailing padding?

When get_flex_array_member() calls find_flex_array(&adt->self, adt->self.size), the offset argument is the struct's total padded size. If the struct contains trailing alignment padding (e.g., a previous 8-byte aligned member followed by the flex array), the struct's padded total size will be strictly greater than the actual starting offset of the flex array.

Will this cause find_flex_array() to fail the equality check and incorrectly recurse into the flex array itself, returning NULL and bypassing the offset adjustment logic?

Quoted 3 lines
tools/perf/util/annotate-data.c +3 -0
+
+	return find_flex_array(child, offset);
+}

[ ... ]

Quoted 1 line
tools/perf/util/annotate-data.c +0 -0
@@ -1743,6 +1786,7 @@ struct annotated_data_type *find_data_type(struct data_loc_info *dloc)

[ ... ]

tools/perf/util/annotate-data.c struct annotated_data_type *find_data_type(struct data_loc_info *dloc) · line 1813

Quoted 8 lines
tools/perf/util/annotate-data.c +8 -0
+	if (result->flex_array && dloc->type_offset > result->self.size) {
+		struct annotated_member *flex_array = get_flex_array_member(result);
+		if (flex_array) {
+			int offset = dloc->type_offset;
+
+			/* adjust offset in the flex array */
+			offset -= result->self.size;
+			offset %= flex_array->size;

[Severity: High]
In find_data_type() in tools/perf/util/annotate-data.c, is it possible for this modulo operation to divide by the flexible array's element size without validating that the size is non-zero?

The flex_array->size is determined by getting the size of the array's element type. If the element type is an empty struct (a GCC extension with size 0) or an incomplete type where DWARF size cannot be determined, flex_array->size becomes 0.

Could evaluating offset %= 0 here directly expose the perf tool to a divide-by-zero exception (SIGFPE) and crash?

Quoted 7 lines
tools/perf/util/annotate-data.c +6 -0
+			offset += result->self.size;
+
+			dloc->type_offset = offset;
+		}
+	}
+	return result;
 }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=4
author maintainer
#12 lore raw

Re: [PATCH 4/4] perf annotate-data: Adjust type offset for flex-array

Quoted 49 lines · On Sat, Sep 12, 2026 at 05:57:56AM +0000, [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 4 potential issue(s) to consider:
- [High] Division by zero when calculating the adjusted offset for a flexible array member if the array element size is zero.
- [Medium] find_flex_array() fails to find the flex array member if the outer struct has trailing padding.
- [Medium] Fallback struct matching fails for typedefs and unions.
- [Medium] Struct padding holes are incorrectly annotated as the last member.
--

commit 29427abf6848041f9bb5e65c33e21982de9656cd
Author: Namhyung Kim <[email protected]>

perf annotate-data: Adjust type offset for flex-array

The flex array members are located beyond the original type size. Also it needs to adjust the offset in an array to find a corresponding element using module operation. Note that we focus on access to type and field, so array index is not important.

Make sure to find a field name for flex arrays.

Quoted 4 lines
tools/perf/util/annotate-data.c +0 -0
index ad043403ced58..0789a8cbea7c0 100644

[ ... ]

Quoted 7 lines
tools/perf/util/annotate-data.c +1 -1
@@ -332,19 +332,40 @@ static void delete_members(struct annotated_member *member)
 }
 
 static int fill_member_name(char *buf, size_t sz, struct annotated_member *m,
-			    int offset, bool first)
+			    int offset, bool first, bool has_flex_array)
 {

[ ... ]

tools/perf/util/annotate-data.c static void delete_members(struct annotated_member *member) · line 360

Quoted 9 lines
tools/perf/util/annotate-data.c +9 -0
+	if (!found && has_flex_array) {
+		/*
+		 * It may have an intermediate struct that has another struct that
+		 * contains a flex array.  In that case, the outer struct itself is
+		 * has no array and the size is less than the offset so the above
+		 * logic won't find the outer struct at the offset.  Let's use the
+		 * last struct if it couldn't find a member for the flex array.
+		 */
+		child = list_last_entry(&m->children, struct annotated_member, node);

[Severity: Medium]
In fill_member_name() in tools/perf/util/annotate-data.c, if the requested offset doesn't fall into any member's bounds (which occurs for accesses to padding bytes between fields), found remains false. If has_flex_array is true, this block unconditionally assigns child to the last member and sets found to true.

Quoted 2 lines

Will this cause random memory accesses to padding bytes to be erroneously annotated as valid accesses to the flexible array's parent struct?

Ok, I think it needs to verify if the offset is greater than equal to the start of the flex array.

Quoted 10 lines

tools/perf/util/annotate-data.c static void delete_members(struct annotated_member *member) · line 363

Quoted 4 lines
tools/perf/util/annotate-data.c +3 -0
+
+		if (!strstr(child->type_name, "struct "))
+			return 0;

[Severity: Medium]
In fill_member_name() in tools/perf/util/annotate-data.c, can this fallback struct matching fail for valid nested flexible arrays declared with a typedef or a union?

Quoted 5 lines

If the nested intermediate member was declared using a typedef (e.g., typedef struct { ... } foo_t;), the DWARF type name will be foo_t, lacking the substring "struct ". If it is a union, its type name begins with "union ". In these cases, this check fails, causing the function to incorrectly return 0 and drop the annotation.

Ok, probably I can just remove this check.

Quoted 26 lines
Quoted 4 lines
tools/perf/util/annotate-data.c +3 -0
+
+		found = true;
+	}

[ ... ]

tools/perf/util/annotate-data.c static int fill_member_name(char *buf, size_t sz, struct annotated_member *m, · line 401

Quoted 10 lines
tools/perf/util/annotate-data.c +10 -0
+static struct annotated_member *find_flex_array(struct annotated_member *m, int offset)
+{
+	struct annotated_member *child;
+
+	if (list_empty(&m->children))
+		return NULL;
+
+	child = list_last_entry(&m->children, struct annotated_member, node);
+	if (offset == child->offset && strstr(child->type_name, "[]"))
+		return child;

[Severity: Medium]
In find_flex_array() in tools/perf/util/annotate-data.c, will this strict offset equality check fail if the outer struct has trailing padding?

When get_flex_array_member() calls find_flex_array(&adt->self, adt->self.size), the offset argument is the struct's total padded size. If the struct contains trailing alignment padding (e.g., a previous 8-byte aligned member followed by the flex array), the struct's padded total size will be strictly greater than the actual starting offset of the flex array.

Quoted 3 lines

Will this cause find_flex_array() to fail the equality check and incorrectly recurse into the flex array itself, returning NULL and bypassing the offset adjustment logic?

Right, probably no need to check the offset as it always checks the last member.

Quoted 21 lines
Quoted 4 lines
tools/perf/util/annotate-data.c +3 -0
+
+	return find_flex_array(child, offset);
+}

[ ... ]

Quoted 1 line
tools/perf/util/annotate-data.c +0 -0
@@ -1743,6 +1786,7 @@ struct annotated_data_type *find_data_type(struct data_loc_info *dloc)

[ ... ]

tools/perf/util/annotate-data.c struct annotated_data_type *find_data_type(struct data_loc_info *dloc) · line 1813

Quoted 8 lines
tools/perf/util/annotate-data.c +8 -0
+	if (result->flex_array && dloc->type_offset > result->self.size) {
+		struct annotated_member *flex_array = get_flex_array_member(result);
+		if (flex_array) {
+			int offset = dloc->type_offset;
+
+			/* adjust offset in the flex array */
+			offset -= result->self.size;
+			offset %= flex_array->size;

[Severity: High]
In find_data_type() in tools/perf/util/annotate-data.c, is it possible for this modulo operation to divide by the flexible array's element size without validating that the size is non-zero?

Quoted 7 lines

The flex_array->size is determined by getting the size of the array's element type. If the element type is an empty struct (a GCC extension with size 0) or an incomplete type where DWARF size cannot be determined, flex_array->size becomes 0.

Could evaluating offset %= 0 here directly expose the perf tool to a divide-by-zero exception (SIGFPE) and crash?

Ok, will check if the size if 0.

Thanks,
Namhyung

Quoted 11 lines
Quoted 8 lines
tools/perf/util/annotate-data.c +6 -0
+			offset += result->self.size;
+
+			dloc->type_offset = offset;
+		}
+	}
+	return result;
 }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=4