From patchwork Fri Oct 13 16:03:49 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 1848400 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256 header.s=mimecast20190719 header.b=OvuRUzy7; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=linux-cifs-owner@vger.kernel.org; receiver=patchwork.ozlabs.org) Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by legolas.ozlabs.org (Postfix) with ESMTP id 4S6Wck5qhDz1yqZ for ; Sat, 14 Oct 2023 03:07:50 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231967AbjJMQHr (ORCPT ); Fri, 13 Oct 2023 12:07:47 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:56084 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233092AbjJMQGy (ORCPT ); Fri, 13 Oct 2023 12:06:54 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A4ED3D4B for ; Fri, 13 Oct 2023 09:05:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1697213143; 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=F0Ay07c0Gz72YNYgMd2laEIR/IQCWOWvRbIa7ptaL9M=; b=OvuRUzy7qQtutclkpzoLeQug+Ca1uZtYbuOQJ1naWJ6A5iA0jziHsIrPfT4IWosITIu1nn Ycy+tDvjjILXO3ZbdoKf1FGSEWwFQAIZq25ThgS/GQ/SnOjzhchCSk4fBqWEgv+pTyKlNE b5hX0JnbpyBonw0TyW6QpYoIASMafxQ= Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-549-ySrH6GjHO9Ka3rsox-_Ymw-1; Fri, 13 Oct 2023 12:05:40 -0400 X-MC-Unique: ySrH6GjHO9Ka3rsox-_Ymw-1 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.rdu2.redhat.com [10.11.54.7]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id C482187B2BB; Fri, 13 Oct 2023 16:05:38 +0000 (UTC) Received: from warthog.procyon.org.uk (unknown [10.42.28.226]) by smtp.corp.redhat.com (Postfix) with ESMTP id 41C051C06535; Fri, 13 Oct 2023 16:05:36 +0000 (UTC) From: David Howells To: Jeff Layton , Steve French Cc: David Howells , Matthew Wilcox , Marc Dionne , Paulo Alcantara , Shyam Prasad N , Tom Talpey , Dominique Martinet , Ilya Dryomov , Christian Brauner , linux-afs@lists.infradead.org, linux-cifs@vger.kernel.org, linux-nfs@vger.kernel.org, ceph-devel@vger.kernel.org, v9fs@lists.linux.dev, linux-fsdevel@vger.kernel.org, linux-mm@kvack.org, netdev@vger.kernel.org, linux-kernel@vger.kernel.org, linux-cachefs@redhat.com Subject: [RFC PATCH 20/53] fscache: Add a function to begin an cache op from a netfslib request Date: Fri, 13 Oct 2023 17:03:49 +0100 Message-ID: <20231013160423.2218093-21-dhowells@redhat.com> In-Reply-To: <20231013160423.2218093-1-dhowells@redhat.com> References: <20231013160423.2218093-1-dhowells@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 3.4.1 on 10.11.54.7 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF, RCVD_IN_DNSWL_BLOCKED,RCVD_IN_MSPIKE_H4,RCVD_IN_MSPIKE_WL, SPF_HELO_NONE,SPF_NONE autolearn=unavailable autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-cifs@vger.kernel.org Add a function to begin an cache read or write operation from a netfslib I/O request. This function can then be pointed to directly by the network filesystem's netfs_request_ops::begin_cache_operation op pointer. Ideally, netfslib would just call into fscache directly, but that would cause dependency cycles as fscache calls into netfslib directly. Signed-off-by: David Howells cc: Jeff Layton cc: linux-cachefs@redhat.com cc: linux-fsdevel@vger.kernel.org cc: linux-mm@kvack.org --- fs/9p/vfs_addr.c | 18 ++---------------- fs/afs/file.c | 14 +------------- fs/ceph/addr.c | 2 +- fs/ceph/cache.h | 12 ------------ fs/fscache/io.c | 42 +++++++++++++++++++++++++++++++++++++++++ include/linux/fscache.h | 6 ++++++ 6 files changed, 52 insertions(+), 42 deletions(-) diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c index 18a666c43e4a..516572bad412 100644 --- a/fs/9p/vfs_addr.c +++ b/fs/9p/vfs_addr.c @@ -17,6 +17,7 @@ #include #include #include +#include #include #include @@ -82,25 +83,10 @@ static void v9fs_free_request(struct netfs_io_request *rreq) p9_fid_put(fid); } -/** - * v9fs_begin_cache_operation - Begin a cache operation for a read - * @rreq: The read request - */ -static int v9fs_begin_cache_operation(struct netfs_io_request *rreq) -{ -#ifdef CONFIG_9P_FSCACHE - struct fscache_cookie *cookie = v9fs_inode_cookie(V9FS_I(rreq->inode)); - - return fscache_begin_read_operation(&rreq->cache_resources, cookie); -#else - return -ENOBUFS; -#endif -} - const struct netfs_request_ops v9fs_req_ops = { .init_request = v9fs_init_request, .free_request = v9fs_free_request, - .begin_cache_operation = v9fs_begin_cache_operation, + .begin_cache_operation = fscache_begin_cache_operation, .issue_read = v9fs_issue_read, }; diff --git a/fs/afs/file.c b/fs/afs/file.c index 3e39a2ebcad6..5bb78d874292 100644 --- a/fs/afs/file.c +++ b/fs/afs/file.c @@ -360,18 +360,6 @@ static int afs_init_request(struct netfs_io_request *rreq, struct file *file) return 0; } -static int afs_begin_cache_operation(struct netfs_io_request *rreq) -{ -#ifdef CONFIG_AFS_FSCACHE - struct afs_vnode *vnode = AFS_FS_I(rreq->inode); - - return fscache_begin_read_operation(&rreq->cache_resources, - afs_vnode_cache(vnode)); -#else - return -ENOBUFS; -#endif -} - static int afs_check_write_begin(struct file *file, loff_t pos, unsigned len, struct folio **foliop, void **_fsdata) { @@ -388,7 +376,7 @@ static void afs_free_request(struct netfs_io_request *rreq) const struct netfs_request_ops afs_req_ops = { .init_request = afs_init_request, .free_request = afs_free_request, - .begin_cache_operation = afs_begin_cache_operation, + .begin_cache_operation = fscache_begin_cache_operation, .check_write_begin = afs_check_write_begin, .issue_read = afs_issue_read, }; diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c index 92a5ddcd9a76..4841b06df78c 100644 --- a/fs/ceph/addr.c +++ b/fs/ceph/addr.c @@ -488,7 +488,7 @@ static void ceph_netfs_free_request(struct netfs_io_request *rreq) const struct netfs_request_ops ceph_netfs_ops = { .init_request = ceph_init_request, .free_request = ceph_netfs_free_request, - .begin_cache_operation = ceph_begin_cache_operation, + .begin_cache_operation = fscache_begin_cache_operation, .issue_read = ceph_netfs_issue_read, .expand_readahead = ceph_netfs_expand_readahead, .clamp_length = ceph_netfs_clamp_length, diff --git a/fs/ceph/cache.h b/fs/ceph/cache.h index dc502daac49a..b804f1094764 100644 --- a/fs/ceph/cache.h +++ b/fs/ceph/cache.h @@ -57,13 +57,6 @@ static inline int ceph_fscache_dirty_folio(struct address_space *mapping, return fscache_dirty_folio(mapping, folio, ceph_fscache_cookie(ci)); } -static inline int ceph_begin_cache_operation(struct netfs_io_request *rreq) -{ - struct fscache_cookie *cookie = ceph_fscache_cookie(ceph_inode(rreq->inode)); - - return fscache_begin_read_operation(&rreq->cache_resources, cookie); -} - static inline bool ceph_is_cache_enabled(struct inode *inode) { return fscache_cookie_enabled(ceph_fscache_cookie(ceph_inode(inode))); @@ -135,11 +128,6 @@ static inline bool ceph_is_cache_enabled(struct inode *inode) return false; } -static inline int ceph_begin_cache_operation(struct netfs_io_request *rreq) -{ - return -ENOBUFS; -} - static inline void ceph_fscache_note_page_release(struct inode *inode) { } diff --git a/fs/fscache/io.c b/fs/fscache/io.c index 0d2b8dec8f82..cb602dd651e6 100644 --- a/fs/fscache/io.c +++ b/fs/fscache/io.c @@ -158,6 +158,48 @@ int __fscache_begin_write_operation(struct netfs_cache_resources *cres, } EXPORT_SYMBOL(__fscache_begin_write_operation); +/** + * fscache_begin_cache_operation - Begin a cache op for netfslib + * @rreq: The netfs request that wants to access the cache. + * + * Begin an I/O operation on behalf of the netfs helper library, read or write. + * @rreq indicates the netfs operation that wishes to access the cache. + * + * This is intended to be pointed to directly by the ->begin_cache_operation() + * netfs lib operation for the network filesystem. + * + * @cres->inval_counter is set from @cookie->inval_counter for comparison at + * the end of the operation. This allows invalidation during the operation to + * be detected by the caller. + * + * Returns: + * * 0 - Success + * * -ENOBUFS - No caching available + * * Other error code from the cache, such as -ENOMEM. + */ +int fscache_begin_cache_operation(struct netfs_io_request *rreq) +{ + struct netfs_inode *ctx = netfs_inode(rreq->inode); + + switch (rreq->origin) { + case NETFS_READAHEAD: + case NETFS_READPAGE: + case NETFS_READ_FOR_WRITE: + return fscache_begin_operation(&rreq->cache_resources, + netfs_i_cookie(ctx), + FSCACHE_WANT_PARAMS, + fscache_access_io_read); + case NETFS_WRITEBACK: + return fscache_begin_operation(&rreq->cache_resources, + netfs_i_cookie(ctx), + FSCACHE_WANT_PARAMS, + fscache_access_io_write); + default: + return -ENOBUFS; + } +} +EXPORT_SYMBOL(fscache_begin_cache_operation); + /** * fscache_dirty_folio - Mark folio dirty and pin a cache object for writeback * @mapping: The mapping the folio belongs to. diff --git a/include/linux/fscache.h b/include/linux/fscache.h index 8e312c8323a8..9c389adaf286 100644 --- a/include/linux/fscache.h +++ b/include/linux/fscache.h @@ -177,6 +177,12 @@ extern void __fscache_write_to_cache(struct fscache_cookie *, struct address_spa bool); extern void __fscache_clear_page_bits(struct address_space *, loff_t, size_t); +#if __fscache_available +extern int fscache_begin_cache_operation(struct netfs_io_request *rreq); +#else +#define fscache_begin_cache_operation NULL +#endif + /** * fscache_acquire_volume - Register a volume as desiring caching services * @volume_key: An identification string for the volume