Skip to contentSkip to conversation

perf tools: Avoid unaligned pointer operations

PATCH Superseded Namhyung Kim 3 participants 7 messages Nov 27, 2024 – Dec 13, 2024 perf events

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

Namhyung Kim

author maintainer
#0 lore raw

PATCH 1/1 perf tools: Avoid unaligned pointer operations

The sample data is 64-bit aligned basically but raw data starts with 32-bit length field and data follows. In perf_event__synthesize_sample it treats the sample data as a 64-bit array. And it needs some trick to update the raw data properly.

But it seems some compilers are not happy with this and the program dies siliently. I found the sample parsing test failed without any messages on affected systems.

Let's update the code to use a 32-bit pointer directly and make sure the result is 64-bit aligned again. No functional changes intended.

---
 tools/perf/util/synthetic-events.c | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)
tools/perf/util/synthetic-events.c +9 -5
index a58444c4aed1f1ea..385383ef6cf1edaf 100644
@@ -1686,12 +1686,16 @@ int perf_event__synthesize_sample(union perf_event *event, u64 type, u64 read_fo
 	}
 
 	if (type & PERF_SAMPLE_RAW) {
-		u.val32[0] = sample->raw_size;
-		*array = u.val64;
-		array = (void *)array + sizeof(u32);
+		u32 *array32 = (void *)array;
+
+		*array32 = sample->raw_size;
+		array32++;
+
+		memcpy(array32, sample->raw_data, sample->raw_size);
+		array = (void *)(array32 + (sample->raw_size / sizeof(u32)));
 
-		memcpy(array, sample->raw_data, sample->raw_size);
-		array = (void *)array + sample->raw_size;
+		/* make sure the array is 64-bit aligned */
+		BUG_ON(((long)array) / sizeof(u64));
 	}
 
 	if (type & PERF_SAMPLE_BRANCH_STACK) {
Signature · 1 line
2.47.0.338.g60cca15819-goog
reviewer Reviewed-by on v1 1/1
#1 lore raw
Quoted 6 lines · Namhyung Kim

The sample data is 64-bit aligned basically but raw data starts with 32-bit length field and data follows. In perf_event__synthesize_sample it treats the sample data as a 64-bit array. And it needs some trick to update the raw data properly.

Quoted 8 lines

But it seems some compilers are not happy with this and the program dies siliently. I found the sample parsing test failed without any messages on affected systems.

Let's update the code to use a 32-bit pointer directly and make sure the result is 64-bit aligned again. No functional changes intended.

Thanks,
Ian

Quoted 33 lines
---
 tools/perf/util/synthetic-events.c | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)
