use per-vma locks for /proc/pid/maps reads
Subsystems (7)
Suren Baghdasaryan
maintainerv8 cover use per-vma locks for /proc/pid/maps reads
Reading /proc/pid/maps requires read-locking mmap_lock which prevents any other task from concurrently modifying the address space. This guarantees coherent reporting of virtual address ranges, however it can block important updates from happening. Oftentimes /proc/pid/maps readers are low priority monitoring tasks and them blocking high priority tasks results in priority inversion.
Locking the entire address space is required to present fully coherent picture of the address space, however even current implementation does not strictly guarantee that by outputting vmas in page-size chunks and dropping mmap_lock in between each chunk. Address space modifications are possible while mmap_lock is dropped and userspace reading the content is expected to deal with possible concurrent address space modifications. Considering these relaxed rules, holding mmap_lock is not strictly needed as long as we can guarantee that a concurrently modified vma is reported either in its original form or after it was modified.
This patchset switches from holding mmap_lock while reading /proc/pid/maps to taking per-vma locks as we walk the vma tree. This reduces the contention with tasks modifying the address space because they would have to contend for the same vma as opposed to the entire address space. Previous version of this patchset [1] tried to perform /proc/pid/maps reading under RCU, however its implementation is quite complex and the results are worse than the new version because it still relied on mmap_lock speculation which retries if any part of the address space gets modified. New implementaion is both simpler and results in less contention. Note that similar approach would not work for /proc/pid/smaps reading as it also walks the page table and that's not RCU-safe.
Paul McKenney's designed a test [2] to measure mmap/munmap latencies while concurrently reading /proc/pid/maps. The test has a pair of processes scanning /proc/PID/maps, and another process unmapping and remapping 4K pages from a 128MB range of anonymous memory. At the end of each 10 second run, the latency of each mmap() or munmap() operation is measured, and for each run the maximum and mean latency is printed. The map/unmap process is started first, its PID is passed to the scanners, and then the map/unmap process waits until both scanners are running before starting its timed test. The scanners keep scanning until the specified /proc/PID/maps file disappears.
The latest results from Paul:
Stock mm-unstable, all of the runs had maximum latencies in excess of 0.5 milliseconds, and with 80% of the runs' latencies exceeding a full millisecond, and ranging up beyond 4 full milliseconds. In contrast, 99% of the runs with this patch series applied had maximum latencies of less than 0.5 milliseconds, with the single outlier at only 0.608 milliseconds.
From a median-performance (as opposed to maximum-latency) viewpoint, this patch series also looks good, with stock mm weighing in at 11 microseconds and patch series at 6 microseconds, better than a 2x improvement.
Before the change:
./run-proc-vs-map.sh --nsamples 100 --rawdata -- --busyduration 2
0.011 0.008 0.521
0.011 0.008 0.552
0.011 0.008 0.590
0.011 0.008 0.660
...
0.011 0.015 2.987
0.011 0.015 3.038
0.011 0.016 3.431
0.011 0.016 4.707After the change:
./run-proc-vs-map.sh --nsamples 100 --rawdata -- --busyduration 2
0.006 0.005 0.026
0.006 0.005 0.029
0.006 0.005 0.034
0.006 0.005 0.035
...
0.006 0.006 0.421
0.006 0.006 0.423
0.006 0.006 0.439
0.006 0.006 0.608The patchset also adds a number of tests to check for /proc/pid/maps data coherency. They are designed to detect any unexpected data tearing while performing some common address space modifications (vma split, resize and remap). Even before these changes, reading /proc/pid/maps might have inconsistent data because the file is read page-by-page with mmap_lock being dropped between the pages. An example of user-visible inconsistency can be that the same vma is printed twice: once before it was modified and then after the modifications. For example if vma was extended, it might be found and reported twice. What is not expected is to see a gap where there should have been a vma both before and after modification. This patchset increases the chances of such tearing, therefore it's even more important now to test for unexpected inconsistencies.
In [3] Lorenzo identified the following possible vma merging/splitting scenarios:
Merges with changes to existing vmas:
1 Merge both - mapping a vma over another one and between two vmas which can be merged after this replacement;
2. Merge left full - mapping a vma at the end of an existing one and completely over its right neighbor;
3. Merge left partial - mapping a vma at the end of an existing one and partially over its right neighbor;
4. Merge right full - mapping a vma before the start of an existing one and completely over its left neighbor;
5. Merge right partial - mapping a vma before the start of an existing one and partially over its left neighbor;
Merges without changes to existing vmas:
6. Merge both - mapping a vma into a gap between two vmas which can be merged after the insertion;
7. Merge left - mapping a vma at the end of an existing one;
8. Merge right - mapping a vma before the start end of an existing one;
Splits
9. Split with new vma at the lower address;
10. Split with new vma at the higher address;
If such merges or splits happen concurrently with the /proc/maps reading we might report a vma twice, once before the modification and once after it is modified:
Case 1 might report overwritten and previous vma along with the final merged vma;
Case 2 might report previous and the final merged vma;
Case 3 might cause us to retry once we detect the temporary gap caused by shrinking of the right neighbor;
Case 4 might report overritten and the final merged vma;
Case 5 might cause us to retry once we detect the temporary gap caused by shrinking of the left neighbor;
Case 6 might report previous vma and the gap along with the final marged vma;
Case 7 might report previous and the final merged vma;
Case 8 might report the original gap and the final merged vma covering the gap;
Case 9 might cause us to retry once we detect the temporary gap caused by shrinking of the original vma at the vma start;
Case 10 might cause us to retry once we detect the temporary gap caused by shrinking of the original vma at the vma end;
In all these cases the retry mechanism prevents us from reporting possible temporary gaps.
Changes since v7 [4]:
- Refactored tests to use kselftest harness, per David Hildenbrand and Lorenzo Stoakes
- Removed PROCMAP_QUERY selftest, per David Hildenbrand and Lorenzo Stoakes
- Added Acked-by, per David Hildenbrand
- Replaced sentinels values with named definitions, per Vlastimil Babka
- Added Reviewed-by, per Vlastimil Babka
!!! NOTES FOR APPLYING THE PATCHSET !!!
Applies cleanly over mm-unstable after reverting v7 version of this patchset (from 94951ab6fe6f to e47914e6c28f in mm-unstable).
[1] https://lore.kernel.org/all/[email protected]/
[2] https://github.com/paulmckrcu/proc-mmap_sem-test
[3] https://lore.kernel.org/all/[email protected]/
[4] https://lore.kernel.org/all/[email protected]/
Suren Baghdasaryan (6):
selftests/proc: add /proc/pid/maps tearing from vma split test selftests/proc: extend /proc/pid/maps tearing test to include vma
resizing
selftests/proc: extend /proc/pid/maps tearing test to include vma
remapping
selftests/proc: add verbose mode for /proc/pid/maps tearing tests fs/proc/task_mmu: remove conversion of seq_file position to unsigned fs/proc/task_mmu: read proc/pid/maps under per-vma lock
fs/proc/internal.h | 5 + fs/proc/task_mmu.c | 158 +++- include/linux/mmap_lock.h | 11 + mm/madvise.c | 3 +- mm/mmap_lock.c | 93 +++ tools/testing/selftests/proc/.gitignore | 1 + tools/testing/selftests/proc/Makefile | 1 + tools/testing/selftests/proc/proc-maps-race.c | 741 ++++++++++++++++++ 8 files changed, 997 insertions(+), 16 deletions(-) create mode 100644 tools/testing/selftests/proc/proc-maps-race.c
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Suren Baghdasaryan
maintainerPATCH v8 1/6 selftests/proc: add /proc/pid/maps tearing from vma split test
The /proc/pid/maps file is generated page by page, with the mmap_lock released between pages. This can lead to inconsistent reads if the underlying vmas are concurrently modified. For instance, if a vma split or merge occurs at a page boundary while /proc/pid/maps is being read, the same vma might be seen twice: once before and once after the change. This duplication is considered acceptable for userspace handling. However, observing a "hole" where a vma should be (e.g., due to a vma being replaced and the space temporarily being empty) is unacceptable.
Implement a test that:
1. Forks a child process which continuously modifies its address space, specifically targeting a vma at the boundary between two pages.
2. The parent process repeatedly reads the child's /proc/pid/maps.
3. The parent process checks the last vma of the first page and the first vma of the second page for consistency, looking for the effects of vma splits or merges.
The test duration is configurable via DURATION environment variable expressed in seconds. The default test duration is 5 seconds.
Example Command: DURATION=10 ./proc-maps-race
--- tools/testing/selftests/proc/.gitignore | 1 + tools/testing/selftests/proc/Makefile | 1 + tools/testing/selftests/proc/proc-maps-race.c | 447 ++++++++++++++++++ 3 files changed, 449 insertions(+) create mode 100644 tools/testing/selftests/proc/proc-maps-race.c
tools/testing/selftests/proc/.gitignore +1 -0
@@ -5,6 +5,7 @@ /proc-2-is-kthread /proc-fsconfig-hidepid /proc-loadavg-001 +/proc-maps-race /proc-multiple-procfs /proc-empty-vm /proc-pid-vm
tools/testing/selftests/proc/Makefile +1 -0
@@ -9,6 +9,7 @@ TEST_GEN_PROGS += fd-002-posix-eq TEST_GEN_PROGS += fd-003-kthread TEST_GEN_PROGS += proc-2-is-kthread TEST_GEN_PROGS += proc-loadavg-001 +TEST_GEN_PROGS += proc-maps-race TEST_GEN_PROGS += proc-empty-vm TEST_GEN_PROGS += proc-pid-vm TEST_GEN_PROGS += proc-self-map-files-001
tools/testing/selftests/proc/proc-maps-race.c new file +447 -0
447 lines not on this page · raw message
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Suren Baghdasaryan
maintainerPATCH v8 2/6 selftests/proc: extend /proc/pid/maps tearing test to include vma resizing
In reply to Suren BaghdasaryanTest that /proc/pid/maps does not report unexpected holes in the address space when a vma at the edge of the page is being concurrently remapped. This remapping results in the vma shrinking and expanding from under the reader. We should always see either shrunk or expanded (original) version of the vma.
--- tools/testing/selftests/proc/proc-maps-race.c | 79 +++++++++++++++++++ 1 file changed, 79 insertions(+)
tools/testing/selftests/proc/proc-maps-race.c +79 -0
@@ -242,6 +242,28 @@ static inline bool check_split_result(struct line_content *mod_last_line,strcmp (mod_first_line->text, restored_first_line->text) !=0 ; } +static inline bool shrink_vma (FIXTURE_DATA (proc_maps_race) *self) +{ +return mremap (self->mod_info->addr, self->page_size *3 , + self->page_size,0 ) !=MAP_FAILED ; +} + +static inline bool expand_vma (FIXTURE_DATA (proc_maps_race) *self) +{ +return mremap (self->mod_info->addr, self->page_size, + self->page_size *3 ,0 ) !=MAP_FAILED ; +} + +static inline bool check_shrink_result (struct line_content *mod_last_line, +struct line_content *mod_first_line, +struct line_content *restored_last_line, +struct line_content *restored_first_line) +{ +/* Make sure only the last vma of the first page is changing */ +return strcmp (mod_last_line->text, restored_last_line->text) !=0 && +strcmp (mod_first_line->text, restored_first_line->text) ==0 ; +} +FIXTURE_SETUP (proc_maps_race) {const char *duration =getenv ("DURATION" );
@@ -444,4 +466,61 @@ TEST_F(proc_maps_race, test_maps_tearing_from_split)signal_state (mod_info,TEST_DONE ); } +TEST_F(proc_maps_race, test_maps_tearing_from_resize) +{ +struct vma_modifier_info *mod_info = self->mod_info; + +struct line_content shrunk_last_line; +struct line_content shrunk_first_line; +struct line_content restored_last_line; +struct line_content restored_first_line; + +wait_for_state (mod_info,SETUP_READY ); + +/* re-read the file to avoid using stale data from previous test */ +ASSERT_TRUE (read_boundary_lines (self, &self->last_line, &self->first_line)); + + mod_info->vma_modify = shrink_vma; + mod_info->vma_restore = expand_vma; + mod_info->vma_mod_check = check_shrink_result; + +ASSERT_TRUE (capture_mod_pattern (self, &shrunk_last_line, &shrunk_first_line, + &restored_last_line, &restored_first_line)); + +/* Now start concurrent modifications for self->duration_sec */ +signal_state (mod_info,TEST_READY ); + +struct line_content new_last_line; +struct line_content new_first_line; +struct timespec start_ts, end_ts; + +clock_gettime (CLOCK_MONOTONIC_COARSE , &start_ts); +do { +ASSERT_TRUE (read_boundary_lines (self, &new_last_line, &new_first_line)); + +/* Check if we read vmas after shrinking it */ +if (!strcmp (new_last_line.text, shrunk_last_line.text)) { +/* +* The vmas should be consistent with shrunk results, +* however if the vma was concurrently restored, it +* can be reported twice (first as shrunk one, then +* as restored one) because we found it as the next vma +* again. In that case new first line will be the same +* as the last restored line. +*/ +ASSERT_FALSE (strcmp (new_first_line.text, shrunk_first_line.text) && +strcmp (new_first_line.text, restored_last_line.text)); + }else { +/* The vmas should be consistent with the original/resored state */ +ASSERT_FALSE (strcmp (new_last_line.text, restored_last_line.text)); +ASSERT_FALSE (strcmp (new_first_line.text, restored_first_line.text)); + } + +clock_gettime (CLOCK_MONOTONIC_COARSE , &end_ts); + }while (end_ts.tv_sec - start_ts.tv_sec < self->duration_sec); + +/* Signal the modifyer thread to stop and wait until it exits */ +signal_state (mod_info,TEST_DONE ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Suren Baghdasaryan
maintainerPATCH v8 3/6 selftests/proc: extend /proc/pid/maps tearing test to include vma remapping
In reply to Suren BaghdasaryanTest that /proc/pid/maps does not report unexpected holes in the address space when we concurrently remap a part of a vma into the middle of another vma. This remapping results in the destination vma being split into three parts and the part in the middle being patched back from, all done concurrently from under the reader. We should always see either original vma or the split one with no holes.
--- tools/testing/selftests/proc/proc-maps-race.c | 86 +++++++++++++++++++ 1 file changed, 86 insertions(+)
tools/testing/selftests/proc/proc-maps-race.c +86 -0
@@ -264,6 +264,35 @@ static inline bool check_shrink_result(struct line_content *mod_last_line,strcmp (mod_first_line->text, restored_first_line->text) ==0 ; } +static inline bool remap_vma (FIXTURE_DATA (proc_maps_race) *self) +{ +/* +* Remap the last page of the next vma into the middle of the vma. +* This splits the current vma and the first and middle parts (the +* parts at lower addresses) become the last vma objserved in the +* first page and the first vma observed in the last page. +*/ +return mremap (self->mod_info->next_addr + self->page_size *2 , self->page_size, + self->page_size,MREMAP_FIXED |MREMAP_MAYMOVE |MREMAP_DONTUNMAP , + self->mod_info->addr + self->page_size) !=MAP_FAILED ; +} + +static inline bool patch_vma (FIXTURE_DATA (proc_maps_race) *self) +{ +return mprotect (self->mod_info->addr + self->page_size, self->page_size, + self->mod_info->prot) ==0 ; +} + +static inline bool check_remap_result (struct line_content *mod_last_line, +struct line_content *mod_first_line, +struct line_content *restored_last_line, +struct line_content *restored_first_line) +{ +/* Make sure vmas at the boundaries are changing */ +return strcmp (mod_last_line->text, restored_last_line->text) !=0 && +strcmp (mod_first_line->text, restored_first_line->text) !=0 ; +} +FIXTURE_SETUP (proc_maps_race) {const char *duration =getenv ("DURATION" );
@@ -523,4 +552,61 @@ TEST_F(proc_maps_race, test_maps_tearing_from_resize)signal_state (mod_info,TEST_DONE ); } +TEST_F(proc_maps_race, test_maps_tearing_from_remap) +{ +struct vma_modifier_info *mod_info = self->mod_info; + +struct line_content remapped_last_line; +struct line_content remapped_first_line; +struct line_content restored_last_line; +struct line_content restored_first_line; + +wait_for_state (mod_info,SETUP_READY ); + +/* re-read the file to avoid using stale data from previous test */ +ASSERT_TRUE (read_boundary_lines (self, &self->last_line, &self->first_line)); + + mod_info->vma_modify = remap_vma; + mod_info->vma_restore = patch_vma; + mod_info->vma_mod_check = check_remap_result; + +ASSERT_TRUE (capture_mod_pattern (self, &remapped_last_line, &remapped_first_line, + &restored_last_line, &restored_first_line)); + +/* Now start concurrent modifications for self->duration_sec */ +signal_state (mod_info,TEST_READY ); + +struct line_content new_last_line; +struct line_content new_first_line; +struct timespec start_ts, end_ts; + +clock_gettime (CLOCK_MONOTONIC_COARSE , &start_ts); +do { +ASSERT_TRUE (read_boundary_lines (self, &new_last_line, &new_first_line)); + +/* Check if we read vmas after remapping it */ +if (!strcmp (new_last_line.text, remapped_last_line.text)) { +/* +* The vmas should be consistent with remap results, +* however if the vma was concurrently restored, it +* can be reported twice (first as split one, then +* as restored one) because we found it as the next vma +* again. In that case new first line will be the same +* as the last restored line. +*/ +ASSERT_FALSE (strcmp (new_first_line.text, remapped_first_line.text) && +strcmp (new_first_line.text, restored_last_line.text)); + }else { +/* The vmas should be consistent with the original/resored state */ +ASSERT_FALSE (strcmp (new_last_line.text, restored_last_line.text)); +ASSERT_FALSE (strcmp (new_first_line.text, restored_first_line.text)); + } + +clock_gettime (CLOCK_MONOTONIC_COARSE , &end_ts); + }while (end_ts.tv_sec - start_ts.tv_sec < self->duration_sec); + +/* Signal the modifyer thread to stop and wait until it exits */ +signal_state (mod_info,TEST_DONE ); +} +TEST_HARNESS_MAIN
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Suren Baghdasaryan
maintainerPATCH v8 4/6 selftests/proc: add verbose mode for /proc/pid/maps tearing tests
In reply to Suren BaghdasaryanAdd verbose mode to the /proc/pid/maps tearing tests to print debugging information. VERBOSE environment variable is used to enable it.
Usage example: VERBOSE=1 ./proc-maps-race
--- tools/testing/selftests/proc/proc-maps-race.c | 153 ++++++++++++++++-- 1 file changed, 141 insertions(+), 12 deletions(-)
tools/testing/selftests/proc/proc-maps-race.c +141 -12
@@ -77,6 +77,7 @@ FIXTURE(proc_maps_race)int shared_mem_size;int page_size;int vma_count; +bool verbose;int maps_fd;pid_t pid; };
@@ -188,12 +189,104 @@ static void stop_vma_modifier(struct vma_modifier_info *mod_info)signal_state (mod_info,SETUP_MODIFY_MAPS ); } +static void print_first_lines (char *text,int nr) +{ +const char *end = text; + +while (nr && (end =strchr (end,'\n' )) !=NULL ) { + nr--; + end++; + } + +if (end) { +int offs = end - text; + + text[offs] ='\0' ; +printf (text); + text[offs] ='\n' ; +printf ("\n" ); + }else { +printf (text); + } +} + +static void print_last_lines (char *text,int nr) +{ +const char *start = text +strlen (text); + + nr++;/* to ignore the last newline */ +while (nr) { +while (start > text && *start !='\n' ) + start--; + nr--; + start--; + } +printf (start); +} + +static void print_boundaries (const char *title,FIXTURE_DATA (proc_maps_race) *self) +{ +if (!self->verbose) +return ; + +printf ("%s" , title); +/* Print 3 boundary lines from each page */ +print_last_lines (self->page1.data,3 ); +printf ("-----------------page boundary-----------------\n" ); +print_first_lines (self->page2.data,3 ); +} + +static bool print_boundaries_on (bool condition,const char *title, +FIXTURE_DATA (proc_maps_race) *self) +{ +if (self->verbose && condition) +print_boundaries (title, self); + +return condition; +} + +static void report_test_start (const char *name,bool verbose) +{ +if (verbose) +printf ("==== %s ====\n" , name); +} + +static struct timespec print_ts; + +static void start_test_loop (struct timespec *ts,bool verbose) +{ +if (verbose) + print_ts.tv_sec = ts->tv_sec; +} + +static void end_test_iteration (struct timespec *ts,bool verbose) +{ +if (!verbose) +return ; + +/* Update every second */ +if (print_ts.tv_sec == ts->tv_sec) +return ; + +printf ("." ); +fflush (stdout); + print_ts.tv_sec = ts->tv_sec; +} + +static void end_test_loop (bool verbose) +{ +if (verbose) +printf ("\n" ); +} +static bool capture_mod_pattern (FIXTURE_DATA (proc_maps_race) *self,struct line_content *mod_last_line,struct line_content *mod_first_line,struct line_content *restored_last_line,struct line_content *restored_first_line) { +print_boundaries ("Before modification" , self); +signal_state (self->mod_info,SETUP_MODIFY_MAPS );wait_for_state (self->mod_info,SETUP_MAPS_MODIFIED );
@@ -201,6 +294,8 @@ static bool capture_mod_pattern(FIXTURE_DATA(proc_maps_race) *self,if (!read_boundary_lines (self, mod_last_line, mod_first_line))return false; +print_boundaries ("After modification" , self); +signal_state (self->mod_info,SETUP_RESTORE_MAPS );wait_for_state (self->mod_info,SETUP_MAPS_RESTORED );
@@ -208,6 +303,8 @@ static bool capture_mod_pattern(FIXTURE_DATA(proc_maps_race) *self,if (!read_boundary_lines (self, restored_last_line, restored_first_line))return false; +print_boundaries ("After restore" , self); +if (!self->mod_info->vma_mod_check (mod_last_line, mod_first_line, restored_last_line, restored_first_line))return false;
@@ -295,6 +392,7 @@ static inline bool check_remap_result(struct line_content *mod_last_line,FIXTURE_SETUP (proc_maps_race) { +const char *verbose =getenv ("VERBOSE" );const char *duration =getenv ("DURATION" );struct vma_modifier_info *mod_info;pthread_mutexattr_t mutex_attr;
@@ -303,6 +401,7 @@ FIXTURE_SETUP(proc_maps_race)char fname[32 ]; self->page_size = (unsigned long )sysconf (_SC_PAGESIZE); + self->verbose = verbose && !strncmp (verbose,"1" ,1 ); duration_sec = duration ?atol (duration) :0 ; self->duration_sec = duration_sec ? duration_sec :5UL ;
@@ -444,6 +543,7 @@ TEST_F(proc_maps_race, test_maps_tearing_from_split) mod_info->vma_restore = merge_vma; mod_info->vma_mod_check = check_split_result; +report_test_start ("Tearing from split" , self->verbose);ASSERT_TRUE (capture_mod_pattern (self, &split_last_line, &split_first_line, &restored_last_line, &restored_first_line));
@@ -455,6 +555,7 @@ TEST_F(proc_maps_race, test_maps_tearing_from_split)struct timespec start_ts, end_ts;clock_gettime (CLOCK_MONOTONIC_COARSE , &start_ts); +start_test_loop (&start_ts, self->verbose); do { bool last_line_changed; bool first_line_changed;
@@ -472,12 +573,18 @@ TEST_F(proc_maps_race, test_maps_tearing_from_split)* In that case new first line will be the same as the * last restored line. */ -ASSERT_FALSE (strcmp (new_first_line.text, split_first_line.text) && -strcmp (new_first_line.text, restored_last_line.text)); +ASSERT_FALSE (print_boundaries_on ( +strcmp (new_first_line.text, split_first_line.text) && +strcmp (new_first_line.text, restored_last_line.text), +"Split result invalid" , self)); }else {/* The vmas should be consistent with merge results */ -ASSERT_FALSE (strcmp (new_last_line.text, restored_last_line.text)); -ASSERT_FALSE (strcmp (new_first_line.text, restored_first_line.text)); +ASSERT_FALSE (print_boundaries_on ( +strcmp (new_last_line.text, restored_last_line.text), +"Merge result invalid" , self)); +ASSERT_FALSE (print_boundaries_on ( +strcmp (new_first_line.text, restored_first_line.text), +"Merge result invalid" , self)); }/* * First and last lines should change in unison. If the last
@@ -489,7 +596,9 @@ TEST_F(proc_maps_race, test_maps_tearing_from_split)ASSERT_EQ (last_line_changed, first_line_changed);clock_gettime (CLOCK_MONOTONIC_COARSE , &end_ts); +end_test_iteration (&end_ts, self->verbose); }while (end_ts.tv_sec - start_ts.tv_sec < self->duration_sec); +end_test_loop (self->verbose);/* Signal the modifyer thread to stop and wait until it exits */ signal_state (mod_info,TEST_DONE );
@@ -513,6 +622,7 @@ TEST_F(proc_maps_race, test_maps_tearing_from_resize) mod_info->vma_restore = expand_vma; mod_info->vma_mod_check = check_shrink_result; +report_test_start ("Tearing from resize" , self->verbose);ASSERT_TRUE (capture_mod_pattern (self, &shrunk_last_line, &shrunk_first_line, &restored_last_line, &restored_first_line));
@@ -524,6 +634,7 @@ TEST_F(proc_maps_race, test_maps_tearing_from_resize)struct timespec start_ts, end_ts;clock_gettime (CLOCK_MONOTONIC_COARSE , &start_ts); +start_test_loop (&start_ts, self->verbose); do { ASSERT_TRUE(read_boundary_lines(self, &new_last_line, &new_first_line));
@@ -537,16 +648,24 @@ TEST_F(proc_maps_race, test_maps_tearing_from_resize)* again. In that case new first line will be the same * as the last restored line. */ -ASSERT_FALSE (strcmp (new_first_line.text, shrunk_first_line.text) && -strcmp (new_first_line.text, restored_last_line.text)); +ASSERT_FALSE (print_boundaries_on ( +strcmp (new_first_line.text, shrunk_first_line.text) && +strcmp (new_first_line.text, restored_last_line.text), +"Shrink result invalid" , self)); }else {/* The vmas should be consistent with the original/resored state */ -ASSERT_FALSE (strcmp (new_last_line.text, restored_last_line.text)); -ASSERT_FALSE (strcmp (new_first_line.text, restored_first_line.text)); +ASSERT_FALSE (print_boundaries_on ( +strcmp (new_last_line.text, restored_last_line.text), +"Expand result invalid" , self)); +ASSERT_FALSE (print_boundaries_on ( +strcmp (new_first_line.text, restored_first_line.text), +"Expand result invalid" , self)); }clock_gettime (CLOCK_MONOTONIC_COARSE , &end_ts); +end_test_iteration (&end_ts, self->verbose); }while (end_ts.tv_sec - start_ts.tv_sec < self->duration_sec); +end_test_loop (self->verbose);/* Signal the modifyer thread to stop and wait until it exits */ signal_state (mod_info,TEST_DONE );
@@ -570,6 +689,7 @@ TEST_F(proc_maps_race, test_maps_tearing_from_remap) mod_info->vma_restore = patch_vma; mod_info->vma_mod_check = check_remap_result; +report_test_start ("Tearing from remap" , self->verbose);ASSERT_TRUE (capture_mod_pattern (self, &remapped_last_line, &remapped_first_line, &restored_last_line, &restored_first_line));
@@ -581,6 +701,7 @@ TEST_F(proc_maps_race, test_maps_tearing_from_remap)struct timespec start_ts, end_ts;clock_gettime (CLOCK_MONOTONIC_COARSE , &start_ts); +start_test_loop (&start_ts, self->verbose); do { ASSERT_TRUE(read_boundary_lines(self, &new_last_line, &new_first_line));
@@ -594,16 +715,24 @@ TEST_F(proc_maps_race, test_maps_tearing_from_remap)* again. In that case new first line will be the same * as the last restored line. */ -ASSERT_FALSE (strcmp (new_first_line.text, remapped_first_line.text) && -strcmp (new_first_line.text, restored_last_line.text)); +ASSERT_FALSE (print_boundaries_on ( +strcmp (new_first_line.text, remapped_first_line.text) && +strcmp (new_first_line.text, restored_last_line.text), +"Remap result invalid" , self)); }else {/* The vmas should be consistent with the original/resored state */ -ASSERT_FALSE (strcmp (new_last_line.text, restored_last_line.text)); -ASSERT_FALSE (strcmp (new_first_line.text, restored_first_line.text)); +ASSERT_FALSE (print_boundaries_on ( +strcmp (new_last_line.text, restored_last_line.text), +"Remap restore result invalid" , self)); +ASSERT_FALSE (print_boundaries_on ( +strcmp (new_first_line.text, restored_first_line.text), +"Remap restore result invalid" , self)); }clock_gettime (CLOCK_MONOTONIC_COARSE , &end_ts); +end_test_iteration (&end_ts, self->verbose); }while (end_ts.tv_sec - start_ts.tv_sec < self->duration_sec); +end_test_loop (self->verbose);/* Signal the modifyer thread to stop and wait until it exits */ signal_state (mod_info,TEST_DONE );
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Suren Baghdasaryan
maintainerPATCH v8 5/6 fs/proc/task_mmu: remove conversion of seq_file position to unsigned
In reply to Suren BaghdasaryanBack in 2.6 era, last_addr used to be stored in seq_file->version variable, which was unsigned long. As a result, sentinels to represent gate vma and end of all vmas used unsigned values. In more recent kernels we don't used seq_file->version anymore and therefore conversion from loff_t into unsigned type is not needed. Similarly, sentinel values don't need to be unsigned. Remove type conversion for set_file position and change sentinel values to signed. While at it, change the hardcoded sentinel values with named definitions for better documentation.
--- fs/proc/task_mmu.c | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-)
fs/proc/task_mmu.c +10 -7
@@ -29,6 +29,9 @@#include <asm/tlbflush.h> #include "internal.h" +#define SENTINEL_VMA_END -1 +#define SENTINEL_VMA_GATE -2 +#define SEQ_PUT_DEC (str, val) \ seq_put_decimal_ull_width(m, str, (val) << (PAGE_SHIFT-10), 8)void task_mem (struct seq_file *m,struct mm_struct *mm)
@@ -135,7 +138,7 @@ static struct vm_area_struct *proc_get_vma(struct proc_maps_private *priv,if (vma) { *ppos = vma->vm_start; }else { - *ppos =-2UL ; + *ppos =SENTINEL_VMA_GATE ; vma =get_gate_vma (priv->mm); }
@@ -145,11 +148,11 @@ static struct vm_area_struct *proc_get_vma(struct proc_maps_private *priv,static void *m_start (struct seq_file *m,loff_t *ppos) {struct proc_maps_private *priv = m->private; -unsigned long last_addr = *ppos; +loff_t last_addr = *ppos;struct mm_struct *mm;/* See m_next(). Zero at the start or after lseek. */ -if (last_addr ==-1UL ) +if (last_addr ==SENTINEL_VMA_END )return NULL ; priv->task =get_proc_task (priv->inode);
@@ -170,9 +173,9 @@ static void *m_start(struct seq_file *m, loff_t *ppos)return ERR_PTR (-EINTR ); } -vma_iter_init (&priv->iter, mm, last_addr); +vma_iter_init (&priv->iter, mm, (unsigned long )last_addr);hold_task_mempolicy (priv); -if (last_addr ==-2UL ) +if (last_addr ==SENTINEL_VMA_GATE )return get_gate_vma (mm);return proc_get_vma (priv, ppos);
@@ -180,8 +183,8 @@ static void *m_start(struct seq_file *m, loff_t *ppos)static void *m_next (struct seq_file *m,void *v,loff_t *ppos) { -if (*ppos ==-2UL ) { - *ppos =-1UL ; +if (*ppos ==SENTINEL_VMA_GATE ) { + *ppos =SENTINEL_VMA_END ;return NULL ; }return proc_get_vma (m->private, ppos);
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Suren Baghdasaryan
maintainerPATCH v8 6/6 fs/proc/task_mmu: read proc/pid/maps under per-vma lock
In reply to Suren BaghdasaryanWith maple_tree supporting vma tree traversal under RCU and per-vma locks, /proc/pid/maps can be read while holding individual vma locks instead of locking the entire address space.
A completely lockless approach (walking vma tree under RCU) would be quite complex with the main issue being get_vma_name() using callbacks which might not work correctly with a stable vma copy, requiring original (unstable) vma - see special_mapping_name() for example.
When per-vma lock acquisition fails, we take the mmap_lock for reading, lock the vma, release the mmap_lock and continue. This fallback to mmap read lock guarantees the reader to make forward progress even during lock contention. This will interfere with the writer but for a very short time while we are acquiring the per-vma lock and only when there was contention on the vma reader is interested in.
We shouldn't see a repeated fallback to mmap read locks in practice, as this require a very unlikely series of lock contentions (for instance due to repeated vma split operations). However even if this did somehow happen, we would still progress.
One case requiring special handling is when a vma changes between the time it was found and the time it got locked. A problematic case would be if a vma got shrunk so that its vm_start moved higher in the address space and a new vma was installed at the beginning:
reader found: |--------VMA A--------| VMA is modified: |-VMA B-|----VMA A----|
reader locks modified VMA A
reader reports VMA A: | gap |----VMA A----|
This would result in reporting a gap in the address space that does not exist. To prevent this we retry the lookup after locking the vma, however we do that only when we identify a gap and detect that the address space was changed after we found the vma.
This change is designed to reduce mmap_lock contention and prevent a process reading /proc/pid/maps files (often a low priority task, such as monitoring/data collection services) from blocking address space updates. Note that this change has a userspace visible disadvantage:
it allows for sub-page data tearing as opposed to the previous mechanism where data tearing could happen only between pages of generated output data. Since current userspace considers data tearing between pages to be acceptable, we assume is will be able to handle sub-page data tearing as well.
--- fs/proc/internal.h | 5 ++ fs/proc/task_mmu.c | 141 +++++++++++++++++++++++++++++++++++--- include/linux/mmap_lock.h | 11 +++ mm/madvise.c | 3 +- mm/mmap_lock.c | 93 +++++++++++++++++++++++++ 5 files changed, 244 insertions(+), 9 deletions(-)
fs/proc/internal.h +5 -0
@@ -384,6 +384,11 @@ struct proc_maps_private {struct task_struct *task;struct mm_struct *mm;struct vma_iterator iter; +loff_t last_pos; +#ifdef CONFIG_PER_VMA_LOCK +bool mmap_locked; +struct vm_area_struct *locked_vma; +#endif #ifdef CONFIG_NUMA struct mempolicy *task_mempolicy;#endif
fs/proc/task_mmu.c +133 -8
179 lines not on this page · raw message
include/linux/mmap_lock.h +11 -0
@@ -309,6 +309,17 @@ void vma_mark_detached(struct vm_area_struct *vma);struct vm_area_struct *lock_vma_under_rcu (struct mm_struct *mm,unsigned long address); +/* +* Locks next vma pointed by the iterator. Confirms the locked vma has not +* been modified and will retry under mmap_lock protection if modification +* was detected. Should be called from read RCU section. +* Returns either a valid locked VMA, NULL if no more VMAs or -EINTR if the +* process was interrupted. +*/ +struct vm_area_struct *lock_next_vma (struct mm_struct *mm, +struct vma_iterator *iter, +unsigned long address); +#else /* CONFIG_PER_VMA_LOCK */ static inline void mm_lock_seqcount_init (struct mm_struct *mm) {}
mm/madvise.c +2 -1
@@ -109,7 +109,8 @@ void anon_vma_name_free(struct kref *kref)struct anon_vma_name *anon_vma_name (struct vm_area_struct *vma) { -mmap_assert_locked (vma->vm_mm); +if (!rwsem_is_locked (&vma->vm_mm->mmap_lock)) +vma_assert_locked (vma);return vma->anon_name; }
mm/mmap_lock.c +93 -0
99 lines not on this page · raw message
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Andrew Morton
maintainerQuoted 2 lines · On Sat, 19 Jul 2025 11:28:48 -0700 Suren Baghdasaryan <[email protected]> wrote:
This patchset switches from holding
mmap_lockwhile reading/proc/pid/mapsto taking per-vma locks as we walk the vma tree.
Thanks, I updated mm-new to this v8 series.