From patchwork Thu Feb 16 15:07:01 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 13143337 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4411BC636CC for ; Thu, 16 Feb 2023 15:07:24 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id C0C476B0075; Thu, 16 Feb 2023 10:07:23 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id BBD466B007B; Thu, 16 Feb 2023 10:07:23 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id A5DF16B007D; Thu, 16 Feb 2023 10:07:23 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0012.hostedemail.com [216.40.44.12]) by kanga.kvack.org (Postfix) with ESMTP id 992846B0075 for ; Thu, 16 Feb 2023 10:07:23 -0500 (EST) Received: from smtpin07.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay08.hostedemail.com (Postfix) with ESMTP id 49FAA14035C for ; Thu, 16 Feb 2023 15:07:23 +0000 (UTC) X-FDA: 80473483566.07.20AEE4C Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by imf18.hostedemail.com (Postfix) with ESMTP id 681E21C0027 for ; Thu, 16 Feb 2023 15:07:21 +0000 (UTC) Authentication-Results: imf18.hostedemail.com; dkim=pass header.d=redhat.com header.s=mimecast20190719 header.b=aZtWnjuU; spf=pass (imf18.hostedemail.com: domain of dhowells@redhat.com designates 170.10.133.124 as permitted sender) smtp.mailfrom=dhowells@redhat.com; dmarc=pass (policy=none) header.from=redhat.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1676560041; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=dEvVR7mNrJtJrzwBvJMyNMWCqmrGhsk9d3FtHweO8aQ=; b=ng0qhMWogx7l+c6sUtZScGzLEJPgsAiggK6/E5B296Lyuf6yrw28532lRBVcO8bYNo1VDv x/II8GGDQj1yayi/DEwclYMlkZrxTDBiCnC2hmBCTg+asMPZLVuLEuGpE+TDeNq/5y4N1n wWYGeG2HKnSIAUkQKxVNSImRRnW44CU= ARC-Authentication-Results: i=1; imf18.hostedemail.com; dkim=pass header.d=redhat.com header.s=mimecast20190719 header.b=aZtWnjuU; spf=pass (imf18.hostedemail.com: domain of dhowells@redhat.com designates 170.10.133.124 as permitted sender) smtp.mailfrom=dhowells@redhat.com; dmarc=pass (policy=none) header.from=redhat.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1676560041; a=rsa-sha256; cv=none; b=PeL899y5xcP7YAj/XC+x2JPS2jghaMoXHoaQdsse37MJYM0mPChRnIWFButNSeql1DafJO 0ZFtq5nhtg6OvSImnM5bw0eKQ0NUeMbb/ROKDnlxTjEhcShMg58ZjSZvjDD8vxN9vddY5t 504EE0qHFCzOhsT0f8WyjAxyVj1EkvE= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1676560040; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=dEvVR7mNrJtJrzwBvJMyNMWCqmrGhsk9d3FtHweO8aQ=; b=aZtWnjuU0bNaBYTko6n3vkNq/sAlZTWssKRyTCr9/serrSqVPGRgZZwjBKPgYp9RqWaqyG DwR+lqpmw0FlB0JhGAxV3vMk6Ien+v8w1kS2EM+6NJY1PW8ttxmJnaVMMjdpkVkEUV5gZH e8Qc+q5qdSAcpck+bqkRqf666cHwlFU= Received: from mimecast-mx02.redhat.com (mx3-rdu2.redhat.com [66.187.233.73]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-518-h1RdFIDIPg6lnrRYr2xXyw-1; Thu, 16 Feb 2023 10:07:16 -0500 X-MC-Unique: h1RdFIDIPg6lnrRYr2xXyw-1 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.rdu2.redhat.com [10.11.54.4]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id CFC4B3C1486A; Thu, 16 Feb 2023 15:07:13 +0000 (UTC) Received: from warthog.procyon.org.uk (unknown [10.33.36.24]) by smtp.corp.redhat.com (Postfix) with ESMTP id 5A3572026D4B; Thu, 16 Feb 2023 15:07:11 +0000 (UTC) From: David Howells To: Matthew Wilcox Cc: David Howells , Linus Torvalds , Jeff Layton , Christoph Hellwig , linux-afs@lists.infradead.org, linux-nfs@vger.kernel.org, linux-cifs@vger.kernel.org, ceph-devel@vger.kernel.org, v9fs-developer@lists.sourceforge.net, linux-erofs@lists.ozlabs.org, linux-ext4@vger.kernel.org, linux-cachefs@redhat.com, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, Rohith Surabattula , Steve French , Shyam Prasad N , Dave Wysochanski , Dominique Martinet , Ilya Dryomov , linux-mm@kvack.org Subject: [PATCH v6 2/2] mm, netfs, fscache: Stop read optimisation when folio removed from pagecache Date: Thu, 16 Feb 2023 15:07:01 +0000 Message-Id: <20230216150701.3654894-3-dhowells@redhat.com> In-Reply-To: <20230216150701.3654894-1-dhowells@redhat.com> References: <20230216150701.3654894-1-dhowells@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 3.1 on 10.11.54.4 X-Rspamd-Server: rspam07 X-Rspamd-Queue-Id: 681E21C0027 X-Rspam-User: X-Stat-Signature: w5767s8kbyaqjnwz1csbzhyy8x68ucye X-HE-Tag: 1676560041-596099 X-HE-Meta: U2FsdGVkX1/GWGcuoLCeuEn4copbZ5GlaBbjBLtZOVZXsksjZ+HiiUSIhAiDy9howcnZ97/M7M2z5H/pIdIYKmDJhHieYrxoHEJZKYFvIh9kvpIqbF897GtSxQ763uZZ3vETtyOO8B6Kgbwsup7yc6ZGs0IcItt9BlxJrlH9ma4rM3ncTnawXnNuHWak+Zavy39qZNMjkRafVdzGq3VvK0/7x8Wu5UPPggXjvv0mLOeaev9O2Xql/lhwpi05V9q1yDDpgBglHz/WkZMMNnnMmQW0rSU4gIgNzxzQZP2pbqszylcbGpSKZrD+AdCpId1ZobxcoJHpRSVmN/ZLU49cslJj3znOb7xQ4YSWuHTnuXvtgnnRWhLEMa32kpWSj2QVnbDM0VACax454VfowPfW4gKxRMHnvNxu4qknBscfmJeMERzYTqtv3b9eOrNWefLuSjx+8Ii4Nm6BJO6eJaPb9tf7QDhfWQeibH+YbbG99jlzk/g65BMsb1smz073uGo/AR9JHQlRjiJTB0Aw8d9Fzob5D3pdtPGGti9MhtQt3nUs9LITVKhTPgfkoy5OGAbmd+YwyvPKgXeDeT489U3iWdiE4PwWZCJeiRaWJbtGDhUqLHgvMLgJX5KAhrdCOuxln3sNSdGlhLWErEct6OfE6gyBhLyi2mj09L3mX065D8MmLG0+oE6BjZCKeXPYzb4C3hgoLDXtKdzXSK/nqAbU/TLyC2KLqwSZVKk3jFYvBY2lmbdskaw5XQprR8t5gPR49j2u39E6SLtTNC8hPzpN8lG0J/+FN/Xn8AjgWQbVFSPdhILqfVIz20cm9pk1wF5Q2GFvZR9XxbxRRJTwJCJxGiMZPWxFksuDNriyg7IrKLyM67IQSAWDuT3oijlAQBQByGrDn5bi7WkEybUQturwmakiEdxV1iQIoY6kM9bX220T4lrhbOhOYs+++GCMQwyr+EYzXADbES8AxXuM2ng 7Fuohq6E Hsa6Hpsluigkrs3hP24HhqZPB/L5biq/I4M6vBYHffjfnFVmV3M8FtKo8ox/jUeOAFpah4Pz5EAh4h8GCyLCENQkgGvQSiNglp7xZ5sMCQawrsuMeabHRGYlH1aRnkegp3GwUseK2E38mwJL6kJ27uVJxTlCFqTyTSTWJYei0LzYXFZZVM2jh2IKp8ksmDcsLBGJmL+sGZTz+2m9Vpd8Fs/UNpsqmnZkwu7Jw8Le+81laMY9lB3QDFS0dMfljcAOxEkv0lp6HbUKZvQwzUoOUOW5du0TY/OpAOEa8Ktj/g2fQ2/DRgmQYR2LLuplt0NtvUhCXTNENE3znLIV8f2oB7JuTZjwWI8mlN95eXKNo8bIkV1LEqrG+5M4ickp0iwauiOP3nDLn01IF/XhZ2N6Obm+NqbXBAzwZNtgYo4Y10T8rOqFdyG9v//E8YA8y1QKevwmjBvG1OdhOJwhSfWl88irQQvq00HTH/6yZYfgDvTN/JIcN2kz5kxbU62HY0+8p5L2H4AFL8kv00L05yZtXqq59itqt8a0TcElE0wdhEENLzMvTzcUv6CLXqcbYfkJtCkGJGX2P/H3/R9cWm2BUR8cmDXene70FLk/ctc8+4Up0ziu2djcpYVeJ172hH62nCBeMLqxMdkUtdqRiH+wF3gRAWU2eDJhjp3Fm X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: Fscache has an optimisation by which reads from the cache are skipped until we know that (a) there's data there to be read and (b) that data isn't entirely covered by pages resident in the netfs pagecache. This is done with two flags manipulated by fscache_note_page_release(): if (... test_bit(FSCACHE_COOKIE_HAVE_DATA, &cookie->flags) && test_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags)) clear_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags); where the NO_DATA_TO_READ flag causes cachefiles_prepare_read() to indicate that netfslib should download from the server or clear the page instead. The fscache_note_page_release() function is intended to be called from ->releasepage() - but that only gets called if PG_private or PG_private_2 is set - and currently the former is at the discretion of the network filesystem and the latter is only set whilst a page is being written to the cache, so sometimes we miss clearing the optimisation. Fix this by following Willy's suggestion[1] and adding an address_space flag, AS_RELEASE_ALWAYS, that causes filemap_release_folio() to always call ->release_folio() if it's set, even if PG_private or PG_private_2 aren't set. Note that this would require folio_test_private() and page_has_private() to become more complicated. To avoid that, in the places[*] where these are used to conditionalise calls to filemap_release_folio() and try_to_release_page(), the tests are removed the those functions just jumped to unconditionally and the test is performed there. [*] There are some exceptions in vmscan.c where the check guards more than just a call to the releaser. I've added a function, folio_needs_release() to wrap all the checks for that. AS_RELEASE_ALWAYS should be set if a non-NULL cookie is obtained from fscache and cleared in ->evict_inode() before truncate_inode_pages_final() is called. Additionally, the FSCACHE_COOKIE_NO_DATA_TO_READ flag needs to be cleared and the optimisation cancelled if a cachefiles object already contains data when we open it. Reported-by: Rohith Surabattula Suggested-by: Matthew Wilcox Signed-off-by: David Howells cc: Matthew Wilcox cc: Linus Torvalds cc: Steve French cc: Shyam Prasad N cc: Rohith Surabattula cc: Dave Wysochanski cc: Dominique Martinet cc: Ilya Dryomov cc: linux-cachefs@redhat.com cc: linux-cifs@vger.kernel.org cc: linux-afs@lists.infradead.org cc: v9fs-developer@lists.sourceforge.net cc: ceph-devel@vger.kernel.org cc: linux-nfs@vger.kernel.org cc: linux-fsdevel@vger.kernel.org cc: linux-mm@kvack.org --- Notes: ver #4) - Split out merging of folio_has_private()/filemap_release_folio() call pairs into a preceding patch. - Don't need to clear AS_RELEASE_ALWAYS in ->evict_inode(). ver #3) - Fixed mapping_clear_release_always() to use clear_bit() not set_bit(). - Moved a '&&' to the correct line. ver #2) - Rewrote entirely according to Willy's suggestion[1]. fs/9p/cache.c | 2 ++ fs/afs/internal.h | 2 ++ fs/cachefiles/namei.c | 2 ++ fs/ceph/cache.c | 2 ++ fs/cifs/fscache.c | 2 ++ include/linux/pagemap.h | 16 ++++++++++++++++ mm/internal.h | 5 ++++- 7 files changed, 30 insertions(+), 1 deletion(-) diff --git a/fs/9p/cache.c b/fs/9p/cache.c index cebba4eaa0b5..12c0ae29f185 100644 --- a/fs/9p/cache.c +++ b/fs/9p/cache.c @@ -68,6 +68,8 @@ void v9fs_cache_inode_get_cookie(struct inode *inode) &path, sizeof(path), &version, sizeof(version), i_size_read(&v9inode->netfs.inode)); + if (v9inode->netfs.cache) + mapping_set_release_always(inode->i_mapping); p9_debug(P9_DEBUG_FSC, "inode %p get cookie %p\n", inode, v9fs_inode_cookie(v9inode)); diff --git a/fs/afs/internal.h b/fs/afs/internal.h index fd8567b98e2b..2d7e06fcb77f 100644 --- a/fs/afs/internal.h +++ b/fs/afs/internal.h @@ -680,6 +680,8 @@ static inline void afs_vnode_set_cache(struct afs_vnode *vnode, { #ifdef CONFIG_AFS_FSCACHE vnode->netfs.cache = cookie; + if (cookie) + mapping_set_release_always(vnode->netfs.inode.i_mapping); #endif } diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c index 03ca8f2f657a..50b2ee163af6 100644 --- a/fs/cachefiles/namei.c +++ b/fs/cachefiles/namei.c @@ -584,6 +584,8 @@ static bool cachefiles_open_file(struct cachefiles_object *object, if (ret < 0) goto check_failed; + clear_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &object->cookie->flags); + object->file = file; /* Always update the atime on an object we've just looked up (this is diff --git a/fs/ceph/cache.c b/fs/ceph/cache.c index 177d8e8d73fe..de1dee46d3df 100644 --- a/fs/ceph/cache.c +++ b/fs/ceph/cache.c @@ -36,6 +36,8 @@ void ceph_fscache_register_inode_cookie(struct inode *inode) &ci->i_vino, sizeof(ci->i_vino), &ci->i_version, sizeof(ci->i_version), i_size_read(inode)); + if (ci->netfs.cache) + mapping_set_release_always(inode->i_mapping); } void ceph_fscache_unregister_inode_cookie(struct ceph_inode_info *ci) diff --git a/fs/cifs/fscache.c b/fs/cifs/fscache.c index f6f3a6b75601..79e9665dfc90 100644 --- a/fs/cifs/fscache.c +++ b/fs/cifs/fscache.c @@ -108,6 +108,8 @@ void cifs_fscache_get_inode_cookie(struct inode *inode) &cifsi->uniqueid, sizeof(cifsi->uniqueid), &cd, sizeof(cd), i_size_read(&cifsi->netfs.inode)); + if (cifsi->netfs.cache) + mapping_set_release_always(inode->i_mapping); } void cifs_fscache_unuse_inode_cookie(struct inode *inode, bool update) diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h index 29e1f9e76eb6..a0d433e0addd 100644 --- a/include/linux/pagemap.h +++ b/include/linux/pagemap.h @@ -199,6 +199,7 @@ enum mapping_flags { /* writeback related tags are not used */ AS_NO_WRITEBACK_TAGS = 5, AS_LARGE_FOLIO_SUPPORT = 6, + AS_RELEASE_ALWAYS, /* Call ->release_folio(), even if no private data */ }; /** @@ -269,6 +270,21 @@ static inline int mapping_use_writeback_tags(struct address_space *mapping) return !test_bit(AS_NO_WRITEBACK_TAGS, &mapping->flags); } +static inline bool mapping_release_always(const struct address_space *mapping) +{ + return test_bit(AS_RELEASE_ALWAYS, &mapping->flags); +} + +static inline void mapping_set_release_always(struct address_space *mapping) +{ + set_bit(AS_RELEASE_ALWAYS, &mapping->flags); +} + +static inline void mapping_clear_release_always(struct address_space *mapping) +{ + clear_bit(AS_RELEASE_ALWAYS, &mapping->flags); +} + static inline gfp_t mapping_gfp_mask(struct address_space * mapping) { return mapping->gfp_mask; diff --git a/mm/internal.h b/mm/internal.h index c4c8e58e1d12..5421ce8661fa 100644 --- a/mm/internal.h +++ b/mm/internal.h @@ -168,7 +168,10 @@ static inline void set_page_refcounted(struct page *page) */ static inline bool folio_needs_release(struct folio *folio) { - return folio_has_private(folio); + struct address_space *mapping = folio->mapping; + + return folio_has_private(folio) || + (mapping && mapping_release_always(mapping)); } extern unsigned long highest_memmap_pfn;