Re: [PATCH v8] mm: vmscan: retry folios written back while isolated for traditional LRU

[Ridong Chen <ridong.chen@linux.dev>]

On 9/13/2026 7:33 PM, Barry Song wrote:
> On Sun, Sep 13, 2026 at 6:00 PM Ridong Chen <ridong.chen@linux.dev> wrote:
>>
>> From: Ridong Chen <chenridong@xiaomi.com>
>>
>> As commit 359a5e1416ca ("mm: multi-gen LRU: retry folios written back
>> while isolated") mentioned:
>>
>>    The page reclaim isolates a batch of folios from the tail of one of the
>>    LRU lists and works on those folios one by one.  For a suitable
>>    swap-backed folio, if the swap device is async, it queues that folio for
>>    writeback.  After the page reclaim finishes an entire batch, it puts back
>>    the folios it queued for writeback to the head of the original LRU list.
>>
>>    In the meantime, the page writeback flushes the queued folios also by
>>    batches.  Its batching logic is independent from that of the page
>>    reclaim. For each of the folios it writes back, the page writeback calls
>>    folio_rotate_reclaimable() which tries to rotate a folio to the tail.
>>
>>    folio_rotate_reclaimable() only works for a folio after the page reclaim
>>    has put it back.  If an async swap device is fast enough, the page
>>    writeback can finish with that folio while the page reclaim is still
>>    working on the rest of the batch containing it.  In this case, that folio
>>    will remain at the head and the page reclaim will not retry it before
>>    reaching there".
>>
>> The commit 359a5e1416ca ("mm: multi-gen LRU: retry folios written back
>> while isolated") only fixed the issue for mglru. However, this issue
>> also exists in the traditional active/inactive LRU and was found at [1].
>>
>> It can be reproduced with below steps:
>>
>> 1. Compile with CONFIG_TRANSPARENT_HUGEPAGE=y
>> 2. Mount memcg v1, and create memcg named test_memcg and set
>>     limit_in_bytes=1G, memsw.limit_in_bytes=2G.
>> 3. Create a 1G swap file, and allocate 1.35G anon memory in test_memcg.
>>
>> It was found that:
>>
>>    cat memory.usage_in_bytes
>>    1073700864
>>    cat memory.memsw.usage_in_bytes
>>    1413124096
>>
>>    free -h
>>                  total        used        free
>>    Mem:           1.6Gi       1.2Gi       299Mi
>>    Swap:          1.0Gi       678Mi       346Mi
>>
>> As shown above, the test_memcg charged about 324M swap (memsw.usage minus
>> usage), but almost 678M swap memory was used, which means that 350M+ may
>> be wasted because other memcgs can not use these swap memory.
>>
>> This issue should be fixed in the same way as mglru. Therefore, the common
>> logic was extracted to the 'find_folios_written_back' function firstly,
>> which is then reused in the 'shrink_inactive_list' function. Finally,
>> retry reclaiming those folios that may have missed the rotation for
>> traditional LRU.
>>
>> After change, the same test case only wasted about 2M swap. The swap
>> device usage matches what the memcg actually charged.
>>
>>    cat memory.usage_in_bytes
>>    1070301184
>>    cat memory.memsw.usage_in_bytes
>>    1412448256
>>
>>    free -h
>>                  total        used        free
>>    Mem:           1.6Gi       1.2Gi       299Mi
>>    Swap:          1.0Gi       327Mi       696Mi
>>
>> [1] https://lore.kernel.org/linux-kernel/20241010081802.290893-1-chenridong@huaweicloud.com/
>> [2] https://lore.kernel.org/linux-kernel/CAGsJ_4zqL8ZHNRZ44o_CC69kE7DBVXvbZfvmQxMGiFqRxqHQdA@mail.gmail.com/
>> Signed-off-by: Ridong Chen <chenridong@xiaomi.com>
>> ---
>> v8: Rebase to the -next tree, adapt to the current reclaim API, and retest.
>>
>> [v7]: https://lore.kernel.org/linux-mm/20250111091504.1363075-1-chenridong@huaweicloud.com/
>>
>>   mm/vmscan.c | 104 ++++++++++++++++++++++++++++++++++++----------------
>>   1 file changed, 73 insertions(+), 31 deletions(-)
>>
>> diff --git a/mm/vmscan.c b/mm/vmscan.c
>> index d1495a7d469d..6e13e570aab8 100644
>> --- a/mm/vmscan.c
>> +++ b/mm/vmscan.c
>> @@ -181,6 +181,10 @@ struct scan_control {
>>          struct reclaim_state reclaim_state;
>>   };
>>
>> +static void find_folios_written_back(struct list_head *list,
>> +                                    struct list_head *clean, struct lruvec *lruvec,
>> +                                    int type, bool skip_retry);
>> +
>>   #ifdef ARCH_HAS_PREFETCHW
>>   static inline void prefetchw_prev_lru_folio(struct folio *folio,
>>                  struct list_head *base)
>> @@ -2013,14 +2017,16 @@ static unsigned long shrink_inactive_list(unsigned long nr_to_scan,
>>                  enum lru_list lru)
>>   {
>>          LIST_HEAD(folio_list);
>> +       LIST_HEAD(clean_list);
>>          unsigned long nr_scanned;
>> -       unsigned int nr_reclaimed = 0;
>> -       unsigned long nr_taken;
>> +       unsigned int nr_reclaimed, total_reclaimed = 0;
>> +       unsigned long nr_taken, isolated;
>>          struct reclaim_stat stat;
>>          bool file = is_file_lru(lru);
>>          enum node_stat_item item;
>>          struct pglist_data *pgdat = lruvec_pgdat(lruvec);
>>          bool stalled = false;
>> +       bool skip_retry = false;
>>
>>          while (unlikely(too_many_isolated(pgdat, file, sc))) {
>>                  if (stalled)
>> @@ -2052,25 +2058,42 @@ static unsigned long shrink_inactive_list(unsigned long nr_to_scan,
>>          if (nr_taken == 0)
>>                  return 0;
>>
>> +       isolated = nr_taken;
>> +retry:
>>          nr_reclaimed = shrink_folio_list(&folio_list, pgdat, sc, &stat, false,
>>                                           lruvec_memcg(lruvec));
>> +       total_reclaimed += nr_reclaimed;
>> +
>> +       /* Retry pass is only meant for clean folios without new isolation */
>> +       if (isolated)
>> +               handle_reclaim_writeback(isolated, pgdat, sc, &stat);
>> +       trace_mm_vmscan_lru_shrink_inactive(pgdat->node_id,
>> +                       nr_scanned, nr_reclaimed, &stat, sc->priority, file);
>> +
>> +       find_folios_written_back(&folio_list, &clean_list, lruvec, file, skip_retry);
>>
>>          move_folios_to_lru(&folio_list);
>>
>>          mod_lruvec_state(lruvec, PGDEMOTE_KSWAPD + reclaimer_offset(sc),
>>                                          stat.nr_demoted);
>> -       mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, -nr_taken);
>>          item = PGSTEAL_KSWAPD + reclaimer_offset(sc);
>>          mod_lruvec_state(lruvec, item, nr_reclaimed);
>>          mod_lruvec_state(lruvec, PGSTEAL_ANON + file, nr_reclaimed);
>> -       if (nr_scanned > nr_reclaimed)
>> +
>> +       if (!list_empty(&clean_list)) {
>> +               list_splice_init(&clean_list, &folio_list);
>> +               skip_retry = true;
>> +               /* Retry folios were already isolated and accounted above */
>> +               isolated = 0;
>> +               goto retry;
>> +       }
>> +
>> +       mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, -nr_taken);
>> +       if (nr_scanned > total_reclaimed)
>>                  mod_lruvec_state(lruvec, PGROTATE_ANON + file,
>> -                                nr_scanned - nr_reclaimed);
>> +                                nr_scanned - total_reclaimed);
>>
>> -       handle_reclaim_writeback(nr_taken, pgdat, sc, &stat);
>> -       trace_mm_vmscan_lru_shrink_inactive(pgdat->node_id,
>> -                       nr_scanned, nr_reclaimed, &stat, sc->priority, file);
>> -       return nr_reclaimed;
> 
> this is a bit weird to move the tracepoint, shouldn't it just trace the total
> number of twice reclamation?
> 
>> +       return total_reclaimed;
>>   }
>>
>>   /*
>> @@ -5006,8 +5029,6 @@ static int evict_folios(unsigned long nr_to_scan, struct lruvec *lruvec,
>>   {
>>          LIST_HEAD(list);
>>          LIST_HEAD(clean);
>> -       struct folio *folio;
>> -       struct folio *next;
>>          enum node_stat_item item;
>>          struct reclaim_stat stat;
>>          struct lru_gen_mm_walk *walk;
>> @@ -5046,26 +5067,7 @@ static int evict_folios(unsigned long nr_to_scan, struct lruvec *lruvec,
>>                          type_scanned, reclaimed, &stat, sc->priority,
>>                          type ? LRU_INACTIVE_FILE : LRU_INACTIVE_ANON);
>>
>> -       list_for_each_entry_safe_reverse(folio, next, &list, lru) {
>> -               DEFINE_MIN_SEQ(lruvec);
>> -
>> -               /* move_folios_to_lru() culls unevictable folios via folio_putback_lru() */
>> -               if (!folio_evictable(folio))
>> -                       continue;
>> -
>> -               /* retry folios that may have missed folio_rotate_reclaimable() */
>> -               if (!skip_retry && !folio_test_active(folio) && !folio_mapped(folio) &&
>> -                   !folio_test_dirty(folio) && !folio_test_writeback(folio)) {
>> -                       list_move(&folio->lru, &clean);
>> -                       continue;
>> -               }
>> -
>> -               /* don't add rejected folios to the oldest generation */
>> -               if (lru_gen_folio_seq(lruvec, folio, false) == min_seq[type]) {
>> -                       folio_set_lru_refs(folio, 0);
>> -                       folio_set_active(folio);
>> -               }
> 
> Baolin has a patch which modifies this.
> so probably you are not based on the mm-new?
> 
> https://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm.git/commit/?id=519f7768585e372b97e568baf9d4648e6beb6863
> 
>> -       }
>> +       find_folios_written_back(&list, &clean, lruvec, type, skip_retry);
>>
>>          move_folios_to_lru(&list);
>>
>> @@ -6108,6 +6110,46 @@ static void lru_gen_shrink_node(struct pglist_data *pgdat, struct scan_control *
>>
>>   #endif /* CONFIG_LRU_GEN */
>>
>> +/**
>> + * find_folios_written_back - Find and move the written back folios to a new list.
>> + * @list: folios list
>> + * @clean: the written back folios list
>> + * @lruvec: the lruvec
>> + * @type: LRU type (only used for CONFIG_LRU_GEN)
>> + * @skip_retry: whether skip retry.
>> + */
>> +static void find_folios_written_back(struct list_head *list,
>> +                                    struct list_head *clean, struct lruvec *lruvec,
>> +                                    int type, bool skip_retry)
>> +{
>> +       struct folio *folio;
>> +       struct folio *next;
>> +
>> +       list_for_each_entry_safe_reverse(folio, next, list, lru) {
>> +#ifdef CONFIG_LRU_GEN
>> +               DEFINE_MIN_SEQ(lruvec);
>> +#endif
>> +               /* move_folios_to_lru() culls unevictable folios via folio_putback_lru() */
>> +               if (!folio_evictable(folio))
>> +                       continue;
>> +
>> +               /* retry folios that may have missed folio_rotate_reclaimable() */
>> +               if (!skip_retry && !folio_test_active(folio) && !folio_mapped(folio) &&
>> +                   !folio_test_dirty(folio) && !folio_test_writeback(folio)) {
>> +                       list_move(&folio->lru, clean);
>> +                       continue;
>> +               }
>> +#ifdef CONFIG_LRU_GEN
>> +               /* don't add rejected folios to the oldest generation */
>> +               if (lruvec->lrugen.enabled &&
>> +                   lru_gen_folio_seq(lruvec, folio, false) == min_seq[type]) {
>> +                       folio_set_lru_refs(folio, 0);
>> +                       folio_set_active(folio);
>> +               }
> 
> as above. please take a look at Baolin's patch:
> https://lore.kernel.org/9214e36bf738fcfba86acc8cea85dff4010f66b0.1788918714.git.baolin.wang@linux.alibaba.com
> 
> 
Thanks, I rebased on the next branch.

I will rebase on mm-new.

-- 
Best regards
Ridong