mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
* [PATCH] mm: mglru: reset the mm iteration cursor in try_to_inc_max_seq_nowalk()
@ 2026-11-17 11:37 Hui Zhu
  2026-11-19  7:29 ` Baoquan He
  0 siblings, 1 reply; 3+ messages in thread
From: Hui Zhu @ 2026-11-17 11:37 UTC (permalink / raw)
  To: Andrew Morton, Kairui Song, Qi Zheng, Shakeel Butt, Barry Song,
	Axel Rasmussen, Yuanchu Xie, Wei Xu, Baoquan He, Baolin Wang,
	Johannes Weiner, David Hildenbrand, Michal Hocko,
	Lorenzo Stoakes, Harry Yoo, linux-mm, linux-kernel
  Cc: Hui Zhu, stable

From: Hui Zhu <zhuhui@kylinos.cn>

iterate_mm_list_nowalk() and try_to_inc_max_seq_nowalk() both advance
mm_state->seq without walking the mm_list, but only the former drops the
cursor. When the latter races with an ongoing page table walk, head is
left pointing into the middle of the fifo.

The next walker reads that as "this generation already started": it skips
reset_bloom_filter() and resumes after the cursor. Every mm before the
cursor is skipped, and none of them have bits in the filter being read, so
walk_pmd_range() descends into none of their PMDs and harvests no accessed
bits. try_to_shrink_lruvec() ignores the failed try_to_inc_max_seq() and
keeps evicting, so those hot folios become reclaim candidates and refault
in the parent memcg, until head wraps around a generation later.

Factor the pattern into skip_mm_iteration(), which carries the rationale
that used to sit in a comment in try_to_inc_max_seq_nowalk(), so the two
callers cannot drift apart again. The wrap-around in iterate_mm_list() is
left open-coded on purpose: there head is already back at the fifo, and
tail has to survive for the force_scan test. Dropping the cursor is safe:
get_next_mm() holds an mmgrab() reference, and a concurrent walker bails
out at "walk->seq <= mm_state->seq" before touching head again. The
unwalked part of the fifo restarts from the head next generation, as
iterate_mm_list_nowalk() already does.

Only reachable from memcg_reparent_objcgs() -> max_lru_gen_memcg(); not a
memory safety issue, since lru_gen_del_mm() repoints head and tail under
mm_list->lock.

Fixes: f304652609ea ("mm: vmscan: prepare for reparenting MGLRU folios")
Cc: stable@vger.kernel.org
Signed-off-by: Hui Zhu <zhuhui@kylinos.cn>
---
 mm/vmscan.c | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/mm/vmscan.c b/mm/vmscan.c
index 6a1af9b92349..0dc4017b87e4 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -3235,6 +3235,7 @@ static bool iterate_mm_list(struct lru_gen_mm_walk *walk, struct mm_struct **ite
 	do {
 		mm_state->head = mm_state->head->next;
 		if (mm_state->head == &mm_list->fifo) {
+			/* head is back at the fifo; keep tail for force_scan below */
 			WRITE_ONCE(mm_state->seq, mm_state->seq + 1);
 			last = true;
 			break;
@@ -3263,6 +3264,18 @@ static bool iterate_mm_list(struct lru_gen_mm_walk *walk, struct mm_struct **ite
 	return last;
 }
 
+/*
+ * Advance mm_state->seq without walking the mm_list. The cursor must be
+ * dropped as well: iterate_mm_list() resumes from head, and resets the Bloom
+ * filter only when head == &mm_list->fifo.
+ */
+static void skip_mm_iteration(struct lru_gen_mm_state *mm_state)
+{
+	mm_state->head = NULL;
+	mm_state->tail = NULL;
+	WRITE_ONCE(mm_state->seq, mm_state->seq + 1);
+}
+
 static bool iterate_mm_list_nowalk(struct lruvec *lruvec, unsigned long seq)
 {
 	bool success = false;
@@ -3275,9 +3288,7 @@ static bool iterate_mm_list_nowalk(struct lruvec *lruvec, unsigned long seq)
 	VM_WARN_ON_ONCE(mm_state->seq + 1 < seq);
 
 	if (seq > mm_state->seq) {
-		mm_state->head = NULL;
-		mm_state->tail = NULL;
-		WRITE_ONCE(mm_state->seq, mm_state->seq + 1);
+		skip_mm_iteration(mm_state);
 		success = true;
 	}
 
@@ -4686,15 +4697,11 @@ static void try_to_inc_max_seq_nowalk(struct mem_cgroup *memcg,
 	DEFINE_MAX_SEQ(lruvec);
 	bool success = false;
 
-	/*
-	 * We are not iterating the mm_list here, updating mm_state->seq is just
-	 * to make mm walkers work properly.
-	 */
 	if (mm_state) {
 		spin_lock(&mm_list->lock);
 		VM_WARN_ON_ONCE(mm_state->seq + 1 < max_seq);
 		if (max_seq > mm_state->seq) {
-			WRITE_ONCE(mm_state->seq, mm_state->seq + 1);
+			skip_mm_iteration(mm_state);
 			success = true;
 		}
 		spin_unlock(&mm_list->lock);
-- 
2.53.0


^ permalink raw reply	[flat|nested] 3+ messages in thread

* Re: [PATCH] mm: mglru: reset the mm iteration cursor in try_to_inc_max_seq_nowalk()
  2026-11-17 11:37 [PATCH] mm: mglru: reset the mm iteration cursor in try_to_inc_max_seq_nowalk() Hui Zhu
@ 2026-11-19  7:29 ` Baoquan He
  2026-11-19  9:35   ` Hui Zhu
  0 siblings, 1 reply; 3+ messages in thread
From: Baoquan He @ 2026-11-19  7:29 UTC (permalink / raw)
  To: Hui Zhu
  Cc: Andrew Morton, Kairui Song, Qi Zheng, Shakeel Butt, Barry Song,
	Axel Rasmussen, Yuanchu Xie, Wei Xu, Baolin Wang,
	Johannes Weiner, David Hildenbrand, Michal Hocko,
	Lorenzo Stoakes, Harry Yoo, linux-mm, linux-kernel, Hui Zhu,
	stable

On 11/17/26 at 07:37pm, Hui Zhu wrote:
> From: Hui Zhu <zhuhui@kylinos.cn>
> 
> iterate_mm_list_nowalk() and try_to_inc_max_seq_nowalk() both advance
> mm_state->seq without walking the mm_list, but only the former drops the
> cursor. When the latter races with an ongoing page table walk, head is
> left pointing into the middle of the fifo.
> 
> The next walker reads that as "this generation already started": it skips
> reset_bloom_filter() and resumes after the cursor. Every mm before the
> cursor is skipped, and none of them have bits in the filter being read, so

Nit:
Isn't it that mm after the cursor is skipped, none of them have bits in
the filter being read? Because bits in the filter are set in the last
generation iteration, mm after cursor didn't iterate, so no bites set
for them? 

> walk_pmd_range() descends into none of their PMDs and harvests no accessed
> bits. try_to_shrink_lruvec() ignores the failed try_to_inc_max_seq() and
> keeps evicting, so those hot folios become reclaim candidates and refault
> in the parent memcg, until head wraps around a generation later.
> 
> Factor the pattern into skip_mm_iteration(), which carries the rationale
> that used to sit in a comment in try_to_inc_max_seq_nowalk(), so the two
> callers cannot drift apart again. The wrap-around in iterate_mm_list() is
> left open-coded on purpose: there head is already back at the fifo, and
> tail has to survive for the force_scan test. Dropping the cursor is safe:
> get_next_mm() holds an mmgrab() reference, and a concurrent walker bails
> out at "walk->seq <= mm_state->seq" before touching head again. The
> unwalked part of the fifo restarts from the head next generation, as
> iterate_mm_list_nowalk() already does.
> 
> Only reachable from memcg_reparent_objcgs() -> max_lru_gen_memcg(); not a
> memory safety issue, since lru_gen_del_mm() repoints head and tail under
> mm_list->lock.
> 
> Fixes: f304652609ea ("mm: vmscan: prepare for reparenting MGLRU folios")
> Cc: stable@vger.kernel.org
> Signed-off-by: Hui Zhu <zhuhui@kylinos.cn>
> ---
>  mm/vmscan.c | 23 +++++++++++++++--------
>  1 file changed, 15 insertions(+), 8 deletions(-)
> 
> diff --git a/mm/vmscan.c b/mm/vmscan.c
> index 6a1af9b92349..0dc4017b87e4 100644
> --- a/mm/vmscan.c
> +++ b/mm/vmscan.c
> @@ -3235,6 +3235,7 @@ static bool iterate_mm_list(struct lru_gen_mm_walk *walk, struct mm_struct **ite
>  	do {
>  		mm_state->head = mm_state->head->next;
>  		if (mm_state->head == &mm_list->fifo) {
> +			/* head is back at the fifo; keep tail for force_scan below */
>  			WRITE_ONCE(mm_state->seq, mm_state->seq + 1);
>  			last = true;
>  			break;
> @@ -3263,6 +3264,18 @@ static bool iterate_mm_list(struct lru_gen_mm_walk *walk, struct mm_struct **ite
>  	return last;
>  }
>  
> +/*
> + * Advance mm_state->seq without walking the mm_list. The cursor must be
> + * dropped as well: iterate_mm_list() resumes from head, and resets the Bloom
> + * filter only when head == &mm_list->fifo.
> + */

This looks like a good catch, while the function name here is a little bit
confusing. From the code block inside, we can't see it's doing iteration,
just a pair of pointer resetting and a max_seq advancing. I would rather
not wrap up them if no good name is concluded. Personal opinion.

Other than the nits, 

Reviewed-by: Baoquan He <baoquan.he@linux.dev>

> +static void skip_mm_iteration(struct lru_gen_mm_state *mm_state)
> +{
> +	mm_state->head = NULL;
> +	mm_state->tail = NULL;
> +	WRITE_ONCE(mm_state->seq, mm_state->seq + 1);
> +}
> +
>  static bool iterate_mm_list_nowalk(struct lruvec *lruvec, unsigned long seq)
>  {
>  	bool success = false;
> @@ -3275,9 +3288,7 @@ static bool iterate_mm_list_nowalk(struct lruvec *lruvec, unsigned long seq)
>  	VM_WARN_ON_ONCE(mm_state->seq + 1 < seq);
>  
>  	if (seq > mm_state->seq) {
> -		mm_state->head = NULL;
> -		mm_state->tail = NULL;
> -		WRITE_ONCE(mm_state->seq, mm_state->seq + 1);
> +		skip_mm_iteration(mm_state);
>  		success = true;
>  	}
>  
> @@ -4686,15 +4697,11 @@ static void try_to_inc_max_seq_nowalk(struct mem_cgroup *memcg,
>  	DEFINE_MAX_SEQ(lruvec);
>  	bool success = false;
>  
> -	/*
> -	 * We are not iterating the mm_list here, updating mm_state->seq is just
> -	 * to make mm walkers work properly.
> -	 */
>  	if (mm_state) {
>  		spin_lock(&mm_list->lock);
>  		VM_WARN_ON_ONCE(mm_state->seq + 1 < max_seq);
>  		if (max_seq > mm_state->seq) {
> -			WRITE_ONCE(mm_state->seq, mm_state->seq + 1);
> +			skip_mm_iteration(mm_state);
>  			success = true;
>  		}
>  		spin_unlock(&mm_list->lock);
> -- 
> 2.53.0
> 

^ permalink raw reply	[flat|nested] 3+ messages in thread

* Re: [PATCH] mm: mglru: reset the mm iteration cursor in try_to_inc_max_seq_nowalk()
  2026-11-19  7:29 ` Baoquan He