tools/perf/util/synthetic-events.c +9 -6
index a58444c4aed1f1ea..385383ef6cf1edaf 100644
@@ -1686,12 +1686,16 @@ int perf_event__synthesize_sample(union perf_event *event, u64 type, u64 read_fo
        }
 
        if (type & PERF_SAMPLE_RAW) {
-               u.val32[0] = sample->raw_size;
-               *array = u.val64;
-               array = (void *)array + sizeof(u32);
+               u32 *array32 = (void *)array;
+
+               *array32 = sample->raw_size;
+               array32++;
+
+               memcpy(array32, sample->raw_data, sample->raw_size);
+               array = (void *)(array32 + (sample->raw_size / sizeof(u32)));
 
-               memcpy(array, sample->raw_data, sample->raw_size);
-               array = (void *)array + sample->raw_size;
+               /* make sure the array is 64-bit aligned */
+               BUG_ON(((long)array) / sizeof(u64));
        }
 
        if (type & PERF_SAMPLE_BRANCH_STACK) {
--

2.47.0.338.g60cca15819-goog

#2 lore raw
Quoted 10 lines · Ian Rogers
Quoted 8 lines · Namhyung Kim

The sample data is 64-bit aligned basically but raw data starts with 32-bit length field and data follows. In perf_event__synthesize_sample it treats the sample data as a 64-bit array. And it needs some trick to update the raw data properly.

But it seems some compilers are not happy with this and the program dies siliently. I found the sample parsing test failed without any messages on affected systems.

Quoted 6 lines
Quoted 4 lines

Let's update the code to use a 32-bit pointer directly and make sure the result is 64-bit aligned again. No functional changes intended.

Looks good, applied to perf-tools-next since this is something that is not new nor looks urgent.

I think that since we have multiple maintainers, one for not urgent stuff/development and the other for the current window/urgent stuff, that we should express the expectation about where a patch should be processed, by having on the subject the tree the submitter thinks should take the patch, i.e. for this one:

[PATCH next] perf tools: Avoid unaligned pointer operations

While for urgent stuff we could do:

[PATCH urgent] perf tools: Avoid unaligned pointer operations

wdyt?

- Arnaldo

author maintainer
#3 lore raw
Quoted 27 lines · Arnaldo Carvalho de Melo
Quoted 10 lines · Ian Rogers
Quoted 8 lines · Namhyung Kim

The sample data is 64-bit aligned basically but raw data starts with 32-bit length field and data follows. In perf_event__synthesize_sample it treats the sample data as a 64-bit array. And it needs some trick to update the raw data properly.

But it seems some compilers are not happy with this and the program dies siliently. I found the sample parsing test failed without any messages on affected systems.

Quoted 6 lines
Quoted 4 lines

Let's update the code to use a 32-bit pointer directly and make sure the result is 64-bit aligned again. No functional changes intended.

Looks good, applied to perf-tools-next since this is something that is not new nor looks urgent.

I think that since we have multiple maintainers, one for not urgent stuff/development and the other for the current window/urgent stuff, that we should express the expectation about where a patch should be processed, by having on the subject the tree the submitter thinks should take the patch, i.e. for this one:

Quoted 7 lines

[PATCH next] perf tools: Avoid unaligned pointer operations

While for urgent stuff we could do:

[PATCH urgent] perf tools: Avoid unaligned pointer operations

wdyt?

Looks good. It'd be really great if contributors can do this.

But I also think 'next' should be the default so only 'urgent' would be specified if needed.

Thanks,
Namhyung

reviewer
#4 lore raw
Quoted 33 lines · Namhyung Kim
Quoted 31 lines · Arnaldo Carvalho de Melo
Quoted 10 lines · Ian Rogers
Quoted 8 lines · Namhyung Kim

The sample data is 64-bit aligned basically but raw data starts with 32-bit length field and data follows. In perf_event__synthesize_sample it treats the sample data as a 64-bit array. And it needs some trick to update the raw data properly.

But it seems some compilers are not happy with this and the program dies siliently. I found the sample parsing test failed without any messages on affected systems.

Quoted 6 lines
Quoted 4 lines

Let's update the code to use a 32-bit pointer directly and make sure the result is 64-bit aligned again. No functional changes intended.

Looks good, applied to perf-tools-next since this is something that is not new nor looks urgent.

I think that since we have multiple maintainers, one for not urgent stuff/development and the other for the current window/urgent stuff, that we should express the expectation about where a patch should be processed, by having on the subject the tree the submitter thinks should take the patch, i.e. for this one:

[PATCH next] perf tools: Avoid unaligned pointer operations

While for urgent stuff we could do:

Quoted 8 lines
Quoted 3 lines

[PATCH urgent] perf tools: Avoid unaligned pointer operations

wdyt?

Looks good. It'd be really great if contributors can do this.

But I also think 'next' should be the default so only 'urgent' would be specified if needed.

Fwiw, I needed this fix, forgot about this change, and wrote my own by just sinking the unaligned array computation (that causes undefined behavior) into where it was used:

```
--- a/tools/perf/util/synthetic-events.c
+++ b/tools/perf/util/synthetic-events.c
@@ -1690,10 +1690,9 @@ int perf_event__synthesize_sample(union
perf_event *event, u64 type, u64 read_fo
        if (type & PERF_SAMPLE_RAW) {
                u.val32[0] = sample->raw_size;
                *array = u.val64;
-               array = (void *)array + sizeof(u32);

-               memcpy(array, sample->raw_data, sample->raw_size);
-               array = (void *)array + sample->raw_size;
+               memcpy((void *)array + sizeof(u32), sample->raw_data,
sample->raw_size);
+               array = (void *)array + sizeof(u32) + sample->raw_size;
        }

        if (type & PERF_SAMPLE_BRANCH_STACK) {
````

Namhyung's change is better because of the BUG_ON. Perhaps that BUG_ON should appear after all the void* math that can create unaligned u64 pointers in this function.

Thanks,
Ian

reviewer
#5 lore raw
In reply to Namhyung Kim
Quoted 31 lines · Namhyung Kim

The sample data is 64-bit aligned basically but raw data starts with 32-bit length field and data follows. In perf_event__synthesize_sample it treats the sample data as a 64-bit array. And it needs some trick to update the raw data properly.

But it seems some compilers are not happy with this and the program dies siliently. I found the sample parsing test failed without any messages on affected systems.

Let's update the code to use a 32-bit pointer directly and make sure the result is 64-bit aligned again. No functional changes intended.

---
 tools/perf/util/synthetic-events.c | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)
tools/perf/util/synthetic-events.c +2 -3
index a58444c4aed1f1ea..385383ef6cf1edaf 100644
@@ -1686,12 +1686,16 @@ int perf_event__synthesize_sample(union perf_event *event, u64 type, u64 read_fo
        }
 
        if (type & PERF_SAMPLE_RAW) {
-               u.val32[0] = sample->raw_size;
-               *array = u.val64;
-               array = (void *)array + sizeof(u32);
+               u32 *array32 = (void *)array;
+

tools/perf/util/synthetic-events.c int perf_event__synthesize_sample(union perf_event *event, u64 type, u64 read_fo · line 1698

Quoted 10 lines
tools/perf/util/synthetic-events.c +7 -2
+               *array32 = sample->raw_size;
+               array32++;
+
+               memcpy(array32, sample->raw_data, sample->raw_size);
+               array = (void *)(array32 + (sample->raw_size / sizeof(u32)));
 
-               memcpy(array, sample->raw_data, sample->raw_size);
-               array = (void *)array + sample->raw_size;
+               /* make sure the array is 64-bit aligned */
+               BUG_ON(((long)array) / sizeof(u64));

I think you intended:

BUG_ON(((long)array) % sizeof(u64));

Thanks,
Ian

Quoted 6 lines
tools/perf/util/synthetic-events.c +0 -1
        }
 
        if (type & PERF_SAMPLE_BRANCH_STACK) {
--

2.47.0.338.g60cca15819-goog

author maintainer
#6 lore raw
Quoted 38 lines · Ian Rogers
Quoted 37 lines · Namhyung Kim

The sample data is 64-bit aligned basically but raw data starts with 32-bit length field and data follows. In perf_event__synthesize_sample it treats the sample data as a 64-bit array. And it needs some trick to update the raw data properly.

But it seems some compilers are not happy with this and the program dies siliently. I found the sample parsing test failed without any messages on affected systems.

Let's update the code to use a 32-bit pointer directly and make sure the result is 64-bit aligned again. No functional changes intended.

---
 tools/perf/util/synthetic-events.c | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)
tools/perf/util/synthetic-events.c +7 -3
index a58444c4aed1f1ea..385383ef6cf1edaf 100644
@@ -1686,12 +1686,16 @@ int perf_event__synthesize_sample(union perf_event *event, u64 type, u64 read_fo
        }
 
        if (type & PERF_SAMPLE_RAW) {
-               u.val32[0] = sample->raw_size;
-               *array = u.val64;
-               array = (void *)array + sizeof(u32);
+               u32 *array32 = (void *)array;
+
+               *array32 = sample->raw_size;
+               array32++;
+
+               memcpy(array32, sample->raw_data, sample->raw_size);
+               array = (void *)(array32 + (sample->raw_size / sizeof(u32)));
 
Quoted 8 lines

tools/perf/util/synthetic-events.c int perf_event__synthesize_sample(union perf_event *event, u64 type, u64 read_fo · line 1698

Quoted 4 lines
tools/perf/util/synthetic-events.c +2 -2
-               memcpy(array, sample->raw_data, sample->raw_size);
-               array = (void *)array + sample->raw_size;
+               /* make sure the array is 64-bit aligned */
+               BUG_ON(((long)array) / sizeof(u64));

I think you intended:

BUG_ON(((long)array) % sizeof(u64));

Yep, fixed in v2.

https://lore.kernel.org/r/[email protected]

Thanks,
Namhyung