perf maps: Avoid RC_CHK use after free
Ian Rogers
reviewerPATCH 1/2 perf maps: Avoid RC_CHK use after free
The case of __maps__fixup_overlap_and_insert where the "new" maps covers existing mappings can create a use-after-free with reference count checking enabled. The issue is that "pos" holds a map pointer from maps_by_address that is put from maps_by_address but then used to look for a map in maps_by_name (the compared map is now a use-after-free). The issue stems from using maps__remove which redoes some of the searches already done by __maps__fixup_overlap_and_insert, so optimize the code (by avoiding repeated searches) and avoid the use-after-free by inlining the appropriate removal code.
--- tools/perf/util/maps.c | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-)
tools/perf/util/maps.c +20 -2
@@ -931,8 +931,9 @@ static int __maps__fixup_overlap_and_insert(struct maps *maps, struct map *new)return err; }else {struct map *next =NULL ; +unsigned int nr_maps =maps__nr_maps (maps); -if (i +1 <maps__nr_maps (maps)) +if (i +1 < nr_maps) next = maps_by_address[i +1 ];if (!next ||map__start (next) >=map__end (new)) {
@@ -953,7 +954,24 @@ static int __maps__fixup_overlap_and_insert(struct maps *maps, struct map *new)check_invariants (maps);return err; } -__maps__remove (maps, pos); +/* +* pos fully covers the previous mapping so remove +* it. The following is an inlined version of +* maps__remove that reuses the already computed +* indices. +*/ +map__put (maps_by_address[i]); +memmove (&maps_by_address[i], + &maps_by_address[i +1 ], + (nr_maps - i -1 ) *sizeof (*maps_by_address)); + +if (maps_by_name) { +map__put (maps_by_name[ni]); +memmove (&maps_by_name[ni], + &maps_by_name[ni +1 ], + (nr_maps - ni -1 ) *sizeof (*maps_by_name)); + } + --RC_CHK_ACCESS (maps)->nr_maps;check_invariants (maps);/* * Maps are ordered but no need to increase `i` as the
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Ian Rogers
reviewerPATCH 2/2 perf test maps: Additional maps__fixup_overlap_and_insert tests
Add additional test to the maps covering maps__fixup_overlap_and_insert. Change the test suite to be for more than just 1 test.
--- tools/perf/tests/builtin-test.c | 2 +- tools/perf/tests/maps.c | 82 ++++++++++++++++++++++++++++++++- tools/perf/tests/tests.h | 2 +- 3 files changed, 83 insertions(+), 3 deletions(-)
tools/perf/tests/builtin-test.c +1 -1
@@ -126,7 +126,7 @@ static struct test_suite *generic_tests[] = { &suite__jit_write_elf, &suite__pfm, &suite__api_io, - &suite__maps__merge_in, + &suite__maps, &suite__demangle_java, &suite__demangle_ocaml, &suite__demangle_rust,
tools/perf/tests/maps.c +81 -1
85 lines not on this page · raw message
tools/perf/tests/tests.h +1 -1
@@ -160,7 +160,7 @@ DECLARE_SUITE(bitmap_print);DECLARE_SUITE (perf_hooks);DECLARE_SUITE (unit_number__scnprint);DECLARE_SUITE (mem2node); -DECLARE_SUITE (maps__merge_in); +DECLARE_SUITE (maps);DECLARE_SUITE (time_utils);DECLARE_SUITE (jit_write_elf);DECLARE_SUITE (api_io);
Signature · 1 line
2.52.0.rc1.455.g30608eb744-goog
Re: [PATCH v1 2/2] perf test maps: Additional maps__fixup_overlap_and_insert tests
Quoted 5 lines · Ian Rogers
Add additional test to the maps covering
maps__fixup_overlap_and_insert. Change the test suite to be for more than just 1 test.Signed-off-by Ian Rogers <[email protected]>
Quoted 122 lines
--- tools/perf/tests/builtin-test.c | 2 +- tools/perf/tests/maps.c | 82 ++++++++++++++++++++++++++++++++- tools/perf/tests/tests.h | 2 +- 3 files changed, 83 insertions(+), 3 deletions(-)tools/perf/tests/builtin-test.c +1
-1@@ -126,7 +126,7 @@ static struct test_suite *generic_tests[] = { &suite__jit_write_elf, &suite__pfm, &suite__api_io, - &suite__maps__merge_in, + &suite__maps, &suite__demangle_java, &suite__demangle_ocaml, &suite__demangle_rust,tools/perf/tests/maps.c +81
-1@@ -162,4 +162,84 @@ static int test__maps__merge_in(struct test_suite *t __maybe_unused, int subtestreturn TEST_OK ; } -DEFINE_SUITE ("maps__merge_in" , maps__merge_in); +static int test__maps__fixup_overlap_and_insert (struct test_suite *t__maybe_unused , +int subtest__maybe_unused ) +{ +struct map_def initial_maps[] = { + {"target_map" ,1000 ,2000 }, + {"next_map" ,3000 ,4000 }, + }; +struct map_def insert_split = {"split_map" ,1400 ,1600 }; +struct map_def expected_after_split[] = { + {"target_map" ,1000 ,1400 }, + {"split_map" ,1400 ,1600 }, + {"target_map" ,1600 ,2000 }, + {"next_map" ,3000 ,4000 }, + }; + +struct map_def insert_eclipse = {"eclipse_map" ,2500 ,4500 }; +struct map_def expected_final[] = { + {"target_map" ,1000 ,1400 }, + {"split_map" ,1400 ,1600 }, + {"target_map" ,1600 ,2000 }, + {"eclipse_map" ,2500 ,4500 }, +/* "next_map" (3000-4000) is removed */ + }; + +struct map *map_split, *map_eclipse; +int ret; +unsigned int i; +struct maps *maps =maps__new (NULL ); + +TEST_ASSERT_VAL ("failed to create maps" , maps); + +for (i =0 ; i <ARRAY_SIZE (initial_maps); i++) { +struct map *map =dso__new_map (initial_maps[i].name); + +TEST_ASSERT_VAL ("failed to create map" , map); +map__set_start (map, initial_maps[i].start); +map__set_end (map, initial_maps[i].end); +TEST_ASSERT_VAL ("failed to insert map" ,maps__insert (maps, map) ==0 ); +map__put (map); + } + +// Check splitting. + map_split =dso__new_map (insert_split.name); +TEST_ASSERT_VAL ("failed to create split map" , map_split); +map__set_start (map_split, insert_split.start); +map__set_end (map_split, insert_split.end); + + ret =maps__fixup_overlap_and_insert (maps, map_split); +TEST_ASSERT_VAL ("failed to fixup and insert split map" , !ret); + +map__zput (map_split); + ret =check_maps (expected_after_split,ARRAY_SIZE (expected_after_split), maps); +TEST_ASSERT_VAL ("split check failed" , !ret); + +// Check cover 1 map with another. + map_eclipse =dso__new_map (insert_eclipse.name); +TEST_ASSERT_VAL ("failed to create eclipse map" , map_eclipse); +map__set_start (map_eclipse, insert_eclipse.start); +map__set_end (map_eclipse, insert_eclipse.end); + + ret =maps__fixup_overlap_and_insert (maps, map_eclipse); +TEST_ASSERT_VAL ("failed to fixup and insert eclipse map" , !ret); + +map__zput (map_eclipse); + ret =check_maps (expected_final,ARRAY_SIZE (expected_final), maps); +TEST_ASSERT_VAL ("eclipse check failed" , !ret); + +maps__zput (maps); +return TEST_OK ; +} + +static struct test_case tests__maps[] = { +TEST_CASE ("Test merge_in interface" , maps__merge_in), +TEST_CASE ("Test fix up overlap interface" , maps__fixup_overlap_and_insert), + { .name =NULL , } +}; + +struct test_suite suite__maps = { + .desc ="Maps - per process mmaps abstraction" , + .test_cases = tests__maps, +};tools/perf/tests/tests.h +1
-1@@ -160,7 +160,7 @@ DECLARE_SUITE(bitmap_print);DECLARE_SUITE (perf_hooks);DECLARE_SUITE (unit_number__scnprint);DECLARE_SUITE (mem2node); -DECLARE_SUITE (maps__merge_in); +DECLARE_SUITE (maps);DECLARE_SUITE (time_utils);DECLARE_SUITE (jit_write_elf);DECLARE_SUITE (api_io);
Quoted 10 lines · Ian Rogers
The case of
__maps__fixup_overlap_and_insertwhere the "new" maps covers existing mappings can create a use-after-free with reference count checking enabled. The issue is that "pos" holds a map pointer frommaps_by_addressthat is put frommaps_by_addressbut then used to look for a map inmaps_by_name(the compared map is now a use-after-free). The issue stems from usingmaps__removewhich redoes some of the searches already done by__maps__fixup_overlap_and_insert, so optimize the code (by avoiding repeated searches) and avoid the use-after-free by inlining the appropriate removal code.
Quoted 3 lines
Reported-by kernel test robot <[email protected]>Signed-off-by Ian Rogers <[email protected]>
Quoted 45 lines
--- tools/perf/util/maps.c | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-)tools/perf/util/maps.c +20
-2@@ -931,8 +931,9 @@ static int __maps__fixup_overlap_and_insert(struct maps *maps, struct map *new)return err; }else {struct map *next =NULL ; +unsigned int nr_maps =maps__nr_maps (maps); -if (i +1 <maps__nr_maps (maps)) +if (i +1 < nr_maps) next = maps_by_address[i +1 ];if (!next ||map__start (next) >=map__end (new)) {@@ -953,7 +954,24 @@ static int __maps__fixup_overlap_and_insert(struct maps *maps, struct map *new)check_invariants (maps);return err; } -__maps__remove (maps, pos); +/* +* pos fully covers the previous mapping so remove +* it. The following is an inlined version of +* maps__remove that reuses the already computed +* indices. +*/ +map__put (maps_by_address[i]); +memmove (&maps_by_address[i], + &maps_by_address[i +1 ], + (nr_maps - i -1 ) *sizeof (*maps_by_address)); + +if (maps_by_name) { +map__put (maps_by_name[ni]); +memmove (&maps_by_name[ni], + &maps_by_name[ni +1 ], + (nr_maps - ni -1 ) *sizeof (*maps_by_name)); + } + --RC_CHK_ACCESS (maps)->nr_maps;check_invariants (maps);/* * Maps are ordered but no need to increase `i` as the
Quoted 11 lines · Ian Rogers
The case of
__maps__fixup_overlap_and_insertwhere the "new" maps covers existing mappings can create a use-after-free with reference count checking enabled. The issue is that "pos" holds a map pointer frommaps_by_addressthat is put frommaps_by_addressbut then used to look for a map inmaps_by_name(the compared map is now a use-after-free). The issue stems from usingmaps__removewhich redoes some of the searches already done by__maps__fixup_overlap_and_insert, so optimize the code (by avoiding repeated searches) and avoid the use-after-free by inlining the appropriate removal code.[...]
Applied to perf-tools-next, thanks!
Best regards,
Namhyung