@ 2026-11-19  9:35   ` Hui Zhu
  0 siblings, 0 replies; 3+ messages in thread
From: Hui Zhu @ 2026-11-19  9:35 UTC (permalink / raw)
  To: Baoquan He
  Cc: Andrew Morton, Kairui Song, Qi Zheng, Shakeel Butt, Barry Song,
	Axel Rasmussen, Yuanchu Xie, Wei Xu, Baolin Wang,
	Johannes Weiner, David Hildenbrand, Michal Hocko,
	Lorenzo Stoakes, Harry Yoo, linux-mm, linux-kernel, Hui Zhu,
	stable


2026/11/19 15:29, Baoquan He:
> On 11/17/26 at 07:37pm, Hui Zhu wrote:
>> From: Hui Zhu <zhuhui@kylinos.cn>
>>
>> iterate_mm_list_nowalk() and try_to_inc_max_seq_nowalk() both advance
>> mm_state->seq without walking the mm_list, but only the former drops the
>> cursor. When the latter races with an ongoing page table walk, head is
>> left pointing into the middle of the fifo.
>>
>> The next walker reads that as "this generation already started": it skips
>> reset_bloom_filter() and resumes after the cursor. Every mm before the
>> cursor is skipped, and none of them have bits in the filter being read, so
> Nit:
> Isn't it that mm after the cursor is skipped, none of them have bits in
> the filter being read? Because bits in the filter are set in the last
> generation iteration, mm after cursor didn't iterate, so no bites set
> for them?
You are right, thanks for catching it. test_bloom_filter() reads
filters[walk->seq % 2], and that buffer was filled by the aborted walk of
the previous generation, which only got as far as the cursor. So the mm
the resumed walk visits -- the ones after the cursor -- are exactly the
ones with no bits in it, and they lose their non-leaf walk. The mm before
the cursor are simply left out of this generation. I will fix the wording
in v2.
>> walk_pmd_range() descends into none of their PMDs and harvests no accessed
>> bits. try_to_shrink_lruvec() ignores the failed try_to_inc_max_seq() and
>> keeps evicting, so those hot folios become reclaim candidates and refault
>> in the parent memcg, until head wraps around a generation later.
>>
>> Factor the pattern into skip_mm_iteration(), which carries the rationale
>> that used to sit in a comment in try_to_inc_max_seq_nowalk(), so the two
>> callers cannot drift apart again. The wrap-around in iterate_mm_list() is
>> left open-coded on purpose: there head is already back at the fifo, and
>> tail has to survive for the force_scan test. Dropping the cursor is safe:
>> get_next_mm() holds an mmgrab() reference, and a concurrent walker bails
>> out at "walk->seq <= mm_state->seq" before touching head again. The
>> unwalked part of the fifo restarts from the head next generation, as
>> iterate_mm_list_nowalk() already does.
>>
>> Only reachable from memcg_reparent_objcgs() -> max_lru_gen_memcg(); not a
>> memory safety issue, since lru_gen_del_mm() repoints head and tail under
>> mm_list->lock.
>>
>> Fixes: f304652609ea ("mm: vmscan: prepare for reparenting MGLRU folios")
>> Cc: stable@vger.kernel.org
>> Signed-off-by: Hui Zhu <zhuhui@kylinos.cn>
>> ---
>>   mm/vmscan.c | 23 +++++++++++++++--------
>>   1 file changed, 15 insertions(+), 8 deletions(-)
>>
>> diff --git a/mm/vmscan.c b/mm/vmscan.c
>> index 6a1af9b92349..0dc4017b87e4 100644
>> --- a/mm/vmscan.c
>> +++ b/mm/vmscan.c
>> @@ -3235,6 +3235,7 @@ static bool iterate_mm_list(struct lru_gen_mm_walk *walk, struct mm_struct **ite
>>   	do {
>>   		mm_state->head = mm_state->head->next;
>>   		if (mm_state->head == &mm_list->fifo) {
>> +			/* head is back at the fifo; keep tail for force_scan below */
>>   			WRITE_ONCE(mm_state->seq, mm_state->seq + 1);
>>   			last = true;
>>   			break;
>> @@ -3263,6 +3264,18 @@ static bool iterate_mm_list(struct lru_gen_mm_walk *walk, struct mm_struct **ite
>>   	return last;
>>   }
>>   
>> +/*
>> + * Advance mm_state->seq without walking the mm_list. The cursor must be
>> + * dropped as well: iterate_mm_list() resumes from head, and resets the Bloom
>> + * filter only when head == &mm_list->fifo.
>> + */
> This looks like a good catch, while the function name here is a little bit
> confusing. From the code block inside, we can't see it's doing iteration,
> just a pair of pointer resetting and a max_seq advancing. I would rather
> not wrap up them if no good name is concluded. Personal opinion.
How about inc_mm_state_seq(), after inc_max_seq(), leaving the "why"
to the comment:

     /*
      * The cursor must be dropped along with mm_state->seq:
      * iterate_mm_list() resumes from head, and resets the Bloom filter
      * only when head == &mm_list->fifo.
      */
     static void inc_mm_state_seq(struct lru_gen_mm_state *mm_state)

If that still does not read well to you, I will drop the helper in v2 and
keep the two lines open-coded.
>
> Other than the nits,
>
> Reviewed-by: Baoquan He <baoquan.he@linux.dev>

Thank you!

Best,
Hui

>
>> +static void skip_mm_iteration(struct lru_gen_mm_state *mm_state)
>> +{
>> +	mm_state->head = NULL;
>> +	mm_state->tail = NULL;
>> +	WRITE_ONCE(mm_state->seq, mm_state->seq + 1);
>> +}
>> +
>>   static bool iterate_mm_list_nowalk(struct lruvec *lruvec, unsigned long seq)
>>   {
>>   	bool success = false;
>> @@ -3275,9 +3288,7 @@ static bool iterate_mm_list_nowalk(struct lruvec *lruvec, unsigned long seq)
>>   	VM_WARN_ON_ONCE(mm_state->seq + 1 < seq);
>>   
>>   	if (seq > mm_state->seq) {
>> -		mm_state->head = NULL;
>> -		mm_state->tail = NULL;
>> -		WRITE_ONCE(mm_state->seq, mm_state->seq + 1);
>> +		skip_mm_iteration(mm_state);
>>   		success = true;
>>   	}
>>   
>> @@ -4686,15 +4697,11 @@ static void try_to_inc_max_seq_nowalk(struct mem_cgroup *memcg,
>>   	DEFINE_MAX_SEQ(lruvec);
>>   	bool success = false;
>>   
>> -	/*
>> -	 * We are not iterating the mm_list here, updating mm_state->seq is just
>> -	 * to make mm walkers work properly.
>> -	 */
>>   	if (mm_state) {
>>   		spin_lock(&mm_list->lock);
>>   		VM_WARN_ON_ONCE(mm_state->seq + 1 < max_seq);
>>   		if (max_seq > mm_state->seq) {
>> -			WRITE_ONCE(mm_state->seq, mm_state->seq + 1);
>> +			skip_mm_iteration(mm_state);
>>   			success = true;
>>   		}
>>   		spin_unlock(&mm_list->lock);
>> -- 
>> 2.53.0
>>

^ permalink raw reply	[flat|nested] 3+ messages in thread

end of thread, other threads:[~2026-11-19  9:36 UTC | newest]

Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-17 11:37 [PATCH] mm: mglru: reset the mm iteration cursor in try_to_inc_max_seq_nowalk() Hui Zhu
2026-11-19  7:29 ` Baoquan He
2026-11-19  9:35   ` Hui Zhu

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®