perf tools: Avoid unaligned pointer operations
Namhyung Kim
maintainerPATCH 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
@@ -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
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_sampleit 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.
Signed-off-by Namhyung Kim <[email protected]>
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@@ -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
Arnaldo Carvalho de Melo
maintainerQuoted 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_sampleit 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.
Signed-off-by Namhyung Kim <[email protected]>Reviewed-by Ian Rogers <[email protected]>
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
Namhyung Kim
maintainerQuoted 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_sampleit 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.
Signed-off-by Namhyung Kim <[email protected]>Reviewed-by Ian Rogers <[email protected]>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
Ian Rogers
reviewerQuoted 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_sampleit 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.
Signed-off-by Namhyung Kim <[email protected]>Reviewed-by Ian Rogers <[email protected]>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
Ian Rogers
reviewerQuoted 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_sampleit 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.
Signed-off-by Namhyung Kim <[email protected]>--- tools/perf/util/synthetic-events.c | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-)tools/perf/util/synthetic-events.c +2
-3@@ -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
Namhyung Kim
maintainerQuoted 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_sampleit 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.
Signed-off-by Namhyung Kim <[email protected]>--- tools/perf/util/synthetic-events.c | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-)tools/perf/util/synthetic-events.c +7
-3@@ -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