From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6DCB878F26 for ; Thu, 11 Dec 2025 01:01:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765414881; cv=none; b=EuSHCuNS9iaPWWjtFJaAxXX+LdZnTIyWlMVFL0+MiEPBViTvGgbnZc80V1z4TlsPYWs7gUq4lGQ/2ESgmh0bqROhu2w3LbN+K/kP2TJNy9I//uGpcw049jqwQkpgtlXypVOcx2j5/rmrcTK4g0ArLjljKKokf3KuPeR60Wlf23o= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765414881; c=relaxed/simple; bh=zpRuttb2h+adUWkg7RwI6+S/t6vNivj8kKQcyiexeb0=; h=Date:From:To:Cc:Subject:Message-ID:References:MIME-Version: Content-Type:Content-Disposition:In-Reply-To; b=KLiuQMZLLy2m1AKPP1qbhQtU72OmV+Cxh27tvzouWgPIbFXPoARhdDCFsc6i+kZL+OBdScGcKnYocOwBBfy83ng/46cCXJX+nGEo4EWaag5pC++YQ5Owkpou9ZouwxjWK9IsZshWlfExPVjvqvc37XRlUtTVY4Nyp5GbhQMPhrM= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=A9/YNtlS; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="A9/YNtlS" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1765414878; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: in-reply-to:in-reply-to:references:references; bh=fN1X1bH+SRooNp/weIju+G0+QJvxB0NZ48vW9OAx0fA=; b=A9/YNtlSF1laEzpbf3Pyi4rYMpSkiQj2C15Q65NyRmiSuiw4vg3Md55mg8ZLwiJZrh1p9H htYcueoNSi4QMinkCW5RIsYbJEeEa4wqdTknBs1EnYcmB2Rway7TTzcCDKSHkoiucc12cR p0iE2gdN/PMoHuhf/q+ptbSsqdBMOfU= Received: from mx-prod-mc-03.mail-002.prod.us-west-2.aws.redhat.com (ec2-54-186-198-63.us-west-2.compute.amazonaws.com [54.186.198.63]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-496-X9J_fMF1NQqda-fS_cdf-A-1; Wed, 10 Dec 2025 20:01:11 -0500 X-MC-Unique: X9J_fMF1NQqda-fS_cdf-A-1 X-Mimecast-MFC-AGG-ID: X9J_fMF1NQqda-fS_cdf-A_1765414869 Received: from mx-prod-int-08.mail-002.prod.us-west-2.aws.redhat.com (mx-prod-int-08.mail-002.prod.us-west-2.aws.redhat.com [10.30.177.111]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by mx-prod-mc-03.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTPS id 3E721195607C; Thu, 11 Dec 2025 01:01:08 +0000 (UTC) Received: from localhost (unknown [10.72.112.161]) by mx-prod-int-08.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTPS id B246B180045B; Thu, 11 Dec 2025 01:01:05 +0000 (UTC) Date: Thu, 11 Dec 2025 09:01:01 +0800 From: Baoquan He To: Kairui Song Cc: linux-mm@kvack.org, Andrew Morton , Barry Song , Chris Li , Nhat Pham , Yosry Ahmed , David Hildenbrand , Johannes Weiner , Youngjun Park , Hugh Dickins , Baolin Wang , Ying Huang , Kemeng Shi , Lorenzo Stoakes , "Matthew Wilcox (Oracle)" , linux-kernel@vger.kernel.org, Kairui Song Subject: Re: [PATCH v4 01/19] mm, swap: rename __read_swap_cache_async to swap_cache_alloc_folio Message-ID: References: <20251205-swap-table-p2-v4-0-cb7e28a26a40@tencent.com> <20251205-swap-table-p2-v4-1-cb7e28a26a40@tencent.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20251205-swap-table-p2-v4-1-cb7e28a26a40@tencent.com> X-Scanned-By: MIMEDefang 3.4.1 on 10.30.177.111 On 12/05/25 at 03:29am, Kairui Song wrote: > From: Kairui Song > > __read_swap_cache_async is widely used to allocate and ensure a folio is > in swapcache, or get the folio if a folio is already there. > > It's not async, and it's not doing any read. Rename it to better present > its usage, and prepare to be reworked as part of new swap cache APIs. > > Also, add some comments for the function. Worth noting that the > skip_if_exists argument is an long existing workaround that will be > dropped soon. > > Reviewed-by: Yosry Ahmed > Acked-by: Chris Li > Reviewed-by: Barry Song > Reviewed-by: Nhat Pham > Signed-off-by: Kairui Song > --- > mm/swap.h | 6 +++--- > mm/swap_state.c | 46 +++++++++++++++++++++++++++++++++------------- > mm/swapfile.c | 2 +- > mm/zswap.c | 4 ++-- > 4 files changed, 39 insertions(+), 19 deletions(-) LGTM, Reviewed-by: Baoquan He > > diff --git a/mm/swap.h b/mm/swap.h > index d034c13d8dd2..0fff92e42cfe 100644 > --- a/mm/swap.h > +++ b/mm/swap.h > @@ -249,6 +249,9 @@ struct folio *swap_cache_get_folio(swp_entry_t entry); > void *swap_cache_get_shadow(swp_entry_t entry); > void swap_cache_add_folio(struct folio *folio, swp_entry_t entry, void **shadow); > void swap_cache_del_folio(struct folio *folio); > +struct folio *swap_cache_alloc_folio(swp_entry_t entry, gfp_t gfp_flags, > + struct mempolicy *mpol, pgoff_t ilx, > + bool *alloced, bool skip_if_exists); > /* Below helpers require the caller to lock and pass in the swap cluster. */ > void __swap_cache_del_folio(struct swap_cluster_info *ci, > struct folio *folio, swp_entry_t entry, void *shadow); > @@ -261,9 +264,6 @@ void swapcache_clear(struct swap_info_struct *si, swp_entry_t entry, int nr); > struct folio *read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask, > struct vm_area_struct *vma, unsigned long addr, > struct swap_iocb **plug); > -struct folio *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_flags, > - struct mempolicy *mpol, pgoff_t ilx, bool *new_page_allocated, > - bool skip_if_exists); > struct folio *swap_cluster_readahead(swp_entry_t entry, gfp_t flag, > struct mempolicy *mpol, pgoff_t ilx); > struct folio *swapin_readahead(swp_entry_t entry, gfp_t flag, > diff --git a/mm/swap_state.c b/mm/swap_state.c > index 5f97c6ae70a2..08252eaef32f 100644 > --- a/mm/swap_state.c > +++ b/mm/swap_state.c > @@ -402,9 +402,29 @@ void swap_update_readahead(struct folio *folio, struct vm_area_struct *vma, > } > } > > -struct folio *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask, > - struct mempolicy *mpol, pgoff_t ilx, bool *new_page_allocated, > - bool skip_if_exists) > +/** > + * swap_cache_alloc_folio - Allocate folio for swapped out slot in swap cache. > + * @entry: the swapped out swap entry to be binded to the folio. > + * @gfp_mask: memory allocation flags > + * @mpol: NUMA memory allocation policy to be applied > + * @ilx: NUMA interleave index, for use only when MPOL_INTERLEAVE > + * @new_page_allocated: sets true if allocation happened, false otherwise > + * @skip_if_exists: if the slot is a partially cached state, return NULL. > + * This is a workaround that would be removed shortly. > + * > + * Allocate a folio in the swap cache for one swap slot, typically before > + * doing IO (e.g. swap in or zswap writeback). The swap slot indicated by > + * @entry must have a non-zero swap count (swapped out). > + * Currently only supports order 0. > + * > + * Context: Caller must protect the swap device with reference count or locks. > + * Return: Returns the existing folio if @entry is cached already. Returns > + * NULL if failed due to -ENOMEM or @entry have a swap count < 1. > + */ > +struct folio *swap_cache_alloc_folio(swp_entry_t entry, gfp_t gfp_mask, > + struct mempolicy *mpol, pgoff_t ilx, > + bool *new_page_allocated, > + bool skip_if_exists) > { > struct swap_info_struct *si = __swap_entry_to_info(entry); > struct folio *folio; > @@ -452,12 +472,12 @@ struct folio *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask, > goto put_and_return; > > /* > - * Protect against a recursive call to __read_swap_cache_async() > + * Protect against a recursive call to swap_cache_alloc_folio() > * on the same entry waiting forever here because SWAP_HAS_CACHE > * is set but the folio is not the swap cache yet. This can > * happen today if mem_cgroup_swapin_charge_folio() below > * triggers reclaim through zswap, which may call > - * __read_swap_cache_async() in the writeback path. > + * swap_cache_alloc_folio() in the writeback path. > */ > if (skip_if_exists) > goto put_and_return; > @@ -466,7 +486,7 @@ struct folio *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask, > * We might race against __swap_cache_del_folio(), and > * stumble across a swap_map entry whose SWAP_HAS_CACHE > * has not yet been cleared. Or race against another > - * __read_swap_cache_async(), which has set SWAP_HAS_CACHE > + * swap_cache_alloc_folio(), which has set SWAP_HAS_CACHE > * in swap_map, but not yet added its folio to swap cache. > */ > schedule_timeout_uninterruptible(1); > @@ -525,7 +545,7 @@ struct folio *read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask, > return NULL; > > mpol = get_vma_policy(vma, addr, 0, &ilx); > - folio = __read_swap_cache_async(entry, gfp_mask, mpol, ilx, > + folio = swap_cache_alloc_folio(entry, gfp_mask, mpol, ilx, > &page_allocated, false); > mpol_cond_put(mpol); > > @@ -643,9 +663,9 @@ struct folio *swap_cluster_readahead(swp_entry_t entry, gfp_t gfp_mask, > blk_start_plug(&plug); > for (offset = start_offset; offset <= end_offset ; offset++) { > /* Ok, do the async read-ahead now */ > - folio = __read_swap_cache_async( > - swp_entry(swp_type(entry), offset), > - gfp_mask, mpol, ilx, &page_allocated, false); > + folio = swap_cache_alloc_folio( > + swp_entry(swp_type(entry), offset), gfp_mask, mpol, ilx, > + &page_allocated, false); > if (!folio) > continue; > if (page_allocated) { > @@ -662,7 +682,7 @@ struct folio *swap_cluster_readahead(swp_entry_t entry, gfp_t gfp_mask, > lru_add_drain(); /* Push any new pages onto the LRU now */ > skip: > /* The page was likely read above, so no need for plugging here */ > - folio = __read_swap_cache_async(entry, gfp_mask, mpol, ilx, > + folio = swap_cache_alloc_folio(entry, gfp_mask, mpol, ilx, > &page_allocated, false); > if (unlikely(page_allocated)) > swap_read_folio(folio, NULL); > @@ -767,7 +787,7 @@ static struct folio *swap_vma_readahead(swp_entry_t targ_entry, gfp_t gfp_mask, > if (!si) > continue; > } > - folio = __read_swap_cache_async(entry, gfp_mask, mpol, ilx, > + folio = swap_cache_alloc_folio(entry, gfp_mask, mpol, ilx, > &page_allocated, false); > if (si) > put_swap_device(si); > @@ -789,7 +809,7 @@ static struct folio *swap_vma_readahead(swp_entry_t targ_entry, gfp_t gfp_mask, > lru_add_drain(); > skip: > /* The folio was likely read above, so no need for plugging here */ > - folio = __read_swap_cache_async(targ_entry, gfp_mask, mpol, targ_ilx, > + folio = swap_cache_alloc_folio(targ_entry, gfp_mask, mpol, targ_ilx, > &page_allocated, false); > if (unlikely(page_allocated)) > swap_read_folio(folio, NULL); > diff --git a/mm/swapfile.c b/mm/swapfile.c > index 46d2008e4b99..e5284067a442 100644 > --- a/mm/swapfile.c > +++ b/mm/swapfile.c > @@ -1574,7 +1574,7 @@ static unsigned char swap_entry_put_locked(struct swap_info_struct *si, > * CPU1 CPU2 > * do_swap_page() > * ... swapoff+swapon > - * __read_swap_cache_async() > + * swap_cache_alloc_folio() > * swapcache_prepare() > * __swap_duplicate() > * // check swap_map > diff --git a/mm/zswap.c b/mm/zswap.c > index 5d0f8b13a958..a7a2443912f4 100644 > --- a/mm/zswap.c > +++ b/mm/zswap.c > @@ -1014,8 +1014,8 @@ static int zswap_writeback_entry(struct zswap_entry *entry, > return -EEXIST; > > mpol = get_task_policy(current); > - folio = __read_swap_cache_async(swpentry, GFP_KERNEL, mpol, > - NO_INTERLEAVE_INDEX, &folio_was_allocated, true); > + folio = swap_cache_alloc_folio(swpentry, GFP_KERNEL, mpol, > + NO_INTERLEAVE_INDEX, &folio_was_allocated, true); > put_swap_device(si); > if (!folio) > return -ENOMEM; > > -- > 2.52.0 >