netfs, afs, 9p: Delegate high-level I/O to netfslib
Subsystems (16)
David Howells
maintainerv4 cover netfs, afs, 9p: Delegate high-level I/O to netfslib
Hi Jeff, Steve, Dominique,
I have been working on my netfslib helpers to the point that I can run xfstests on AFS to completion (both with write-back buffering and, with a small patch, write-through buffering in the pagecache). I have a patch for 9P, but am currently unable to test it.
The patches remove a little over 800 lines from AFS, 300 from 9P, albeit with around 3000 lines added to netfs. Hopefully, I will be able to remove a bunch of lines from Ceph too.
I've split the CIFS patches out to a separate branch, cifs-netfs, where a further 2000+ lines are removed. I can run a certain amount of xfstests on CIFS, though I'm running into ksmbd issues and not all the tests work correctly because of issues between fallocate and what the SMB protocol actually supports.
I've also dropped the content-crypto patches out for the moment as they're only usable by the ceph changes which I'm still working on.
The patch to use PG_writeback instead of PG_fscache for writing to the cache has also been deferred, pending 9p, afs, ceph and cifs all being converted.
The main aims of these patches are to get high-level I/O and knowledge of the pagecache out of the filesystem drivers as much as possible and to get rid, as much of possible, of the knowledge that pages/folios exist.
Further, I would like to see ->write_begin, ->write_end and ->launder_folio go away.
Features that are added by these patches to that which is already there in netfslib:
(1) NFS-style (and Ceph-style) locking around DIO vs buffered I/O calls to prevent these from happening at the same time. mmap'd I/O can, of necessity, happen at any time ignoring these locks.
(2) Support for unbuffered I/O. The data is kept in the bounce buffer and the pagecache is not used. This can be turned on with an inode flag.
(3) Support for direct I/O. This is basically unbuffered I/O with some extra restrictions and no RMW.
(4) Support for using a bounce buffer in an operation. The bounce buffer may be bigger than the target data/buffer, allowing for crypto rounding.
(5) ->write_begin() and ->write_end() are ignored in favour of merging all of that into one function, netfs_perform_write(), thereby avoiding the function pointer traversals.
(6) Support for write-through caching in the pagecache. netfs_perform_write() adds the pages is modifies to an I/O operation as it goes and directly marks them writeback rather than dirty. When writing back from write-through, it limits the range written back. This should allow CIFS to deal with byte-range mandatory locks correctly.
(7) O_*SYNC and RWF_*SYNC writes use write-through rather than writing to the pagecache and then flushing afterwards. An AIO O_*SYNC write will notify of completion when the sub-writes all complete.
(8) Support for write-streaming where modifed data is held in !uptodate folios, with a private struct attached indicating the range that is valid.
(9) Support for write grouping, multiplexing a pointer to a group in the folio private data with the write-streaming data. The writepages algorithm only writes stuff back that's in the nominated group. This is intended for use by Ceph to write is snaps in order.
(10) Skipping reads for which we know the server could only supply zeros or EOF (for instance if we've done a local write that leaves a hole in the file and extends the local inode size).
General notes:
(1) The fscache module is merged into the netfslib module to avoid cyclic exported symbol usage that prevents either module from being loaded.
(2) Some helpers from fscache are reassigned to netfslib by name.
(3) netfslib now makes use of folio->private, which means the filesystem can't use it.
(4) The filesystem provides wrappers to call the write helpers, allowing it to do pre-validation, oplock/capability fetching and the passing in of write group info.
(5) I want to try flushing the data when tearing down an inode before invalidating it to try and render launder_folio unnecessary.
(6) Write-through caching will generate and dispatch write subrequests as it gathers enough data to hit wsize and has whole pages that at least span that size. This needs to be a bit more flexible, allowing for a filesystem such as CIFS to have a variable wsize.
(7) The filesystem driver is just given read and write calls with an iov_iter describing the data/buffer to use. Ideally, they don't see pages or folios at all. A function, extract_iter_to_sg(), is already available to decant part of an iterator into a scatterlist for crypto purposes.
9P notes:
(1) I haven't managed to test this as I haven't been able to get Ganesha to work correctly with 9P.
(2) Writes should now occur in larger-than-page-sized chunks.
(3) It should be possible to turn on multipage folio support in 9P now.
Changes
=======
ver #4)
- Slimmed down the branch:
- Split the cifs-related patches off to a separate branch (cifs-netfs)
- Deferred the content-encryption to the in-progress ceph changes.
- Deferred the use-PG_writeback rather than PG_fscache patch
- Rebased on a later linux-next with afs-rotation patches.
ver #3)
- Moved the fscache module into netfslib to avoid export cycles.
- Fixed a bunch of bugs.
- Got CIFS to pass as much of xfstests as possible.
- Added a patch to make 9P use all the helpers.
- Added a patch to stop using PG_fscache, but rather dirty pages on reading and have writepages write to the cache.
ver #2)
- Folded the addition of NETFS_RREQ_NONBLOCK/BLOCKED into first patch that uses them.
- Folded addition of rsize member into first user.
- Don't set rsize in ceph (yet) and set it in kafs to 256KiB. cifs sets it dynamically.
- Moved direct_bv next to direct_bv_count in struct netfs_io_request and labelled it with a __counted_by().
- Passed flags into netfs_xa_store_and_mark() rather than two bools.
- Removed netfs_set_up_buffer() as it wasn't used.
David
David Howells (39):
netfs, fscache: Move fs/fscache/* into fs/netfs/
netfs, fscache: Combine fscache with netfs
netfs, fscache: Remove ->begin_cache_operation
netfs, fscache: Move /proc/fs/fscache to /proc/fs/netfs and put in a
symlink
netfs: Move pinning-for-writeback from fscache to netfs
netfs: Add a procfile to list in-progress requests
netfs: Allow the netfs to make the io (sub)request alloc larger
netfs: Add a ->free_subrequest() op
afs: Don't use folio->private to record partial modification
netfs: Provide invalidate_folio and release_folio calls
netfs: Implement unbuffered/DIO vs buffered I/O locking
netfs: Add iov_iters to (sub)requests to describe various buffers
netfs: Add support for DIO buffering
netfs: Provide tools to create a buffer in an xarray
netfs: Add bounce buffering support
netfs: Add func to calculate pagecount/size-limited span of an
iterator
netfs: Limit subrequest by size or number of segments
netfs: Export netfs_put_subrequest() and some tracepoints
netfs: Extend the netfs_io_*request structs to handle writes
netfs: Add a hook to allow tell the netfs to update its i_size
netfs: Make netfs_put_request() handle a NULL pointer
netfs: Make the refcounting of netfs_begin_read() easier to use
netfs: Prep to use folio->private for write grouping and streaming
write
netfs: Dispatch write requests to process a writeback slice
netfs: Provide func to copy data to pagecache for buffered write
netfs: Make netfs_read_folio() handle streaming-write pages
netfs: Allocate multipage folios in the writepath
netfs: Implement support for unbuffered/DIO read
netfs: Implement unbuffered/DIO write support
netfs: Implement buffered write API
netfs: Allow buffered shared-writeable mmap through
netfs_page_mkwrite()
netfs: Provide netfs_file_read_iter()
netfs, cachefiles: Pass upper bound length to allow expansion
netfs: Provide a writepages implementation
netfs: Provide a launder_folio implementation
netfs: Implement a write-through caching option
netfs: Optimise away reads above the point at which there can be no
data
afs: Use the netfs write helpers
9p: Use netfslib read/write_iter
Documentation/filesystems/netfs_library.rst | 23 +-
MAINTAINERS | 2 +-
fs/9p/vfs_addr.c | 352 +----
fs/9p/vfs_file.c | 89 +-
fs/9p/vfs_inode.c | 5 +-
fs/9p/vfs_super.c | 14 +-
fs/Kconfig | 1 -
fs/Makefile | 1 -
fs/afs/file.c | 213 +--
fs/afs/inode.c | 26 +-
fs/afs/internal.h | 72 +-
fs/afs/super.c | 2 +-
fs/afs/write.c | 826 +----------
fs/cachefiles/internal.h | 2 +-
fs/cachefiles/io.c | 10 +-
fs/cachefiles/ondemand.c | 2 +-
fs/ceph/addr.c | 25 +-
fs/ceph/cache.h | 35 +-
fs/ceph/inode.c | 2 +-
fs/fs-writeback.c | 10 +-
fs/fscache/Kconfig | 40 -
fs/fscache/Makefile | 16 -
fs/fscache/internal.h | 277 ----
fs/netfs/Kconfig | 39 +
fs/netfs/Makefile | 22 +-
fs/netfs/buffered_read.c | 229 ++-
fs/netfs/buffered_write.c | 1247 +++++++++++++++++
fs/netfs/direct_read.c | 252 ++++
fs/netfs/direct_write.c | 170 +++
fs/{fscache/cache.c => netfs/fscache_cache.c} | 0
.../cookie.c => netfs/fscache_cookie.c} | 0
fs/netfs/fscache_internal.h | 14 +
fs/{fscache/io.c => netfs/fscache_io.c} | 42 +-
fs/{fscache/main.c => netfs/fscache_main.c} | 25 +-
fs/{fscache/proc.c => netfs/fscache_proc.c} | 23 +-
fs/{fscache/stats.c => netfs/fscache_stats.c} | 4 +-
.../volume.c => netfs/fscache_volume.c} | 0
fs/netfs/internal.h | 288 ++++
fs/netfs/io.c | 214 ++-
fs/netfs/iterator.c | 97 ++
fs/netfs/locking.c | 215 +++
fs/netfs/main.c | 110 ++
fs/netfs/misc.c | 260 ++++
fs/netfs/objects.c | 63 +-
fs/netfs/output.c | 478 +++++++
fs/netfs/stats.c | 31 +-
fs/nfs/Kconfig | 4 +-
fs/nfs/fscache.c | 7 -
fs/smb/client/cifsfs.c | 9 +-
fs/smb/client/file.c | 18 +-
fs/smb/client/fscache.c | 2 +-
include/linux/fs.h | 2 +-
include/linux/fscache.h | 45 -
include/linux/netfs.h | 176 ++-
include/linux/writeback.h | 2 +-
include/trace/events/afs.h | 31 -
include/trace/events/netfs.h | 155 +-
mm/filemap.c | 1 +
58 files changed, 4197 insertions(+), 2123 deletions(-)
delete mode 100644 fs/fscache/Kconfig
delete mode 100644 fs/fscache/Makefile
delete mode 100644 fs/fscache/internal.h
create mode 100644 fs/netfs/buffered_write.c
create mode 100644 fs/netfs/direct_read.c
create mode 100644 fs/netfs/direct_write.c
rename fs/{fscache/cache.c => netfs/fscache_cache.c} (100%)
rename fs/{fscache/cookie.c => netfs/fscache_cookie.c} (100%)
create mode 100644 fs/netfs/fscache_internal.h
rename fs/{fscache/io.c => netfs/fscache_io.c} (86%)
rename fs/{fscache/main.c => netfs/fscache_main.c} (84%)
rename fs/{fscache/proc.c => netfs/fscache_proc.c} (58%)
rename fs/{fscache/stats.c => netfs/fscache_stats.c} (97%)
rename fs/{fscache/volume.c => netfs/fscache_volume.c} (100%)
create mode 100644 fs/netfs/locking.c
create mode 100644 fs/netfs/misc.c
create mode 100644 fs/netfs/output.cDavid Howells
maintainerPATCH v4 1/39 netfs, fscache: Move fs/fscache/* into fs/netfs/
There's a problem with dependencies between netfslib and fscache as each wants to access some functions of the other. Deal with this by moving fs/fscache/* into fs/netfs/ and renaming those files to begin with "fscache-".
For the moment, the moved files are changed as little as possible and an fscache module is still built. A subsequent patch will integrate them.
---
MAINTAINERS | 2 +-
fs/Kconfig | 1 -
fs/Makefile | 1 -
fs/fscache/Kconfig | 40 -------------------
fs/fscache/Makefile | 16 --------
fs/netfs/Kconfig | 39 ++++++++++++++++++
fs/netfs/Makefile | 14 ++++++-
fs/{fscache/cache.c => netfs/fscache_cache.c} | 0
.../cookie.c => netfs/fscache_cookie.c} | 0
.../internal.h => netfs/fscache_internal.h} | 0
fs/{fscache/io.c => netfs/fscache_io.c} | 0
fs/{fscache/main.c => netfs/fscache_main.c} | 0
fs/{fscache/proc.c => netfs/fscache_proc.c} | 0
fs/{fscache/stats.c => netfs/fscache_stats.c} | 0
.../volume.c => netfs/fscache_volume.c} | 0
fs/netfs/internal.h | 5 +++
fs/netfs/main.c | 5 ++-
17 files changed, 61 insertions(+), 62 deletions(-)
delete mode 100644 fs/fscache/Kconfig
delete mode 100644 fs/fscache/Makefile
rename fs/{fscache/cache.c => netfs/fscache_cache.c} (100%)
rename fs/{fscache/cookie.c => netfs/fscache_cookie.c} (100%)
rename fs/{fscache/internal.h => netfs/fscache_internal.h} (100%)
rename fs/{fscache/io.c => netfs/fscache_io.c} (100%)
rename fs/{fscache/main.c => netfs/fscache_main.c} (100%)
rename fs/{fscache/proc.c => netfs/fscache_proc.c} (100%)
rename fs/{fscache/stats.c => netfs/fscache_stats.c} (100%)
rename fs/{fscache/volume.c => netfs/fscache_volume.c} (100%)MAINTAINERS +1 -1
@@ -8617,7 +8617,7 @@ M: David Howells <[email protected]> L: [email protected] (moderated for non-subscribers) S: Supported F: Documentation/filesystems/caching/ -F: fs/fscache/ +F: fs/netfs/fscache-* F: include/linux/fscache*.h FSCRYPT: FILE SYSTEM LEVEL ENCRYPTION SUPPORT
fs/Kconfig +0 -1
@@ -140,7 +140,6 @@ source "fs/overlayfs/Kconfig" menu "Caches" source "fs/netfs/Kconfig" -source "fs/fscache/Kconfig" source "fs/cachefiles/Kconfig" endmenu
fs/Makefile +0 -1
@@ -60,7 +60,6 @@ obj-$(CONFIG_DLM) += dlm/ # Do not add any filesystems before this line obj-$(CONFIG_NETFS_SUPPORT) += netfs/ -obj-$(CONFIG_FSCACHE) += fscache/ obj-$(CONFIG_REISERFS_FS) += reiserfs/ obj-$(CONFIG_EXT4_FS) += ext4/ # We place ext4 before ext2 so that clean ext3 root fs's do NOT mount using the
fs/fscache/Kconfig deleted +0 -40
@@ -1,40 +0,0 @@ -# SPDX-License-Identifier: GPL-2.0-only - -config FSCACHE - tristate "General filesystem local caching manager" - select NETFS_SUPPORT - help - This option enables a generic filesystem caching manager that can be - used by various network and other filesystems to cache data locally. - Different sorts of caches can be plugged in, depending on the - resources available. - - See Documentation/filesystems/caching/fscache.rst for more information. - -config FSCACHE_STATS - bool "Gather statistical information on local caching" - depends on FSCACHE && PROC_FS - select NETFS_STATS - help - This option causes statistical information to be gathered on local - caching and exported through file: - - /proc/fs/fscache/stats - - The gathering of statistics adds a certain amount of overhead to - execution as there are a quite a few stats gathered, and on a - multi-CPU system these may be on cachelines that keep bouncing - between CPUs. On the other hand, the stats are very useful for - debugging purposes. Saying 'Y' here is recommended. - - See Documentation/filesystems/caching/fscache.rst for more information. - -config FSCACHE_DEBUG - bool "Debug FS-Cache" - depends on FSCACHE - help - This permits debugging to be dynamically enabled in the local caching - management module. If this is set, the debugging output may be - enabled by setting bits in /sys/modules/fscache/parameter/debug. - - See Documentation/filesystems/caching/fscache.rst for more information.
fs/fscache/Makefile deleted +0 -16
@@ -1,16 +0,0 @@ -# SPDX-License-Identifier: GPL-2.0 -# -# Makefile for general filesystem caching code -# - -fscache-y := \ - cache.o \ - cookie.o \ - io.o \ - main.o \ - volume.o - -fscache-$(CONFIG_PROC_FS) += proc.o -fscache-$(CONFIG_FSCACHE_STATS) += stats.o - -obj-$(CONFIG_FSCACHE) := fscache.o
fs/netfs/Kconfig +39 -0
@@ -21,3 +21,42 @@ config NETFS_STATS multi-CPU system these may be on cachelines that keep bouncing between CPUs. On the other hand, the stats are very useful for debugging purposes. Saying 'Y' here is recommended. + +config FSCACHE + tristate "General filesystem local caching manager" + select NETFS_SUPPORT + help + This option enables a generic filesystem caching manager that can be + used by various network and other filesystems to cache data locally. + Different sorts of caches can be plugged in, depending on the + resources available. + + See Documentation/filesystems/caching/fscache.rst for more information. + +config FSCACHE_STATS + bool "Gather statistical information on local caching" + depends on FSCACHE && PROC_FS + select NETFS_STATS + help + This option causes statistical information to be gathered on local + caching and exported through file: + + /proc/fs/fscache/stats + + The gathering of statistics adds a certain amount of overhead to + execution as there are a quite a few stats gathered, and on a + multi-CPU system these may be on cachelines that keep bouncing + between CPUs. On the other hand, the stats are very useful for + debugging purposes. Saying 'Y' here is recommended. + + See Documentation/filesystems/caching/fscache.rst for more information. + +config FSCACHE_DEBUG + bool "Debug FS-Cache" + depends on FSCACHE + help + This permits debugging to be dynamically enabled in the local caching + management module. If this is set, the debugging output may be + enabled by setting bits in /sys/modules/fscache/parameter/debug. + + See Documentation/filesystems/caching/fscache.rst for more information.
fs/netfs/Makefile +13 -1
@@ -1,5 +1,17 @@ # SPDX-License-Identifier: GPL-2.0 +fscache-y := \ + fscache_cache.o \ + fscache_cookie.o \ + fscache_io.o \ + fscache_main.o \ + fscache_volume.o + +fscache-$(CONFIG_PROC_FS) += fscache_proc.o +fscache-$(CONFIG_FSCACHE_STATS) += fscache_stats.o + +obj-$(CONFIG_FSCACHE) := fscache.o + netfs-y := \ buffered_read.o \ io.o \
@@ -9,4 +21,4 @@ netfs-y := \ netfs-$(CONFIG_NETFS_STATS) += stats.o -obj-$(CONFIG_NETFS_SUPPORT) := netfs.o +obj-$(CONFIG_NETFS_SUPPORT) += netfs.o
fs/netfs/fscache_cache.c renamed from fs/fscache/cache.c +0 -0
fs/netfs/fscache_cookie.c renamed from fs/fscache/cookie.c +0 -0
fs/netfs/fscache_internal.h renamed from fs/fscache/internal.h +0 -0
fs/netfs/fscache_io.c renamed from fs/fscache/io.c +0 -0
fs/netfs/fscache_main.c renamed from fs/fscache/main.c +0 -0
fs/netfs/fscache_proc.c renamed from fs/fscache/proc.c +0 -0
fs/netfs/fscache_stats.c renamed from fs/fscache/stats.c +0 -0
fs/netfs/fscache_volume.c renamed from fs/fscache/volume.c +0 -0
fs/netfs/internal.h +5 -0
@@ -5,9 +5,12 @@* Written by David Howells ([email protected]) */ +#include <linux/slab.h> +#include <linux/seq_file.h> #include <linux/netfs.h> #include <linux/fscache.h> #include <trace/events/netfs.h> +#include "fscache_internal.h" #ifdef pr_fmt#undef pr_fmt
@@ -107,6 +110,7 @@ static inline bool netfs_is_cache_enabled(struct netfs_inode *ctx)/* * debug tracing */ +#if 0 #define dbgprintk (FMT , ...) \ printk("[%-6.6s] "FMT"\n", current->comm, ##__VA_ARGS__)
@@ -143,3 +147,4 @@ do { \#define _leave (FMT , ...) no_printk("<== %s()"FMT"", __func__, ##__VA_ARGS__)#define _debug (FMT , ...) no_printk(FMT, ##__VA_ARGS__)#endif +#endif
fs/netfs/main.c +3 -2
@@ -8,8 +8,8 @@#include <linux/module.h> #include <linux/export.h> #include "internal.h" -#define CREATE_TRACE_POINTS -#include <trace/events/netfs.h> +//#define CREATE_TRACE_POINTS +//#include <trace/events/netfs.h> MODULE_DESCRIPTION ("Network fs support" );MODULE_AUTHOR ("Red Hat, Inc." );
@@ -18,3 +18,4 @@ MODULE_LICENSE("GPL");unsigned netfs_debug;module_param_named (debug, netfs_debug, uint,S_IWUSR |S_IRUGO );MODULE_PARM_DESC (netfs_debug,"Netfs support debugging mask" ); +
David Howells
maintainerPATCH v4 2/39 netfs, fscache: Combine fscache with netfs
In reply to David HowellsNow that the fscache code is moved to be colocated with the netfslib code so that they combined into one module, do the combining.
--- fs/netfs/Kconfig | 4 +- fs/netfs/Makefile | 24 ++-- fs/netfs/fscache_internal.h | 267 +----------------------------------- fs/netfs/fscache_main.c | 17 +-- fs/netfs/internal.h | 192 +++++++++++++++++++++++++- fs/netfs/main.c | 4 +- fs/nfs/Kconfig | 4 +- 7 files changed, 213 insertions(+), 299 deletions(-)
fs/netfs/Kconfig +2 -2
@@ -23,8 +23,8 @@ config NETFS_STATS debugging purposes. Saying 'Y' here is recommended. config FSCACHE - tristate "General filesystem local caching manager" - select NETFS_SUPPORT + bool "General filesystem local caching manager" + depends on NETFS_SUPPORT help This option enables a generic filesystem caching manager that can be used by various network and other filesystems to cache data locally.
fs/netfs/Makefile +12 -12
@@ -1,17 +1,5 @@ # SPDX-License-Identifier: GPL-2.0 -fscache-y := \ - fscache_cache.o \ - fscache_cookie.o \ - fscache_io.o \ - fscache_main.o \ - fscache_volume.o - -fscache-$(CONFIG_PROC_FS) += fscache_proc.o -fscache-$(CONFIG_FSCACHE_STATS) += fscache_stats.o - -obj-$(CONFIG_FSCACHE) := fscache.o - netfs-y := \ buffered_read.o \ io.o \
@@ -21,4 +9,16 @@ netfs-y := \ netfs-$(CONFIG_NETFS_STATS) += stats.o +netfs-$(CONFIG_FSCACHE) += \ + fscache_cache.o \ + fscache_cookie.o \ + fscache_io.o \ + fscache_main.o \ + fscache_volume.o + +ifeq ($(CONFIG_PROC_FS),y) +netfs-$(CONFIG_FSCACHE) += fscache_proc.o +endif +netfs-$(CONFIG_FSCACHE_STATS) += fscache_stats.o + obj-$(CONFIG_NETFS_SUPPORT) += netfs.o
fs/netfs/fscache_internal.h +2 -265
275 lines not on this page · raw message
fs/netfs/fscache_main.c +4 -13
@@ -8,18 +8,9 @@#define FSCACHE_DEBUG_LEVEL CACHE#include <linux/module.h> #include <linux/init.h> -#define CREATE_TRACE_POINTS #include "internal.h" - -MODULE_DESCRIPTION ("FS Cache Manager" ); -MODULE_AUTHOR ("Red Hat, Inc." ); -MODULE_LICENSE ("GPL" ); - -unsigned fscache_debug; -module_param_named (debug, fscache_debug, uint, -S_IWUSR |S_IRUGO ); -MODULE_PARM_DESC (fscache_debug, -"FS-Cache debugging mask" ); +#define CREATE_TRACE_POINTS +#include <trace/events/fscache.h> EXPORT_TRACEPOINT_SYMBOL (fscache_access_cache);EXPORT_TRACEPOINT_SYMBOL (fscache_access_volume);
@@ -92,7 +83,7 @@ static int __init fscache_init(void) goto error_cookie_jar; } -pr_notice ("Loaded\n" ); +pr_notice ("FS-Cache loaded\n" );return 0 ; error_cookie_jar:
@@ -115,7 +106,7 @@ static void __exit fscache_exit(void)kmem_cache_destroy (fscache_cookie_jar);fscache_proc_cleanup ();destroy_workqueue (fscache_wq); -pr_notice ("Unloaded\n" ); +pr_notice ("FS-Cache unloaded\n" ); }module_exit (fscache_exit);
fs/netfs/internal.h +189 -3
212 lines not on this page · raw message
fs/netfs/main.c +2 -2
@@ -8,8 +8,8 @@#include <linux/module.h> #include <linux/export.h> #include "internal.h" -//#define CREATE_TRACE_POINTS -//#include <trace/events/netfs.h> +#define CREATE_TRACE_POINTS +#include <trace/events/netfs.h> MODULE_DESCRIPTION ("Network fs support" );MODULE_AUTHOR ("Red Hat, Inc." );
fs/nfs/Kconfig +2 -2
@@ -169,8 +169,8 @@ config ROOT_NFS config NFS_FSCACHE bool "Provide NFS client caching support" - depends on NFS_FS=m && FSCACHE || NFS_FS=y && FSCACHE=y - select NETFS_SUPPORT + depends on NFS_FS=m && NETFS_SUPPORT || NFS_FS=y && NETFS_SUPPORT=y + select FSCACHE help Say Y here if you want NFS data to be cached locally on disc through the general filesystem cache manager
David Howells
maintainerPATCH v4 3/39 netfs, fscache: Remove ->begin_cache_operation
In reply to David HowellsRemove ->begin_cache_operation() in favour of just calling fscache directly.
--- Documentation/filesystems/netfs_library.rst | 23 +++----------- fs/9p/vfs_addr.c | 16 ---------- fs/afs/file.c | 13 -------- fs/ceph/addr.c | 1 - fs/ceph/cache.h | 12 -------- fs/netfs/buffered_read.c | 33 +++++++++++---------- fs/nfs/fscache.c | 7 ----- include/linux/fscache.h | 3 -- include/linux/netfs.h | 4 +-- 9 files changed, 23 insertions(+), 89 deletions(-)
Documentation/filesystems/netfs_library.rst +4 -19
@@ -295,7 +295,6 @@ through which it can issue requests and negotiate:: struct netfs_request_ops { void (*init_request)(struct netfs_io_request *rreq, struct file *file); void (*free_request)(struct netfs_io_request *rreq); - int (*begin_cache_operation)(struct netfs_io_request *rreq); void (*expand_readahead)(struct netfs_io_request *rreq); bool (*clamp_length)(struct netfs_io_subrequest *subreq); void (*issue_read)(struct netfs_io_subrequest *subreq);
@@ -317,20 +316,6 @@ The operations are as follows: [Optional] This is called as the request is being deallocated so that the filesystem can clean up any state it has attached there. - * ``begin_cache_operation()`` - - [Optional] This is called to ask the network filesystem to call into the - cache (if present) to initialise the caching state for this read. The netfs - library module cannot access the cache directly, so the cache should call - something like fscache_begin_read_operation() to do this. - - The cache gets to store its state in ->cache_resources and must set a table - of operations of its own there (though of a different type). - - This should return 0 on success and an error code otherwise. If an error is - reported, the operation may proceed anyway, just without local caching (only - out of memory and interruption errors cause failure here). - * ``expand_readahead()`` [Optional] This is called to allow the filesystem to expand the size of a
@@ -460,14 +445,14 @@ When implementing a local cache to be used by the read helpers, two things are required: some way for the network filesystem to initialise the caching for a read request and a table of operations for the helpers to call. -The network filesystem's ->begin_cache_operation() method is called to set up a -cache and this must call into the cache to do the work. If using fscache, for -example, the cache would call:: +To begin a cache operation on an fscache object, the following function is +called:: int fscache_begin_read_operation(struct netfs_io_request *rreq, struct fscache_cookie *cookie); -passing in the request pointer and the cookie corresponding to the file. +passing in the request pointer and the cookie corresponding to the file. This +fills in the cache resources mentioned below. The netfs_io_request object contains a place for the cache to hang its state::
fs/9p/vfs_addr.c +0 -16
@@ -82,25 +82,9 @@ 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, .issue_read = v9fs_issue_read, };
fs/afs/file.c +0 -13
@@ -363,18 +363,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) {
@@ -391,7 +379,6 @@ 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, .check_write_begin = afs_check_write_begin, .issue_read = afs_issue_read, };
fs/ceph/addr.c +0 -1
@@ -509,7 +509,6 @@ 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, .issue_read = ceph_netfs_issue_read, .expand_readahead = ceph_netfs_expand_readahead, .clamp_length = ceph_netfs_clamp_length,
fs/ceph/cache.h +0 -12
@@ -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) { }
fs/netfs/buffered_read.c +18 -15
@@ -147,6 +147,15 @@ static void netfs_rreq_expand(struct netfs_io_request *rreq, } } +/* +* Begin an operation, and fetch the stored zero point value from the cookie if +* available. +*/ +static int netfs_begin_cache_read (struct netfs_io_request *rreq,struct netfs_inode *ctx) +{ +return fscache_begin_read_operation (&rreq->cache_resources,netfs_i_cookie (ctx)); +} +/** * netfs_readahead - Helper to manage a read request * @ractl: The description of the readahead request
@@ -180,11 +189,9 @@ void netfs_readahead(struct readahead_control *ractl)if (IS_ERR (rreq))return ; -if (ctx->ops->begin_cache_operation) { - ret = ctx->ops->begin_cache_operation (rreq); -if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS ) - goto cleanup_free; - } + ret =netfs_begin_cache_read (rreq, ctx); +if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS ) + goto cleanup_free;netfs_stat (&netfs_n_rh_readahead); trace_netfs_read(rreq, readahead_pos(ractl), readahead_length(ractl),
@@ -238,11 +245,9 @@ int netfs_read_folio(struct file *file, struct folio *folio) goto alloc_error; } -if (ctx->ops->begin_cache_operation) { - ret = ctx->ops->begin_cache_operation (rreq); -if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS ) - goto discard; - } + ret =netfs_begin_cache_read (rreq, ctx); +if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS ) + goto discard;netfs_stat (&netfs_n_rh_readpage);trace_netfs_read (rreq, rreq->start, rreq->len, netfs_read_trace_readpage);
@@ -390,11 +395,9 @@ int netfs_write_begin(struct netfs_inode *ctx, rreq->no_unlock_folio =folio_index (folio);__set_bit (NETFS_RREQ_NO_UNLOCK_FOLIO , &rreq->flags); -if (ctx->ops->begin_cache_operation) { - ret = ctx->ops->begin_cache_operation (rreq); -if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS ) - goto error_put; - } + ret =netfs_begin_cache_read (rreq, ctx); +if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS ) + goto error_put;netfs_stat (&netfs_n_rh_write_begin);trace_netfs_read (rreq, pos, len, netfs_read_trace_write_begin);
fs/nfs/fscache.c +0 -7
@@ -274,12 +274,6 @@ static void nfs_netfs_free_request(struct netfs_io_request *rreq)put_nfs_open_context (rreq->netfs_priv); } -static inline int nfs_netfs_begin_cache_operation (struct netfs_io_request *rreq) -{ -return fscache_begin_read_operation (&rreq->cache_resources, -netfs_i_cookie (netfs_inode (rreq->inode))); -} -static struct nfs_netfs_io_data *nfs_netfs_alloc (struct netfs_io_subrequest *sreq) {struct nfs_netfs_io_data *netfs;
@@ -387,7 +381,6 @@ void nfs_netfs_read_completion(struct nfs_pgio_header *hdr)const struct netfs_request_ops nfs_netfs_ops = { .init_request = nfs_netfs_init_request, .free_request = nfs_netfs_free_request, - .begin_cache_operation = nfs_netfs_begin_cache_operation, .issue_read = nfs_netfs_issue_read, .clamp_length = nfs_netfs_clamp_length };
include/linux/fscache.h +0 -3
@@ -437,9 +437,6 @@ const struct netfs_cache_ops *fscache_operation_valid(const struct netfs_cache_r* indicates the cache resources to which the operation state should be * attached; @cookie indicates the cache object that will be accessed. * -* This is intended to be called from the ->begin_cache_operation() netfs lib -* operation as implemented by 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.
include/linux/netfs.h +1 -3
@@ -208,7 +208,6 @@ struct netfs_io_request {struct netfs_request_ops {int (*init_request)(struct netfs_io_request *rreq,struct file *file);void (*free_request)(struct netfs_io_request *rreq); -int (*begin_cache_operation)(struct netfs_io_request *rreq);void (*expand_readahead)(struct netfs_io_request *rreq);bool (*clamp_length)(struct netfs_io_subrequest *subreq);
@@ -229,8 +228,7 @@ enum netfs_read_from_hole { };/* -* Table of operations for access to a cache. This is obtained by -* rreq->ops->begin_cache_operation(). +* Table of operations for access to a cache. */ struct netfs_cache_ops {/* End an operation */
David Howells
maintainerPATCH v4 4/39 netfs, fscache: Move /proc/fs/fscache to /proc/fs/netfs and put in a symlink
In reply to David HowellsRename /proc/fs/fscache to "netfs" and make a symlink from fscache to that.
--- fs/netfs/fscache_main.c | 8 ++------ fs/netfs/fscache_proc.c | 23 ++++++++--------------- fs/netfs/fscache_stats.c | 4 +--- fs/netfs/internal.h | 12 +++++++++++- fs/netfs/main.c | 33 +++++++++++++++++++++++++++++++++ fs/netfs/stats.c | 13 +++++++------ include/linux/netfs.h | 1 - 7 files changed, 62 insertions(+), 32 deletions(-)
fs/netfs/fscache_main.c +2 -6
@@ -62,7 +62,7 @@ unsigned int fscache_hash(unsigned int salt, const void *data, size_t len)/* * initialise the fs caching module */ -static int __init fscache_init (void ) +int __init fscache_init (void ) {int ret = -ENOMEM ;
@@ -94,12 +94,10 @@ static int __init fscache_init(void)return ret; } -fs_initcall (fscache_init); -/* * clean up on module removal */ -static void __exit fscache_exit(void) +void __exit fscache_exit(void) {_enter ("" );
@@ -108,5 +106,3 @@ static void __exit fscache_exit(void)destroy_workqueue (fscache_wq);pr_notice ("FS-Cache unloaded\n" ); } - -module_exit (fscache_exit);
fs/netfs/fscache_proc.c +8 -15
@@ -12,41 +12,34 @@#include "internal.h" /* -* initialise the /proc/fs/fscache/ directory +* Add files to /proc/fs/netfs/. */ int __init fscache_proc_init (void ) { -if (!proc_mkdir ("fs/fscache" ,NULL )) - goto error_dir; +if (!proc_symlink ("fs/fscache" ,NULL ,"../netfs" )) + goto error_sym; -if (!proc_create_seq ("fs/fscache/caches" ,S_IFREG |0444 ,NULL , +if (!proc_create_seq ("fs/netfs/caches" ,S_IFREG |0444 ,NULL , &fscache_caches_seq_ops)) goto error; -if (!proc_create_seq ("fs/fscache/volumes" ,S_IFREG |0444 ,NULL , +if (!proc_create_seq ("fs/netfs/volumes" ,S_IFREG |0444 ,NULL , &fscache_volumes_seq_ops)) goto error; -if (!proc_create_seq ("fs/fscache/cookies" ,S_IFREG |0444 ,NULL , +if (!proc_create_seq ("fs/netfs/cookies" ,S_IFREG |0444 ,NULL , &fscache_cookies_seq_ops)) goto error; - -#ifdef CONFIG_FSCACHE_STATS -if (!proc_create_single ("fs/fscache/stats" ,S_IFREG |0444 ,NULL , - fscache_stats_show)) - goto error; -#endif -return 0 ; error:remove_proc_entry ("fs/fscache" ,NULL ); -error_dir: +error_sym:return -ENOMEM ; }/* -* clean up the /proc/fs/fscache/ directory +* Clean up the /proc/fs/fscache symlink. */ void fscache_proc_cleanup (void ) {
fs/netfs/fscache_stats.c +1 -3
@@ -52,7 +52,7 @@ EXPORT_SYMBOL(fscache_n_culled);/* * display the general statistics */ -int fscache_stats_show (struct seq_file *m,void *v) +int fscache_stats_show (struct seq_file *m) {seq_puts (m,"FS-Cache statistics\n" ); seq_printf(m, "Cookies: n=%d v=%d vcol=%u voom=%u\n",
@@ -96,7 +96,5 @@ int fscache_stats_show(struct seq_file *m, void *v)seq_printf (m,"IO : rd=%u wr=%u\n" ,atomic_read (&fscache_n_read),atomic_read (&fscache_n_write)); - -netfs_stats_show (m);return 0 ; }
fs/netfs/internal.h +11 -1
@@ -76,6 +76,7 @@ extern atomic_t netfs_n_rh_write_done;extern atomic_t netfs_n_rh_write_failed;extern atomic_t netfs_n_rh_write_zskip; +int netfs_stats_show (struct seq_file *m,void *v);static inline void netfs_stat (atomic_t *stat) {
@@ -166,6 +167,13 @@ static inline void fscache_see_cookie(struct fscache_cookie *cookie,* fscache-main.c */ extern unsigned int fscache_hash (unsigned int salt,const void *data,size_t len); +#ifdef CONFIG_PROC_FS +int __init fscache_init (void ); +void __exit fscache_exit(void); +#else +static inline int fscache_init (void ) {return 0 ; } +static inline void fscache_exit (void ) {} +#endif /* * fscache-proc.c
@@ -216,12 +224,14 @@ static inline void fscache_stat_d(atomic_t *stat)#define __fscache_stat (stat) (stat) -int fscache_stats_show (struct seq_file *m,void *v); +int fscache_stats_show (struct seq_file *m);#else #define __fscache_stat (stat) (NULL)#define fscache_stat (stat) do {} while (0)#define fscache_stat_d (stat) do {} while (0) + +static inline int fscache_stats_show (struct seq_file *m) {return 0 ; }#endif /*
fs/netfs/main.c +33 -0
@@ -7,6 +7,8 @@#include <linux/module.h> #include <linux/export.h> +#include <linux/proc_fs.h> +#include <linux/seq_file.h> #include "internal.h" #define CREATE_TRACE_POINTS #include <trace/events/netfs.h>
@@ -19,3 +21,34 @@ unsigned netfs_debug;module_param_named (debug, netfs_debug, uint,S_IWUSR |S_IRUGO );MODULE_PARM_DESC (netfs_debug,"Netfs support debugging mask" ); +static int __init netfs_init (void ) +{ +int ret = -ENOMEM ; + +if (!proc_mkdir ("fs/netfs" ,NULL )) + goto error; + +#ifdef CONFIG_FSCACHE_STATS +if (!proc_create_single ("fs/netfs/stats" ,S_IFREG |0444 ,NULL , + netfs_stats_show)) + goto error_proc; +#endif + + ret =fscache_init (); +if (ret <0 ) + goto error_proc; +return 0 ; + +error_proc: +remove_proc_entry ("fs/netfs" ,NULL ); +error: +return ret; +} +fs_initcall (netfs_init); + +static void __exit netfs_exit(void) +{ +fscache_exit (); +remove_proc_entry ("fs/netfs" ,NULL ); +} +module_exit (netfs_exit);
fs/netfs/stats.c +7 -6
@@ -28,31 +28,32 @@ atomic_t netfs_n_rh_write_done;atomic_t netfs_n_rh_write_failed;atomic_t netfs_n_rh_write_zskip; -void netfs_stats_show (struct seq_file *m) +int netfs_stats_show (struct seq_file *m,void *v) { -seq_printf (m,"RdHelp : RA=%u RP=%u WB=%u WBZ=%u rr=%u sr=%u\n" , +seq_printf (m,"Netfs : RA=%u RP=%u WB=%u WBZ=%u rr=%u sr=%u\n" ,atomic_read (&netfs_n_rh_readahead),atomic_read (&netfs_n_rh_readpage),atomic_read (&netfs_n_rh_write_begin),atomic_read (&netfs_n_rh_write_zskip),atomic_read (&netfs_n_rh_rreq),atomic_read (&netfs_n_rh_sreq)); -seq_printf (m,"RdHelp : ZR=%u sh=%u sk=%u\n" , +seq_printf (m,"Netfs : ZR=%u sh=%u sk=%u\n" ,atomic_read (&netfs_n_rh_zero),atomic_read (&netfs_n_rh_short_read),atomic_read (&netfs_n_rh_write_zskip)); -seq_printf (m,"RdHelp : DL=%u ds=%u df=%u di=%u\n" , +seq_printf (m,"Netfs : DL=%u ds=%u df=%u di=%u\n" ,atomic_read (&netfs_n_rh_download),atomic_read (&netfs_n_rh_download_done),atomic_read (&netfs_n_rh_download_failed),atomic_read (&netfs_n_rh_download_instead)); -seq_printf (m,"RdHelp : RD=%u rs=%u rf=%u\n" , +seq_printf (m,"Netfs : RD=%u rs=%u rf=%u\n" ,atomic_read (&netfs_n_rh_read),atomic_read (&netfs_n_rh_read_done),atomic_read (&netfs_n_rh_read_failed)); -seq_printf (m,"RdHelp : WR=%u ws=%u wf=%u\n" , +seq_printf (m,"Netfs : WR=%u ws=%u wf=%u\n" ,atomic_read (&netfs_n_rh_write),atomic_read (&netfs_n_rh_write_done),atomic_read (&netfs_n_rh_write_failed)); +return fscache_stats_show (m); }EXPORT_SYMBOL (netfs_stats_show);
include/linux/netfs.h +0 -1
@@ -294,7 +294,6 @@ void netfs_get_subrequest(struct netfs_io_subrequest *subreq, enum netfs_sreq_ref_trace what);void netfs_put_subrequest (struct netfs_io_subrequest *subreq,bool was_async,enum netfs_sreq_ref_trace what); -void netfs_stats_show (struct seq_file *);ssize_t netfs_extract_user_iter (struct iov_iter *orig,size_t orig_len,struct iov_iter *new,iov_iter_extraction_t extraction_flags);
David Howells
maintainerPATCH v4 5/39 netfs: Move pinning-for-writeback from fscache to netfs
In reply to David HowellsMove the resource pinning-for-writeback from fscache code to netfslib code. This is used to keep a cache backing object pinned whilst we have dirty pages on the netfs inode in the pagecache such that VM writeback will be able to reach it.
Whilst we're at it, switch the parameters of netfs_unpin_writeback() to match ->write_inode() so that it can be used for that directly.
Note that this mechanism could be more generically useful than that for network filesystems. Quite often they have to keep around other resources (e.g. authentication tokens or network connections) until the writeback is complete.
--- fs/9p/vfs_addr.c | 33 ++++----------- fs/9p/vfs_inode.c | 3 +- fs/9p/vfs_super.c | 14 +------ fs/afs/file.c | 8 +--- fs/afs/inode.c | 2 +- fs/afs/internal.h | 6 --- fs/afs/super.c | 2 +- fs/afs/write.c | 9 ---- fs/ceph/cache.h | 23 ++++------- fs/ceph/inode.c | 2 +- fs/fs-writeback.c | 10 ++--- fs/netfs/Makefile | 1 + fs/netfs/fscache_io.c | 40 ------------------ fs/netfs/misc.c | 86 +++++++++++++++++++++++++++++++++++++++ fs/smb/client/cifsfs.c | 5 +-- fs/smb/client/file.c | 18 +------- include/linux/fs.h | 2 +- include/linux/fscache.h | 42 ------------------- include/linux/netfs.h | 3 ++ include/linux/writeback.h | 2 +- 20 files changed, 124 insertions(+), 187 deletions(-) create mode 100644 fs/netfs/misc.c
fs/9p/vfs_addr.c +9 -24
@@ -317,30 +317,15 @@ static int v9fs_write_end(struct file *filp, struct address_space *mapping,return copied; } -#ifdef CONFIG_9P_FSCACHE -/* -* Mark a page as having been made dirty and thus needing writeback. We also -* need to pin the cache object to write back to. -*/ -static bool v9fs_dirty_folio (struct address_space *mapping,struct folio *folio) -{ -struct v9fs_inode *v9inode =V9FS_I (mapping->host); - -return fscache_dirty_folio (mapping, folio,v9fs_inode_cookie (v9inode)); -} -#else -#define v9fs_dirty_folio filemap_dirty_folio -#endif -const struct address_space_operations v9fs_addr_operations = { - .read_folio = netfs_read_folio, - .readahead = netfs_readahead, - .dirty_folio = v9fs_dirty_folio, - .writepage = v9fs_vfs_writepage, - .write_begin = v9fs_write_begin, - .write_end = v9fs_write_end, - .release_folio = v9fs_release_folio, + .read_folio = netfs_read_folio, + .readahead = netfs_readahead, + .dirty_folio = netfs_dirty_folio, + .writepage = v9fs_vfs_writepage, + .write_begin = v9fs_write_begin, + .write_end = v9fs_write_end, + .release_folio = v9fs_release_folio, .invalidate_folio = v9fs_invalidate_folio, - .launder_folio = v9fs_launder_folio, - .direct_IO = v9fs_direct_IO, + .launder_folio = v9fs_launder_folio, + .direct_IO = v9fs_direct_IO, };
fs/9p/vfs_inode.c +1 -2
@@ -376,8 +376,7 @@ void v9fs_evict_inode(struct inode *inode)#ifdef CONFIG_9P_FSCACHE version =cpu_to_le32 (v9inode->qid.version); -fscache_clear_inode_writeback (v9fs_inode_cookie (v9inode), inode, - &version); +netfs_clear_inode_writeback (inode, &version);#endif clear_inode (inode);
fs/9p/vfs_super.c +2 -12
@@ -289,31 +289,21 @@ static int v9fs_drop_inode(struct inode *inode)static int v9fs_write_inode (struct inode *inode,struct writeback_control *wbc) { -struct v9fs_inode *v9inode; -/* * send an fsync request to server irrespective of * wbc->sync_mode. */ p9_debug (P9_DEBUG_VFS ,"%s: inode %p\n" , __func__, inode); - - v9inode =V9FS_I (inode); -fscache_unpin_writeback (wbc,v9fs_inode_cookie (v9inode)); - -return 0 ; +return netfs_unpin_writeback (inode, wbc); }static int v9fs_write_inode_dotl (struct inode *inode,struct writeback_control *wbc) { -struct v9fs_inode *v9inode; - v9inode =V9FS_I (inode);p9_debug (P9_DEBUG_VFS ,"%s: inode %p\n" , __func__, inode); -fscache_unpin_writeback (wbc,v9fs_inode_cookie (v9inode)); - -return 0 ; +return netfs_unpin_writeback (inode, wbc); }static const struct super_operations v9fs_super_ops = {
fs/afs/file.c +1 -7
@@ -55,7 +55,7 @@ const struct inode_operations afs_file_inode_operations = {const struct address_space_operations afs_file_aops = { .read_folio = netfs_read_folio, .readahead = netfs_readahead, - .dirty_folio = afs_dirty_folio, + .dirty_folio = netfs_dirty_folio, .launder_folio = afs_launder_folio, .release_folio = afs_release_folio, .invalidate_folio = afs_invalidate_folio,
@@ -383,12 +383,6 @@ const struct netfs_request_ops afs_req_ops = { .issue_read = afs_issue_read, }; -int afs_write_inode (struct inode *inode,struct writeback_control *wbc) -{ -fscache_unpin_writeback (wbc,afs_vnode_cache (AFS_FS_I (inode))); -return 0 ; -} -/* * Adjust the dirty region of the page on truncation or full invalidation, * getting rid of the markers altogether if the region is entirely invalidated.
fs/afs/inode.c +1 -1
@@ -647,7 +647,7 @@ void afs_evict_inode(struct inode *inode)truncate_inode_pages_final (&inode->i_data);afs_set_cache_aux (vnode, &aux); -fscache_clear_inode_writeback (afs_vnode_cache (vnode), inode, &aux); +netfs_clear_inode_writeback (inode, &aux);clear_inode (inode);while (!list_empty (&vnode->wb_keys)) {
fs/afs/internal.h +0 -6
@@ -1166,7 +1166,6 @@ extern int afs_release(struct inode *, struct file *);extern int afs_fetch_data (struct afs_vnode *,struct afs_read *);extern struct afs_read *afs_alloc_read (gfp_t );extern void afs_put_read (struct afs_read *); -extern int afs_write_inode (struct inode *,struct writeback_control *);static inline struct afs_read *afs_get_read (struct afs_read *req) {
@@ -1658,11 +1657,6 @@ bool afs_try_get_volume(struct afs_volume *volume, enum afs_volume_trace reason)/* * write.c */ -#ifdef CONFIG_AFS_FSCACHE -bool afs_dirty_folio (struct address_space *,struct folio *); -#else -#define afs_dirty_folio filemap_dirty_folio -#endif extern int afs_write_begin (struct file *file,struct address_space *mapping,loff_t pos,unsigned len,struct page **pagep,void **fsdata);
fs/afs/super.c +1 -1
@@ -55,7 +55,7 @@ int afs_net_id;static const struct super_operations afs_super_ops = { .statfs = afs_statfs, .alloc_inode = afs_alloc_inode, - .write_inode = afs_write_inode, + .write_inode = netfs_unpin_writeback, .drop_inode = afs_drop_inode, .destroy_inode = afs_destroy_inode, .free_inode = afs_free_inode,
fs/afs/write.c +0 -9
@@ -23,15 +23,6 @@ static void afs_write_to_cache(struct afs_vnode *vnode, loff_t start, size_t len loff_t i_size, bool caching);#ifdef CONFIG_AFS_FSCACHE -/* -* Mark a page as having been made dirty and thus needing writeback. We also -* need to pin the cache object to write back to. -*/ -bool afs_dirty_folio (struct address_space *mapping,struct folio *folio) -{ -return fscache_dirty_folio (mapping, folio, -afs_vnode_cache (AFS_FS_I (mapping->host))); -}static void afs_folio_start_fscache (bool caching,struct folio *folio) {if (caching)
fs/ceph/cache.h +7 -16
@@ -43,19 +43,13 @@ static inline void ceph_fscache_resize(struct inode *inode, loff_t to) } } -static inline void ceph_fscache_unpin_writeback (struct inode *inode, +static inline int ceph_fscache_unpin_writeback (struct inode *inode,struct writeback_control *wbc) { -fscache_unpin_writeback (wbc,ceph_fscache_cookie (ceph_inode (inode))); +return netfs_unpin_writeback (inode, wbc); } -static inline int ceph_fscache_dirty_folio (struct address_space *mapping, -struct folio *folio) -{ -struct ceph_inode_info *ci =ceph_inode (mapping->host); - -return fscache_dirty_folio (mapping, folio,ceph_fscache_cookie (ci)); -} +#define ceph_fscache_dirty_folio netfs_dirty_foliostatic inline bool ceph_is_cache_enabled (struct inode *inode) {
@@ -112,16 +106,13 @@ static inline void ceph_fscache_resize(struct inode *inode, loff_t to) { } -static inline void ceph_fscache_unpin_writeback (struct inode *inode, -struct writeback_control *wbc) +static inline int ceph_fscache_unpin_writeback (struct inode *inode, +struct writeback_control *wbc) { +return 0 ; } -static inline int ceph_fscache_dirty_folio (struct address_space *mapping, -struct folio *folio) -{ -return filemap_dirty_folio (mapping, folio); -} +#define ceph_fscache_dirty_folio filemap_dirty_foliostatic inline bool ceph_is_cache_enabled (struct inode *inode) {
fs/ceph/inode.c +1 -1
@@ -694,7 +694,7 @@ void ceph_evict_inode(struct inode *inode)percpu_counter_dec (&mdsc->metric.total_inodes);truncate_inode_pages_final (&inode->i_data); -if (inode->i_state &I_PINNING_FSCACHE_WB ) +if (inode->i_state &I_PINNING_NETFS_WB )ceph_fscache_unuse_cookie (inode, true);clear_inode (inode);
fs/fs-writeback.c +5 -5
@@ -1675,11 +1675,11 @@ __writeback_single_inode(struct inode *inode, struct writeback_control *wbc)if (mapping_tagged (mapping,PAGECACHE_TAG_DIRTY )) inode->i_state |=I_DIRTY_PAGES ; -else if (unlikely (inode->i_state &I_PINNING_FSCACHE_WB )) { +else if (unlikely (inode->i_state &I_PINNING_NETFS_WB )) {if (!(inode->i_state &I_DIRTY_PAGES )) { - inode->i_state &= ~I_PINNING_FSCACHE_WB ; - wbc->unpinned_fscache_wb = true; - dirty |=I_PINNING_FSCACHE_WB ;/* Cause write_inode */ + inode->i_state &= ~I_PINNING_NETFS_WB ; + wbc->unpinned_netfs_wb = true; + dirty |=I_PINNING_NETFS_WB ;/* Cause write_inode */ } }
@@ -1691,7 +1691,7 @@ __writeback_single_inode(struct inode *inode, struct writeback_control *wbc)if (ret ==0 ) ret = err; } - wbc->unpinned_fscache_wb = false; + wbc->unpinned_netfs_wb = false;trace_writeback_single_inode (inode, wbc, nr_to_write);return ret; }
fs/netfs/Makefile +1 -0
@@ -5,6 +5,7 @@ netfs-y := \ io.o \ iterator.o \ main.o \ + misc.o \ objects.o netfs-$(CONFIG_NETFS_STATS) += stats.o
fs/netfs/fscache_io.c +0 -40
@@ -158,46 +158,6 @@ int __fscache_begin_write_operation(struct netfs_cache_resources *cres, }EXPORT_SYMBOL (__fscache_begin_write_operation); -/** -* fscache_dirty_folio - Mark folio dirty and pin a cache object for writeback -* @mapping: The mapping the folio belongs to. -* @folio: The folio being dirtied. -* @cookie: The cookie referring to the cache object -* -* Set the dirty flag on a folio and pin an in-use cache object in memory -* so that writeback can later write to it. This is intended -* to be called from the filesystem's ->dirty_folio() method. -* -* Return: true if the dirty flag was set on the folio, false otherwise. -*/ -bool fscache_dirty_folio (struct address_space *mapping,struct folio *folio, -struct fscache_cookie *cookie) -{ -struct inode *inode = mapping->host; -bool need_use = false; - -_enter ("" ); - -if (!filemap_dirty_folio (mapping, folio)) -return false; -if (!fscache_cookie_valid (cookie)) -return true; - -if (!(inode->i_state &I_PINNING_FSCACHE_WB )) { -spin_lock (&inode->i_lock); -if (!(inode->i_state &I_PINNING_FSCACHE_WB )) { - inode->i_state |=I_PINNING_FSCACHE_WB ; - need_use = true; - } -spin_unlock (&inode->i_lock); - -if (need_use) -fscache_use_cookie (cookie, true); - } -return true; -} -EXPORT_SYMBOL (fscache_dirty_folio); -struct fscache_write_request {struct netfs_cache_resources cache_resources;struct address_space *mapping;
fs/netfs/misc.c new file +86 -0
86 lines not on this page · raw message
fs/smb/client/cifsfs.c +2 -3
@@ -429,7 +429,7 @@ static void cifs_evict_inode(struct inode *inode) {truncate_inode_pages_final (&inode->i_data); -if (inode->i_state &I_PINNING_FSCACHE_WB ) +if (inode->i_state &I_PINNING_NETFS_WB )cifs_fscache_unuse_inode_cookie (inode, true);cifs_fscache_release_inode_cookie (inode);clear_inode (inode);
@@ -792,8 +792,7 @@ static int cifs_show_stats(struct seq_file *s, struct dentry *root)static int cifs_write_inode (struct inode *inode,struct writeback_control *wbc) { -fscache_unpin_writeback (wbc,cifs_inode_cookie (inode)); -return 0 ; +return netfs_unpin_writeback (inode, wbc); }static int cifs_drop_inode (struct inode *inode)
fs/smb/client/file.c +2 -16
@@ -5041,27 +5041,13 @@ static void cifs_swap_deactivate(struct file *file)/* do we need to unpin (or unlock) the file */ } -/* -* Mark a page as having been made dirty and thus needing writeback. We also -* need to pin the cache object to write back to. -*/ -#ifdef CONFIG_CIFS_FSCACHE -static bool cifs_dirty_folio (struct address_space *mapping,struct folio *folio) -{ -return fscache_dirty_folio (mapping, folio, -cifs_inode_cookie (mapping->host)); -} -#else -#define cifs_dirty_folio filemap_dirty_folio -#endif -const struct address_space_operations cifs_addr_ops = { .read_folio = cifs_read_folio, .readahead = cifs_readahead, .writepages = cifs_writepages, .write_begin = cifs_write_begin, .write_end = cifs_write_end, - .dirty_folio = cifs_dirty_folio, + .dirty_folio = netfs_dirty_folio, .release_folio = cifs_release_folio, .direct_IO = cifs_direct_io, .invalidate_folio = cifs_invalidate_folio,
@@ -5085,7 +5071,7 @@ const struct address_space_operations cifs_addr_ops_smallbuf = { .writepages = cifs_writepages, .write_begin = cifs_write_begin, .write_end = cifs_write_end, - .dirty_folio = cifs_dirty_folio, + .dirty_folio = netfs_dirty_folio, .release_folio = cifs_release_folio, .invalidate_folio = cifs_invalidate_folio, .launder_folio = cifs_launder_folio,
include/linux/fs.h +1 -1
@@ -2373,7 +2373,7 @@ static inline void kiocb_clone(struct kiocb *kiocb, struct kiocb *kiocb_src,#define I_CREATING (1 << 15)#define I_DONTCACHE (1 << 16)#define I_SYNC_QUEUED (1 << 17) -#define I_PINNING_FSCACHE_WB (1 << 18) +#define I_PINNING_NETFS_WB (1 << 18)#define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC)#define I_DIRTY (I_DIRTY_INODE | I_DIRTY_PAGES)
include/linux/fscache.h +0 -42
48 lines not on this page · raw message
include/linux/netfs.h +3 -0
@@ -288,6 +288,9 @@ int netfs_read_folio(struct file *, struct folio *);int netfs_write_begin (struct netfs_inode *,struct file *,struct address_space *,loff_t pos,unsigned int len,struct folio **,void **fsdata); +bool netfs_dirty_folio (struct address_space *mapping,struct folio *folio); +int netfs_unpin_writeback (struct inode *inode,struct writeback_control *wbc); +void netfs_clear_inode_writeback (struct inode *inode,const void *aux);void netfs_subreq_terminated (struct netfs_io_subrequest *,ssize_t ,bool ); void netfs_get_subrequest(struct netfs_io_subrequest *subreq,
include/linux/writeback.h +1 -1
@@ -60,7 +60,7 @@ struct writeback_control { unsigned for_reclaim:1; /* Invoked from the page allocator */ unsigned range_cyclic:1; /* range_start is cyclic */ unsigned for_sync:1; /* sync(2) WB_SYNC_ALL writeback */ - unsigned unpinned_fscache_wb:1; /* Cleared I_PINNING_FSCACHE_WB */ + unsigned unpinned_netfs_wb:1; /* Cleared I_PINNING_NETFS_WB *//* * When writeback IOs are bounced through async layers, only the
David Howells
maintainerPATCH v4 6/39 netfs: Add a procfile to list in-progress requests
In reply to David HowellsAdd a procfile, /proc/fs/netfs/requests, to list in-progress netfslib I/O requests.
--- fs/netfs/internal.h | 22 ++++++++++++++ fs/netfs/main.c | 69 ++++++++++++++++++++++++++++++++++++++++++- fs/netfs/objects.c | 4 ++- include/linux/netfs.h | 6 +++- 4 files changed, 98 insertions(+), 3 deletions(-)
fs/netfs/internal.h +22 -0
@@ -33,6 +33,28 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync);* main.c */ extern unsigned int netfs_debug; +extern struct list_head netfs_io_requests; +extern spinlock_t netfs_proc_lock; + +#ifdef CONFIG_PROC_FS +static inline void netfs_proc_add_rreq (struct netfs_io_request *rreq) +{ +spin_lock (&netfs_proc_lock); +list_add_tail_rcu (&rreq->proc_link, &netfs_io_requests); +spin_unlock (&netfs_proc_lock); +} +static inline void netfs_proc_del_rreq (struct netfs_io_request *rreq) +{ +if (!list_empty (&rreq->proc_link)) { +spin_lock (&netfs_proc_lock); +list_del_rcu (&rreq->proc_link); +spin_unlock (&netfs_proc_lock); + } +} +#else +static inline void netfs_proc_add_rreq (struct netfs_io_request *rreq) {} +static inline void netfs_proc_del_rreq (struct netfs_io_request *rreq) {} +#endif /* * objects.c
fs/netfs/main.c +68 -1
81 lines not on this page · raw message
fs/netfs/objects.c +3 -1
@@ -45,6 +45,7 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping, } } +netfs_proc_add_rreq (rreq);netfs_stat (&netfs_n_rh_rreq);return rreq; }
@@ -76,12 +77,13 @@ static void netfs_free_request(struct work_struct *work) container_of(work, struct netfs_io_request, work);trace_netfs_rreq (rreq, netfs_rreq_trace_free); +netfs_proc_del_rreq (rreq);netfs_clear_subrequests (rreq, false);if (rreq->netfs_ops->free_request) rreq->netfs_ops->free_request (rreq);if (rreq->cache_resources.ops) rreq->cache_resources.ops->end_operation (&rreq->cache_resources); -kfree (rreq); +kfree_rcu (rreq, rcu);netfs_stat_d (&netfs_n_rh_rreq); }
include/linux/netfs.h +5 -1
@@ -175,10 +175,14 @@ enum netfs_io_origin {* operations to a variety of data stores and then stitch the result together. */ struct netfs_io_request { -struct work_struct work; +union { +struct work_struct work; +struct rcu_head rcu; + };struct inode *inode;/* The file being accessed */ struct address_space *mapping;/* The mapping being accessed */ struct netfs_cache_resources cache_resources; +struct list_head proc_link;/* Link in netfs_iorequests */ struct list_head subrequests;/* Contributory I/O operations */ void *netfs_priv;/* Private data for the netfs */ unsigned int debug_id;
Jeff Layton
maintainerRe: [PATCH v4 06/39] netfs: Add a procfile to list in-progress requests
Quoted 3 lines · David Howells
Add a procfile,
/proc/fs/netfs/requests, to list in-progress netfslib I/O requests.
This should probably be in debugfs. I could see us wanting to improve this interface over time. That's harder with procfs but with debugfs we'd have carte blanche to do so.
Quoted 179 lines
Signed-off-by David Howells <[email protected]>cc Jeff Layton <[email protected]>--- fs/netfs/internal.h | 22 ++++++++++++++ fs/netfs/main.c | 69 ++++++++++++++++++++++++++++++++++++++++++- fs/netfs/objects.c | 4 ++- include/linux/netfs.h | 6 +++- 4 files changed, 98 insertions(+), 3 deletions(-)fs/netfs/internal.h +22
-0@@ -33,6 +33,28 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync);* main.c */ extern unsigned int netfs_debug; +extern struct list_head netfs_io_requests; +extern spinlock_t netfs_proc_lock; + +#ifdef CONFIG_PROC_FS +static inline void netfs_proc_add_rreq (struct netfs_io_request *rreq) +{ +spin_lock (&netfs_proc_lock); +list_add_tail_rcu (&rreq->proc_link, &netfs_io_requests); +spin_unlock (&netfs_proc_lock); +} +static inline void netfs_proc_del_rreq (struct netfs_io_request *rreq) +{ +if (!list_empty (&rreq->proc_link)) { +spin_lock (&netfs_proc_lock); +list_del_rcu (&rreq->proc_link); +spin_unlock (&netfs_proc_lock); + } +} +#else +static inline void netfs_proc_add_rreq (struct netfs_io_request *rreq) {} +static inline void netfs_proc_del_rreq (struct netfs_io_request *rreq) {} +#endif /* * objects.c fs/netfs/main.c +68
-1@@ -21,13 +21,80 @@ unsigned netfs_debug;module_param_named (debug, netfs_debug, uint,S_IWUSR |S_IRUGO );MODULE_PARM_DESC (netfs_debug,"Netfs support debugging mask" ); +#ifdef CONFIG_PROC_FS +LIST_HEAD (netfs_io_requests); +DEFINE_SPINLOCK (netfs_proc_lock); + +static const char *netfs_origins[] = { + [NETFS_READAHEAD ] ="RA" , + [NETFS_READPAGE ] ="RP" , + [NETFS_READ_FOR_WRITE ] ="RW" , +}; + +/* +* Generate a list of I/O requests in /proc/fs/netfs/requests +*/ +static int netfs_requests_seq_show (struct seq_file *m,void *v) +{ +struct netfs_io_request *rreq; + +if (v == &netfs_io_requests) { +seq_puts (m, +"REQUEST OR REF FL ERR OPS COVERAGE\n" +"======== == === == ==== === =========\n" + ); +return 0 ; + } + + rreq = list_entry(v, struct netfs_io_request, proc_link); +seq_printf (m, +"%08x %s %3d %2lx %4d %3d @%04llx %zx/%zx" , + rreq->debug_id, + netfs_origins[rreq->origin], +refcount_read (&rreq->ref), + rreq->flags, + rreq->error, +atomic_read (&rreq->nr_outstanding), + rreq->start, rreq->submitted, rreq->len); +seq_putc (m,'\n' ); +return 0 ; +} + +static void *netfs_requests_seq_start (struct seq_file *m,loff_t *_pos) +__acquires (rcu) +{ +rcu_read_lock (); +return seq_list_start_head (&netfs_io_requests, *_pos); +} + +static void *netfs_requests_seq_next (struct seq_file *m,void *v,loff_t *_pos) +{ +return seq_list_next (v, &netfs_io_requests, _pos); +} + +static void netfs_requests_seq_stop (struct seq_file *m,void *v) +__releases (rcu) +{ +rcu_read_unlock (); +} + +static const struct seq_operations netfs_requests_seq_ops = { + .start = netfs_requests_seq_start, + .next = netfs_requests_seq_next, + .stop = netfs_requests_seq_stop, + .show = netfs_requests_seq_show, +}; +#endif /* CONFIG_PROC_FS */ +static int __init netfs_init (void ) {int ret = -ENOMEM ;if (!proc_mkdir ("fs/netfs" ,NULL )) goto error; - +if (!proc_create_seq ("fs/netfs/requests" ,S_IFREG |0444 ,NULL , + &netfs_requests_seq_ops)) + goto error_proc;#ifdef CONFIG_FSCACHE_STATS if (!proc_create_single ("fs/netfs/stats" ,S_IFREG |0444 ,NULL , netfs_stats_show))fs/netfs/objects.c +3
-1@@ -45,6 +45,7 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping, } } +netfs_proc_add_rreq (rreq);netfs_stat (&netfs_n_rh_rreq);return rreq; }@@ -76,12 +77,13 @@ static void netfs_free_request(struct work_struct *work) container_of(work, struct netfs_io_request, work);trace_netfs_rreq (rreq, netfs_rreq_trace_free); +netfs_proc_del_rreq (rreq);netfs_clear_subrequests (rreq, false);if (rreq->netfs_ops->free_request) rreq->netfs_ops->free_request (rreq);if (rreq->cache_resources.ops) rreq->cache_resources.ops->end_operation (&rreq->cache_resources); -kfree (rreq); +kfree_rcu (rreq, rcu);netfs_stat_d (&netfs_n_rh_rreq); }include/linux/netfs.h +5
-1@@ -175,10 +175,14 @@ enum netfs_io_origin {* operations to a variety of data stores and then stitch the result together. */ struct netfs_io_request { -struct work_struct work; +union { +struct work_struct work; +struct rcu_head rcu; + };struct inode *inode;/* The file being accessed */ struct address_space *mapping;/* The mapping being accessed */ struct netfs_cache_resources cache_resources; +struct list_head proc_link;/* Link in netfs_iorequests */ struct list_head subrequests;/* Contributory I/O operations */ void *netfs_priv;/* Private data for the netfs */ unsigned int debug_id;
Signature · 1 line
Jeff Layton <[email protected]>
David Howells
maintainerPATCH v4 7/39 netfs: Allow the netfs to make the io (sub)request alloc larger
In reply to David HowellsAllow the network filesystem to specify extra space to be allocated on the end of the io (sub)request. This allows cifs, for example, to use this space rather than allocating its own cifs_readdata struct.
--- fs/netfs/objects.c | 7 +++++-- include/linux/netfs.h | 2 ++ 2 files changed, 7 insertions(+), 2 deletions(-)
fs/netfs/objects.c +5 -2
@@ -22,7 +22,8 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,struct netfs_io_request *rreq;int ret; - rreq =kzalloc (sizeof (struct netfs_io_request ),GFP_KERNEL ); + rreq =kzalloc (ctx->ops->io_request_size ?:sizeof (struct netfs_io_request ), +GFP_KERNEL );if (!rreq)return ERR_PTR (-ENOMEM );
@@ -114,7 +115,9 @@ struct netfs_io_subrequest *netfs_alloc_subrequest(struct netfs_io_request *rreq {struct netfs_io_subrequest *subreq; - subreq =kzalloc (sizeof (struct netfs_io_subrequest ),GFP_KERNEL ); + subreq =kzalloc (rreq->netfs_ops->io_subrequest_size ?: +sizeof (struct netfs_io_subrequest ), +GFP_KERNEL );if (subreq) {INIT_LIST_HEAD (&subreq->rreq_link);refcount_set (&subreq->ref,2 );
include/linux/netfs.h +2 -0
@@ -210,6 +210,8 @@ struct netfs_io_request {* Operations the network filesystem can/must provide to the helpers. */ struct netfs_request_ops { +unsigned int io_request_size;/* Alloc size for netfs_io_request struct */ +unsigned int io_subrequest_size;/* Alloc size for netfs_io_subrequest struct */ int (*init_request)(struct netfs_io_request *rreq,struct file *file);void (*free_request)(struct netfs_io_request *rreq);
David Howells
maintainerPATCH v4 8/39 netfs: Add a ->free_subrequest() op
In reply to David HowellsAdd a ->free_subrequest() op so that the netfs can clean up data attached to a subrequest.
--- fs/netfs/objects.c | 2 ++ include/linux/netfs.h | 1 + 2 files changed, 3 insertions(+)
fs/netfs/objects.c +2 -0
@@ -145,6 +145,8 @@ static void netfs_free_subrequest(struct netfs_io_subrequest *subreq,struct netfs_io_request *rreq = subreq->rreq;trace_netfs_sreq (subreq, netfs_sreq_trace_free); +if (rreq->netfs_ops->free_subrequest) + rreq->netfs_ops->free_subrequest (subreq);kfree (subreq);netfs_stat_d (&netfs_n_rh_sreq);netfs_put_request (rreq, was_async, netfs_rreq_trace_put_subreq);
include/linux/netfs.h +1 -0
@@ -214,6 +214,7 @@ struct netfs_request_ops {unsigned int io_subrequest_size;/* Alloc size for netfs_io_subrequest struct */ int (*init_request)(struct netfs_io_request *rreq,struct file *file);void (*free_request)(struct netfs_io_request *rreq); +void (*free_subrequest)(struct netfs_io_subrequest *rreq);void (*expand_readahead)(struct netfs_io_request *rreq);bool (*clamp_length)(struct netfs_io_subrequest *subreq);
David Howells
maintainerPATCH v4 9/39 afs: Don't use folio->private to record partial modification
In reply to David HowellsAFS currently uses folio->private to store the range of bytes within a folio that have been modified - the idea being that if we have, say, a 2MiB folio and someone writes a single byte, we only have to write back that single page and not the whole 2MiB folio - thereby saving on network bandwidth.
Remove this, at least for now, and accept the extra network load (which doesn't matter in the common case of writing a whole file at a time from beginning to end).
This makes folio->private available for netfslib to use.
--- fs/afs/file.c | 67 ------------- fs/afs/internal.h | 56 ----------- fs/afs/write.c | 188 ++++++++----------------------------- include/trace/events/afs.h | 16 +--- 4 files changed, 42 insertions(+), 285 deletions(-)
fs/afs/file.c +0 -67
@@ -383,63 +383,6 @@ const struct netfs_request_ops afs_req_ops = { .issue_read = afs_issue_read, }; -/* -* Adjust the dirty region of the page on truncation or full invalidation, -* getting rid of the markers altogether if the region is entirely invalidated. -*/ -static void afs_invalidate_dirty (struct folio *folio,size_t offset, -size_t length) -{ -struct afs_vnode *vnode =AFS_FS_I (folio_inode (folio)); -unsigned long priv; -unsigned int f, t, end = offset + length; - - priv = (unsigned long )folio_get_private (folio); - -/* we clean up only if the entire page is being invalidated */ -if (offset ==0 && length ==folio_size (folio)) - goto full_invalidate; - -/* If the page was dirtied by page_mkwrite(), the PTE stays writable -* and we don't get another notification to tell us to expand it -* again. -*/ -if (afs_is_folio_dirty_mmapped (priv)) -return ; - -/* We may need to shorten the dirty region */ - f =afs_folio_dirty_from (folio, priv); - t =afs_folio_dirty_to (folio, priv); - -if (t <= offset || f >= end) -return ;/* Doesn't overlap */ - -if (f < offset && t > end) -return ;/* Splits the dirty region - just absorb it */ - -if (f >= offset && t <= end) - goto undirty; - -if (f < offset) - t = offset; -else - f = end; -if (f == t) - goto undirty; - - priv =afs_folio_dirty (folio, f, t); -folio_change_private (folio, (void *)priv); -trace_afs_folio_dirty (vnode,tracepoint_string ("trunc" ), folio); -return ; - -undirty: -trace_afs_folio_dirty (vnode,tracepoint_string ("undirty" ), folio); -folio_clear_dirty_for_io (folio); -full_invalidate: -trace_afs_folio_dirty (vnode,tracepoint_string ("inval" ), folio); -folio_detach_private (folio); -} -/* * invalidate part or all of a page * - release a page and clean up its private data if offset is 0 (indicating
@@ -450,11 +393,6 @@ static void afs_invalidate_folio(struct folio *folio, size_t offset, {_enter ("{%lu},%zu,%zu" , folio->index, offset, length); -BUG_ON (!folio_test_locked (folio)); - -if (folio_get_private (folio)) -afs_invalidate_dirty (folio, offset, length); -folio_wait_fscache (folio);_leave ("" ); }
@@ -482,11 +420,6 @@ static bool afs_release_folio(struct folio *folio, gfp_t gfp)fscache_note_page_release (afs_vnode_cache (vnode));#endif -if (folio_test_private (folio)) { -trace_afs_folio_dirty (vnode,tracepoint_string ("rel" ), folio); -folio_detach_private (folio); - } -/* Indicate that the folio can be released */ _leave (" = T" );return true;
fs/afs/internal.h +0 -56
62 lines not on this page · raw message
fs/afs/write.c +38 -150
353 lines not on this page · raw message
include/trace/events/afs.h +4 -12
@@ -911,26 +911,18 @@ TRACE_EVENT(afs_folio_dirty, __field(struct afs_vnode *, vnode) __field(const char *, where) __field(pgoff_t, index) - __field(unsigned long, from) - __field(unsigned long, to) + __field(size_t, size) ),TP_fast_assign ( - unsigned long priv = (unsigned long)folio_get_private(folio); __entry->vnode = vnode; __entry->where = where; __entry->index =folio_index (folio); - __entry->from =afs_folio_dirty_from (folio, priv); - __entry->to =afs_folio_dirty_to (folio, priv); - __entry->to |= (afs_is_folio_dirty_mmapped (priv) ? - (1UL << (BITS_PER_LONG -1 )) :0 ); + __entry->size =folio_size (folio); ), -TP_printk ("vn=%p %lx %s %lx-%lx%s" , - __entry->vnode, __entry->index, __entry->where, - __entry->from, - __entry->to & ~(1UL << (BITS_PER_LONG -1 )), - __entry->to & (1UL << (BITS_PER_LONG -1 )) ?" M" :"" ) +TP_printk ("vn=%p ix=%05lx s=%05lx %s" , + __entry->vnode, __entry->index, __entry->size, __entry->where) ); TRACE_EVENT(afs_call_state,
David Howells
maintainerPATCH v4 10/39 netfs: Provide invalidate_folio and release_folio calls
In reply to David HowellsProvide default invalidate_folio and release_folio calls. These will need to interact with invalidation correctly at some point. They will be needed if netfslib is to make use of folio->private for its own purposes.
--- fs/9p/vfs_addr.c | 33 ++------------------------- fs/afs/file.c | 53 ++++--------------------------------------- fs/ceph/addr.c | 24 ++------------------ fs/netfs/misc.c | 42 ++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 6 +++-- 5 files changed, 54 insertions(+), 104 deletions(-)
fs/9p/vfs_addr.c +2 -31
@@ -88,35 +88,6 @@ const struct netfs_request_ops v9fs_req_ops = { .issue_read = v9fs_issue_read, }; -/** -* v9fs_release_folio - release the private state associated with a folio -* @folio: The folio to be released -* @gfp: The caller's allocation restrictions -* -* Returns true if the page can be released, false otherwise. -*/ - -static bool v9fs_release_folio (struct folio *folio,gfp_t gfp) -{ -if (folio_test_private (folio)) -return false; -#ifdef CONFIG_9P_FSCACHE -if (folio_test_fscache (folio)) { -if (current_is_kswapd () || !(gfp & __GFP_FS)) -return false; -folio_wait_fscache (folio); - } -fscache_note_page_release (v9fs_inode_cookie (V9FS_I (folio_inode (folio)))); -#endif -return true; -} - -static void v9fs_invalidate_folio (struct folio *folio,size_t offset, -size_t length) -{ -folio_wait_fscache (folio); -} -#ifdef CONFIG_9P_FSCACHE static void v9fs_write_to_cache_done (void *priv,ssize_t transferred_or_error,bool was_async)
@@ -324,8 +295,8 @@ const struct address_space_operations v9fs_addr_operations = { .writepage = v9fs_vfs_writepage, .write_begin = v9fs_write_begin, .write_end = v9fs_write_end, - .release_folio = v9fs_release_folio, - .invalidate_folio = v9fs_invalidate_folio, + .release_folio = netfs_release_folio, + .invalidate_folio = netfs_invalidate_folio, .launder_folio = v9fs_launder_folio, .direct_IO = v9fs_direct_IO, };
fs/afs/file.c +4 -49
77 lines not on this page · raw message
fs/ceph/addr.c +2 -22
@@ -159,27 +159,7 @@ static void ceph_invalidate_folio(struct folio *folio, size_t offset,ceph_put_snap_context (snapc); } -folio_wait_fscache (folio); -} - -static bool ceph_release_folio (struct folio *folio,gfp_t gfp) -{ -struct inode *inode = folio->mapping->host; -struct ceph_client *cl =ceph_inode_to_client (inode); - -doutc (cl,"%llx.%llx idx %lu (%sdirty)\n" ,ceph_vinop (inode), - folio->index,folio_test_dirty (folio) ?"" :"not " ); - -if (folio_test_private (folio)) -return false; - -if (folio_test_fscache (folio)) { -if (current_is_kswapd () || !(gfp & __GFP_FS)) -return false; -folio_wait_fscache (folio); - } -ceph_fscache_note_page_release (inode); -return true; +netfs_invalidate_folio (folio, offset, length); }static void ceph_netfs_expand_readahead (struct netfs_io_request *rreq)
@@ -1585,7 +1565,7 @@ const struct address_space_operations ceph_aops = { .write_end = ceph_write_end, .dirty_folio = ceph_dirty_folio, .invalidate_folio = ceph_invalidate_folio, - .release_folio = ceph_release_folio, + .release_folio = netfs_release_folio, .direct_IO = noop_direct_IO, };
fs/netfs/misc.c +42 -0
45 lines not on this page · raw message
include/linux/netfs.h +4 -2
@@ -293,11 +293,13 @@ struct readahead_control;void netfs_readahead (struct readahead_control *);int netfs_read_folio (struct file *,struct folio *);int netfs_write_begin (struct netfs_inode *,struct file *, -struct address_space *,loff_t pos,unsigned int len, -struct folio **,void **fsdata); +struct address_space *,loff_t pos,unsigned int len, +struct folio **,void **fsdata);bool netfs_dirty_folio (struct address_space *mapping,struct folio *folio);int netfs_unpin_writeback (struct inode *inode,struct writeback_control *wbc);void netfs_clear_inode_writeback (struct inode *inode,const void *aux); +void netfs_invalidate_folio (struct folio *folio,size_t offset,size_t length); +bool netfs_release_folio (struct folio *folio,gfp_t gfp);void netfs_subreq_terminated (struct netfs_io_subrequest *,ssize_t ,bool ); void netfs_get_subrequest(struct netfs_io_subrequest *subreq,
Jeff Layton
maintainerRe: [PATCH v4 10/39] netfs: Provide invalidate_folio and release_folio calls
Quoted 171 lines · David Howells
Provide default
invalidate_folioandrelease_foliocalls. These will need to interact with invalidation correctly at some point. They will be needed if netfslib is to make use offolio->privatefor its own purposes.Signed-off-by David Howells <[email protected]>Reviewed-by Jeff Layton <[email protected]>--- fs/9p/vfs_addr.c | 33 ++------------------------- fs/afs/file.c | 53 ++++--------------------------------------- fs/ceph/addr.c | 24 ++------------------ fs/netfs/misc.c | 42 ++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 6 +++-- 5 files changed, 54 insertions(+), 104 deletions(-)fs/9p/vfs_addr.c +2
-31@@ -88,35 +88,6 @@ const struct netfs_request_ops v9fs_req_ops = { .issue_read = v9fs_issue_read, }; -/** -* v9fs_release_folio - release the private state associated with a folio -* @folio: The folio to be released -* @gfp: The caller's allocation restrictions -* -* Returns true if the page can be released, false otherwise. -*/ - -static bool v9fs_release_folio (struct folio *folio,gfp_t gfp) -{ -if (folio_test_private (folio)) -return false; -#ifdef CONFIG_9P_FSCACHE -if (folio_test_fscache (folio)) { -if (current_is_kswapd () || !(gfp & __GFP_FS)) -return false; -folio_wait_fscache (folio); - } -fscache_note_page_release (v9fs_inode_cookie (V9FS_I (folio_inode (folio)))); -#endif -return true; -} - -static void v9fs_invalidate_folio (struct folio *folio,size_t offset, -size_t length) -{ -folio_wait_fscache (folio); -} -#ifdef CONFIG_9P_FSCACHE static void v9fs_write_to_cache_done (void *priv,ssize_t transferred_or_error,bool was_async)@@ -324,8 +295,8 @@ const struct address_space_operations v9fs_addr_operations = { .writepage = v9fs_vfs_writepage, .write_begin = v9fs_write_begin, .write_end = v9fs_write_end, - .release_folio = v9fs_release_folio, - .invalidate_folio = v9fs_invalidate_folio, + .release_folio = netfs_release_folio, + .invalidate_folio = netfs_invalidate_folio, .launder_folio = v9fs_launder_folio, .direct_IO = v9fs_direct_IO, };fs/afs/file.c +4
-49@@ -20,9 +20,6 @@static int afs_file_mmap (struct file *file,struct vm_area_struct *vma);static int afs_symlink_read_folio (struct file *file,struct folio *folio); -static void afs_invalidate_folio (struct folio *folio,size_t offset, -size_t length); -static bool afs_release_folio (struct folio *folio,gfp_t gfp_flags);static ssize_t afs_file_read_iter (struct kiocb *iocb,struct iov_iter *iter); static ssize_t afs_file_splice_read(struct file *in, loff_t *ppos,@@ -57,8 +54,8 @@ const struct address_space_operations afs_file_aops = { .readahead = netfs_readahead, .dirty_folio = netfs_dirty_folio, .launder_folio = afs_launder_folio, - .release_folio = afs_release_folio, - .invalidate_folio = afs_invalidate_folio, + .release_folio = netfs_release_folio, + .invalidate_folio = netfs_invalidate_folio, .write_begin = afs_write_begin, .write_end = afs_write_end, .writepages = afs_writepages,@@ -67,8 +64,8 @@ const struct address_space_operations afs_file_aops = {const struct address_space_operations afs_symlink_aops = { .read_folio = afs_symlink_read_folio, - .release_folio = afs_release_folio, - .invalidate_folio = afs_invalidate_folio, + .release_folio = netfs_release_folio, + .invalidate_folio = netfs_invalidate_folio, .migrate_folio = filemap_migrate_folio, };@@ -383,48 +380,6 @@ const struct netfs_request_ops afs_req_ops = { .issue_read = afs_issue_read, }; -/* -* invalidate part or all of a page -* - release a page and clean up its private data if offset is 0 (indicating -* the entire page) -*/ -static void afs_invalidate_folio (struct folio *folio,size_t offset, -size_t length) -{ -_enter ("{%lu},%zu,%zu" , folio->index, offset, length); - -folio_wait_fscache (folio); -_leave ("" ); -} - -/* -* release a page and clean up its private state if it's not busy -* - return true if the page can now be released, false if not -*/ -static bool afs_release_folio (struct folio *folio,gfp_t gfp) -{ -struct afs_vnode *vnode =AFS_FS_I (folio_inode (folio)); - -_enter ("{{%llx:%llu}[%lu],%lx},%x" , - vnode->fid.vid, vnode->fid.vnode,folio_index (folio), folio->flags, - gfp); - -/* deny if folio is being written to the cache and the caller hasn't -* elected to wait */ -#ifdef CONFIG_AFS_FSCACHE -if (folio_test_fscache (folio)) { -if (current_is_kswapd () || !(gfp & __GFP_FS)) -return false; -folio_wait_fscache (folio); - } -fscache_note_page_release (afs_vnode_cache (vnode)); -#endif - -/* Indicate that the folio can be released */ -_leave (" = T" ); -return true; -} -static void afs_add_open_mmap (struct afs_vnode *vnode) {if (atomic_inc_return (&vnode->cb_nr_mmap) ==1 ) {fs/ceph/addr.c +0
-10@@ -159,27 +159,7 @@ static void ceph_invalidate_folio(struct folio *folio, size_t offset,ceph_put_snap_context (snapc); } -folio_wait_fscache (folio); -} - -static bool ceph_release_folio (struct folio *folio,gfp_t gfp) -{ -struct inode *inode = folio->mapping->host; -struct ceph_client *cl =ceph_inode_to_client (inode); - -doutc (cl,"%llx.%llx idx %lu (%sdirty)\n" ,ceph_vinop (inode), - folio->index,folio_test_dirty (folio) ?"" :"not " );
fs/ceph/addr.c static void ceph_invalidate_folio(struct folio *folio, size_t offset, · line 181
Quoted 10 lines
fs/ceph/addr.c +0
-10- -if (folio_test_private (folio)) -return false; - -if (folio_test_fscache (folio)) { -if (current_is_kswapd () || !(gfp & __GFP_FS)) -return false; -folio_wait_fscache (folio); - } -ceph_fscache_note_page_release (inode);
I think this is the only call to ceph_fscache_note_page_release, so that can likely be removed as well.
Quoted 85 lines
fs/ceph/addr.c +2
-2-return true; +netfs_invalidate_folio (folio, offset, length); }static void ceph_netfs_expand_readahead (struct netfs_io_request *rreq)@@ -1585,7 +1565,7 @@ const struct address_space_operations ceph_aops = { .write_end = ceph_write_end, .dirty_folio = ceph_dirty_folio, .invalidate_folio = ceph_invalidate_folio, - .release_folio = ceph_release_folio, + .release_folio = netfs_release_folio, .direct_IO = noop_direct_IO, };fs/netfs/misc.c +42
-0@@ -84,3 +84,45 @@ void netfs_clear_inode_writeback(struct inode *inode, const void *aux) } }EXPORT_SYMBOL (netfs_clear_inode_writeback); + +/* +* netfs_invalidate_folio - Invalidate or partially invalidate a folio +* @folio: Folio proposed for release +* @offset: Offset of the invalidated region +* @length: Length of the invalidated region +* +* Invalidate part or all of a folio for a network filesystem. The folio will +* be removed afterwards if the invalidated region covers the entire folio. +*/ +void netfs_invalidate_folio (struct folio *folio,size_t offset,size_t length) +{ +_enter ("{%lx},%zx,%zx" ,folio_index (folio), offset, length); + +folio_wait_fscache (folio); +} +EXPORT_SYMBOL (netfs_invalidate_folio); + +/** +* netfs_release_folio - Try to release a folio +* @folio: Folio proposed for release +* @gfp: Flags qualifying the release +* +* Request release of a folio and clean up its private state if it's not busy. +* Returns true if the folio can now be released, false if not +*/ +bool netfs_release_folio (struct folio *folio,gfp_t gfp) +{ +struct netfs_inode *ctx =netfs_inode (folio_inode (folio)); + +if (folio_test_private (folio)) +return false; +if (folio_test_fscache (folio)) { +if (current_is_kswapd () || !(gfp & __GFP_FS)) +return false; +folio_wait_fscache (folio); + } + +fscache_note_page_release (netfs_i_cookie (ctx)); +return true; +} +EXPORT_SYMBOL (netfs_release_folio);include/linux/netfs.h +4
-2@@ -293,11 +293,13 @@ struct readahead_control;void netfs_readahead (struct readahead_control *);int netfs_read_folio (struct file *,struct folio *);int netfs_write_begin (struct netfs_inode *,struct file *, -struct address_space *,loff_t pos,unsigned int len, -struct folio **,void **fsdata); +struct address_space *,loff_t pos,unsigned int len, +struct folio **,void **fsdata);bool netfs_dirty_folio (struct address_space *mapping,struct folio *folio);int netfs_unpin_writeback (struct inode *inode,struct writeback_control *wbc);void netfs_clear_inode_writeback (struct inode *inode,const void *aux); +void netfs_invalidate_folio (struct folio *folio,size_t offset,size_t length); +bool netfs_release_folio (struct folio *folio,gfp_t gfp);void netfs_subreq_terminated (struct netfs_io_subrequest *,ssize_t ,bool ); void netfs_get_subrequest(struct netfs_io_subrequest *subreq,
Signature · 1 line
Jeff Layton <[email protected]>
David Howells
maintainerPATCH v4 11/39 netfs: Implement unbuffered/DIO vs buffered I/O locking
In reply to David HowellsBorrow NFS's direct-vs-buffered I/O locking into netfslib. Similar code is also used in ceph.
Modify it to have the correct checker annotations for i_rwsem lock acquisition/release and to return -ERESTARTSYS if waits are interrupted.
--- fs/netfs/Makefile | 1 + fs/netfs/locking.c | 215 ++++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 10 ++ 3 files changed, 226 insertions(+) create mode 100644 fs/netfs/locking.c
fs/netfs/Makefile +1 -0
@@ -4,6 +4,7 @@ netfs-y := \ buffered_read.o \ io.o \ iterator.o \ + locking.o \ main.o \ misc.o \ objects.o
fs/netfs/locking.c new file +215 -0
215 lines not on this page · raw message
include/linux/netfs.h +10 -0
@@ -129,6 +129,8 @@ struct netfs_inode {struct fscache_cookie *cache;#endif loff_t remote_i_size;/* Size of the remote file */ +unsigned long flags; +#define NETFS_ICTX_ODIRECT 0/* The file has DIO in progress */ };/*
@@ -310,6 +312,13 @@ ssize_t netfs_extract_user_iter(struct iov_iter *orig, size_t orig_len,struct iov_iter *new, iov_iter_extraction_t extraction_flags); +int netfs_start_io_read (struct inode *inode); +void netfs_end_io_read (struct inode *inode); +int netfs_start_io_write (struct inode *inode); +void netfs_end_io_write (struct inode *inode); +int netfs_start_io_direct (struct inode *inode); +void netfs_end_io_direct (struct inode *inode); +/** * netfs_inode - Get the netfs inode context from the inode * @inode: The inode to query
@@ -335,6 +344,7 @@ static inline void netfs_inode_init(struct netfs_inode *ctx, { ctx->ops = ops; ctx->remote_i_size =i_size_read (&ctx->inode); + ctx->flags =0 ;#if IS_ENABLED (CONFIG_FSCACHE ) ctx->cache =NULL ;#endif
Jeff Layton
maintainerRe: [PATCH v4 11/39] netfs: Implement unbuffered/DIO vs buffered I/O locking
Quoted 6 lines · David Howells
Borrow NFS's direct-vs-buffered I/O locking into netfslib. Similar code is also used in ceph.
Modify it to have the correct checker annotations for
i_rwsemlock acquisition/release and to return-ERESTARTSYSif waits are interrupted.
This is just adding new infrastructure. It'd be nice to go ahead and convert a filesystem to use this at the same time. Ceph would be a good candidate. Otherwise, I'm not sure how this shakes out as far as cleanliness in the callers.
Quoted 281 lines
Signed-off-by David Howells <[email protected]>cc Jeff Layton <[email protected]>--- fs/netfs/Makefile | 1 + fs/netfs/locking.c | 215 ++++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 10 ++ 3 files changed, 226 insertions(+) create mode 100644 fs/netfs/locking.cfs/netfs/Makefile +1
-0@@ -4,6 +4,7 @@ netfs-y := \ buffered_read.o \ io.o \ iterator.o \ + locking.o \ main.o \ misc.o \ objects.ofs/netfs/locking.c new file +215
-0@@ -0,0 +1,215 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* I/O and data path helper functionality. +* +* Borrowed from NFS Copyright (c) 2016 Trond Myklebust +*/ + +#include <linux/kernel.h> +#include <linux/netfs.h> + +/* +* inode_dio_wait_interruptible - wait for outstanding DIO requests to finish +* @inode: inode to wait for +* +* Waits for all pending direct I/O requests to finish so that we can +* proceed with a truncate or equivalent operation. +* +* Must be called under a lock that serializes taking new references +* to i_dio_count, usually by inode->i_mutex. +*/ +static int inode_dio_wait_interruptible (struct inode *inode) +{ +if (!atomic_read (&inode->i_dio_count)) +return 0 ; + +wait_queue_head_t *wq =bit_waitqueue (&inode->i_state, __I_DIO_WAKEUP); +DEFINE_WAIT_BIT (q, &inode->i_state, __I_DIO_WAKEUP); + +for (;;) { +prepare_to_wait (wq, &q.wq_entry,TASK_INTERRUPTIBLE ); +if (!atomic_read (&inode->i_dio_count)) +break ; +if (signal_pending (current)) +break ; +schedule (); + } +finish_wait (wq, &q.wq_entry); + +return atomic_read (&inode->i_dio_count) ? -ERESTARTSYS :0 ; +} + +/* Call with exclusively locked inode->i_rwsem */ +static int netfs_block_o_direct (struct netfs_inode *ictx) +{ +if (!test_bit (NETFS_ICTX_ODIRECT , &ictx->flags)) +return 0 ; +clear_bit (NETFS_ICTX_ODIRECT , &ictx->flags); +return inode_dio_wait_interruptible (&ictx->inode); +} + +/** +* netfs_start_io_read - declare the file is being used for buffered reads +* @inode: file inode +* +* Declare that a buffered read operation is about to start, and ensure +* that we block all direct I/O. +* On exit, the function ensures that the NETFS_ICTX_ODIRECT flag is unset, +* and holds a shared lock on inode->i_rwsem to ensure that the flag +* cannot be changed. +* In practice, this means that buffered read operations are allowed to +* execute in parallel, thanks to the shared lock, whereas direct I/O +* operations need to wait to grab an exclusive lock in order to set +* NETFS_ICTX_ODIRECT. +* Note that buffered writes and truncates both take a write lock on +* inode->i_rwsem, meaning that those are serialised w.r.t. the reads. +*/ +int netfs_start_io_read (struct inode *inode) + __acquires(inode->i_rwsem) +{ +struct netfs_inode *ictx =netfs_inode (inode); + +/* Be an optimist! */ +if (down_read_interruptible (&inode->i_rwsem) <0 ) +return -ERESTARTSYS ; +if (test_bit (NETFS_ICTX_ODIRECT , &ictx->flags) ==0 ) +return 0 ; +up_read (&inode->i_rwsem); + +/* Slow path.... */ +if (down_write_killable (&inode->i_rwsem) <0 ) +return -ERESTARTSYS ; +if (netfs_block_o_direct (ictx) <0 ) { +up_write (&inode->i_rwsem); +return -ERESTARTSYS ; + } +downgrade_write (&inode->i_rwsem); +return 0 ; +} +EXPORT_SYMBOL (netfs_start_io_read); + +/** +* netfs_end_io_read - declare that the buffered read operation is done +* @inode: file inode +* +* Declare that a buffered read operation is done, and release the shared +* lock on inode->i_rwsem. +*/ +void netfs_end_io_read (struct inode *inode) + __releases(inode->i_rwsem) +{ +up_read (&inode->i_rwsem); +} +EXPORT_SYMBOL (netfs_end_io_read); + +/** +* netfs_start_io_write - declare the file is being used for buffered writes +* @inode: file inode +* +* Declare that a buffered read operation is about to start, and ensure +* that we block all direct I/O. +*/ +int netfs_start_io_write (struct inode *inode) + __acquires(inode->i_rwsem) +{ +struct netfs_inode *ictx =netfs_inode (inode); + +if (down_write_killable (&inode->i_rwsem) <0 ) +return -ERESTARTSYS ; +if (netfs_block_o_direct (ictx) <0 ) { +up_write (&inode->i_rwsem); +return -ERESTARTSYS ; + } +return 0 ; +} +EXPORT_SYMBOL (netfs_start_io_write); + +/** +* netfs_end_io_write - declare that the buffered write operation is done +* @inode: file inode +* +* Declare that a buffered write operation is done, and release the +* lock on inode->i_rwsem. +*/ +void netfs_end_io_write (struct inode *inode) + __releases(inode->i_rwsem) +{ +up_write (&inode->i_rwsem); +} +EXPORT_SYMBOL (netfs_end_io_write); + +/* Call with exclusively locked inode->i_rwsem */ +static int netfs_block_buffered (struct inode *inode) +{ +struct netfs_inode *ictx =netfs_inode (inode); +int ret; + +if (!test_bit (NETFS_ICTX_ODIRECT , &ictx->flags)) { +set_bit (NETFS_ICTX_ODIRECT , &ictx->flags); +if (inode->i_mapping->nrpages !=0 ) { +unmap_mapping_range (inode->i_mapping,0 ,0 ,0 ); + ret =filemap_fdatawait (inode->i_mapping); +if (ret <0 ) { +clear_bit (NETFS_ICTX_ODIRECT , &ictx->flags); +return ret; + } + } + } +return 0 ; +} + +/** +* netfs_start_io_direct - declare the file is being used for direct i/o +* @inode: file inode +* +* Declare that a direct I/O operation is about to start, and ensure +* that we block all buffered I/O. +* On exit, the function ensures that the NETFS_ICTX_ODIRECT flag is set, +* and holds a shared lock on inode->i_rwsem to ensure that the flag +* cannot be changed. +* In practice, this means that direct I/O operations are allowed to +* execute in parallel, thanks to the shared lock, whereas buffered I/O +* operations need to wait to grab an exclusive lock in order to clear +* NETFS_ICTX_ODIRECT. +* Note that buffered writes and truncates both take a write lock on +* inode->i_rwsem, meaning that those are serialised w.r.t. O_DIRECT. +*/ +int netfs_start_io_direct (struct inode *inode) + __acquires(inode->i_rwsem) +{ +struct netfs_inode *ictx =netfs_inode (inode); +int ret; + +/* Be an optimist! */ +if (down_read_interruptible (&inode->i_rwsem) <0 ) +return -ERESTARTSYS ; +if (test_bit (NETFS_ICTX_ODIRECT , &ictx->flags) !=0 ) +return 0 ; +up_read (&inode->i_rwsem); + +/* Slow path.... */ +if (down_write_killable (&inode->i_rwsem) <0 ) +return -ERESTARTSYS ; + ret =netfs_block_buffered (inode); +if (ret <0 ) { +up_write (&inode->i_rwsem); +return ret; + } +downgrade_write (&inode->i_rwsem); +return 0 ; +} +EXPORT_SYMBOL (netfs_start_io_direct); + +/** +* netfs_end_io_direct - declare that the direct i/o operation is done +* @inode: file inode +* +* Declare that a direct I/O operation is done, and release the shared +* lock on inode->i_rwsem. +*/ +void netfs_end_io_direct (struct inode *inode) + __releases(inode->i_rwsem) +{ +up_read (&inode->i_rwsem); +} +EXPORT_SYMBOL (netfs_end_io_direct);include/linux/netfs.h +10
-0@@ -129,6 +129,8 @@ struct netfs_inode {struct fscache_cookie *cache;#endif loff_t remote_i_size;/* Size of the remote file */ +unsigned long flags; +#define NETFS_ICTX_ODIRECT 0/* The file has DIO in progress */ };/* @@ -310,6 +312,13 @@ ssize_t netfs_extract_user_iter(struct iov_iter *orig, size_t orig_len,struct iov_iter *new, iov_iter_extraction_t extraction_flags); +int netfs_start_io_read (struct inode *inode); +void netfs_end_io_read (struct inode *inode); +int netfs_start_io_write (struct inode *inode); +void netfs_end_io_write (struct inode *inode); +int netfs_start_io_direct (struct inode *inode); +void netfs_end_io_direct (struct inode *inode); +/** * netfs_inode - Get the netfs inode context from the inode * @inode: The inode to query @@ -335,6 +344,7 @@ static inline void netfs_inode_init(struct netfs_inode *ctx, { ctx->ops = ops; ctx->remote_i_size =i_size_read (&ctx->inode); + ctx->flags =0 ;#if IS_ENABLED (CONFIG_FSCACHE ) ctx->cache =NULL ;#endif
Signature · 1 line
Jeff Layton <[email protected]>
Jeff Layton
maintainerRe: [PATCH v4 11/39] netfs: Implement unbuffered/DIO vs buffered I/O locking
Quoted 4 lines · Jeff Layton
Quoted 3 lines · David Howells
Borrow NFS's direct-vs-buffered I/O locking into netfslib. Similar code is also used in ceph.
Quoted 9 lines
Quoted 3 lines
Modify it to have the correct checker annotations for
i_rwsemlock acquisition/release and to return-ERESTARTSYSif waits are interrupted.This is just adding new infrastructure. It'd be nice to go ahead and convert a filesystem to use this at the same time. Ceph would be a good candidate. Otherwise, I'm not sure how this shakes out as far as cleanliness in the callers.
Nevermind...I misunderstood what you were trying to do here. You're not subsuming this into common code that filesystems will use directly, this is just using the same scheme when doing I/O using netfs helpers.
Ceph and other filesystems will get converted to this when they are converted to do all of their I/O via netfs.
Signature · 1 line
Jeff Layton <[email protected]>
David Howells
maintainerPATCH v4 12/39 netfs: Add iov_iters to (sub)requests to describe various buffers
In reply to David HowellsAdd three iov_iter structs:
(1) Add an iov_iter (->iter) to the I/O request to describe the unencrypted-side buffer.
(2) Add an iov_iter (->io_iter) to the I/O request to describe the encrypted-side I/O buffer. This may be a different size to the buffer in (1).
(3) Add an iov_iter (->io_iter) to the I/O subrequest to describe the part of the I/O buffer for that subrequest.
This will allow future patches to point to a bounce buffer instead for purposes of handling oversize writes, decryption (where we want to save the encrypted data to the cache) and decompression.
These iov_iters persist for the lifetime of the (sub)request, and so can be accessed multiple times without worrying about them being deallocated upon return to the caller.
The network filesystem must appropriately advance the iterator before terminating the request.
--- fs/afs/file.c | 6 +--- fs/netfs/buffered_read.c | 13 ++++++++ fs/netfs/io.c | 69 +++++++++++++++++++++++++++++----------- include/linux/netfs.h | 3 ++ 4 files changed, 67 insertions(+), 24 deletions(-)
fs/afs/file.c +1 -5
@@ -320,11 +320,7 @@ static void afs_issue_read(struct netfs_io_subrequest *subreq) fsreq->len = subreq->len - subreq->transferred; fsreq->key =key_get (subreq->rreq->netfs_priv); fsreq->vnode = vnode; - fsreq->iter = &fsreq->def_iter; - -iov_iter_xarray (&fsreq->def_iter,ITER_DEST , - &fsreq->vnode->netfs.inode.i_mapping->i_pages, - fsreq->pos, fsreq->len); + fsreq->iter = &subreq->io_iter;afs_fetch_data (fsreq->vnode, fsreq);afs_put_read (fsreq);
fs/netfs/buffered_read.c +13 -0
@@ -199,6 +199,10 @@ void netfs_readahead(struct readahead_control *ractl)netfs_rreq_expand (rreq, ractl); +/* Set up the output buffer */ +iov_iter_xarray (&rreq->iter,ITER_DEST , &ractl->mapping->i_pages, + rreq->start, rreq->len); +/* Drop the refs on the folios here rather than in the cache or * filesystem. The locks will be dropped in netfs_rreq_unlock(). */
@@ -251,6 +255,11 @@ int netfs_read_folio(struct file *file, struct folio *folio)netfs_stat (&netfs_n_rh_readpage);trace_netfs_read (rreq, rreq->start, rreq->len, netfs_read_trace_readpage); + +/* Set up the output buffer */ +iov_iter_xarray (&rreq->iter,ITER_DEST , &mapping->i_pages, + rreq->start, rreq->len); +return netfs_begin_read (rreq, true); discard:
@@ -408,6 +417,10 @@ int netfs_write_begin(struct netfs_inode *ctx, ractl._nr_pages =folio_nr_pages (folio);netfs_rreq_expand (rreq, &ractl); +/* Set up the output buffer */ +iov_iter_xarray (&rreq->iter,ITER_DEST , &mapping->i_pages, + rreq->start, rreq->len); +/* We hold the folio locks, so we can drop the references */ folio_get (folio);while (readahead_folio (&ractl))
fs/netfs/io.c +50 -19
152 lines not on this page · raw message
include/linux/netfs.h +3 -0
@@ -150,6 +150,7 @@ struct netfs_cache_resources {struct netfs_io_subrequest {struct netfs_io_request *rreq;/* Supervising I/O request */ struct list_head rreq_link;/* Link in rreq->subrequests */ +struct iov_iter io_iter;/* Iterator for this subrequest */ loff_t start;/* Where to start the I/O */ size_t len;/* Size of the I/O */ size_t transferred;/* Amount of data transferred */
@@ -186,6 +187,8 @@ struct netfs_io_request {struct netfs_cache_resources cache_resources;struct list_head proc_link;/* Link in netfs_iorequests */ struct list_head subrequests;/* Contributory I/O operations */ +struct iov_iter iter;/* Unencrypted-side iterator */ +struct iov_iter io_iter;/* I/O (Encrypted-side) iterator */ void *netfs_priv;/* Private data for the netfs */ unsigned int debug_id;atomic_t nr_outstanding;/* Number of ops in progress */
Jeff Layton
maintainerRe: [PATCH v4 12/39] netfs: Add iov_iters to (sub)requests to describe various buffers
Quoted 80 lines · David Howells
Add three
iov_iterstructs:(1) Add an
iov_iter(->iter) to the I/O request to describe the unencrypted-side buffer.(2) Add an
iov_iter(->io_iter) to the I/O request to describe the encrypted-side I/O buffer. This may be a different size to the buffer in (1).(3) Add an
iov_iter(->io_iter) to the I/O subrequest to describe the part of the I/O buffer for that subrequest.This will allow future patches to point to a bounce buffer instead for purposes of handling oversize writes, decryption (where we want to save the encrypted data to the cache) and decompression.
These
iov_iterspersist for the lifetime of the (sub)request, and so can be accessed multiple times without worrying about them being deallocated upon return to the caller.The network filesystem must appropriately advance the iterator before terminating the request.
Signed-off-by David Howells <[email protected]>cc Jeff Layton <[email protected]>--- fs/afs/file.c | 6 +--- fs/netfs/buffered_read.c | 13 ++++++++ fs/netfs/io.c | 69 +++++++++++++++++++++++++++++----------- include/linux/netfs.h | 3 ++ 4 files changed, 67 insertions(+), 24 deletions(-)fs/afs/file.c +1
-5@@ -320,11 +320,7 @@ static void afs_issue_read(struct netfs_io_subrequest *subreq) fsreq->len = subreq->len - subreq->transferred; fsreq->key =key_get (subreq->rreq->netfs_priv); fsreq->vnode = vnode; - fsreq->iter = &fsreq->def_iter; - -iov_iter_xarray (&fsreq->def_iter,ITER_DEST , - &fsreq->vnode->netfs.inode.i_mapping->i_pages, - fsreq->pos, fsreq->len); + fsreq->iter = &subreq->io_iter;afs_fetch_data (fsreq->vnode, fsreq);afs_put_read (fsreq);fs/netfs/buffered_read.c +9
-0@@ -199,6 +199,10 @@ void netfs_readahead(struct readahead_control *ractl)netfs_rreq_expand (rreq, ractl); +/* Set up the output buffer */ +iov_iter_xarray (&rreq->iter,ITER_DEST , &ractl->mapping->i_pages, + rreq->start, rreq->len); +/* Drop the refs on the folios here rather than in the cache or * filesystem. The locks will be dropped in netfs_rreq_unlock(). */ @@ -251,6 +255,11 @@ int netfs_read_folio(struct file *file, struct folio *folio)netfs_stat (&netfs_n_rh_readpage);trace_netfs_read (rreq, rreq->start, rreq->len, netfs_read_trace_readpage); + +/* Set up the output buffer */ +iov_iter_xarray (&rreq->iter,ITER_DEST , &mapping->i_pages, + rreq->start, rreq->len); +return netfs_begin_read (rreq, true); discard:
fs/netfs/buffered_read.c int netfs_write_begin(struct netfs_inode *ctx, · line 422
Quoted 6 lines
fs/netfs/buffered_read.c +3
-0@@ -408,6 +417,10 @@ int netfs_write_begin(struct netfs_inode *ctx, ractl._nr_pages =folio_nr_pages (folio);netfs_rreq_expand (rreq, &ractl); +/* Set up the output buffer */ +iov_iter_xarray (&rreq->iter,ITER_DEST , &mapping->i_pages, + rreq->start, rreq->len);
Should the above be ITER_SOURCE ?
Quoted 39 lines
fs/netfs/buffered_read.c +1
-0+/* We hold the folio locks, so we can drop the references */ folio_get (folio);while (readahead_folio (&ractl))fs/netfs/io.c +2
-12@@ -21,12 +21,7 @@*/ static void netfs_clear_unread (struct netfs_io_subrequest *subreq) { -struct iov_iter iter; - -iov_iter_xarray (&iter,ITER_DEST , &subreq->rreq->mapping->i_pages, - subreq->start + subreq->transferred, - subreq->len - subreq->transferred); -iov_iter_zero (iov_iter_count (&iter), &iter); +iov_iter_zero (iov_iter_count (&subreq->io_iter), &subreq->io_iter); } static void netfs_cache_read_terminated(void *priv, ssize_t transferred_or_error,@@ -46,14 +41,9 @@ static void netfs_read_from_cache(struct netfs_io_request *rreq, enum netfs_read_from_hole read_hole) {struct netfs_cache_resources *cres = &rreq->cache_resources; -struct iov_iter iter;netfs_stat (&netfs_n_rh_read); -iov_iter_xarray (&iter,ITER_DEST , &rreq->mapping->i_pages, - subreq->start + subreq->transferred, - subreq->len - subreq->transferred); - - cres->ops->read (cres, subreq->start, &iter, read_hole, + cres->ops->read (cres, subreq->start, &subreq->io_iter, read_hole, netfs_cache_read_terminated, subreq); }
fs/netfs/io.c static void netfs_read_from_server(struct netfs_io_request *rreq, · line 85
Quoted 8 lines
fs/netfs/io.c +5
-0@@ -88,6 +78,11 @@ static void netfs_read_from_server(struct netfs_io_request *rreq, struct netfs_io_subrequest *subreq) {netfs_stat (&netfs_n_rh_download); +if (iov_iter_count (&subreq->io_iter) != subreq->len - subreq->transferred) +pr_warn ("R=%08x[%u] ITER PRE-MISMATCH %zx != %zx-%zx %lx\n" , + rreq->debug_id, subreq->debug_index, +iov_iter_count (&subreq->io_iter), subreq->len, + subreq->transferred, subreq->flags);
pr_warn is a bit alarmist, esp given the cryptic message. Maybe demote this to INFO or DEBUG?
Does this indicate a bug in the client or that the server is sending us malformed frames?
Quoted 148 lines
fs/netfs/io.c +43
-7rreq->netfs_ops->issue_read (subreq); }@@ -259,6 +254,30 @@ static void netfs_rreq_short_read(struct netfs_io_request *rreq,netfs_read_from_server (rreq, subreq); } +/* +* Reset the subrequest iterator prior to resubmission. +*/ +static void netfs_reset_subreq_iter (struct netfs_io_request *rreq, +struct netfs_io_subrequest *subreq) +{ +size_t remaining = subreq->len - subreq->transferred; +size_t count =iov_iter_count (&subreq->io_iter); + +if (count == remaining) +return ; + +_debug ("R=%08x[%u] ITER RESUB-MISMATCH %zx != %zx-%zx-%llx %x\n" , + rreq->debug_id, subreq->debug_index, +iov_iter_count (&subreq->io_iter), subreq->transferred, + subreq->len, rreq->i_size, + subreq->io_iter.iter_type); + +if (count < remaining) +iov_iter_revert (&subreq->io_iter, remaining - count); +else +iov_iter_advance (&subreq->io_iter, count - remaining); +} +/* * Resubmit any short or failed operations. Returns true if we got the rreq * ref back. @@ -287,6 +306,7 @@ static bool netfs_rreq_perform_resubmissions(struct netfs_io_request *rreq)trace_netfs_sreq (subreq, netfs_sreq_trace_download_instead);netfs_get_subrequest (subreq, netfs_sreq_trace_get_resubmit);atomic_inc (&rreq->nr_outstanding); +netfs_reset_subreq_iter (rreq, subreq);netfs_read_from_server (rreq, subreq); }else if (test_bit (NETFS_SREQ_SHORT_IO , &subreq->flags)) {netfs_rreq_short_read (rreq, subreq);@@ -399,9 +419,9 @@ void netfs_subreq_terminated(struct netfs_io_subrequest *subreq,struct netfs_io_request *rreq = subreq->rreq;int u; -_enter ("[%u]{%llx,%lx},%zd" , - subreq->debug_index, subreq->start, subreq->flags, - transferred_or_error); +_enter ("R=%x[%x]{%llx,%lx},%zd" , + rreq->debug_id, subreq->debug_index, + subreq->start, subreq->flags, transferred_or_error);switch (subreq->source) {case NETFS_READ_FROM_CACHE :@@ -501,7 +521,8 @@ static enum netfs_io_source netfs_cache_prepare_read(struct netfs_io_subrequest*/ static enum netfs_io_source netfs_rreq_prepare_read (struct netfs_io_request *rreq, -struct netfs_io_subrequest *subreq) +struct netfs_io_subrequest *subreq, +struct iov_iter *io_iter) {enum netfs_io_source source;@@ -528,9 +549,14 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq, } } -if (WARN_ON (subreq->len ==0 )) +if (WARN_ON (subreq->len ==0 )) { source =NETFS_INVALID_READ ; + goto out; + } + subreq->io_iter = *io_iter; +iov_iter_truncate (&subreq->io_iter, subreq->len); +iov_iter_advance (io_iter, subreq->len); out: subreq->source = source;trace_netfs_sreq (subreq, netfs_sreq_trace_prepare);@@ -541,6 +567,7 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq,* Slice off a piece of a read request and submit an I/O request for it. */ static bool netfs_rreq_submit_slice (struct netfs_io_request *rreq, +struct iov_iter *io_iter,unsigned int *_debug_index) {struct netfs_io_subrequest *subreq;@@ -565,7 +592,7 @@ static bool netfs_rreq_submit_slice(struct netfs_io_request *rreq,* (the starts must coincide), in which case, we go around the loop * again and ask it to download the next piece. */ - source =netfs_rreq_prepare_read (rreq, subreq); + source =netfs_rreq_prepare_read (rreq, subreq, io_iter);if (source ==NETFS_INVALID_READ ) goto subreq_failed;@@ -603,6 +630,7 @@ static bool netfs_rreq_submit_slice(struct netfs_io_request *rreq,*/ int netfs_begin_read (struct netfs_io_request *rreq,bool sync) { +struct iov_iter io_iter;unsigned int debug_index =0 ;int ret;@@ -615,6 +643,8 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync)return -EIO ; } + rreq->io_iter = rreq->iter; +INIT_WORK (&rreq->work, netfs_rreq_work);if (sync)@@ -624,8 +654,9 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync)* want and submit each one. */ atomic_set (&rreq->nr_outstanding,1 ); + io_iter = rreq->io_iter;do { -if (!netfs_rreq_submit_slice (rreq, &debug_index)) +if (!netfs_rreq_submit_slice (rreq, &io_iter, &debug_index))break ; }while (rreq->submitted < rreq->len);include/linux/netfs.h +3
-0@@ -150,6 +150,7 @@ struct netfs_cache_resources {struct netfs_io_subrequest {struct netfs_io_request *rreq;/* Supervising I/O request */ struct list_head rreq_link;/* Link in rreq->subrequests */ +struct iov_iter io_iter;/* Iterator for this subrequest */ loff_t start;/* Where to start the I/O */ size_t len;/* Size of the I/O */ size_t transferred;/* Amount of data transferred */ @@ -186,6 +187,8 @@ struct netfs_io_request {struct netfs_cache_resources cache_resources;struct list_head proc_link;/* Link in netfs_iorequests */ struct list_head subrequests;/* Contributory I/O operations */ +struct iov_iter iter;/* Unencrypted-side iterator */ +struct iov_iter io_iter;/* I/O (Encrypted-side) iterator */ void *netfs_priv;/* Private data for the netfs */ unsigned int debug_id;atomic_t nr_outstanding;/* Number of ops in progress */
Signature · 1 line
Jeff Layton <[email protected]>
David Howells
maintainerRe: [PATCH v4 12/39] netfs: Add iov_iters to (sub)requests to describe various buffers
Quoted 9 lines · Jeff Layton
fs/netfs/buffered_read.c int netfs_write_begin(struct netfs_inode *ctx, · line 422
Quoted 7 lines
fs/netfs/buffered_read.c +3
-0@@ -408,6 +417,10 @@ int netfs_write_begin(struct netfs_inode *ctx, ractl._nr_pages =folio_nr_pages (folio);netfs_rreq_expand (rreq, &ractl); +/* Set up the output buffer */ +iov_iter_xarray (&rreq->iter,ITER_DEST , &mapping->i_pages, + rreq->start, rreq->len);Should the above be
ITER_SOURCE?
No - we're in ->write_begin() and are prefetching. If you look in the code, there's a netfs_begin_read() call a few lines below. The output buffer for the read is the page we're going to write into.
Note that netfs_write_begin() should be considered deprecated as the whole perform_write thing will get replaced.
Quoted 13 lines
fs/netfs/io.c static void netfs_read_from_server(struct netfs_io_request *rreq, · line 85
Quoted 9 lines
fs/netfs/io.c +5
-0@@ -88,6 +78,11 @@ static void netfs_read_from_server(struct netfs_io_request *rreq, struct netfs_io_subrequest *subreq) {netfs_stat (&netfs_n_rh_download); +if (iov_iter_count (&subreq->io_iter) != subreq->len - subreq->transferred) +pr_warn ("R=%08x[%u] ITER PRE-MISMATCH %zx != %zx-%zx %lx\n" , + rreq->debug_id, subreq->debug_index, +iov_iter_count (&subreq->io_iter), subreq->len, + subreq->transferred, subreq->flags);
pr_warnis a bit alarmist, esp given the cryptic message. Maybe demote this to INFO or DEBUG?
Quoted 2 lines
Does this indicate a bug in the client or that the server is sending us malformed frames?
Good question. The network filesystem updated subreq->transferred to indicate it had transferred X amount of data, but the iterator had been updated to indicate Y amount of data was transferred. They really ought to match as it may otherwise indicate an underrun (and potential leakage of old data). Overruns are less of a problem since the iterator would have to 'go negative' as it were.
However, it might be better just to leave io_iter unchecked since we end up resetting it anyway each time we reinvoke the ->issue_read() op. It's always possible that it will get copied and a different iterator get passed to the network layer or cache fs - and so the change to the iterator then has to be manually propagated just to avoid the warning.
David
David Howells
maintainerRe: [PATCH v4 12/39] netfs: Add iov_iters to (sub)requests to describe various buffers
Quoted 23 lines · David Howells
Quoted 13 lines
fs/netfs/io.c static void netfs_read_from_server(struct netfs_io_request *rreq, · line 85
Quoted 9 lines
fs/netfs/io.c +5
-0@@ -88,6 +78,11 @@ static void netfs_read_from_server(struct netfs_io_request *rreq, struct netfs_io_subrequest *subreq) {netfs_stat (&netfs_n_rh_download); +if (iov_iter_count (&subreq->io_iter) != subreq->len - subreq->transferred) +pr_warn ("R=%08x[%u] ITER PRE-MISMATCH %zx != %zx-%zx %lx\n" , + rreq->debug_id, subreq->debug_index, +iov_iter_count (&subreq->io_iter), subreq->len, + subreq->transferred, subreq->flags);
pr_warnis a bit alarmist, esp given the cryptic message. Maybe demote this to INFO or DEBUG?Quoted 2 lines
Does this indicate a bug in the client or that the server is sending us malformed frames?
Good question. The network filesystem updated
subreq->transferredto indicate it had transferred X amount of data, but the iterator had been updated to indicate Y amount of data was transferred. They really ought to match as it may otherwise indicate an underrun (and potential leakage of old data). Overruns are less of a problem since the iterator would have to 'go negative' as it were.
Quoted 5 lines
However, it might be better just to leave
io_iterunchecked since we end up resetting it anyway each time we reinvoke the ->issue_read() op. It's always possible that it will get copied and a different iterator get passed to the network layer or cache fs - and so the change to the iterator then has to be manually propagated just to avoid the warning.
Actually, it's more complicated than that. It's an assertion that netfslib is doing the right prep. This assertion is checked both when we initially make a request (in which case it definitely shouldn't fire) and when we perform a resubmission on partial/complete read failure when we need to carefully revalidate the numbers to make sure we don't end up with holes or wrinkles in the buffer.
Anyway, it shouldn't happen - but if it does, it probably presages data corruption.
David
David Howells
maintainerPATCH v4 13/39 netfs: Add support for DIO buffering
In reply to David HowellsAdd a bvec array pointer and an iterator to netfs_io_request for either holding a copy of a DIO iterator or a list of all the bits of buffer pointed to by a DIO iterator.
There are two problems: Firstly, if an iovec-class iov_iter is passed to ->read_iter() or ->write_iter(), this cannot be passed directly to kernel_sendmsg() or kernel_recvmsg() as that may cause locking recursion if a fault is generated, so we need to keep track of the pages involved separately.
Secondly, if the I/O is asynchronous, we must copy the iov_iter describing the buffer before returning to the caller as it may be immediately deallocated.
--- fs/netfs/objects.c | 10 ++++++++++ include/linux/netfs.h | 4 ++++ 2 files changed, 14 insertions(+)
fs/netfs/objects.c +10 -0
@@ -76,6 +76,7 @@ static void netfs_free_request(struct work_struct *work) {struct netfs_io_request *rreq = container_of(work, struct netfs_io_request, work); +unsigned int i;trace_netfs_rreq (rreq, netfs_rreq_trace_free);netfs_proc_del_rreq (rreq);
@@ -84,6 +85,15 @@ static void netfs_free_request(struct work_struct *work) rreq->netfs_ops->free_request (rreq);if (rreq->cache_resources.ops) rreq->cache_resources.ops->end_operation (&rreq->cache_resources); +if (rreq->direct_bv) { +for (i =0 ; i < rreq->direct_bv_count; i++) { +if (rreq->direct_bv[i].bv_page) { +if (rreq->direct_bv_unpin) +unpin_user_page (rreq->direct_bv[i].bv_page); + } + } +kvfree (rreq->direct_bv); + }kfree_rcu (rreq, rcu);netfs_stat_d (&netfs_n_rh_rreq); }
include/linux/netfs.h +4 -0
@@ -190,6 +190,9 @@ struct netfs_io_request {struct iov_iter iter;/* Unencrypted-side iterator */ struct iov_iter io_iter;/* I/O (Encrypted-side) iterator */ void *netfs_priv;/* Private data for the netfs */ + struct bio_vec *direct_bv /* DIO buffer list (when handling iovec-iter) */ +__counted_by (direct_bv_count ); +unsigned int direct_bv_count;/* Number of elements in direct_bv[] */ unsigned int debug_id;atomic_t nr_outstanding;/* Number of ops in progress */ atomic_t nr_copy_ops;/* Number of copy-to-cache ops in progress */
@@ -197,6 +200,7 @@ struct netfs_io_request {size_t len;/* Length of the request */ short error;/* 0 or error that occurred */ enum netfs_io_origin origin;/* Origin of the request */ +bool direct_bv_unpin;/* T if direct_bv[] must be unpinned */ loff_t i_size;/* Size of the file */ loff_t start;/* Start position */ pgoff_t no_unlock_folio;/* Don't unlock this folio after read */
David Howells
maintainerPATCH v4 14/39 netfs: Provide tools to create a buffer in an xarray
In reply to David HowellsProvide tools to create a buffer in an xarray, with a function to add new folios with a mark. This will be used to create bounce buffer and can be used more easily to create a list of folios the span of which would require more than a page's worth of bio_vec structs.
--- fs/netfs/internal.h | 13 +++++++ fs/netfs/misc.c | 81 +++++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 4 +++ 3 files changed, 98 insertions(+)
fs/netfs/internal.h +13 -0
@@ -56,6 +56,19 @@ static inline void netfs_proc_add_rreq(struct netfs_io_request *rreq) {}static inline void netfs_proc_del_rreq (struct netfs_io_request *rreq) {}#endif +/* +* misc.c +*/ +#define NETFS_FLAG_PUT_MARK BIT(0) +#define NETFS_FLAG_PAGECACHE_MARK BIT(1) +int netfs_xa_store_and_mark (struct xarray *xa,unsigned long index, +struct folio *folio,unsigned int flags, +gfp_t gfp_mask); +int netfs_add_folios_to_buffer (struct xarray *buffer, +struct address_space *mapping, +pgoff_t index,pgoff_t to,gfp_t gfp_mask); +void netfs_clear_buffer (struct xarray *buffer); +/* * objects.c */
fs/netfs/misc.c +81 -0
87 lines not on this page · raw message
include/linux/netfs.h +4 -0
@@ -109,6 +109,10 @@ static inline int wait_on_page_fscache_killable(struct page *page)return folio_wait_private_2_killable (page_folio (page)); } +/* Marks used on xarray-based buffers */ +#define NETFS_BUF_PUT_MARK XA_MARK_0/* - Page needs putting */ +#define NETFS_BUF_PAGECACHE_MARK XA_MARK_1/* - Page needs wb/dirty flag wrangling */ +enum netfs_io_source {NETFS_FILL_WITH_ZEROES ,NETFS_DOWNLOAD_FROM_SERVER ,
David Howells
maintainerPATCH v4 15/39 netfs: Add bounce buffering support
In reply to David HowellsAdd a second xarray struct to netfs_io_request for the purposes of holding a bounce buffer for when we have to deal with encrypted/compressed data or if we have to up/download data in blocks larger than we were asked for.
--- fs/netfs/io.c | 6 +++++- fs/netfs/objects.c | 3 +++ include/linux/netfs.h | 2 ++ 3 files changed, 10 insertions(+), 1 deletion(-)
fs/netfs/io.c +5 -1
@@ -643,7 +643,11 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync)return -EIO ; } - rreq->io_iter = rreq->iter; +if (test_bit (NETFS_RREQ_USE_BOUNCE_BUFFER , &rreq->flags)) +iov_iter_xarray (&rreq->io_iter,ITER_DEST , &rreq->bounce, + rreq->start, rreq->len); +else + rreq->io_iter = rreq->iter;INIT_WORK (&rreq->work, netfs_rreq_work);
fs/netfs/objects.c +3 -0
@@ -35,12 +35,14 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping, rreq->inode = inode; rreq->i_size =i_size_read (inode); rreq->debug_id =atomic_inc_return (&debug_ids); +xa_init (&rreq->bounce);INIT_LIST_HEAD (&rreq->subrequests);refcount_set (&rreq->ref,1 );__set_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags);if (rreq->netfs_ops->init_request) { ret = rreq->netfs_ops->init_request (rreq, file);if (ret <0 ) { +xa_destroy (&rreq->bounce);kfree (rreq);return ERR_PTR (ret); }
@@ -94,6 +96,7 @@ static void netfs_free_request(struct work_struct *work) }kvfree (rreq->direct_bv); } +netfs_clear_buffer (&rreq->bounce);kfree_rcu (rreq, rcu);netfs_stat_d (&netfs_n_rh_rreq); }
include/linux/netfs.h +2 -0
@@ -194,6 +194,7 @@ struct netfs_io_request {struct iov_iter iter;/* Unencrypted-side iterator */ struct iov_iter io_iter;/* I/O (Encrypted-side) iterator */ void *netfs_priv;/* Private data for the netfs */ +struct xarray bounce;/* Bounce buffer (eg. for crypto/compression) */ struct bio_vec *direct_bv /* DIO buffer list (when handling iovec-iter) */__counted_by (direct_bv_count );unsigned int direct_bv_count;/* Number of elements in direct_bv[] */
@@ -216,6 +217,7 @@ struct netfs_io_request {#define NETFS_RREQ_DONT_UNLOCK_FOLIOS 3/* Don't unlock the folios on completion */ #define NETFS_RREQ_FAILED 4/* The request failed */ #define NETFS_RREQ_IN_PROGRESS 5/* Unlocked when the request completes */ +#define NETFS_RREQ_USE_BOUNCE_BUFFER 6/* Use bounce buffer */ const struct netfs_request_ops *netfs_ops; };
David Howells
maintainerPATCH v4 16/39 netfs: Add func to calculate pagecount/size-limited span of an iterator
In reply to David HowellsAdd a function to work out how much of an ITER_BVEC or ITER_XARRAY iterator we can use in a pagecount-limited and size-limited span. This will be used, for example, to limit the number of segments in a subrequest to the maximum number of elements that an RDMA transfer can handle.
--- fs/netfs/iterator.c | 97 +++++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 2 + 2 files changed, 99 insertions(+)
fs/netfs/iterator.c +97 -0
@@ -101,3 +101,100 @@ ssize_t netfs_extract_user_iter(struct iov_iter *orig, size_t orig_len,return npages; }EXPORT_SYMBOL_GPL (netfs_extract_user_iter); + +/* +* Select the span of a bvec iterator we're going to use. Limit it by both maximum +* size and maximum number of segments. Returns the size of the span in bytes. +*/ +static size_t netfs_limit_bvec (const struct iov_iter *iter,size_t start_offset, +size_t max_size,size_t max_segs) +{ +const struct bio_vec *bvecs = iter->bvec; +unsigned int nbv = iter->nr_segs, ix =0 , nsegs =0 ; +size_t len, span =0 , n = iter->count; +size_t skip = iter->iov_offset + start_offset; + +if (WARN_ON (!iov_iter_is_bvec (iter)) || +WARN_ON (start_offset > n) || + n ==0 ) +return 0 ; + +while (n && ix < nbv && skip) { + len = bvecs[ix].bv_len; +if (skip < len) +break ; + skip -= len; + n -= len; + ix++; + } + +while (n && ix < nbv) { + len =min3 (n, bvecs[ix].bv_len - skip, max_size); + span += len; + nsegs++; + ix++; +if (span >= max_size || nsegs >= max_segs) +break ; + skip =0 ; + n -= len; + } + +return min (span, max_size); +} + +/* +* Select the span of an xarray iterator we're going to use. Limit it by both +* maximum size and maximum number of segments. It is assumed that segments +* can be larger than a page in size, provided they're physically contiguous. +* Returns the size of the span in bytes. +*/ +static size_t netfs_limit_xarray (const struct iov_iter *iter,size_t start_offset, +size_t max_size,size_t max_segs) +{ +struct folio *folio; +unsigned int nsegs =0 ; +loff_t pos = iter->xarray_start + iter->iov_offset; +pgoff_t index = pos /PAGE_SIZE ; +size_t span =0 , n = iter->count; + +XA_STATE (xas, iter->xarray, index); + +if (WARN_ON (!iov_iter_is_xarray (iter)) || +WARN_ON (start_offset > n) || + n ==0 ) +return 0 ; + max_size =min (max_size, n - start_offset); + +rcu_read_lock (); +xas_for_each (&xas, folio,ULONG_MAX ) { +size_t offset, flen, len; +if (xas_retry (&xas, folio)) +continue ; +if (WARN_ON (xa_is_value (folio))) +break ; +if (WARN_ON (folio_test_hugetlb (folio))) +break ; + + flen =folio_size (folio); + offset =offset_in_folio (folio, pos); + len =min (max_size, flen - offset); + span += len; + nsegs++; +if (span >= max_size || nsegs >= max_segs) +break ; + } + +rcu_read_unlock (); +return min (span, max_size); +} + +size_t netfs_limit_iter (const struct iov_iter *iter,size_t start_offset, +size_t max_size,size_t max_segs) +{ +if (iov_iter_is_bvec (iter)) +return netfs_limit_bvec (iter, start_offset, max_size, max_segs); +if (iov_iter_is_xarray (iter)) +return netfs_limit_xarray (iter, start_offset, max_size, max_segs); +BUG (); +} +EXPORT_SYMBOL (netfs_limit_iter);
include/linux/netfs.h +2 -0
@@ -324,6 +324,8 @@ void netfs_put_subrequest(struct netfs_io_subrequest *subreq,ssize_t netfs_extract_user_iter (struct iov_iter *orig,size_t orig_len,struct iov_iter *new,iov_iter_extraction_t extraction_flags); +size_t netfs_limit_iter (const struct iov_iter *iter,size_t start_offset, +size_t max_size,size_t max_segs);int netfs_start_io_read (struct inode *inode);void netfs_end_io_read (struct inode *inode);
David Howells
maintainerPATCH v4 17/39 netfs: Limit subrequest by size or number of segments
In reply to David HowellsLimit a subrequest to a maximum size and/or a maximum number of contiguous physical regions. This permits, for instance, an subreq's iterator to be limited to the number of DMA'able segments that a large RDMA request can handle.
--- fs/netfs/io.c | 18 ++++++++++++++++++ include/linux/netfs.h | 1 + include/trace/events/netfs.h | 1 + 3 files changed, 20 insertions(+)
fs/netfs/io.c +18 -0
@@ -525,6 +525,7 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq, struct iov_iter *io_iter) {enum netfs_io_source source; +size_t lsize;_enter ("%llx-%llx,%llx" , subreq->start, subreq->start + subreq->len, rreq->i_size);
@@ -547,13 +548,30 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq, source =NETFS_INVALID_READ ; goto out; } + +if (subreq->max_nr_segs) { + lsize =netfs_limit_iter (io_iter,0 , subreq->len, + subreq->max_nr_segs); +if (subreq->len > lsize) { + subreq->len = lsize; +trace_netfs_sreq (subreq, netfs_sreq_trace_limited); + } + } } +if (subreq->len > rreq->len) +pr_warn ("R=%08x[%u] SREQ>RREQ %zx > %zx\n" , + rreq->debug_id, subreq->debug_index, + subreq->len, rreq->len); +if (WARN_ON (subreq->len ==0 )) { source =NETFS_INVALID_READ ; goto out; } + subreq->source = source; +trace_netfs_sreq (subreq, netfs_sreq_trace_prepare); + subreq->io_iter = *io_iter;iov_iter_truncate (&subreq->io_iter, subreq->len);iov_iter_advance (io_iter, subreq->len);
include/linux/netfs.h +1 -0
@@ -161,6 +161,7 @@ struct netfs_io_subrequest {refcount_t ref;short error;/* 0 or error that occurred */ unsigned short debug_index;/* Index in list (for debugging output) */ +unsigned int max_nr_segs;/* 0 or max number of segments in an iterator */ enum netfs_io_source source;/* Where to read from/write to */ unsigned long flags;#define NETFS_SREQ_COPY_TO_CACHE 0/* Set if should copy the data to the cache */
include/trace/events/netfs.h +1 -0
@@ -44,6 +44,7 @@#define netfs_sreq_traces \ EM(netfs_sreq_trace_download_instead, "RDOWN") \ EM(netfs_sreq_trace_free, "FREE ") \ + EM(netfs_sreq_trace_limited, "LIMIT") \ EM(netfs_sreq_trace_prepare, "PREP ") \ EM(netfs_sreq_trace_resubmit_short, "SHORT") \ EM(netfs_sreq_trace_submit, "SUBMT") \
David Howells
maintainerPATCH v4 18/39 netfs: Export netfs_put_subrequest() and some tracepoints
In reply to David HowellsExport netfs_put_subrequest() and the netfs_rreq and netfs_sreq tracepoints.
--- fs/netfs/main.c | 3 +++ fs/netfs/objects.c | 1 + 2 files changed, 4 insertions(+)
fs/netfs/main.c +3 -0
@@ -17,6 +17,9 @@ MODULE_DESCRIPTION("Network fs support");MODULE_AUTHOR ("Red Hat, Inc." );MODULE_LICENSE ("GPL" ); +EXPORT_TRACEPOINT_SYMBOL (netfs_rreq); +EXPORT_TRACEPOINT_SYMBOL (netfs_sreq); +unsigned netfs_debug;module_param_named (debug, netfs_debug, uint,S_IWUSR |S_IRUGO );MODULE_PARM_DESC (netfs_debug,"Netfs support debugging mask" );
fs/netfs/objects.c +1 -0
@@ -178,3 +178,4 @@ void netfs_put_subrequest(struct netfs_io_subrequest *subreq, bool was_async,if (dead)netfs_free_subrequest (subreq, was_async); } +EXPORT_SYMBOL (netfs_put_subrequest);
Jeff Layton
maintainerRe: [PATCH v4 18/39] netfs: Export netfs_put_subrequest() and some tracepoints
Quoted 3 lines · David Howells
Export
netfs_put_subrequest()and thenetfs_rreqandnetfs_sreqtracepoints.
Erm...why? Are these called directly from module code in a later patch? Some rationale for this would be a nice thing.
Quoted 34 lines
Signed-off-by David Howells <[email protected]>cc Jeff Layton <[email protected]>--- fs/netfs/main.c | 3 +++ fs/netfs/objects.c | 1 + 2 files changed, 4 insertions(+)fs/netfs/main.c +3
-0@@ -17,6 +17,9 @@ MODULE_DESCRIPTION("Network fs support");MODULE_AUTHOR ("Red Hat, Inc." );MODULE_LICENSE ("GPL" ); +EXPORT_TRACEPOINT_SYMBOL (netfs_rreq); +EXPORT_TRACEPOINT_SYMBOL (netfs_sreq); +unsigned netfs_debug;module_param_named (debug, netfs_debug, uint,S_IWUSR |S_IRUGO );MODULE_PARM_DESC (netfs_debug,"Netfs support debugging mask" );fs/netfs/objects.c +1
-0@@ -178,3 +178,4 @@ void netfs_put_subrequest(struct netfs_io_subrequest *subreq, bool was_async,if (dead)netfs_free_subrequest (subreq, was_async); } +EXPORT_SYMBOL (netfs_put_subrequest);
Signature · 1 line
Jeff Layton <[email protected]>
David Howells
maintainerRe: [PATCH v4 18/39] netfs: Export netfs_put_subrequest() and some tracepoints
Quoted 1 line · Jeff Layton
Erm...why? Are these called directly from module code in a later patch?
Yes. I'll expand the commit message.
David
David Howells
maintainerRe: [PATCH v4 18/39] netfs: Export netfs_put_subrequest() and some tracepoints
Quoted 5 lines · David Howells
Quoted 1 line · Jeff Layton
Erm...why? Are these called directly from module code in a later patch?
Yes. I'll expand the commit message.
That said, only trace_netfs_sreq() is required. The other two can be dropped.
David
David Howells
maintainerPATCH v4 19/39 netfs: Extend the netfs_io_*request structs to handle writes
In reply to David HowellsModify the netfs_io_request struct to act as a point around which writes can be coordinated. It represents and pins a range of pages that need writing and a list of regions of dirty data in that range of pages.
If RMW is required, the original data can be downloaded into the bounce buffer, decrypted if necessary, the modifications made, then the modified data can be reencrypted/recompressed and sent back to the server.
--- fs/netfs/internal.h | 6 ++++++ fs/netfs/main.c | 3 ++- fs/netfs/objects.c | 6 ++++++ fs/netfs/stats.c | 16 +++++++++++++--- include/linux/netfs.h | 15 ++++++++++++++- include/trace/events/netfs.h | 8 ++++++-- 6 files changed, 47 insertions(+), 7 deletions(-)
fs/netfs/internal.h +6 -0
@@ -110,6 +110,12 @@ extern atomic_t netfs_n_rh_write_begin;extern atomic_t netfs_n_rh_write_done;extern atomic_t netfs_n_rh_write_failed;extern atomic_t netfs_n_rh_write_zskip; +extern atomic_t netfs_n_wh_upload; +extern atomic_t netfs_n_wh_upload_done; +extern atomic_t netfs_n_wh_upload_failed; +extern atomic_t netfs_n_wh_write; +extern atomic_t netfs_n_wh_write_done; +extern atomic_t netfs_n_wh_write_failed;int netfs_stats_show (struct seq_file *m,void *v);
fs/netfs/main.c +2 -1
@@ -28,10 +28,11 @@ MODULE_PARM_DESC(netfs_debug, "Netfs support debugging mask");LIST_HEAD (netfs_io_requests);DEFINE_SPINLOCK (netfs_proc_lock); -static const char *netfs_origins[] = { +static const char *netfs_origins[nr__netfs_io_origin] = { [NETFS_READAHEAD ] ="RA" , [NETFS_READPAGE ] ="RP" , [NETFS_READ_FOR_WRITE ] ="RW" , + [NETFS_WRITEBACK ] ="WB" , };/*
fs/netfs/objects.c +6 -0
@@ -20,6 +20,7 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,struct inode *inode = file ?file_inode (file) : mapping->host;struct netfs_inode *ctx =netfs_inode (inode);struct netfs_io_request *rreq; +bool cached =netfs_is_cache_enabled (ctx);int ret; rreq = kzalloc(ctx->ops->io_request_size ?: sizeof(struct netfs_io_request),
@@ -38,7 +39,10 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,xa_init (&rreq->bounce);INIT_LIST_HEAD (&rreq->subrequests);refcount_set (&rreq->ref,1 ); +__set_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags); +if (cached) +__set_bit (NETFS_RREQ_WRITE_TO_CACHE , &rreq->flags);if (rreq->netfs_ops->init_request) { ret = rreq->netfs_ops->init_request (rreq, file);if (ret <0 ) {
@@ -48,6 +52,7 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping, } } +trace_netfs_rreq_ref (rreq->debug_id,1 , netfs_rreq_trace_new);netfs_proc_add_rreq (rreq);netfs_stat (&netfs_n_rh_rreq);return rreq;
@@ -132,6 +137,7 @@ struct netfs_io_subrequest *netfs_alloc_subrequest(struct netfs_io_request *rreqsizeof (struct netfs_io_subrequest ), GFP_KERNEL);if (subreq) { +INIT_WORK (&subreq->work,NULL );INIT_LIST_HEAD (&subreq->rreq_link);refcount_set (&subreq->ref,2 ); subreq->rreq = rreq;
fs/netfs/stats.c +13 -3
@@ -27,6 +27,12 @@ atomic_t netfs_n_rh_write_begin;atomic_t netfs_n_rh_write_done;atomic_t netfs_n_rh_write_failed;atomic_t netfs_n_rh_write_zskip; +atomic_t netfs_n_wh_upload; +atomic_t netfs_n_wh_upload_done; +atomic_t netfs_n_wh_upload_failed; +atomic_t netfs_n_wh_write; +atomic_t netfs_n_wh_write_done; +atomic_t netfs_n_wh_write_failed;int netfs_stats_show (struct seq_file *m,void *v) {
@@ -50,10 +56,14 @@ int netfs_stats_show(struct seq_file *m, void *v)atomic_read (&netfs_n_rh_read),atomic_read (&netfs_n_rh_read_done), atomic_read(&netfs_n_rh_read_failed)); +seq_printf (m,"Netfs : UL=%u us=%u uf=%u\n" , +atomic_read (&netfs_n_wh_upload), +atomic_read (&netfs_n_wh_upload_done), +atomic_read (&netfs_n_wh_upload_failed));seq_printf (m,"Netfs : WR=%u ws=%u wf=%u\n" , -atomic_read (&netfs_n_rh_write), -atomic_read (&netfs_n_rh_write_done), -atomic_read (&netfs_n_rh_write_failed)); +atomic_read (&netfs_n_wh_write), +atomic_read (&netfs_n_wh_write_done), +atomic_read (&netfs_n_wh_write_failed));return fscache_stats_show (m); }EXPORT_SYMBOL (netfs_stats_show);
include/linux/netfs.h +14 -1
@@ -118,6 +118,9 @@ enum netfs_io_source {NETFS_DOWNLOAD_FROM_SERVER ,NETFS_READ_FROM_CACHE ,NETFS_INVALID_READ , +NETFS_UPLOAD_TO_SERVER , +NETFS_WRITE_TO_CACHE , +NETFS_INVALID_WRITE , } __mode(byte); typedef void (*netfs_io_terminated_t)(void *priv, ssize_t transferred_or_error,
@@ -149,9 +152,14 @@ struct netfs_cache_resources { };/* -* Descriptor for a single component subrequest. +* Descriptor for a single component subrequest. Each operation represents an +* individual read/write from/to a server, a cache, a journal, etc.. +* +* The buffer iterator is persistent for the life of the subrequest struct and +* the pages it points to can be relied on to exist for the duration. */ struct netfs_io_subrequest { +struct work_struct work;struct netfs_io_request *rreq;/* Supervising I/O request */ struct list_head rreq_link;/* Link in rreq->subrequests */ struct iov_iter io_iter;/* Iterator for this subrequest */
@@ -176,6 +184,8 @@ enum netfs_io_origin {NETFS_READAHEAD ,/* This read was triggered by readahead */ NETFS_READPAGE ,/* This read is a synchronous read */ NETFS_READ_FOR_WRITE ,/* This read is to prepare a write */ +NETFS_WRITEBACK ,/* This write was triggered by writepages */ + nr__netfs_io_origin }__mode (byte);/*
@@ -200,6 +210,7 @@ struct netfs_io_request {__counted_by (direct_bv_count);unsigned int direct_bv_count;/* Number of elements in direct_bv[] */ unsigned int debug_id; +unsigned int subreq_counter;/* Next subreq->debug_index */ atomic_t nr_outstanding;/* Number of ops in progress */ atomic_t nr_copy_ops;/* Number of copy-to-cache ops in progress */ size_t submitted;/* Amount submitted for I/O so far */
@@ -219,6 +230,8 @@ struct netfs_io_request {#define NETFS_RREQ_FAILED 4/* The request failed */ #define NETFS_RREQ_IN_PROGRESS 5/* Unlocked when the request completes */ #define NETFS_RREQ_USE_BOUNCE_BUFFER 6/* Use bounce buffer */ +#define NETFS_RREQ_WRITE_TO_CACHE 7/* Need to write to the cache */ +#define NETFS_RREQ_UPLOAD_TO_SERVER 8/* Need to write to the server */ const struct netfs_request_ops *netfs_ops; };
include/trace/events/netfs.h +6 -2
@@ -24,7 +24,8 @@#define netfs_rreq_origins \ EM(NETFS_READAHEAD, "RA") \ EM(NETFS_READPAGE, "RP") \ - E_(NETFS_READ_FOR_WRITE, "RW") + EM(NETFS_READ_FOR_WRITE, "RW") \ + E_(NETFS_WRITEBACK, "WB")#define netfs_rreq_traces \ EM(netfs_rreq_trace_assess, "ASSESS ") \
@@ -39,7 +40,10 @@ EM(NETFS_FILL_WITH_ZEROES, "ZERO") \ EM(NETFS_DOWNLOAD_FROM_SERVER, "DOWN") \ EM(NETFS_READ_FROM_CACHE, "READ") \ - E_(NETFS_INVALID_READ, "INVL") \ + EM(NETFS_INVALID_READ, "INVL") \ + EM(NETFS_UPLOAD_TO_SERVER, "UPLD") \ + EM(NETFS_WRITE_TO_CACHE, "WRIT") \ + E_(NETFS_INVALID_WRITE, "INVL")#define netfs_sreq_traces \ EM(netfs_sreq_trace_download_instead, "RDOWN") \
David Howells
maintainerPATCH v4 20/39 netfs: Add a hook to allow tell the netfs to update its i_size
In reply to David HowellsAdd a hook for netfslib's write helpers to call to tell the network filesystem that it should update its i_size.
--- include/linux/netfs.h | 4 ++++ 1 file changed, 4 insertions(+)
include/linux/netfs.h +4 -0
@@ -245,6 +245,7 @@ struct netfs_request_ops {void (*free_request)(struct netfs_io_request *rreq);void (*free_subrequest)(struct netfs_io_subrequest *rreq); +/* Read request handling */ void (*expand_readahead)(struct netfs_io_request *rreq);bool (*clamp_length)(struct netfs_io_subrequest *subreq);void (*issue_read)(struct netfs_io_subrequest *subreq);
@@ -252,6 +253,9 @@ struct netfs_request_ops {int (*check_write_begin)(struct file *file,loff_t pos,unsigned len,struct folio **foliop,void **_fsdata);void (*done)(struct netfs_io_request *rreq); + +/* Modification handling */ +void (*update_i_size)(struct inode *inode,loff_t i_size); };/*
David Howells
maintainerPATCH v4 21/39 netfs: Make netfs_put_request() handle a NULL pointer
In reply to David HowellsMake netfs_put_request() just return if given a NULL request pointer.
--- fs/netfs/objects.c | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-)
fs/netfs/objects.c +13 -10
@@ -109,19 +109,22 @@ static void netfs_free_request(struct work_struct *work)void netfs_put_request (struct netfs_io_request *rreq,bool was_async,enum netfs_rreq_ref_trace what) { -unsigned int debug_id = rreq->debug_id; +unsigned int debug_id;bool dead;int r; - dead =__refcount_dec_and_test (&rreq->ref, &r); -trace_netfs_rreq_ref (debug_id, r -1 , what); -if (dead) { -if (was_async) { - rreq->work.func = netfs_free_request; -if (!queue_work (system_unbound_wq, &rreq->work)) -BUG (); - }else { -netfs_free_request (&rreq->work); +if (rreq) { + debug_id = rreq->debug_id; + dead =__refcount_dec_and_test (&rreq->ref, &r); +trace_netfs_rreq_ref (debug_id, r -1 , what); +if (dead) { +if (was_async) { + rreq->work.func = netfs_free_request; +if (!queue_work (system_unbound_wq, &rreq->work)) +BUG (); + }else { +netfs_free_request (&rreq->work); + } } } }
David Howells
maintainerPATCH v4 22/39 netfs: Make the refcounting of netfs_begin_read() easier to use
In reply to David HowellsMake the refcounting of netfs_begin_read() easier to use by not eating the caller's ref on the netfs_io_request it's given. This makes it easier to use when we need to look in the request struct after.
--- fs/netfs/buffered_read.c | 6 +++++- fs/netfs/io.c | 28 +++++++++++++--------------- include/trace/events/netfs.h | 9 +++++---- 3 files changed, 23 insertions(+), 20 deletions(-)
fs/netfs/buffered_read.c +5 -1
@@ -210,6 +210,7 @@ void netfs_readahead(struct readahead_control *ractl) ;netfs_begin_read (rreq, false); +netfs_put_request (rreq, false, netfs_rreq_trace_put_return);return ; cleanup_free:
@@ -260,7 +261,9 @@ int netfs_read_folio(struct file *file, struct folio *folio)iov_iter_xarray (&rreq->iter,ITER_DEST , &mapping->i_pages, rreq->start, rreq->len); -return netfs_begin_read (rreq, true); + ret =netfs_begin_read (rreq, true); +netfs_put_request (rreq, false, netfs_rreq_trace_put_return); +return ret; discard:netfs_put_request (rreq, false, netfs_rreq_trace_put_discard);
@@ -429,6 +432,7 @@ int netfs_write_begin(struct netfs_inode *ctx, ret =netfs_begin_read (rreq, true);if (ret <0 ) goto error; +netfs_put_request (rreq, false, netfs_rreq_trace_put_return); have_folio: ret =folio_wait_fscache_killable (folio);
fs/netfs/io.c +13 -15
@@ -362,6 +362,7 @@ static void netfs_rreq_assess(struct netfs_io_request *rreq, bool was_async)netfs_rreq_unlock_folios (rreq); +trace_netfs_rreq (rreq, netfs_rreq_trace_wake_ip);clear_bit_unlock (NETFS_RREQ_IN_PROGRESS , &rreq->flags);wake_up_bit (&rreq->flags,NETFS_RREQ_IN_PROGRESS );
@@ -657,7 +658,6 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync)if (rreq->len ==0 ) {pr_err ("Zero-sized read [R=%x]\n" , rreq->debug_id); -netfs_put_request (rreq, false, netfs_rreq_trace_put_zero_len);return -EIO ; }
@@ -669,12 +669,10 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync)INIT_WORK (&rreq->work, netfs_rreq_work); -if (sync) -netfs_get_request (rreq, netfs_rreq_trace_get_hold); -/* Chop the read into slices according to what the cache and the netfs * want and submit each one. */ +netfs_get_request (rreq, netfs_rreq_trace_get_for_outstanding);atomic_set (&rreq->nr_outstanding,1 ); io_iter = rreq->io_iter; do {
@@ -684,25 +682,25 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync) }while (rreq->submitted < rreq->len);if (sync) { -/* Keep nr_outstanding incremented so that the ref always belongs to -* us, and the service code isn't punted off to a random thread pool to -* process. +/* Keep nr_outstanding incremented so that the ref always +* belongs to us, and the service code isn't punted off to a +* random thread pool to process. Note that this might start +* further work, such as writing to the cache. */ -for (;;) { -wait_var_event (&rreq->nr_outstanding, -atomic_read (&rreq->nr_outstanding) ==1 ); +wait_var_event (&rreq->nr_outstanding, +atomic_read (&rreq->nr_outstanding) ==1 ); +if (atomic_dec_and_test (&rreq->nr_outstanding))netfs_rreq_assess (rreq, false); -if (!test_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags)) -break ; -cond_resched (); - } + +trace_netfs_rreq (rreq, netfs_rreq_trace_wait_ip); +wait_on_bit (&rreq->flags,NETFS_RREQ_IN_PROGRESS , +TASK_UNINTERRUPTIBLE ); ret = rreq->error;if (ret ==0 && rreq->submitted < rreq->len) {trace_netfs_failure (rreq,NULL , ret, netfs_fail_short_read); ret = -EIO ; } -netfs_put_request (rreq, false, netfs_rreq_trace_put_hold); }else {/* If we decrement nr_outstanding to 0, the ref belongs to us. */ if (atomic_dec_and_test (&rreq->nr_outstanding))
include/trace/events/netfs.h +5 -4
@@ -34,7 +34,9 @@ EM(netfs_rreq_trace_free, "FREE ") \ EM(netfs_rreq_trace_resubmit, "RESUBMT") \ EM(netfs_rreq_trace_unlock, "UNLOCK ") \ - E_(netfs_rreq_trace_unmark, "UNMARK ") + EM(netfs_rreq_trace_unmark, "UNMARK ") \ + EM(netfs_rreq_trace_wait_ip, "WAIT-IP") \ + E_(netfs_rreq_trace_wake_ip, "WAKE-IP")#define netfs_sreq_sources \ EM(NETFS_FILL_WITH_ZEROES, "ZERO") \
@@ -65,14 +67,13 @@ E_(netfs_fail_prepare_write, "prep-write")#define netfs_rreq_ref_traces \ - EM(netfs_rreq_trace_get_hold, "GET HOLD ") \ + EM(netfs_rreq_trace_get_for_outstanding,"GET OUTSTND") \ EM(netfs_rreq_trace_get_subreq, "GET SUBREQ ") \ EM(netfs_rreq_trace_put_complete, "PUT COMPLT ") \ EM(netfs_rreq_trace_put_discard, "PUT DISCARD") \ EM(netfs_rreq_trace_put_failed, "PUT FAILED ") \ - EM(netfs_rreq_trace_put_hold, "PUT HOLD ") \ + EM(netfs_rreq_trace_put_return, "PUT RETURN ") \ EM(netfs_rreq_trace_put_subreq, "PUT SUBREQ ") \ - EM(netfs_rreq_trace_put_zero_len, "PUT ZEROLEN") \ E_(netfs_rreq_trace_new, "NEW ")#define netfs_sreq_ref_traces \
David Howells
maintainerPATCH v4 23/39 netfs: Prep to use folio->private for write grouping and streaming write
In reply to David HowellsPrepare to use folio->private to hold information write grouping and streaming write. These are implemented in the same commit as they both make use of folio->private and will be both checked at the same time in several places.
"Write grouping" involves ordering the writeback of groups of writes, such as is needed for ceph snaps. A group is represented by a filesystem-supplied object which must contain a netfs_group struct. This contains just a refcount and a pointer to a destructor.
"Streaming write" is the storage of data in folios that are marked dirty, but not uptodate, to avoid unnecessary reads of data. This is represented by a netfs_folio struct. This contains the offset and length of the modified region plus the otherwise displaced write grouping pointer.
The way folio->private is multiplexed is:
(1) If private is NULL then neither is in operation on a dirty folio.
(2) If private is set, with bit 0 clear, then this points to a group.
(3) If private is set, with bit 0 set, then this points to a netfs_folio struct (with bit 0 AND'ed out).
--- fs/netfs/internal.h | 28 ++++++++++++++++++++++++++ fs/netfs/misc.c | 46 +++++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 41 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 115 insertions(+)
fs/netfs/internal.h +28 -0
@@ -149,6 +149,34 @@ static inline bool netfs_is_cache_enabled(struct netfs_inode *ctx)#endif } +/* +* Get a ref on a netfs group attached to a dirty page (e.g. a ceph snap). +*/ +static inline struct netfs_group *netfs_get_group (struct netfs_group *netfs_group) +{ +if (netfs_group) +refcount_inc (&netfs_group->ref); +return netfs_group; +} + +/* +* Dispose of a netfs group attached to a dirty page (e.g. a ceph snap). +*/ +static inline void netfs_put_group (struct netfs_group *netfs_group) +{ +if (netfs_group &&refcount_dec_and_test (&netfs_group->ref)) + netfs_group->free (netfs_group); +} + +/* +* Dispose of a netfs group attached to a dirty page (e.g. a ceph snap). +*/ +static inline void netfs_put_group_many (struct netfs_group *netfs_group,int nr) +{ +if (netfs_group &&refcount_sub_and_test (nr, &netfs_group->ref)) + netfs_group->free (netfs_group); +} +/* * fscache-cache.c */
fs/netfs/misc.c +46 -0
55 lines not on this page · raw message
include/linux/netfs.h +41 -0
47 lines not on this page · raw message
David Howells
maintainerPATCH v4 24/39 netfs: Dispatch write requests to process a writeback slice
In reply to David HowellsDispatch one or more write reqeusts to process a writeback slice, where a slice is tailored more to logical block divisions within the file (such as crypto blocks, an object layout or cache granules) than the protocol RPC maximum capacity.
The dispatch doesn't happen until throttling allows, at which point the entire writeback slice is processed and queued. A slice may be written to multiple destinations (one or more servers and the local cache) and the writes to each destination might be split up along different lines.
The writeback slice holds the required folios pinned. An iov_iter is provided in netfs_write_request that describes the buffer to be used. This may be part of the pagecache, may have auxiliary padding pages attached or may be a bounce buffer resulting from crypto or compression. Consequently, the filesystem must not twiddle the folio markings directly.
The following API is available to the filesystem:
(1) The ->create_write_requests() method is called to ask the filesystem to create the requests it needs. This is passed the writeback slice to be processed.
(2) The filesystem should then call netfs_create_write_request() to create the requests it needs.
(3) Once a request is initialised, netfs_queue_write_request() can be called to dispatch it asynchronously, if not completed immediately.
(4) netfs_write_request_completed() should be called to note the completion of a request.
(5) netfs_get_write_request() and netfs_put_write_request() are provided to refcount a request. These take constants from the netfs_wreq_trace enum for logging into ftrace.
(6) The ->free_write_request is method is called to ask the filesystem to clean up a request.
--- fs/netfs/Makefile | 3 +- fs/netfs/internal.h | 6 + fs/netfs/output.c | 363 +++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 13 ++ include/trace/events/netfs.h | 50 ++++- 5 files changed, 432 insertions(+), 3 deletions(-) create mode 100644 fs/netfs/output.c
fs/netfs/Makefile +2 -1
@@ -7,7 +7,8 @@ netfs-y := \ locking.o \ main.o \ misc.o \ - objects.o + objects.o \ + output.o netfs-$(CONFIG_NETFS_STATS) += stats.o
fs/netfs/internal.h +6 -0
@@ -88,6 +88,12 @@ static inline void netfs_see_request(struct netfs_io_request *rreq,trace_netfs_rreq_ref (rreq->debug_id,refcount_read (&rreq->ref), what); } +/* +* output.c +*/ +int netfs_begin_write (struct netfs_io_request *wreq,bool may_wait, +enum netfs_write_trace what); +/* * stats.c */
fs/netfs/output.c new file +363 -0
363 lines not on this page · raw message
include/linux/netfs.h +13 -0
@@ -251,6 +251,7 @@ struct netfs_io_request {__counted_by (direct_bv_count);unsigned int direct_bv_count;/* Number of elements in direct_bv[] */ unsigned int debug_id; +unsigned int wsize;/* Maximum write size (0 for none) */ unsigned int subreq_counter;/* Next subreq->debug_index */ atomic_t nr_outstanding;/* Number of ops in progress */ atomic_t nr_copy_ops;/* Number of copy-to-cache ops in progress */
@@ -274,6 +275,7 @@ struct netfs_io_request {#define NETFS_RREQ_WRITE_TO_CACHE 7/* Need to write to the cache */ #define NETFS_RREQ_UPLOAD_TO_SERVER 8/* Need to write to the server */ const struct netfs_request_ops *netfs_ops; +void (*cleanup)(struct netfs_io_request *req); };/*
@@ -297,6 +299,11 @@ struct netfs_request_ops {/* Modification handling */ void (*update_i_size)(struct inode *inode,loff_t i_size); + +/* Write request handling */ +void (*create_write_requests)(struct netfs_io_request *wreq, +loff_t start,size_t len); +void (*invalidate_cache)(struct netfs_io_request *wreq); };/*
@@ -385,6 +392,12 @@ ssize_t netfs_extract_user_iter(struct iov_iter *orig, size_t orig_len, iov_iter_extraction_t extraction_flags);size_t netfs_limit_iter (const struct iov_iter *iter,size_t start_offset,size_t max_size,size_t max_segs); +struct netfs_io_subrequest *netfs_create_write_request ( +struct netfs_io_request *wreq,enum netfs_io_source dest, +loff_t start,size_t len,work_func_t worker); +void netfs_write_subrequest_terminated (void *_op,ssize_t transferred_or_error, +bool was_async); +void netfs_queue_write_request (struct netfs_io_subrequest *subreq);int netfs_start_io_read (struct inode *inode);void netfs_end_io_read (struct inode *inode);
include/trace/events/netfs.h +48 -2
105 lines not on this page · raw message
David Howells
maintainerPATCH v4 25/39 netfs: Provide func to copy data to pagecache for buffered write
In reply to David HowellsProvide a netfs write helper, netfs_perform_write() to buffer data to be written in the pagecache and mark the modified folios dirty.
It will perform "streaming writes" for folios that aren't currently resident, if possible, storing data in partially modified folios that are marked dirty, but not uptodate. It will also tag pages as belonging to fs-specific write groups if so directed by the filesystem.
This is derived from generic_perform_write(), but doesn't use ->write_begin() and ->write_end(), having that logic rolled in instead.
--- fs/netfs/Makefile | 1 + fs/netfs/buffered_read.c | 49 ++++++ fs/netfs/buffered_write.c | 330 +++++++++++++++++++++++++++++++++++ fs/netfs/internal.h | 2 + fs/netfs/io.c | 1 + include/linux/netfs.h | 5 + include/trace/events/netfs.h | 73 ++++++++ 7 files changed, 461 insertions(+) create mode 100644 fs/netfs/buffered_write.c
fs/netfs/Makefile +1 -0
@@ -2,6 +2,7 @@ netfs-y := \ buffered_read.o \ + buffered_write.o \ io.o \ iterator.o \ locking.o \
fs/netfs/buffered_read.c +49 -0
58 lines not on this page · raw message
fs/netfs/buffered_write.c new file +330 -0
330 lines not on this page · raw message
fs/netfs/internal.h +2 -0
@@ -23,6 +23,8 @@* buffered_read.c */ void netfs_rreq_unlock_folios (struct netfs_io_request *rreq); +int netfs_prefetch_for_write (struct file *file,struct folio *folio, +size_t offset,size_t len);/* * io.c
fs/netfs/io.c +1 -0
@@ -125,6 +125,7 @@ static void netfs_rreq_unmark_after_write(struct netfs_io_request *rreq,if (have_unlocked &&folio_index (folio) <= unlocked)continue ; unlocked =folio_index (folio); +trace_netfs_folio (folio, netfs_folio_trace_end_copy);folio_end_fscache (folio); have_unlocked = true; }
include/linux/netfs.h +5 -0
@@ -370,6 +370,11 @@ struct netfs_cache_ops { loff_t *_data_start, size_t *_data_len); }; +/* High-level write API */ +ssize_t netfs_perform_write (struct kiocb *iocb,struct iov_iter *iter, +struct netfs_group *netfs_group); + +/* Address operations API */ struct readahead_control ;void netfs_readahead (struct readahead_control *);int netfs_read_folio (struct file *,struct folio *);
include/trace/events/netfs.h +73 -0
103 lines not on this page · raw message
David Howells
maintainerPATCH v4 26/39 netfs: Make netfs_read_folio() handle streaming-write pages
In reply to David Howellsnetfs_read_folio() needs to handle partially-valid pages that are marked dirty, but not uptodate in the event that someone tries to read a page was used to cache data by a streaming write.
In such a case, make netfs_read_folio() set up a bvec iterator that points to the parts of the folio that need filling and to a sink page for the data that should be discarded and use that instead of i_pages as the iterator to be written to.
This requires netfs_rreq_unlock_folios() to convert the page into a normal dirty uptodate page, getting rid of the partial write record and bumping the group pointer over to folio->private.
--- fs/netfs/buffered_read.c | 61 ++++++++++++++++++++++++++++++++++-- include/trace/events/netfs.h | 2 ++ 2 files changed, 60 insertions(+), 3 deletions(-)
fs/netfs/buffered_read.c +58 -3
@@ -16,6 +16,7 @@void netfs_rreq_unlock_folios (struct netfs_io_request *rreq) {struct netfs_io_subrequest *subreq; +struct netfs_folio *finfo;struct folio *folio;pgoff_t start_page = rreq->start /PAGE_SIZE ;pgoff_t last_page = ((rreq->start + rreq->len) /PAGE_SIZE ) -1 ;
@@ -87,6 +88,15 @@ void netfs_rreq_unlock_folios(struct netfs_io_request *rreq)if (!pg_failed) {flush_dcache_folio (folio); + finfo =netfs_folio_info (folio); +if (finfo) { +trace_netfs_folio (folio, netfs_folio_trace_filled_gaps); +if (finfo->netfs_group) +folio_change_private (folio, finfo->netfs_group); +else +folio_detach_private (folio); +kfree (finfo); + }folio_mark_uptodate (folio); }
@@ -239,6 +249,7 @@ int netfs_read_folio(struct file *file, struct folio *folio)struct address_space *mapping =folio_file_mapping (folio);struct netfs_io_request *rreq;struct netfs_inode *ctx =netfs_inode (mapping->host); +struct folio *sink =NULL ;int ret;_enter ("%lx" ,folio_index (folio));
@@ -259,12 +270,56 @@ int netfs_read_folio(struct file *file, struct folio *folio)trace_netfs_read (rreq, rreq->start, rreq->len, netfs_read_trace_readpage);/* Set up the output buffer */ -iov_iter_xarray (&rreq->iter,ITER_DEST , &mapping->i_pages, - rreq->start, rreq->len); +if (folio_test_dirty (folio)) { +/* Handle someone trying to read from an unflushed streaming +* write. We fiddle the buffer so that a gap at the beginning +* and/or a gap at the end get copied to, but the middle is +* discarded. +*/ +struct netfs_folio *finfo =netfs_folio_info (folio); +struct bio_vec *bvec; +unsigned int from = finfo->dirty_offset; +unsigned int to = from + finfo->dirty_len; +unsigned int off =0 , i =0 ; +size_t flen =folio_size (folio); +size_t nr_bvec = flen /PAGE_SIZE +2 ; +size_t part; + + ret = -ENOMEM ; + bvec =kmalloc_array (nr_bvec,sizeof (*bvec),GFP_KERNEL ); +if (!bvec) + goto discard; + + sink =folio_alloc (GFP_KERNEL ,0 ); +if (!sink) + goto discard; + +trace_netfs_folio (folio, netfs_folio_trace_read_gaps); + + rreq->direct_bv = bvec; + rreq->direct_bv_count = nr_bvec; +if (from >0 ) { +bvec_set_folio (&bvec[i++], folio, from,0 ); + off = from; + } +while (off < to) { + part =min_t (size_t, to - off,PAGE_SIZE ); +bvec_set_folio (&bvec[i++], sink, part,0 ); + off += part; + } +if (to < flen) +bvec_set_folio (&bvec[i++], folio, flen - to, to); +iov_iter_bvec (&rreq->iter,ITER_DEST , bvec, i, rreq->len); + }else { +iov_iter_xarray (&rreq->iter,ITER_DEST , &mapping->i_pages, + rreq->start, rreq->len); + } ret =netfs_begin_read (rreq, true); +if (sink) +folio_put (sink);netfs_put_request (rreq, false, netfs_rreq_trace_put_return); -return ret; +return ret <0 ? ret :0 ; discard:netfs_put_request (rreq, false, netfs_rreq_trace_put_discard);
include/trace/events/netfs.h +2 -0
@@ -118,9 +118,11 @@ EM(netfs_folio_trace_clear_g, "clear-g") \ EM(netfs_folio_trace_copy_to_cache, "copy") \ EM(netfs_folio_trace_end_copy, "end-copy") \ + EM(netfs_folio_trace_filled_gaps, "filled-gaps") \ EM(netfs_folio_trace_kill, "kill") \ EM(netfs_folio_trace_mkwrite, "mkwrite") \ EM(netfs_folio_trace_mkwrite_plus, "mkwrite+") \ + EM(netfs_folio_trace_read_gaps, "read-gaps") \ EM(netfs_folio_trace_redirty, "redirty") \ EM(netfs_folio_trace_redirtied, "redirtied") \EM (netfs_folio_trace_store,"store" ) \
David Howells
maintainerPATCH v4 27/39 netfs: Allocate multipage folios in the writepath
In reply to David HowellsAllocate a multipage folio when copying data into the pagecache if possible if there's sufficient data to warrant it.
--- fs/netfs/buffered_write.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
fs/netfs/buffered_write.c +7 -2
@@ -84,14 +84,19 @@ static enum netfs_how_to_modify netfs_how_to_modify(struct netfs_inode *ctx, }/* -* Grab a folio for writing and lock it. +* Grab a folio for writing and lock it. Attempt to allocate as large a folio +* as possible to hold as much of the remaining length as possible in one go. */ static struct folio *netfs_grab_folio_for_write (struct address_space *mapping,loff_t pos,size_t part) {pgoff_t index = pos /PAGE_SIZE ; +fgf_t fgp_flags =FGP_WRITEBEGIN ; -return __filemap_get_folio (mapping, index,FGP_WRITEBEGIN , +if (mapping_large_folio_support (mapping)) + fgp_flags |=fgf_set_order (pos %PAGE_SIZE + part); + +return __filemap_get_folio (mapping, index, fgp_flags,mapping_gfp_mask (mapping)); }
David Howells
maintainerPATCH v4 28/39 netfs: Implement support for unbuffered/DIO read
In reply to David HowellsImplement support for unbuffered and DIO reads in the netfs library, utilising the existing read helper code to do block splitting and individual queuing. The code also handles extraction of the destination buffer from the supplied iterator, allowing async unbuffered reads to take place.
The read will be split up according to the rsize setting and, if supplied, the ->clamp_length() method. Note that the next subrequest will be issued as soon as issue_op returns, without waiting for previous ones to finish. The network filesystem needs to pause or handle queuing them if it doesn't want to fire them all at the server simultaneously.
Once all the subrequests have finished, the state will be assessed and the amount of data to be indicated as having being obtained will be determined. As the subrequests may finish in any order, if an intermediate subrequest is short, any further subrequests may be copied into the buffer and then abandoned.
In the future, this will also take care of doing an unbuffered read from encrypted content, with the decryption being done by the library.
--- fs/netfs/Makefile | 1 + fs/netfs/direct_read.c | 252 +++++++++++++++++++++++++++++++++++ fs/netfs/internal.h | 1 + fs/netfs/io.c | 82 ++++++++++-- fs/netfs/main.c | 1 + fs/netfs/objects.c | 5 +- fs/netfs/stats.c | 4 +- include/linux/netfs.h | 9 ++ include/trace/events/netfs.h | 7 +- mm/filemap.c | 1 + 10 files changed, 352 insertions(+), 11 deletions(-) create mode 100644 fs/netfs/direct_read.c
fs/netfs/Makefile +1 -0
@@ -3,6 +3,7 @@ netfs-y := \ buffered_read.o \ buffered_write.o \ + direct_read.o \ io.o \ iterator.o \ locking.o \
fs/netfs/direct_read.c new file +252 -0
252 lines not on this page · raw message
fs/netfs/internal.h +1 -0
@@ -100,6 +100,7 @@ int netfs_begin_write(struct netfs_io_request *wreq, bool may_wait,* stats.c */ #ifdef CONFIG_NETFS_STATS +extern atomic_t netfs_n_rh_dio_read;extern atomic_t netfs_n_rh_readahead;extern atomic_t netfs_n_rh_readpage;extern atomic_t netfs_n_rh_rreq;
fs/netfs/io.c +74 -8
145 lines not on this page · raw message
fs/netfs/main.c +1 -0
@@ -33,6 +33,7 @@ static const char *netfs_origins[nr__netfs_io_origin] = { [NETFS_READPAGE] = "RP", [NETFS_READ_FOR_WRITE] = "RW", [NETFS_WRITEBACK] = "WB", + [NETFS_DIO_READ] = "DR", };/*
fs/netfs/objects.c +4 -1
@@ -20,7 +20,8 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,struct inode *inode = file ?file_inode (file) : mapping->host;struct netfs_inode *ctx =netfs_inode (inode);struct netfs_io_request *rreq; -bool cached =netfs_is_cache_enabled (ctx); +bool is_dio = (origin ==NETFS_DIO_READ ); +bool cached = is_dio &&netfs_is_cache_enabled (ctx);int ret; rreq = kzalloc(ctx->ops->io_request_size ?: sizeof(struct netfs_io_request),
@@ -43,6 +44,8 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,__set_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags);if (cached)__set_bit (NETFS_RREQ_WRITE_TO_CACHE , &rreq->flags); +if (file && file->f_flags &O_NONBLOCK ) +__set_bit (NETFS_RREQ_NONBLOCK , &rreq->flags);if (rreq->netfs_ops->init_request) { ret = rreq->netfs_ops->init_request (rreq, file);if (ret <0 ) {
fs/netfs/stats.c +3 -1
@@ -9,6 +9,7 @@#include <linux/seq_file.h> #include "internal.h" +atomic_t netfs_n_rh_dio_read;atomic_t netfs_n_rh_readahead;atomic_t netfs_n_rh_readpage;atomic_t netfs_n_rh_rreq;
@@ -36,7 +37,8 @@ atomic_t netfs_n_wh_write_failed;int netfs_stats_show (struct seq_file *m,void *v) { - seq_printf(m, "Netfs : RA=%u RP=%u WB=%u WBZ=%u rr=%u sr=%u\n", + seq_printf(m, "Netfs : DR=%u RA=%u RP=%u WB=%u WBZ=%u rr=%u sr=%u\n", + atomic_read(&netfs_n_rh_dio_read), atomic_read(&netfs_n_rh_readahead), atomic_read(&netfs_n_rh_readpage), atomic_read(&netfs_n_rh_write_begin),
include/linux/netfs.h +9 -0
@@ -226,6 +226,7 @@ enum netfs_io_origin {NETFS_READPAGE ,/* This read is a synchronous read */ NETFS_READ_FOR_WRITE ,/* This read is to prepare a write */ NETFS_WRITEBACK ,/* This write was triggered by writepages */ +NETFS_DIO_READ ,/* This is a direct I/O read */ nr__netfs_io_origin }__mode (byte);
@@ -240,6 +241,7 @@ struct netfs_io_request { };struct inode *inode;/* The file being accessed */ struct address_space *mapping;/* The mapping being accessed */ +struct kiocb *iocb;/* AIO completion vector */ struct netfs_cache_resources cache_resources;struct list_head proc_link;/* Link in netfs_iorequests */ struct list_head subrequests;/* Contributory I/O operations */
@@ -251,12 +253,14 @@ struct netfs_io_request {__counted_by (direct_bv_count);unsigned int direct_bv_count;/* Number of elements in direct_bv[] */ unsigned int debug_id; +unsigned int rsize;/* Maximum read size (0 for none) */ unsigned int wsize;/* Maximum write size (0 for none) */ unsigned int subreq_counter;/* Next subreq->debug_index */ atomic_t nr_outstanding;/* Number of ops in progress */ atomic_t nr_copy_ops;/* Number of copy-to-cache ops in progress */ size_t submitted;/* Amount submitted for I/O so far */ size_t len;/* Length of the request */ +size_t transferred;/* Amount to be indicated as transferred */ short error;/* 0 or error that occurred */ enum netfs_io_origin origin;/* Origin of the request */ bool direct_bv_unpin;/* T if direct_bv[] must be unpinned */
@@ -274,6 +278,8 @@ struct netfs_io_request {#define NETFS_RREQ_USE_BOUNCE_BUFFER 6/* Use bounce buffer */ #define NETFS_RREQ_WRITE_TO_CACHE 7/* Need to write to the cache */ #define NETFS_RREQ_UPLOAD_TO_SERVER 8/* Need to write to the server */ +#define NETFS_RREQ_NONBLOCK 9/* Don't block if possible (O_NONBLOCK) */ +#define NETFS_RREQ_BLOCKED 10/* We blocked */ const struct netfs_request_ops *netfs_ops;void (*cleanup)(struct netfs_io_request *req); };
@@ -370,6 +376,9 @@ struct netfs_cache_ops { loff_t *_data_start, size_t *_data_len); }; +/* High-level read API. */ +ssize_t netfs_unbuffered_read_iter (struct kiocb *iocb,struct iov_iter *iter); +/* High-level write API */ ssize_t netfs_perform_write (struct kiocb *iocb,struct iov_iter *iter,struct netfs_group *netfs_group);
include/trace/events/netfs.h +6 -1
@@ -16,6 +16,7 @@* Define enums for tracing information. */ #define netfs_read_traces \ + EM(netfs_read_trace_dio_read, "DIO-READ ") \ EM(netfs_read_trace_expanded, "EXPANDED ") \ EM(netfs_read_trace_readahead, "READAHEAD") \ EM(netfs_read_trace_readpage, "READPAGE ") \
@@ -31,7 +32,8 @@ EM(NETFS_READAHEAD, "RA") \ EM(NETFS_READPAGE, "RP") \ EM(NETFS_READ_FOR_WRITE, "RW") \ - E_(NETFS_WRITEBACK, "WB") + EM(NETFS_WRITEBACK, "WB") \ + E_(NETFS_DIO_READ, "DR")#define netfs_rreq_traces \ EM(netfs_rreq_trace_assess, "ASSESS ") \
@@ -70,6 +72,8 @@#define netfs_failures \ EM(netfs_fail_check_write_begin, "check-write-begin") \ EM(netfs_fail_copy_to_cache, "copy-to-cache") \ + EM(netfs_fail_dio_read_short, "dio-read-short") \ + EM(netfs_fail_dio_read_zero, "dio-read-zero") \ EM(netfs_fail_read, "read") \ EM(netfs_fail_short_read, "short-read") \ EM(netfs_fail_prepare_write, "prep-write") \
@@ -81,6 +85,7 @@ EM(netfs_rreq_trace_put_complete, "PUT COMPLT ") \ EM(netfs_rreq_trace_put_discard, "PUT DISCARD") \ EM(netfs_rreq_trace_put_failed, "PUT FAILED ") \ + EM(netfs_rreq_trace_put_no_submit, "PUT NO-SUBM") \ EM(netfs_rreq_trace_put_return, "PUT RETURN ") \ EM(netfs_rreq_trace_put_subreq, "PUT SUBREQ ") \EM (netfs_rreq_trace_put_work,"PUT WORK " ) \
mm/filemap.c +1 -0
@@ -2678,6 +2678,7 @@ int kiocb_write_and_wait(struct kiocb *iocb, size_t count)return filemap_write_and_wait_range (mapping, pos, end); } +EXPORT_SYMBOL_GPL (kiocb_write_and_wait);int kiocb_invalidate_pages (struct kiocb *iocb,size_t count) {
Jeff Layton
maintainerRe: [PATCH v4 28/39] netfs: Implement support for unbuffered/DIO read
Quoted 105 lines · David Howells
Implement support for unbuffered and DIO reads in the netfs library, utilising the existing read helper code to do block splitting and individual queuing. The code also handles extraction of the destination buffer from the supplied iterator, allowing async unbuffered reads to take place.
The read will be split up according to the rsize setting and, if supplied, the ->clamp_length() method. Note that the next subrequest will be issued as soon as
issue_opreturns, without waiting for previous ones to finish. The network filesystem needs to pause or handle queuing them if it doesn't want to fire them all at the server simultaneously.Once all the subrequests have finished, the state will be assessed and the amount of data to be indicated as having being obtained will be determined. As the subrequests may finish in any order, if an intermediate subrequest is short, any further subrequests may be copied into the buffer and then abandoned.
In the future, this will also take care of doing an unbuffered read from encrypted content, with the decryption being done by the library.
Signed-off-by David Howells <[email protected]>cc Jeff Layton <[email protected]>--- fs/netfs/Makefile | 1 + fs/netfs/direct_read.c | 252 +++++++++++++++++++++++++++++++++++ fs/netfs/internal.h | 1 + fs/netfs/io.c | 82 ++++++++++-- fs/netfs/main.c | 1 + fs/netfs/objects.c | 5 +- fs/netfs/stats.c | 4 +- include/linux/netfs.h | 9 ++ include/trace/events/netfs.h | 7 +- mm/filemap.c | 1 + 10 files changed, 352 insertions(+), 11 deletions(-) create mode 100644 fs/netfs/direct_read.cfs/netfs/Makefile +1
-0@@ -3,6 +3,7 @@ netfs-y := \ buffered_read.o \ buffered_write.o \ + direct_read.o \ io.o \ iterator.o \ locking.o \fs/netfs/direct_read.c new file +47
-0@@ -0,0 +1,252 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* Direct I/O support. +* +* Copyright (C) 2023 Red Hat, Inc. All Rights Reserved. +* Written by David Howells ([email protected]) +*/ + +#include <linux/export.h> +#include <linux/fs.h> +#include <linux/mm.h> +#include <linux/pagemap.h> +#include <linux/slab.h> +#include <linux/uio.h> +#include <linux/sched/mm.h> +#include <linux/task_io_accounting_ops.h> +#include <linux/netfs.h> +#include "internal.h" + +/* +* Copy all of the data from the folios in the source xarray into the +* destination iterator. We cannot step through and kmap the dest iterator if +* it's an iovec, so we have to step through the xarray and drop the RCU lock +* each time. +*/ +static int netfs_copy_xarray_to_iter (struct netfs_io_request *rreq, +struct xarray *xa,struct iov_iter *dst, +unsigned long long start,size_t avail) +{ +struct folio *folio; +void *base; +pgoff_t index = start /PAGE_SIZE ; +size_t len, copied, count =min (avail,iov_iter_count (dst)); + +XA_STATE (xas, xa, index); + +_enter ("%zx" , count); + +if (!count) { +trace_netfs_failure (rreq,NULL , -EIO , netfs_fail_dio_read_zero); +return -EIO ; + } + + len =PAGE_SIZE -offset_in_page (start); +rcu_read_lock (); +xas_for_each (&xas, folio,ULONG_MAX ) { +size_t offset; +
fs/netfs/direct_read.c line 57
Quoted 10 lines
fs/netfs/direct_read.c new file +10
-0+if (xas_retry (&xas, folio)) +continue ; + +/* There shouldn't be a need to call xas_pause() as no one else +* should be modifying the xarray we're iterating over. +* Really, we only need the RCU readlock to keep lockdep happy +* inside xas_for_each(). +*/ +rcu_read_unlock (); +
Are you sure it's still safe to access "folio" once you've dropped the rcu_read_lock? I wonder if you need to take a reference or something.
I guess if this is a "private" xarray then nothing should be modifying it?
Quoted 528 lines
fs/netfs/direct_read.c new file +195
-0+ offset =offset_in_folio (folio, start); +kdebug ("folio %lx +%zx [%llx]" , folio->index, offset, start); + +while (offset <folio_size (folio)) { + len =min (count, len); + + base =kmap_local_folio (folio, offset); + copied =copy_to_iter (base, len, dst); +kunmap_local (base); +if (copied != len) + goto out; + count -= len; +if (count ==0 ) + goto out; + + start += len; + offset += len; + len =PAGE_SIZE ; + } + +rcu_read_lock (); + } + +rcu_read_unlock (); +out: +_leave (" = %zx" , count); +return count ? -EFAULT :0 ; +} + +/* +* If we did a direct read to a bounce buffer (say we needed to decrypt it), +* copy the data obtained to the destination iterator. +*/ +static int netfs_dio_copy_bounce_to_dest (struct netfs_io_request *rreq) +{ +struct iov_iter *dest_iter = &rreq->iter; +struct kiocb *iocb = rreq->iocb; +unsigned long long start = rreq->start; + +_enter ("%zx/%zx @%llx" , rreq->transferred, rreq->len, start); + +if (!test_bit (NETFS_RREQ_USE_BOUNCE_BUFFER , &rreq->flags)) +return 0 ; + +if (start < iocb->ki_pos) { +if (rreq->transferred <= iocb->ki_pos - start) { +trace_netfs_failure (rreq,NULL , -EIO , netfs_fail_dio_read_short); +return -EIO ; + } + rreq->len = rreq->transferred; + rreq->transferred -= iocb->ki_pos - start; + } + +if (rreq->transferred >iov_iter_count (dest_iter)) + rreq->transferred =iov_iter_count (dest_iter); + +_debug ("xfer %zx/%zx @%llx" , rreq->transferred, rreq->len, iocb->ki_pos); +return netfs_copy_xarray_to_iter (rreq, &rreq->bounce, dest_iter, + iocb->ki_pos, rreq->transferred); +} + +/** +* netfs_unbuffered_read_iter_locked - Perform an unbuffered or direct I/O read +* @iocb: The I/O control descriptor describing the read +* @iter: The output buffer (also specifies read length) +* +* Perform an unbuffered I/O or direct I/O from the file in @iocb to the +* output buffer. No use is made of the pagecache. +* +* The caller must hold any appropriate locks. +*/ +static ssize_t netfs_unbuffered_read_iter_locked (struct kiocb *iocb,struct iov_iter *iter) +{ +struct netfs_io_request *rreq; +struct netfs_inode *ctx; +unsigned long long start, end; +unsigned int min_bsize; +pgoff_t first, last; +ssize_t ret; +size_t orig_count =iov_iter_count (iter); +bool async = !is_sync_kiocb (iocb); + +_enter ("" ); + +if (!orig_count) +return 0 ;/* Don't update atime */ + + ret =kiocb_write_and_wait (iocb, orig_count); +if (ret <0 ) +return ret; +file_accessed (iocb->ki_filp); + + rreq =netfs_alloc_request (iocb->ki_filp->f_mapping, iocb->ki_filp, + iocb->ki_pos, orig_count, +NETFS_DIO_READ ); +if (IS_ERR (rreq)) +return PTR_ERR (rreq); + + ctx =netfs_inode (rreq->inode); +netfs_stat (&netfs_n_rh_dio_read); +trace_netfs_read (rreq, rreq->start, rreq->len, netfs_read_trace_dio_read); + +/* If this is an async op, we have to keep track of the destination +* buffer for ourselves as the caller's iterator will be trashed when +* we return. +* +* In such a case, extract an iterator to represent as much of the the +* output buffer as we can manage. Note that the extraction might not +* be able to allocate a sufficiently large bvec array and may shorten +* the request. +*/ +if (user_backed_iter (iter)) { + ret =netfs_extract_user_iter (iter, rreq->len, &rreq->iter,0 ); +if (ret <0 ) + goto out; + rreq->direct_bv = (struct bio_vec *)rreq->iter.bvec; + rreq->direct_bv_count = ret; + rreq->direct_bv_unpin =iov_iter_extract_will_pin (iter); + rreq->len =iov_iter_count (&rreq->iter); + }else { + rreq->iter = *iter; + rreq->len = orig_count; + rreq->direct_bv_unpin = false; +iov_iter_advance (iter, orig_count); + } + +/* If we're going to use a bounce buffer, we need to set it up. We +* will then need to pad the request out to the minimum block size. +*/ +if (test_bit (NETFS_RREQ_USE_BOUNCE_BUFFER , &rreq->flags)) { + start = rreq->start; + end = min_t(unsigned long long, +round_up (rreq->start + rreq->len, min_bsize), + ctx->remote_i_size); + + rreq->start = start; + rreq->len = end - start; + first = start /PAGE_SIZE ; + last = (end -1 ) /PAGE_SIZE ; +_debug ("bounce %llx-%llx %lx-%lx" , + rreq->start, end, first, last); + + ret =netfs_add_folios_to_buffer (&rreq->bounce, rreq->mapping, + first, last,GFP_KERNEL ); +if (ret <0 ) + goto out; + } + +if (async) + rreq->iocb = iocb; + + ret =netfs_begin_read (rreq,is_sync_kiocb (iocb)); +if (ret <0 ) + goto out;/* May be -EIOCBQUEUED */ +if (!async) { + ret =netfs_dio_copy_bounce_to_dest (rreq); +if (ret ==0 ) { + iocb->ki_pos += rreq->transferred; + ret = rreq->transferred; + } + } + +out: +netfs_put_request (rreq, false, netfs_rreq_trace_put_return); +if (ret >0 ) + orig_count -= ret; +if (ret != -EIOCBQUEUED ) +iov_iter_revert (iter, orig_count -iov_iter_count (iter)); +return ret; +} + +/** +* netfs_unbuffered_read_iter - Perform an unbuffered or direct I/O read +* @iocb: The I/O control descriptor describing the read +* @iter: The output buffer (also specifies read length) +* +* Perform an unbuffered I/O or direct I/O from the file in @iocb to the +* output buffer. No use is made of the pagecache. +*/ +ssize_t netfs_unbuffered_read_iter (struct kiocb *iocb,struct iov_iter *iter) +{ +struct inode *inode =file_inode (iocb->ki_filp); +ssize_t ret; + +if (!iter->count) +return 0 ;/* Don't update atime */ + + ret =netfs_start_io_direct (inode); +if (ret ==0 ) { + ret =netfs_unbuffered_read_iter_locked (iocb, iter); +netfs_end_io_direct (inode); + } +return ret; +} +EXPORT_SYMBOL (netfs_unbuffered_read_iter);fs/netfs/internal.h +1
-0@@ -100,6 +100,7 @@ int netfs_begin_write(struct netfs_io_request *wreq, bool may_wait,* stats.c */ #ifdef CONFIG_NETFS_STATS +extern atomic_t netfs_n_rh_dio_read;extern atomic_t netfs_n_rh_readahead;extern atomic_t netfs_n_rh_readpage;extern atomic_t netfs_n_rh_rreq;fs/netfs/io.c +74
-8@@ -78,7 +78,9 @@ static void netfs_read_from_server(struct netfs_io_request *rreq, struct netfs_io_subrequest *subreq) {netfs_stat (&netfs_n_rh_download); -if (iov_iter_count (&subreq->io_iter) != subreq->len - subreq->transferred) + +if (rreq->origin !=NETFS_DIO_READ && +iov_iter_count (&subreq->io_iter) != subreq->len - subreq->transferred) pr_warn("R=%08x[%u] ITER PRE-MISMATCH %zx != %zx-%zx %lx\n", rreq->debug_id, subreq->debug_index, iov_iter_count(&subreq->io_iter), subreq->len,@@ -341,6 +343,43 @@ static void netfs_rreq_is_still_valid(struct netfs_io_request *rreq) } } +/* +* Determine how much we can admit to having read from a DIO read. +*/ +static void netfs_rreq_assess_dio (struct netfs_io_request *rreq) +{ +struct netfs_io_subrequest *subreq; +unsigned int i; +size_t transferred =0 ; + +for (i =0 ; i < rreq->direct_bv_count; i++) +flush_dcache_page (rreq->direct_bv[i].bv_page); + +list_for_each_entry (subreq, &rreq->subrequests, rreq_link) { +if (subreq->error || subreq->transferred ==0 ) +break ; + transferred += subreq->transferred; +if (subreq->transferred < subreq->len) +break ; + } + +for (i =0 ; i < rreq->direct_bv_count; i++) +flush_dcache_page (rreq->direct_bv[i].bv_page); + + rreq->transferred = transferred; +task_io_account_read (transferred); + +if (rreq->iocb) { + rreq->iocb->ki_pos += transferred; +if (rreq->iocb->ki_complete) + rreq->iocb->ki_complete ( + rreq->iocb, rreq->error ? rreq->error : transferred); + } +if (rreq->netfs_ops->done) + rreq->netfs_ops->done (rreq); +inode_dio_end (rreq->inode); +} +/* * Assess the state of a read request and decide what to do next. * @@ -361,7 +400,10 @@ static void netfs_rreq_assess(struct netfs_io_request *rreq, bool was_async)return ; } -netfs_rreq_unlock_folios (rreq); +if (rreq->origin !=NETFS_DIO_READ ) +netfs_rreq_unlock_folios (rreq); +else +netfs_rreq_assess_dio (rreq);trace_netfs_rreq (rreq, netfs_rreq_trace_wake_ip);clear_bit_unlock (NETFS_RREQ_IN_PROGRESS , &rreq->flags);@@ -526,14 +568,16 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq,struct netfs_io_subrequest *subreq, struct iov_iter *io_iter) { - enum netfs_io_source source; + enum netfs_io_source source = NETFS_DOWNLOAD_FROM_SERVER;size_t lsize;_enter ("%llx-%llx,%llx" , subreq->start, subreq->start + subreq->len, rreq->i_size); - source =netfs_cache_prepare_read (subreq, rreq->i_size); -if (source ==NETFS_INVALID_READ ) - goto out; +if (rreq->origin !=NETFS_DIO_READ ) { + source =netfs_cache_prepare_read (subreq, rreq->i_size); +if (source ==NETFS_INVALID_READ ) + goto out; + }if (source ==NETFS_DOWNLOAD_FROM_SERVER ) {/* Call out to the netfs to let it shrink the request to fit @@ -544,6 +588,8 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq,*/ if (subreq->len > rreq->i_size - subreq->start) subreq->len = rreq->i_size - subreq->start; +if (rreq->rsize && subreq->len > rreq->rsize) + subreq->len = rreq->rsize;if (rreq->netfs_ops->clamp_length && !rreq->netfs_ops->clamp_length (subreq)) {@@ -662,6 +708,9 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync)return -EIO ; } +if (rreq->origin ==NETFS_DIO_READ ) +inode_dio_begin (rreq->inode); +if (test_bit (NETFS_RREQ_USE_BOUNCE_BUFFER , &rreq->flags))iov_iter_xarray (&rreq->io_iter,ITER_DEST , &rreq->bounce, rreq->start, rreq->len);@@ -677,11 +726,25 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync)atomic_set (&rreq->nr_outstanding,1 ); io_iter = rreq->io_iter;do { +_debug ("submit %llx + %zx >= %llx" , + rreq->start, rreq->submitted, rreq->i_size); +if (rreq->origin ==NETFS_DIO_READ && + rreq->start + rreq->submitted >= rreq->i_size) +break ;if (!netfs_rreq_submit_slice (rreq, &io_iter, &debug_index))break ; +if (test_bit (NETFS_RREQ_BLOCKED , &rreq->flags) && +test_bit (NETFS_RREQ_NONBLOCK , &rreq->flags)) +break ; }while (rreq->submitted < rreq->len); +if (!rreq->submitted) { +netfs_put_request (rreq, false, netfs_rreq_trace_put_no_submit); + ret =0 ; + goto out; + } +if (sync) {/* Keep nr_outstanding incremented so that the ref always * belongs to us, and the service code isn't punted off to a @@ -698,7 +761,8 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync) TASK_UNINTERRUPTIBLE); ret = rreq->error; -if (ret ==0 && rreq->submitted < rreq->len) { +if (ret ==0 && rreq->submitted < rreq->len && + rreq->origin !=NETFS_DIO_READ ) {trace_netfs_failure (rreq,NULL , ret, netfs_fail_short_read); ret = -EIO ; }@@ -706,7 +770,9 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync)/* If we decrement nr_outstanding to 0, the ref belongs to us. */ if (atomic_dec_and_test (&rreq->nr_outstanding))netfs_rreq_assess (rreq, false); - ret =0 ; + ret = -EIOCBQUEUED ; } + +out:return ret; }fs/netfs/main.c +1
-0@@ -33,6 +33,7 @@ static const char *netfs_origins[nr__netfs_io_origin] = { [NETFS_READPAGE] = "RP", [NETFS_READ_FOR_WRITE] = "RW", [NETFS_WRITEBACK] = "WB", + [NETFS_DIO_READ] = "DR", };/* fs/netfs/objects.c +4
-1@@ -20,7 +20,8 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,struct inode *inode = file ?file_inode (file) : mapping->host;struct netfs_inode *ctx =netfs_inode (inode);struct netfs_io_request *rreq; -bool cached =netfs_is_cache_enabled (ctx); +bool is_dio = (origin ==NETFS_DIO_READ ); +bool cached = is_dio &&netfs_is_cache_enabled (ctx);int ret; rreq = kzalloc(ctx->ops->io_request_size ?: sizeof(struct netfs_io_request),@@ -43,6 +44,8 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,__set_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags);if (cached)__set_bit (NETFS_RREQ_WRITE_TO_CACHE , &rreq->flags); +if (file && file->f_flags &O_NONBLOCK ) +__set_bit (NETFS_RREQ_NONBLOCK , &rreq->flags);if (rreq->netfs_ops->init_request) { ret = rreq->netfs_ops->init_request (rreq, file);if (ret <0 ) {fs/netfs/stats.c +3
-1@@ -9,6 +9,7 @@#include <linux/seq_file.h> #include "internal.h" +atomic_t netfs_n_rh_dio_read;atomic_t netfs_n_rh_readahead;atomic_t netfs_n_rh_readpage;atomic_t netfs_n_rh_rreq;@@ -36,7 +37,8 @@ atomic_t netfs_n_wh_write_failed;int netfs_stats_show (struct seq_file *m,void *v) { - seq_printf(m, "Netfs : RA=%u RP=%u WB=%u WBZ=%u rr=%u sr=%u\n", + seq_printf(m, "Netfs : DR=%u RA=%u RP=%u WB=%u WBZ=%u rr=%u sr=%u\n", + atomic_read(&netfs_n_rh_dio_read), atomic_read(&netfs_n_rh_readahead), atomic_read(&netfs_n_rh_readpage), atomic_read(&netfs_n_rh_write_begin),include/linux/netfs.h +9
-0@@ -226,6 +226,7 @@ enum netfs_io_origin {NETFS_READPAGE ,/* This read is a synchronous read */ NETFS_READ_FOR_WRITE ,/* This read is to prepare a write */ NETFS_WRITEBACK ,/* This write was triggered by writepages */ +NETFS_DIO_READ ,/* This is a direct I/O read */ nr__netfs_io_origin }__mode (byte);@@ -240,6 +241,7 @@ struct netfs_io_request { };struct inode *inode;/* The file being accessed */ struct address_space *mapping;/* The mapping being accessed */ +struct kiocb *iocb;/* AIO completion vector */ struct netfs_cache_resources cache_resources;struct list_head proc_link;/* Link in netfs_iorequests */ struct list_head subrequests;/* Contributory I/O operations */ @@ -251,12 +253,14 @@ struct netfs_io_request {__counted_by (direct_bv_count);unsigned int direct_bv_count;/* Number of elements in direct_bv[] */ unsigned int debug_id; +unsigned int rsize;/* Maximum read size (0 for none) */ unsigned int wsize;/* Maximum write size (0 for none) */ unsigned int subreq_counter;/* Next subreq->debug_index */ atomic_t nr_outstanding;/* Number of ops in progress */ atomic_t nr_copy_ops;/* Number of copy-to-cache ops in progress */ size_t submitted;/* Amount submitted for I/O so far */ size_t len;/* Length of the request */ +size_t transferred;/* Amount to be indicated as transferred */ short error;/* 0 or error that occurred */ enum netfs_io_origin origin;/* Origin of the request */ bool direct_bv_unpin;/* T if direct_bv[] must be unpinned */ @@ -274,6 +278,8 @@ struct netfs_io_request {#define NETFS_RREQ_USE_BOUNCE_BUFFER 6/* Use bounce buffer */ #define NETFS_RREQ_WRITE_TO_CACHE 7/* Need to write to the cache */ #define NETFS_RREQ_UPLOAD_TO_SERVER 8/* Need to write to the server */ +#define NETFS_RREQ_NONBLOCK 9/* Don't block if possible (O_NONBLOCK) */ +#define NETFS_RREQ_BLOCKED 10/* We blocked */ const struct netfs_request_ops *netfs_ops;void (*cleanup)(struct netfs_io_request *req); };@@ -370,6 +376,9 @@ struct netfs_cache_ops { loff_t *_data_start, size_t *_data_len); }; +/* High-level read API. */ +ssize_t netfs_unbuffered_read_iter (struct kiocb *iocb,struct iov_iter *iter); +/* High-level write API */ ssize_t netfs_perform_write (struct kiocb *iocb,struct iov_iter *iter,struct netfs_group *netfs_group);include/trace/events/netfs.h +6
-1@@ -16,6 +16,7 @@* Define enums for tracing information. */ #define netfs_read_traces \ + EM(netfs_read_trace_dio_read, "DIO-READ ") \ EM(netfs_read_trace_expanded, "EXPANDED ") \ EM(netfs_read_trace_readahead, "READAHEAD") \ EM(netfs_read_trace_readpage, "READPAGE ") \@@ -31,7 +32,8 @@ EM(NETFS_READAHEAD, "RA") \ EM(NETFS_READPAGE, "RP") \ EM(NETFS_READ_FOR_WRITE, "RW") \ - E_(NETFS_WRITEBACK, "WB") + EM(NETFS_WRITEBACK, "WB") \ + E_(NETFS_DIO_READ, "DR")#define netfs_rreq_traces \ EM(netfs_rreq_trace_assess, "ASSESS ") \@@ -70,6 +72,8 @@#define netfs_failures \ EM(netfs_fail_check_write_begin, "check-write-begin") \ EM(netfs_fail_copy_to_cache, "copy-to-cache") \ + EM(netfs_fail_dio_read_short, "dio-read-short") \ + EM(netfs_fail_dio_read_zero, "dio-read-zero") \ EM(netfs_fail_read, "read") \ EM(netfs_fail_short_read, "short-read") \ EM(netfs_fail_prepare_write, "prep-write") \@@ -81,6 +85,7 @@ EM(netfs_rreq_trace_put_complete, "PUT COMPLT ") \ EM(netfs_rreq_trace_put_discard, "PUT DISCARD") \ EM(netfs_rreq_trace_put_failed, "PUT FAILED ") \ + EM(netfs_rreq_trace_put_no_submit, "PUT NO-SUBM") \ EM(netfs_rreq_trace_put_return, "PUT RETURN ") \ EM(netfs_rreq_trace_put_subreq, "PUT SUBREQ ") \EM (netfs_rreq_trace_put_work,"PUT WORK " ) \mm/filemap.c +1
-0@@ -2678,6 +2678,7 @@ int kiocb_write_and_wait(struct kiocb *iocb, size_t count)return filemap_write_and_wait_range (mapping, pos, end); } +EXPORT_SYMBOL_GPL (kiocb_write_and_wait);int kiocb_invalidate_pages (struct kiocb *iocb,size_t count) {
Signature · 1 line
Jeff Layton <[email protected]>
David Howells
maintainerRe: [PATCH v4 28/39] netfs: Implement support for unbuffered/DIO read
Quoted 21 lines · Jeff Layton
Quoted 3 lines
fs/netfs/direct_read.c new file +3
-0+static int netfs_copy_xarray_to_iter (struct netfs_io_request *rreq, +struct xarray *xa,struct iov_iter *dst, +unsigned long long start,size_t avail)...
fs/netfs/direct_read.c line 57
Quoted 13 lines
fs/netfs/direct_read.c new file +13
-0+xas_for_each (&xas, folio,ULONG_MAX ) { +size_t offset; + +if (xas_retry (&xas, folio)) +continue ; + +/* There shouldn't be a need to call xas_pause() as no one else +* should be modifying the xarray we're iterating over. +* Really, we only need the RCU readlock to keep lockdep happy +* inside xas_for_each(). +*/ +rcu_read_unlock (); +Are you sure it's still safe to access "folio" once you've dropped the
rcu_read_lock? I wonder if you need to take a reference or something.
Quoted 2 lines
I guess if this is a "private" xarray then nothing should be modifying it?
It is a private xarray in this case. The only reason I need the RCU read lock is because the xarray code will complain if we're not holding it:-/.
Actually, I can probably excise the bounce buffer code for this series as nothing in 9p or afs currently uses it. It's needed for content crypto - so ceph will need it.
David
David Howells
maintainerPATCH v4 29/39 netfs: Implement unbuffered/DIO write support
In reply to David HowellsImplement support for unbuffered writes and direct I/O writes. If the write is misaligned with respect to the fscrypt block size, then RMW cycles are performed if necessary. DIO writes are a special case of unbuffered writes with extra restriction imposed, such as block size alignment requirements.
Also provide a field that can tell the code to add some extra space onto the bounce buffer for use by the filesystem in the case of a content-encrypted file.
--- fs/afs/inode.c | 2 +- fs/netfs/Makefile | 1 + fs/netfs/direct_write.c | 166 +++++++++++++++++++++++++++++++++++ fs/netfs/internal.h | 6 ++ fs/netfs/io.c | 2 +- fs/netfs/main.c | 12 +-- fs/netfs/objects.c | 6 +- fs/netfs/output.c | 30 +++++++ include/linux/netfs.h | 4 + include/trace/events/netfs.h | 4 +- 10 files changed, 223 insertions(+), 10 deletions(-) create mode 100644 fs/netfs/direct_write.c
fs/afs/inode.c +1 -1
@@ -249,7 +249,7 @@ static void afs_apply_status(struct afs_operation *op,* what's on the server. */ vnode->netfs.remote_i_size = status->size; -if (change_size) { +if (change_size || status->size >i_size_read (inode)) {afs_set_i_size (vnode, status->size);inode_set_ctime_to_ts (inode, t);inode_set_atime_to_ts (inode, t);
fs/netfs/Makefile +1 -0
@@ -4,6 +4,7 @@ netfs-y := \ buffered_read.o \ buffered_write.o \ direct_read.o \ + direct_write.o \ io.o \ iterator.o \ locking.o \
fs/netfs/direct_write.c new file +166 -0
166 lines not on this page · raw message
fs/netfs/internal.h +6 -0
@@ -26,6 +26,12 @@ void netfs_rreq_unlock_folios(struct netfs_io_request *rreq);int netfs_prefetch_for_write (struct file *file,struct folio *folio,size_t offset,size_t len); +/* +* direct_write.c +*/ +ssize_t netfs_unbuffered_write_iter_locked (struct kiocb *iocb,struct iov_iter *iter, +struct netfs_group *netfs_group); +/* * io.c */
fs/netfs/io.c +1 -1
@@ -645,7 +645,7 @@ static bool netfs_rreq_submit_slice(struct netfs_io_request *rreq, subreq->debug_index = (*_debug_index)++; subreq->start = rreq->start + rreq->submitted; - subreq->len = rreq->len - rreq->submitted; + subreq->len = io_iter->count;_debug ("slice %llx,%zx,%zx" , subreq->start, subreq->len, rreq->submitted);list_add_tail (&subreq->rreq_link, &rreq->subrequests);
fs/netfs/main.c +7 -5
@@ -29,11 +29,13 @@ LIST_HEAD(netfs_io_requests);DEFINE_SPINLOCK (netfs_proc_lock);static const char *netfs_origins[nr__netfs_io_origin] = { - [NETFS_READAHEAD ] ="RA" , - [NETFS_READPAGE ] ="RP" , - [NETFS_READ_FOR_WRITE ] ="RW" , - [NETFS_WRITEBACK ] ="WB" , - [NETFS_DIO_READ ] ="DR" , + [NETFS_READAHEAD ] ="RA" , + [NETFS_READPAGE ] ="RP" , + [NETFS_READ_FOR_WRITE ] ="RW" , + [NETFS_WRITEBACK ] ="WB" , + [NETFS_UNBUFFERED_WRITE ] ="UW" , + [NETFS_DIO_READ ] ="DR" , + [NETFS_DIO_WRITE ] ="DW" , };/*
fs/netfs/objects.c +4 -2
@@ -20,8 +20,10 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,struct inode *inode = file ?file_inode (file) : mapping->host;struct netfs_inode *ctx =netfs_inode (inode);struct netfs_io_request *rreq; -bool is_dio = (origin ==NETFS_DIO_READ ); -bool cached = is_dio &&netfs_is_cache_enabled (ctx); +bool is_unbuffered = (origin ==NETFS_UNBUFFERED_WRITE || + origin ==NETFS_DIO_READ || + origin ==NETFS_DIO_WRITE ); +bool cached = !is_unbuffered &&netfs_is_cache_enabled (ctx);int ret; rreq = kzalloc(ctx->ops->io_request_size ?: sizeof(struct netfs_io_request),
fs/netfs/output.c +30 -0
@@ -74,11 +74,21 @@ static void netfs_write_terminated(struct netfs_io_request *wreq, bool was_async {struct netfs_io_subrequest *subreq;struct netfs_inode *ctx =netfs_inode (wreq->inode); +size_t transferred =0 ;_enter ("R=%x[]" , wreq->debug_id);trace_netfs_rreq (wreq, netfs_rreq_trace_write_done); +list_for_each_entry (subreq, &wreq->subrequests, rreq_link) { +if (subreq->error || subreq->transferred ==0 ) +break ; + transferred += subreq->transferred; +if (subreq->transferred < subreq->len) +break ; + } + wreq->transferred = transferred; +list_for_each_entry (subreq, &wreq->subrequests, rreq_link) {if (!subreq->error)continue ;
@@ -110,11 +120,28 @@ static void netfs_write_terminated(struct netfs_io_request *wreq, bool was_async wreq->cleanup (wreq); +if (wreq->origin ==NETFS_DIO_WRITE && + wreq->mapping->nrpages) { +pgoff_t first = wreq->start >>PAGE_SHIFT ; +pgoff_t last = (wreq->start + wreq->transferred -1 ) >>PAGE_SHIFT ; +invalidate_inode_pages2_range (wreq->mapping, first, last); + } + +if (wreq->origin ==NETFS_DIO_WRITE ) +inode_dio_end (wreq->inode); +_debug ("finished" );trace_netfs_rreq (wreq, netfs_rreq_trace_wake_ip);clear_bit_unlock (NETFS_RREQ_IN_PROGRESS , &wreq->flags);wake_up_bit (&wreq->flags,NETFS_RREQ_IN_PROGRESS ); +if (wreq->iocb) { + wreq->iocb->ki_pos += transferred; +if (wreq->iocb->ki_complete) + wreq->iocb->ki_complete ( + wreq->iocb, wreq->error ? wreq->error : transferred); + } +netfs_clear_subrequests (wreq, was_async);netfs_put_request (wreq, was_async, netfs_rreq_trace_put_complete); }
@@ -329,6 +356,9 @@ int netfs_begin_write(struct netfs_io_request *wreq, bool may_wait,return -EIO ; } +if (wreq->origin ==NETFS_DIO_WRITE ) +inode_dio_begin (wreq->inode); + wreq->io_iter = wreq->iter;/* ->outstanding > 0 carries a ref */
include/linux/netfs.h +4 -0
@@ -138,6 +138,7 @@ struct netfs_inode {loff_t remote_i_size;/* Size of the remote file */ unsigned long flags;#define NETFS_ICTX_ODIRECT 0/* The file has DIO in progress */ +#define NETFS_ICTX_UNBUFFERED 1/* I/O should not use the pagecache */ };/*
@@ -226,7 +227,9 @@ enum netfs_io_origin {NETFS_READPAGE ,/* This read is a synchronous read */ NETFS_READ_FOR_WRITE ,/* This read is to prepare a write */ NETFS_WRITEBACK ,/* This write was triggered by writepages */ +NETFS_UNBUFFERED_WRITE ,/* This is an unbuffered write */ NETFS_DIO_READ ,/* This is a direct I/O read */ +NETFS_DIO_WRITE ,/* This is a direct I/O write */ nr__netfs_io_origin }__mode (byte);
@@ -382,6 +385,7 @@ ssize_t netfs_unbuffered_read_iter(struct kiocb *iocb, struct iov_iter *iter);/* High-level write API */ ssize_t netfs_perform_write (struct kiocb *iocb,struct iov_iter *iter,struct netfs_group *netfs_group); +ssize_t netfs_unbuffered_write_iter (struct kiocb *iocb,struct iov_iter *from);/* Address operations API */ struct readahead_control ;
include/trace/events/netfs.h +3 -1
@@ -33,7 +33,9 @@ EM(NETFS_READPAGE, "RP") \ EM(NETFS_READ_FOR_WRITE, "RW") \ EM(NETFS_WRITEBACK, "WB") \ - E_(NETFS_DIO_READ, "DR") + EM(NETFS_UNBUFFERED_WRITE, "UW") \ + EM(NETFS_DIO_READ, "DR") \ + E_(NETFS_DIO_WRITE, "DW")#define netfs_rreq_traces \ EM(netfs_rreq_trace_assess, "ASSESS ") \
David Howells
maintainerPATCH v4 30/39 netfs: Implement buffered write API
In reply to David HowellsInstitute a netfs write helper, netfs_file_write_iter(), to be pointed at by the network filesystem ->write_iter() call. Make it handled buffered writes by calling the previously defined netfs_perform_write() to copy the source data into the pagecache.
--- fs/netfs/buffered_write.c | 83 +++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 3 ++ 2 files changed, 86 insertions(+)
fs/netfs/buffered_write.c +83 -0
@@ -333,3 +333,86 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, goto out; }EXPORT_SYMBOL (netfs_perform_write); + +/** +* netfs_buffered_write_iter_locked - write data to a file +* @iocb: IO state structure (file, offset, etc.) +* @from: iov_iter with data to write +* @netfs_group: Grouping for dirty pages (eg. ceph snaps). +* +* This function does all the work needed for actually writing data to a +* file. It does all basic checks, removes SUID from the file, updates +* modification times and calls proper subroutines depending on whether we +* do direct IO or a standard buffered write. +* +* The caller must hold appropriate locks around this function and have called +* generic_write_checks() already. The caller is also responsible for doing +* any necessary syncing afterwards. +* +* This function does *not* take care of syncing data in case of O_SYNC write. +* A caller has to handle it. This is mainly due to the fact that we want to +* avoid syncing under i_rwsem. +* +* Return: +* * number of bytes written, even for truncated writes +* * negative error code if no data has been written at all +*/ +ssize_t netfs_buffered_write_iter_locked (struct kiocb *iocb,struct iov_iter *from, +struct netfs_group *netfs_group) +{ +struct file *file = iocb->ki_filp; +ssize_t ret; + +trace_netfs_write_iter (iocb, from); + + ret =file_remove_privs (file); +if (ret) +return ret; + + ret =file_update_time (file); +if (ret) +return ret; + +return netfs_perform_write (iocb, from, netfs_group); +} +EXPORT_SYMBOL (netfs_buffered_write_iter_locked); + +/** +* netfs_file_write_iter - write data to a file +* @iocb: IO state structure +* @from: iov_iter with data to write +* +* Perform a write to a file, writing into the pagecache if possible and doing +* an unbuffered write instead if not. +* +* Return: +* * Negative error code if no data has been written at all of +* vfs_fsync_range() failed for a synchronous write +* * Number of bytes written, even for truncated writes +*/ +ssize_t netfs_file_write_iter (struct kiocb *iocb,struct iov_iter *from) +{ +struct file *file = iocb->ki_filp; +struct inode *inode = file->f_mapping->host; +struct netfs_inode *ictx =netfs_inode (inode); +ssize_t ret; + +_enter ("%llx,%zx,%llx" , iocb->ki_pos,iov_iter_count (from),i_size_read (inode)); + +if ((iocb->ki_flags &IOCB_DIRECT ) || +test_bit (NETFS_ICTX_UNBUFFERED , &ictx->flags)) +return netfs_unbuffered_write_iter (iocb, from); + + ret =netfs_start_io_write (inode); +if (ret <0 ) +return ret; + + ret =generic_write_checks (iocb, from); +if (ret >0 ) + ret =netfs_buffered_write_iter_locked (iocb, from,NULL ); +netfs_end_io_write (inode); +if (ret >0 ) + ret =generic_write_sync (iocb, ret); +return ret; +} +EXPORT_SYMBOL (netfs_file_write_iter);
include/linux/netfs.h +3 -0
@@ -385,7 +385,10 @@ ssize_t netfs_unbuffered_read_iter(struct kiocb *iocb, struct iov_iter *iter);/* High-level write API */ ssize_t netfs_perform_write (struct kiocb *iocb,struct iov_iter *iter,struct netfs_group *netfs_group); +ssize_t netfs_buffered_write_iter_locked (struct kiocb *iocb,struct iov_iter *from, +struct netfs_group *netfs_group);ssize_t netfs_unbuffered_write_iter (struct kiocb *iocb,struct iov_iter *from); +ssize_t netfs_file_write_iter (struct kiocb *iocb,struct iov_iter *from);/* Address operations API */ struct readahead_control ;
David Howells
maintainerPATCH v4 31/39 netfs: Allow buffered shared-writeable mmap through netfs_page_mkwrite()
In reply to David HowellsProvide an entry point to delegate a filesystem's ->page_mkwrite() to. This checks for conflicting writes, then attached any netfs-specific group marking (e.g. ceph snap) to the page to be considered dirty.
--- fs/netfs/buffered_write.c | 59 +++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 4 +++ 2 files changed, 63 insertions(+)
fs/netfs/buffered_write.c +59 -0
@@ -416,3 +416,62 @@ ssize_t netfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)return ret; }EXPORT_SYMBOL (netfs_file_write_iter); + +/* +* Notification that a previously read-only page is about to become writable. +* Note that the caller indicates a single page of a multipage folio. +*/ +vm_fault_t netfs_page_mkwrite (struct vm_fault *vmf,struct netfs_group *netfs_group) +{ +struct folio *folio =page_folio (vmf->page); +struct file *file = vmf->vma->vm_file; +struct inode *inode =file_inode (file); +vm_fault_t ret =VM_FAULT_RETRY ; +int err; + +_enter ("%lx" , folio->index); + +sb_start_pagefault (inode->i_sb); + +if (folio_wait_writeback_killable (folio)) + goto out; + +if (folio_lock_killable (folio) <0 ) + goto out; + +/* Can we see a streaming write here? */ +if (WARN_ON (!folio_test_uptodate (folio))) { + ret =VM_FAULT_SIGBUS |VM_FAULT_LOCKED ; + goto out; + } + +if (netfs_folio_group (folio) != netfs_group) { +folio_unlock (folio); + err =filemap_fdatawait_range (inode->i_mapping, +folio_pos (folio), +folio_pos (folio) +folio_size (folio)); +switch (err) { +case 0 : + ret =VM_FAULT_RETRY ; + goto out; +case -ENOMEM : + ret =VM_FAULT_OOM ; + goto out; +default : + ret =VM_FAULT_SIGBUS ; + goto out; + } + } + +if (folio_test_dirty (folio)) +trace_netfs_folio (folio, netfs_folio_trace_mkwrite_plus); +else +trace_netfs_folio (folio, netfs_folio_trace_mkwrite); +netfs_set_group (folio, netfs_group); +file_update_time (file); + ret =VM_FAULT_LOCKED ; +out: +sb_end_pagefault (inode->i_sb); +return ret; +} +EXPORT_SYMBOL (netfs_page_mkwrite);
include/linux/netfs.h +4 -0
@@ -403,6 +403,10 @@ void netfs_clear_inode_writeback(struct inode *inode, const void *aux);void netfs_invalidate_folio (struct folio *folio,size_t offset,size_t length);bool netfs_release_folio (struct folio *folio,gfp_t gfp); +/* VMA operations API. */ +vm_fault_t netfs_page_mkwrite (struct vm_fault *vmf,struct netfs_group *netfs_group); + +/* (Sub)request management API. */ void netfs_subreq_terminated (struct netfs_io_subrequest *,ssize_t ,bool );void netfs_get_subrequest (struct netfs_io_subrequest *subreq,enum netfs_sreq_ref_trace what);
David Howells
maintainerPATCH v4 32/39 netfs: Provide netfs_file_read_iter()
In reply to David HowellsProvide a top-level-ish function that can be pointed to directly by ->read_iter file op.
--- fs/netfs/buffered_read.c | 73 ++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 2 ++ 2 files changed, 75 insertions(+)
fs/netfs/buffered_read.c +73 -0
@@ -558,3 +558,76 @@ int netfs_prefetch_for_write(struct file *file, struct folio *folio,_leave (" = %d" , ret);return ret; } + +/** +* netfs_buffered_read_iter - Filesystem buffered I/O read routine +* @iocb: kernel I/O control block +* @iter: destination for the data read +* +* This is the ->read_iter() routine for all filesystems that can use the page +* cache directly. +* +* The IOCB_NOWAIT flag in iocb->ki_flags indicates that -EAGAIN shall be +* returned when no data can be read without waiting for I/O requests to +* complete; it doesn't prevent readahead. +* +* The IOCB_NOIO flag in iocb->ki_flags indicates that no new I/O requests +* shall be made for the read or for readahead. When no data can be read, +* -EAGAIN shall be returned. When readahead would be triggered, a partial, +* possibly empty read shall be returned. +* +* Return: +* * number of bytes copied, even for partial reads +* * negative error code (or 0 if IOCB_NOIO) if nothing was read +*/ +ssize_t netfs_buffered_read_iter (struct kiocb *iocb,struct iov_iter *iter) +{ +struct inode *inode =file_inode (iocb->ki_filp); +struct netfs_inode *ictx =netfs_inode (inode); +ssize_t ret; + +if (WARN_ON_ONCE ((iocb->ki_flags &IOCB_DIRECT ) || +test_bit (NETFS_ICTX_UNBUFFERED , &ictx->flags))) +return -EINVAL ; + + ret =netfs_start_io_read (inode); +if (ret ==0 ) { + ret =filemap_read (iocb, iter,0 ); +netfs_end_io_read (inode); + } +return ret; +} +EXPORT_SYMBOL (netfs_buffered_read_iter); + +/** +* netfs_file_read_iter - Generic filesystem read routine +* @iocb: kernel I/O control block +* @iter: destination for the data read +* +* This is the ->read_iter() routine for all filesystems that can use the page +* cache directly. +* +* The IOCB_NOWAIT flag in iocb->ki_flags indicates that -EAGAIN shall be +* returned when no data can be read without waiting for I/O requests to +* complete; it doesn't prevent readahead. +* +* The IOCB_NOIO flag in iocb->ki_flags indicates that no new I/O requests +* shall be made for the read or for readahead. When no data can be read, +* -EAGAIN shall be returned. When readahead would be triggered, a partial, +* possibly empty read shall be returned. +* +* Return: +* * number of bytes copied, even for partial reads +* * negative error code (or 0 if IOCB_NOIO) if nothing was read +*/ +ssize_t netfs_file_read_iter (struct kiocb *iocb,struct iov_iter *iter) +{ +struct netfs_inode *ictx =netfs_inode (iocb->ki_filp->f_mapping->host); + +if ((iocb->ki_flags &IOCB_DIRECT ) || +test_bit (NETFS_ICTX_UNBUFFERED , &ictx->flags)) +return netfs_unbuffered_read_iter (iocb, iter); + +return netfs_buffered_read_iter (iocb, iter); +} +EXPORT_SYMBOL (netfs_file_read_iter);
include/linux/netfs.h +2 -0
@@ -381,6 +381,8 @@ struct netfs_cache_ops {/* High-level read API. */ ssize_t netfs_unbuffered_read_iter (struct kiocb *iocb,struct iov_iter *iter); +ssize_t netfs_buffered_read_iter (struct kiocb *iocb,struct iov_iter *iter); +ssize_t netfs_file_read_iter (struct kiocb *iocb,struct iov_iter *iter);/* High-level write API */ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,
David Howells
maintainerPATCH v4 33/39 netfs, cachefiles: Pass upper bound length to allow expansion
In reply to David HowellsMake netfslib pass the maximum length to the ->prepare_write() op to tell the cache how much it can expand the length of a write to. This allows a write to the server at the end of a file to be limited to a few bytes whilst writing an entire block to the cache (something required by direct I/O).
--- fs/cachefiles/internal.h | 2 +- fs/cachefiles/io.c | 10 ++++++---- fs/cachefiles/ondemand.c | 2 +- fs/netfs/fscache_io.c | 2 +- fs/netfs/io.c | 2 +- fs/netfs/objects.c | 1 + fs/netfs/output.c | 25 ++++++++++--------------- fs/smb/client/fscache.c | 2 +- include/linux/netfs.h | 5 +++-- 9 files changed, 25 insertions(+), 26 deletions(-)
fs/cachefiles/internal.h +1 -1
@@ -246,7 +246,7 @@ extern bool cachefiles_begin_operation(struct netfs_cache_resources *cres, enum fscache_want_state want_state);extern int __cachefiles_prepare_write (struct cachefiles_object *object,struct file *file, -loff_t *_start,size_t *_len, +loff_t *_start,size_t *_len,size_t upper_len,bool no_space_allocated_yet); extern int __cachefiles_write(struct cachefiles_object *object, struct file *file,
fs/cachefiles/io.c +6 -4
@@ -517,7 +517,7 @@ cachefiles_prepare_ondemand_read(struct netfs_cache_resources *cres,*/ int __cachefiles_prepare_write (struct cachefiles_object *object,struct file *file, -loff_t *_start,size_t *_len, +loff_t *_start,size_t *_len,size_t upper_len,bool no_space_allocated_yet) {struct cachefiles_cache *cache = object->volume->cache;
@@ -529,6 +529,8 @@ int __cachefiles_prepare_write(struct cachefiles_object *object, down = start -round_down (start,PAGE_SIZE ); *_start = start - down; *_len =round_up (down + len,PAGE_SIZE ); +if (down < start || *_len > upper_len) +return -ENOBUFS ;/* We need to work out whether there's sufficient disk space to perform * the write - but we can skip that check if we have space already
@@ -591,8 +593,8 @@ int __cachefiles_prepare_write(struct cachefiles_object *object, }static int cachefiles_prepare_write (struct netfs_cache_resources *cres, -loff_t *_start,size_t *_len,loff_t i_size, -bool no_space_allocated_yet) +loff_t *_start,size_t *_len,size_t upper_len, +loff_t i_size,bool no_space_allocated_yet) {struct cachefiles_object *object =cachefiles_cres_object (cres);struct cachefiles_cache *cache = object->volume->cache;
@@ -608,7 +610,7 @@ static int cachefiles_prepare_write(struct netfs_cache_resources *cres,cachefiles_begin_secure (cache, &saved_cred); ret =__cachefiles_prepare_write (object,cachefiles_cres_file (cres), - _start, _len, + _start, _len, upper_len, no_space_allocated_yet);cachefiles_end_secure (cache, saved_cred);return ret;
fs/cachefiles/ondemand.c +1 -1
@@ -50,7 +50,7 @@ static ssize_t cachefiles_ondemand_fd_write_iter(struct kiocb *kiocb,return -ENOBUFS ;cachefiles_begin_secure (cache, &saved_cred); - ret =__cachefiles_prepare_write (object, file, &pos, &len, true); + ret =__cachefiles_prepare_write (object, file, &pos, &len, len, true);cachefiles_end_secure (cache, saved_cred);if (ret <0 )return ret;
fs/netfs/fscache_io.c +1 -1
@@ -237,7 +237,7 @@ void __fscache_write_to_cache(struct fscache_cookie *cookie, fscache_access_io_write) < 0) goto abandon_free; - ret = cres->ops->prepare_write (cres, &start, &len, i_size, false); + ret = cres->ops->prepare_write (cres, &start, &len, len, i_size, false);if (ret <0 ) goto abandon_end;
fs/netfs/io.c +1 -1
@@ -199,7 +199,7 @@ static void netfs_rreq_do_write_to_cache(struct netfs_io_request *rreq) } ret = cres->ops->prepare_write (cres, &subreq->start, &subreq->len, - rreq->i_size, true); + subreq->len, rreq->i_size, true);if (ret <0 ) {trace_netfs_failure (rreq, subreq, ret, netfs_fail_prepare_write);trace_netfs_sreq (subreq, netfs_sreq_trace_write_skip);
fs/netfs/objects.c +1 -0
@@ -33,6 +33,7 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping, rreq->start = start; rreq->len = len; + rreq->upper_len = len; rreq->origin = origin; rreq->netfs_ops = ctx->ops; rreq->mapping = mapping;
fs/netfs/output.c +10 -15
@@ -280,7 +280,7 @@ EXPORT_SYMBOL(netfs_queue_write_request);*/ static void netfs_set_up_write_to_cache (struct netfs_io_request *wreq) { -struct netfs_cache_resources *cres; +struct netfs_cache_resources *cres = &wreq->cache_resources;struct netfs_io_subrequest *subreq;struct netfs_inode *ctx =netfs_inode (wreq->inode);struct fscache_cookie *cookie =netfs_i_cookie (ctx);
@@ -294,26 +294,21 @@ static void netfs_set_up_write_to_cache(struct netfs_io_request *wreq) }_debug ("write to cache" ); - subreq =netfs_create_write_request (wreq,NETFS_WRITE_TO_CACHE , start, len, - netfs_write_to_cache_op_worker); -if (!subreq) + ret =fscache_begin_write_operation (cres, cookie); +if (ret <0 )return ; - cres = &wreq->cache_resources; - ret =fscache_begin_read_operation (cres, cookie); -if (ret <0 ) { -netfs_write_subrequest_terminated (subreq, ret, false); + ret = cres->ops->prepare_write (cres, &start, &len, wreq->upper_len, +i_size_read (wreq->inode), true); +if (ret <0 )return ; - } - ret = cres->ops->prepare_write (cres, &start, &len,i_size_read (wreq->inode), - true); -if (ret <0 ) { -netfs_write_subrequest_terminated (subreq, ret, false); + subreq =netfs_create_write_request (wreq,NETFS_WRITE_TO_CACHE , start, len, + netfs_write_to_cache_op_worker); +if (!subreq)return ; - } -netfs_queue_write_request (subreq); +netfs_write_to_cache_op (subreq); }/*
fs/smb/client/fscache.c +1 -1
@@ -180,7 +180,7 @@ static int fscache_fallback_write_pages(struct inode *inode, loff_t start, size_if (ret <0 )return ret; - ret = cres.ops->prepare_write (&cres, &start, &len,i_size_read (inode), + ret = cres.ops->prepare_write (&cres, &start, &len, len,i_size_read (inode), no_space_allocated_yet);if (ret ==0 ) ret =fscache_write (&cres, start, &iter,NULL ,NULL );
include/linux/netfs.h +3 -2
@@ -263,6 +263,7 @@ struct netfs_io_request {atomic_t nr_copy_ops;/* Number of copy-to-cache ops in progress */ size_t submitted;/* Amount submitted for I/O so far */ size_t len;/* Length of the request */ +size_t upper_len;/* Length can be extended to here */ size_t transferred;/* Amount to be indicated as transferred */ short error;/* 0 or error that occurred */ enum netfs_io_origin origin;/* Origin of the request */
@@ -360,8 +361,8 @@ struct netfs_cache_ops {* actually do. */ int (*prepare_write)(struct netfs_cache_resources *cres, -loff_t *_start,size_t *_len,loff_t i_size, -bool no_space_allocated_yet); +loff_t *_start,size_t *_len,size_t upper_len, +loff_t i_size,bool no_space_allocated_yet);/* Prepare an on-demand read operation, shortening it to a cached/uncached * boundary as appropriate.
David Howells
maintainerPATCH v4 34/39 netfs: Provide a writepages implementation
In reply to David HowellsProvide an implementation of writepages for network filesystems to delegate to.
--- fs/netfs/buffered_write.c | 647 ++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 2 + 2 files changed, 649 insertions(+)
fs/netfs/buffered_write.c +647 -0
@@ -32,6 +32,18 @@ static void netfs_set_group(struct folio *folio, struct netfs_group *netfs_groupfolio_attach_private (folio,netfs_get_group (netfs_group)); } +#if IS_ENABLED (CONFIG_FSCACHE ) +static void netfs_folio_start_fscache (bool caching,struct folio *folio) +{ +if (caching) +folio_start_fscache (folio); +} +#else +static void netfs_folio_start_fscache (bool caching,struct folio *folio) +{ +} +#endif +/* * Decide how we should modify a folio. We might be attempting to do * write-streaming, in which case we don't want to a local RMW cycle if we can
@@ -475,3 +487,638 @@ vm_fault_t netfs_page_mkwrite(struct vm_fault *vmf, struct netfs_group *netfs_grreturn ret; }EXPORT_SYMBOL (netfs_page_mkwrite); + +/* +* Kill all the pages in the given range +*/ +static void netfs_kill_pages (struct address_space *mapping, +loff_t start,loff_t len) +{ +struct folio *folio; +pgoff_t index = start /PAGE_SIZE ; +pgoff_t last = (start + len -1 ) /PAGE_SIZE , next; + +_enter ("%llx-%llx" , start, start + len -1 ); + +do { +_debug ("kill %lx (to %lx)" , index, last); + + folio =filemap_get_folio (mapping, index); +if (IS_ERR (folio)) { + next = index +1 ; +continue ; + } + + next =folio_next_index (folio); + +trace_netfs_folio (folio, netfs_folio_trace_kill); +folio_clear_uptodate (folio); +if (folio_test_fscache (folio)) +folio_end_fscache (folio); +folio_end_writeback (folio); +folio_lock (folio); +generic_error_remove_folio (mapping, folio); +folio_unlock (folio); +folio_put (folio); + + }while (index = next, index <= last); + +_leave ("" ); +} + +/* +* Redirty all the pages in a given range. +*/ +static void netfs_redirty_pages (struct address_space *mapping, +loff_t start,loff_t len) +{ +struct folio *folio; +pgoff_t index = start /PAGE_SIZE ; +pgoff_t last = (start + len -1 ) /PAGE_SIZE , next; + +_enter ("%llx-%llx" , start, start + len -1 ); + +do { +_debug ("redirty %llx @%llx" , len, start); + + folio =filemap_get_folio (mapping, index); +if (IS_ERR (folio)) { + next = index +1 ; +continue ; + } + + next =folio_next_index (folio); +trace_netfs_folio (folio, netfs_folio_trace_redirty); +filemap_dirty_folio (mapping, folio); +if (folio_test_fscache (folio)) +folio_end_fscache (folio); +folio_end_writeback (folio); +folio_put (folio); + }while (index = next, index <= last); + +balance_dirty_pages_ratelimited (mapping); + +_leave ("" ); +} + +/* +* Completion of write to server +*/ +static void netfs_pages_written_back (struct netfs_io_request *wreq) +{ +struct address_space *mapping = wreq->mapping; +struct netfs_folio *finfo; +struct netfs_group *group =NULL ; +struct folio *folio; +pgoff_t last; +int gcount =0 ; + +XA_STATE (xas, &mapping->i_pages, wreq->start /PAGE_SIZE ); + +_enter ("%llx-%llx" , wreq->start, wreq->start + wreq->len); + +rcu_read_lock (); + + last = (wreq->start + wreq->len -1 ) /PAGE_SIZE ; +xas_for_each (&xas, folio, last) { +WARN (!folio_test_writeback (folio), +"bad %zx @%llx page %lx %lx\n" , + wreq->len, wreq->start,folio_index (folio), last); + +if ((finfo =netfs_folio_info (folio))) { +/* Streaming writes cannot be redirtied whilst under +* writeback, so discard the streaming record. +*/ +folio_detach_private (folio); + group = finfo->netfs_group; + gcount++; +trace_netfs_folio (folio, netfs_folio_trace_clear_s); +kfree (finfo); + }else if ((group =netfs_folio_group (folio))) { +/* Need to detach the group pointer if the page didn't +* get redirtied. If it has been redirtied, then it +* must be within the same group. +*/ +if (folio_test_dirty (folio)) { +trace_netfs_folio (folio, netfs_folio_trace_redirtied); + goto end_wb; + } +if (folio_trylock (folio)) { +if (!folio_test_dirty (folio)) { +folio_detach_private (folio); + gcount++; +trace_netfs_folio (folio, netfs_folio_trace_clear_g); + }else { +trace_netfs_folio (folio, netfs_folio_trace_redirtied); + } +folio_unlock (folio); + goto end_wb; + } + +xas_pause (&xas); +rcu_read_unlock (); +folio_lock (folio); +if (!folio_test_dirty (folio)) { +folio_detach_private (folio); + gcount++; +trace_netfs_folio (folio, netfs_folio_trace_clear_g); + }else { +trace_netfs_folio (folio, netfs_folio_trace_redirtied); + } +folio_unlock (folio); +rcu_read_lock (); + }else { +trace_netfs_folio (folio, netfs_folio_trace_clear); + } + end_wb: +if (folio_test_fscache (folio)) +folio_end_fscache (folio); +folio_end_writeback (folio); + } + +rcu_read_unlock (); +netfs_put_group_many (group, gcount); +_leave ("" ); +} + +/* +* Deal with the disposition of the folios that are under writeback to close +* out the operation. +*/ +static void netfs_cleanup_buffered_write (struct netfs_io_request *wreq) +{ +struct address_space *mapping = wreq->mapping; + +_enter ("" ); + +switch (wreq->error) { +case 0 : +netfs_pages_written_back (wreq); +break ; + +default : +pr_notice ("R=%08x Unexpected error %d\n" , wreq->debug_id, wreq->error); + fallthrough; +case -EACCES : +case -EPERM : +case -ENOKEY : +case -EKEYEXPIRED : +case -EKEYREJECTED : +case -EKEYREVOKED : +case -ENETRESET : +case -EDQUOT : +case -ENOSPC : +netfs_redirty_pages (mapping, wreq->start, wreq->len); +break ; + +case -EROFS : +case -EIO : +case -EREMOTEIO : +case -EFBIG : +case -ENOENT : +case -ENOMEDIUM : +case -ENXIO : +netfs_kill_pages (mapping, wreq->start, wreq->len); +break ; + } + +if (wreq->error) +mapping_set_error (mapping, wreq->error); +if (wreq->netfs_ops->done) + wreq->netfs_ops->done (wreq); +} + +/* +* Extend the region to be written back to include subsequent contiguously +* dirty pages if possible, but don't sleep while doing so. +* +* If this page holds new content, then we can include filler zeros in the +* writeback. +*/ +static void netfs_extend_writeback (struct address_space *mapping, +struct netfs_group *group, +struct xa_state *xas, +long *_count, +loff_t start, +loff_t max_len, +bool caching, +size_t *_len, +size_t *_top) +{ +struct netfs_folio *finfo; +struct folio_batch fbatch; +struct folio *folio; +unsigned int i; +pgoff_t index = (start + *_len) /PAGE_SIZE ; +size_t len; +void *priv; +bool stop = true; + +folio_batch_init (&fbatch); + +do { +/* Firstly, we gather up a batch of contiguous dirty pages +* under the RCU read lock - but we can't clear the dirty flags +* there if any of those pages are mapped. +*/ +rcu_read_lock (); + +xas_for_each (xas, folio,ULONG_MAX ) { + stop = true; +if (xas_retry (xas, folio)) +continue ; +if (xa_is_value (folio)) +break ; +if (folio_index (folio) != index) { +xas_reset (xas); +break ; + } + + priv =rcu_dereference (*(__force void __rcu **)&folio->private); +if ((const struct netfs_group *)priv != group) { + finfo = (void *)((unsigned long )priv & ~NETFS_FOLIO_INFO ); +if (finfo->netfs_group != group) { +xas_reset (xas); +break ; + } +if (finfo->dirty_offset >0 ) { +xas_reset (xas); +break ; + } + } + +if (!folio_try_get_rcu (folio)) { +xas_reset (xas); +continue ; + } + +/* Has the folio moved or been split? */ +if (unlikely (folio !=xas_reload (xas))) { +folio_put (folio); +xas_reset (xas); +break ; + } + +if (!folio_trylock (folio)) { +folio_put (folio); +xas_reset (xas); +break ; + } +if (!folio_test_dirty (folio) || +folio_test_writeback (folio) || +folio_test_fscache (folio)) { +folio_unlock (folio); +folio_put (folio); +xas_reset (xas); +break ; + } + + stop = false; + len =folio_size (folio); + priv = folio->private; +if ((const struct netfs_group *)priv != group) { + stop = true; + finfo = (void *)((unsigned long )priv & ~NETFS_FOLIO_INFO ); +if (finfo->netfs_group != group || + finfo->dirty_offset >0 ) { +folio_unlock (folio); +folio_put (folio); +xas_reset (xas); +break ; + } + len = finfo->dirty_len; + } + + *_top +=folio_size (folio); + index +=folio_nr_pages (folio); + *_count -=folio_nr_pages (folio); + *_len += len; +if (*_len >= max_len || *_count <=0 ) + stop = true; + +if (!folio_batch_add (&fbatch, folio)) +break ; +if (stop) +break ; + } + +xas_pause (xas); +rcu_read_unlock (); + +/* Now, if we obtained any folios, we can shift them to being +* writable and mark them for caching. +*/ +if (!folio_batch_count (&fbatch)) +break ; + +for (i =0 ; i <folio_batch_count (&fbatch); i++) { + folio = fbatch.folios[i]; +trace_netfs_folio (folio, netfs_folio_trace_store_plus); + +if (!folio_clear_dirty_for_io (folio)) +BUG (); +folio_start_writeback (folio); +netfs_folio_start_fscache (caching, folio); +folio_unlock (folio); + } + +folio_batch_release (&fbatch); +cond_resched (); + }while (!stop); +} + +/* +* Synchronously write back the locked page and any subsequent non-locked dirty +* pages. +*/ +static ssize_t netfs_write_back_from_locked_folio (struct address_space *mapping, +struct writeback_control *wbc, +struct netfs_group *group, +struct xa_state *xas, +struct folio *folio, +unsigned long long start, +unsigned long long end) +{ +struct netfs_io_request *wreq; +struct netfs_folio *finfo; +struct netfs_inode *ctx =netfs_inode (mapping->host); +unsigned long long i_size =i_size_read (&ctx->inode); +size_t len, max_len; +bool caching =netfs_is_cache_enabled (ctx); +long count = wbc->nr_to_write; +int ret; + +_enter (",%lx,%llx-%llx,%u" ,folio_index (folio), start, end, caching); + + wreq =netfs_alloc_request (mapping,NULL , start,folio_size (folio), +NETFS_WRITEBACK ); +if (IS_ERR (wreq)) { +folio_unlock (folio); +return PTR_ERR (wreq); + } + +if (!folio_clear_dirty_for_io (folio)) +BUG (); +folio_start_writeback (folio); +netfs_folio_start_fscache (caching, folio); + + count -=folio_nr_pages (folio); + +/* Find all consecutive lockable dirty pages that have contiguous +* written regions, stopping when we find a page that is not +* immediately lockable, is not dirty or is missing, or we reach the +* end of the range. +*/ +trace_netfs_folio (folio, netfs_folio_trace_store); + + len = wreq->len; + finfo =netfs_folio_info (folio); +if (finfo) { + start += finfo->dirty_offset; +if (finfo->dirty_offset + finfo->dirty_len != len) { + len = finfo->dirty_len; + goto cant_expand; + } + len = finfo->dirty_len; + } + +if (start < i_size) { +/* Trim the write to the EOF; the extra data is ignored. Also +* put an upper limit on the size of a single storedata op. +*/ + max_len =65536 *4096 ; + max_len = min_t(unsigned long long, max_len, end - start + 1); + max_len = min_t(unsigned long long, max_len, i_size - start); + +if (len < max_len) +netfs_extend_writeback (mapping, group, xas, &count, start, + max_len, caching, &len, &wreq->upper_len); + } + +cant_expand: + len = min_t(unsigned long long, len, i_size - start); + +/* We now have a contiguous set of dirty pages, each with writeback +* set; the first page is still locked at this point, but all the rest +* have been unlocked. +*/ +folio_unlock (folio); + wreq->start = start; + wreq->len = len; + +if (start < i_size) { +_debug ("write back %zx @%llx [%llx]" , len, start, i_size); + +/* Speculatively write to the cache. We have to fix this up +* later if the store fails. +*/ + wreq->cleanup = netfs_cleanup_buffered_write; + +iov_iter_xarray (&wreq->iter,ITER_SOURCE , &mapping->i_pages, start, + wreq->upper_len); +__set_bit (NETFS_RREQ_UPLOAD_TO_SERVER , &wreq->flags); + ret =netfs_begin_write (wreq, true, netfs_write_trace_writeback); +if (ret ==0 || ret == -EIOCBQUEUED ) + wbc->nr_to_write -= len /PAGE_SIZE ; + }else { +_debug ("write discard %zx @%llx [%llx]" , len, start, i_size); + +/* The dirty region was entirely beyond the EOF. */ +fscache_clear_page_bits (mapping, start, len, caching); +netfs_pages_written_back (wreq); + ret =0 ; + } + +netfs_put_request (wreq, false, netfs_rreq_trace_put_return); +_leave (" = 1" ); +return 1 ; +} + +/* +* Write a region of pages back to the server +*/ +static ssize_t netfs_writepages_begin (struct address_space *mapping, +struct writeback_control *wbc, +struct netfs_group *group, +struct xa_state *xas, +unsigned long long *_start, +unsigned long long end) +{ +const struct netfs_folio *finfo; +struct folio *folio; +unsigned long long start = *_start; +ssize_t ret; +void *priv; +int skips =0 ; + +_enter ("%llx,%llx," , start, end); + +search_again: +/* Find the first dirty page in the group. */ +rcu_read_lock (); + +for (;;) { + folio =xas_find_marked (xas, end /PAGE_SIZE ,PAGECACHE_TAG_DIRTY ); +if (xas_retry (xas, folio) ||xa_is_value (folio)) +continue ; +if (!folio) +break ; + +/* Skip any dirty folio that's not in the group of interest. */ + priv =rcu_dereference (*(__force void __rcu **)&folio->private); +if ((const struct netfs_group *)priv != group) { + finfo = (void *)((unsigned long )priv & ~NETFS_FOLIO_INFO ); +if (finfo->netfs_group != group) +continue ; + } + +if (!folio_try_get_rcu (folio)) { +xas_reset (xas); +continue ; + } + +if (unlikely (folio !=xas_reload (xas))) { +folio_put (folio); +xas_reset (xas); +continue ; + } + +xas_pause (xas); +break ; + } +rcu_read_unlock (); +if (!folio) +return 0 ; + + start =folio_pos (folio);/* May regress with THPs */ + +_debug ("wback %lx" ,folio_index (folio)); + +/* At this point we hold neither the i_pages lock nor the page lock: +* the page may be truncated or invalidated (changing page->mapping to +* NULL), or even swizzled back from swapper_space to tmpfs file +* mapping +*/ +lock_again: +if (wbc->sync_mode !=WB_SYNC_NONE ) { + ret =folio_lock_killable (folio); +if (ret <0 ) +return ret; + }else { +if (!folio_trylock (folio)) + goto search_again; + } + +if (folio->mapping != mapping || + !folio_test_dirty (folio)) { + start +=folio_size (folio); +folio_unlock (folio); + goto search_again; + } + +if (folio_test_writeback (folio) || +folio_test_fscache (folio)) { +folio_unlock (folio); +if (wbc->sync_mode !=WB_SYNC_NONE ) { +folio_wait_writeback (folio); +#ifdef CONFIG_NETFS_FSCACHE +folio_wait_fscache (folio); +#endif + goto lock_again; + } + + start +=folio_size (folio); +if (wbc->sync_mode ==WB_SYNC_NONE ) { +if (skips >=5 ||need_resched ()) { + ret =0 ; + goto out; + } + skips++; + } + goto search_again; + } + + ret =netfs_write_back_from_locked_folio (mapping, wbc, group, xas, + folio, start, end); +out: +if (ret >0 ) + *_start = start + ret; +_leave (" = %zd [%llx]" , ret, *_start); +return ret; +} + +/* +* Write a region of pages back to the server +*/ +static int netfs_writepages_region (struct address_space *mapping, +struct writeback_control *wbc, +struct netfs_group *group, +unsigned long long *_start, +unsigned long long end) +{ +ssize_t ret; + +XA_STATE (xas, &mapping->i_pages, *_start /PAGE_SIZE ); + +do { + ret =netfs_writepages_begin (mapping, wbc, group, &xas, + _start, end); +if (ret >0 && wbc->nr_to_write >0 ) +cond_resched (); + }while (ret >0 && wbc->nr_to_write >0 ); + +return ret >0 ?0 : ret; +} + +/* +* write some of the pending data back to the server +*/ +int netfs_writepages (struct address_space *mapping, +struct writeback_control *wbc) +{ +struct netfs_group *group =NULL ; +loff_t start, end; +int ret; + +_enter ("" ); + +/* We have to be careful as we can end up racing with setattr() +* truncating the pagecache since the caller doesn't take a lock here +* to prevent it. +*/ + +if (wbc->range_cyclic && mapping->writeback_index) { + start = mapping->writeback_index *PAGE_SIZE ; + ret =netfs_writepages_region (mapping, wbc, group, + &start,LLONG_MAX ); +if (ret <0 ) + goto out; + +if (wbc->nr_to_write <=0 ) { + mapping->writeback_index = start /PAGE_SIZE ; + goto out; + } + + start =0 ; + end = mapping->writeback_index *PAGE_SIZE ; + mapping->writeback_index =0 ; + ret =netfs_writepages_region (mapping, wbc, group, &start, end); +if (ret ==0 ) + mapping->writeback_index = start /PAGE_SIZE ; + }else if (wbc->range_start ==0 && wbc->range_end ==LLONG_MAX ) { + start =0 ; + ret =netfs_writepages_region (mapping, wbc, group, + &start,LLONG_MAX ); +if (wbc->nr_to_write >0 && ret ==0 ) + mapping->writeback_index = start /PAGE_SIZE ; + }else { + start = wbc->range_start; + ret =netfs_writepages_region (mapping, wbc, group, + &start, wbc->range_end); + } + +out: +_leave (" = %d" , ret); +return ret; +} +EXPORT_SYMBOL (netfs_writepages);
include/linux/netfs.h +2 -0
@@ -400,6 +400,8 @@ int netfs_read_folio(struct file *, struct folio *);int netfs_write_begin (struct netfs_inode *,struct file *,struct address_space *,loff_t pos,unsigned int len,struct folio **,void **fsdata); +int netfs_writepages (struct address_space *mapping, +struct writeback_control *wbc);bool netfs_dirty_folio (struct address_space *mapping,struct folio *folio);int netfs_unpin_writeback (struct inode *inode,struct writeback_control *wbc);void netfs_clear_inode_writeback (struct inode *inode,const void *aux);
David Howells
maintainerPATCH v4 35/39 netfs: Provide a launder_folio implementation
In reply to David HowellsProvide a launder_folio implementation for netfslib.
--- fs/netfs/buffered_write.c | 74 ++++++++++++++++++++++++++++++++++++ fs/netfs/main.c | 1 + include/linux/netfs.h | 2 + include/trace/events/netfs.h | 3 ++ 4 files changed, 80 insertions(+)
fs/netfs/buffered_write.c +74 -0
@@ -1122,3 +1122,77 @@ int netfs_writepages(struct address_space *mapping,return ret; }EXPORT_SYMBOL (netfs_writepages); + +/* +* Deal with the disposition of a laundered folio. +*/ +static void netfs_cleanup_launder_folio (struct netfs_io_request *wreq) +{ +if (wreq->error) { +pr_notice ("R=%08x Laundering error %d\n" , wreq->debug_id, wreq->error); +mapping_set_error (wreq->mapping, wreq->error); + } +} + +/** +* netfs_launder_folio - Clean up a dirty folio that's being invalidated +* @folio: The folio to clean +* +* This is called to write back a folio that's being invalidated when an inode +* is getting torn down. Ideally, writepages would be used instead. +*/ +int netfs_launder_folio (struct folio *folio) +{ +struct netfs_io_request *wreq; +struct address_space *mapping = folio->mapping; +struct netfs_folio *finfo =netfs_folio_info (folio); +struct netfs_group *group =netfs_folio_group (folio); +struct bio_vec bvec; +unsigned long long i_size =i_size_read (mapping->host); +unsigned long long start =folio_pos (folio); +size_t offset =0 , len; +int ret =0 ; + +if (finfo) { + offset = finfo->dirty_offset; + start += offset; + len = finfo->dirty_len; + }else { + len =folio_size (folio); + } + len = min_t(unsigned long long, len, i_size - start); + + wreq =netfs_alloc_request (mapping,NULL , start, len,NETFS_LAUNDER_WRITE ); +if (IS_ERR (wreq)) { + ret =PTR_ERR (wreq); + goto out; + } + +if (!folio_clear_dirty_for_io (folio)) + goto out_put; + +trace_netfs_folio (folio, netfs_folio_trace_launder); + +_debug ("launder %llx-%llx" , start, start + len -1 ); + +/* Speculatively write to the cache. We have to fix this up later if +* the store fails. +*/ + wreq->cleanup = netfs_cleanup_launder_folio; + +bvec_set_folio (&bvec, folio, len, offset); +iov_iter_bvec (&wreq->iter,ITER_SOURCE , &bvec,1 , len); +__set_bit (NETFS_RREQ_UPLOAD_TO_SERVER , &wreq->flags); + ret =netfs_begin_write (wreq, true, netfs_write_trace_launder); + +out_put: +folio_detach_private (folio); +netfs_put_group (group); +kfree (finfo); +netfs_put_request (wreq, false, netfs_rreq_trace_put_return); +out: +folio_wait_fscache (folio); +_leave (" = %d" , ret); +return ret; +} +EXPORT_SYMBOL (netfs_launder_folio);
fs/netfs/main.c +1 -0
@@ -33,6 +33,7 @@ static const char *netfs_origins[nr__netfs_io_origin] = { [NETFS_READPAGE] = "RP", [NETFS_READ_FOR_WRITE] = "RW", [NETFS_WRITEBACK] = "WB", + [NETFS_LAUNDER_WRITE] = "LW", [NETFS_UNBUFFERED_WRITE] = "UW", [NETFS_DIO_READ] = "DR", [NETFS_DIO_WRITE] = "DW",
include/linux/netfs.h +2 -0
@@ -227,6 +227,7 @@ enum netfs_io_origin {NETFS_READPAGE ,/* This read is a synchronous read */ NETFS_READ_FOR_WRITE ,/* This read is to prepare a write */ NETFS_WRITEBACK ,/* This write was triggered by writepages */ +NETFS_LAUNDER_WRITE ,/* This is triggered by ->launder_folio() */ NETFS_UNBUFFERED_WRITE ,/* This is an unbuffered write */ NETFS_DIO_READ ,/* This is a direct I/O read */ NETFS_DIO_WRITE, /* This is a direct I/O write */
@@ -407,6 +408,7 @@ int netfs_unpin_writeback(struct inode *inode, struct writeback_control *wbc);void netfs_clear_inode_writeback (struct inode *inode,const void *aux);void netfs_invalidate_folio (struct folio *folio,size_t offset,size_t length);bool netfs_release_folio (struct folio *folio,gfp_t gfp); +int netfs_launder_folio (struct folio *folio);/* VMA operations API. */ vm_fault_t netfs_page_mkwrite (struct vm_fault *vmf,struct netfs_group *netfs_group);
include/trace/events/netfs.h +3 -0
@@ -25,6 +25,7 @@#define netfs_write_traces \ EM(netfs_write_trace_dio_write, "DIO-WRITE") \ + EM(netfs_write_trace_launder, "LAUNDER ") \ EM(netfs_write_trace_unbuffered_write, "UNB-WRITE") \ E_(netfs_write_trace_writeback, "WRITEBACK")
@@ -33,6 +34,7 @@ EM(NETFS_READPAGE, "RP") \ EM(NETFS_READ_FOR_WRITE, "RW") \ EM(NETFS_WRITEBACK, "WB") \ + EM(NETFS_LAUNDER_WRITE, "LW") \ EM(NETFS_UNBUFFERED_WRITE, "UW") \ EM(NETFS_DIO_READ, "DR") \E_ (NETFS_DIO_WRITE ,"DW" )
@@ -127,6 +129,7 @@ EM(netfs_folio_trace_end_copy, "end-copy") \ EM(netfs_folio_trace_filled_gaps, "filled-gaps") \ EM(netfs_folio_trace_kill, "kill") \ + EM(netfs_folio_trace_launder, "launder") \ EM(netfs_folio_trace_mkwrite, "mkwrite") \ EM(netfs_folio_trace_mkwrite_plus, "mkwrite+") \EM (netfs_folio_trace_read_gaps,"read-gaps" ) \
David Howells
maintainerPATCH v4 36/39 netfs: Implement a write-through caching option
In reply to David HowellsProvide a flag whereby a filesystem may request that cifs_perform_write() perform write-through caching. This involves putting pages directly into writeback rather than dirty and attaching them to a write operation as we go.
Further, the writes being made are limited to the byte range being written rather than whole folios being written. This can be used by cifs, for example, to deal with strict byte-range locking.
This can't be used with content encryption as that may require expansion of the write RPC beyond the write being made.
This doesn't affect writes via mmap - those are written back in the normal way; similarly failed writethrough writes are marked dirty and left to writeback to retry. Another option would be to simply invalidate them, but the contents can be simultaneously accessed by read() and through mmap.
--- fs/netfs/buffered_write.c | 69 +++++++++++++++++++++++---- fs/netfs/internal.h | 3 ++ fs/netfs/main.c | 1 + fs/netfs/objects.c | 1 + fs/netfs/output.c | 90 ++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 2 + include/trace/events/netfs.h | 8 +++- 7 files changed, 162 insertions(+), 12 deletions(-)
fs/netfs/buffered_write.c +59 -10
@@ -26,6 +26,8 @@ enum netfs_how_to_modify { NETFS_FLUSH_CONTENT, /* Flush incompatible content. */ }; +static void netfs_cleanup_buffered_write (struct netfs_io_request *wreq); +static void netfs_set_group (struct folio *folio,struct netfs_group *netfs_group) {if (netfs_group && !folio_get_private (folio))
@@ -133,6 +135,14 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,struct inode *inode =file_inode (file);struct address_space *mapping = inode->i_mapping;struct netfs_inode *ctx =netfs_inode (inode); +struct writeback_control wbc = { + .sync_mode =WB_SYNC_NONE , + .for_sync = true, + .nr_to_write =LONG_MAX , + .range_start = iocb->ki_pos, + .range_end = iocb->ki_pos + iter->count, + }; +struct netfs_io_request *wreq =NULL ;struct netfs_folio *finfo;struct folio *folio;enum netfs_how_to_modify howto;
@@ -143,6 +153,30 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,size_t max_chunk =PAGE_SIZE <<MAX_PAGECACHE_ORDER ;bool maybe_trouble = false; +if (unlikely (test_bit (NETFS_ICTX_WRITETHROUGH , &ctx->flags) || + iocb->ki_flags & (IOCB_DSYNC |IOCB_SYNC )) + ) { +if (pos <i_size_read (inode)) { + ret =filemap_write_and_wait_range (mapping, pos, pos + iter->count); +if (ret <0 ) { + goto out; + } + } + +wbc_attach_fdatawrite_inode (&wbc, mapping->host); + + wreq =netfs_begin_writethrough (iocb, iter->count); +if (IS_ERR (wreq)) { +wbc_detach_inode (&wbc); + ret =PTR_ERR (wreq); + wreq =NULL ; + goto out; + } +if (!is_sync_kiocb (iocb)) + wreq->iocb = iocb; + wreq->cleanup = netfs_cleanup_buffered_write; + } + do { size_t flen; size_t offset; /* Offset into pagecache folio */
@@ -315,7 +349,25 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, } written += copied; -folio_mark_dirty (folio); +if (likely (!wreq)) { +folio_mark_dirty (folio); + }else { +if (folio_test_dirty (folio)) +/* Sigh. mmap. */ +folio_clear_dirty_for_io (folio); +/* We make multiple writes to the folio... */ +if (!folio_test_writeback (folio)) { +folio_wait_fscache (folio); +folio_start_writeback (folio); +folio_start_fscache (folio); +if (wreq->iter.count ==0 ) +trace_netfs_folio (folio, netfs_folio_trace_wthru); +else +trace_netfs_folio (folio, netfs_folio_trace_wthru_plus); + } +netfs_advance_writethrough (wreq, copied, + offset + copied == flen); + } retry:folio_unlock (folio);folio_put (folio);
@@ -325,17 +377,14 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, }while (iov_iter_count (iter)); out: -if (likely (written)) { -/* Flush and wait for a write that requires immediate synchronisation. */ -if (iocb->ki_flags & (IOCB_DSYNC |IOCB_SYNC )) { -_debug ("dsync" ); - ret =filemap_fdatawait_range (mapping, iocb->ki_pos, - iocb->ki_pos + written); - } - - iocb->ki_pos += written; +if (unlikely (wreq)) { + ret =netfs_end_writethrough (wreq, iocb); +wbc_detach_inode (&wbc); +if (ret == -EIOCBQUEUED ) +return ret; } + iocb->ki_pos += written;_leave (" = %zd [%zd]" , written, ret);return written ? written : ret;
fs/netfs/internal.h +3 -0
@@ -101,6 +101,9 @@ static inline void netfs_see_request(struct netfs_io_request *rreq,*/ int netfs_begin_write (struct netfs_io_request *wreq,bool may_wait,enum netfs_write_trace what); +struct netfs_io_request *netfs_begin_writethrough (struct kiocb *iocb,size_t len); +int netfs_advance_writethrough (struct netfs_io_request *wreq,size_t copied,bool to_page_end); +int netfs_end_writethrough (struct netfs_io_request *wreq,struct kiocb *iocb);/* * stats.c
fs/netfs/main.c +1 -0
@@ -33,6 +33,7 @@ static const char *netfs_origins[nr__netfs_io_origin] = { [NETFS_READPAGE] = "RP", [NETFS_READ_FOR_WRITE] = "RW", [NETFS_WRITEBACK] = "WB", + [NETFS_WRITETHROUGH] = "WT", [NETFS_LAUNDER_WRITE] = "LW", [NETFS_UNBUFFERED_WRITE] = "UW", [NETFS_DIO_READ] = "DR",
fs/netfs/objects.c +1 -0
@@ -42,6 +42,7 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping, rreq->debug_id =atomic_inc_return (&debug_ids);xa_init (&rreq->bounce);INIT_LIST_HEAD (&rreq->subrequests); +INIT_WORK (&rreq->work,NULL );refcount_set (&rreq->ref,1 );__set_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags);
fs/netfs/output.c +90 -0
93 lines not on this page · raw message
include/linux/netfs.h +2 -0
@@ -139,6 +139,7 @@ struct netfs_inode {unsigned long flags;#define NETFS_ICTX_ODIRECT 0/* The file has DIO in progress */ #define NETFS_ICTX_UNBUFFERED 1/* I/O should not use the pagecache */ +#define NETFS_ICTX_WRITETHROUGH 2/* Write-through caching */ };/*
@@ -227,6 +228,7 @@ enum netfs_io_origin {NETFS_READPAGE ,/* This read is a synchronous read */ NETFS_READ_FOR_WRITE ,/* This read is to prepare a write */ NETFS_WRITEBACK ,/* This write was triggered by writepages */ +NETFS_WRITETHROUGH ,/* This write was made by netfs_perform_write() */ NETFS_LAUNDER_WRITE ,/* This is triggered by ->launder_folio() */ NETFS_UNBUFFERED_WRITE ,/* This is an unbuffered write */ NETFS_DIO_READ, /* This is a direct I/O read */
include/trace/events/netfs.h +6 -2
@@ -27,13 +27,15 @@ EM(netfs_write_trace_dio_write, "DIO-WRITE") \ EM(netfs_write_trace_launder, "LAUNDER ") \ EM(netfs_write_trace_unbuffered_write, "UNB-WRITE") \ - E_(netfs_write_trace_writeback, "WRITEBACK") + EM(netfs_write_trace_writeback, "WRITEBACK") \ + E_(netfs_write_trace_writethrough, "WRITETHRU")#define netfs_rreq_origins \ EM(NETFS_READAHEAD, "RA") \ EM(NETFS_READPAGE, "RP") \ EM(NETFS_READ_FOR_WRITE, "RW") \ EM(NETFS_WRITEBACK, "WB") \ + EM(NETFS_WRITETHROUGH, "WT") \ EM(NETFS_LAUNDER_WRITE, "LW") \ EM(NETFS_UNBUFFERED_WRITE, "UW") \ EM(NETFS_DIO_READ, "DR") \
@@ -136,7 +138,9 @@ EM(netfs_folio_trace_redirty, "redirty") \ EM(netfs_folio_trace_redirtied, "redirtied") \ EM(netfs_folio_trace_store, "store") \ - E_(netfs_folio_trace_store_plus, "store+") + EM(netfs_folio_trace_store_plus, "store+") \ + EM(netfs_folio_trace_wthru, "wthru") \ + E_(netfs_folio_trace_wthru_plus, "wthru+")#ifndef __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY#define __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
Jeff Layton
maintainerRe: [PATCH v4 36/39] netfs: Implement a write-through caching option
Quoted 9 lines · David Howells
Provide a flag whereby a filesystem may request that
cifs_perform_write()perform write-through caching. This involves putting pages directly into writeback rather than dirty and attaching them to a write operation as we go.Further, the writes being made are limited to the byte range being written rather than whole folios being written. This can be used by cifs, for example, to deal with strict byte-range locking.
This is pretty cool. I wonder if that will help cifs pass more locking tests?
Quoted 8 lines
This can't be used with content encryption as that may require expansion of the write RPC beyond the write being made.
This doesn't affect writes via mmap - those are written back in the normal way; similarly failed writethrough writes are marked dirty and left to writeback to retry. Another option would be to simply invalidate them, but the contents can be simultaneously accessed by
read()and through mmap.
I do wish Linux were less of a mess in this regard. Different filesystems behave differently when writeback fails.
That said, the modern consensus with local filesystems is to just leave the pages clean when buffered writeback fails, but set a writeback error on the inode. That at least keeps dirty pages from stacking up in the cache. In the case of something like a netfs, we usually invalidate the inode and the pages -- netfs's usually have to spontaneously deal with that anyway, so we might as well.
Marking the pages dirty here should mean that they'll effectively get a second try at writeback, which is a change in behavior from most filesystems. I'm not sure it's a bad one, but writeback can take a long time if you have a laggy network.
When a write has already failed once, why do you think it'll succeed on a second attempt (and probably with page-aligned I/O, I guess)?
Another question: when the writeback is (re)attempted, will it end up just doing page-aligned I/O, or is the byte range still going to be limited to the written range?
The more I consider it, I think it might be a lot simpler to just "fail fast" here rather than remarking the write dirty.
Quoted 314 lines
Signed-off-by David Howells <[email protected]>cc Jeff Layton <[email protected]>--- fs/netfs/buffered_write.c | 69 +++++++++++++++++++++++---- fs/netfs/internal.h | 3 ++ fs/netfs/main.c | 1 + fs/netfs/objects.c | 1 + fs/netfs/output.c | 90 ++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 2 + include/trace/events/netfs.h | 8 +++- 7 files changed, 162 insertions(+), 12 deletions(-)fs/netfs/buffered_write.c +59
-10@@ -26,6 +26,8 @@ enum netfs_how_to_modify { NETFS_FLUSH_CONTENT, /* Flush incompatible content. */ }; +static void netfs_cleanup_buffered_write (struct netfs_io_request *wreq); +static void netfs_set_group (struct folio *folio,struct netfs_group *netfs_group) {if (netfs_group && !folio_get_private (folio))@@ -133,6 +135,14 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,struct inode *inode =file_inode (file);struct address_space *mapping = inode->i_mapping;struct netfs_inode *ctx =netfs_inode (inode); +struct writeback_control wbc = { + .sync_mode =WB_SYNC_NONE , + .for_sync = true, + .nr_to_write =LONG_MAX , + .range_start = iocb->ki_pos, + .range_end = iocb->ki_pos + iter->count, + }; +struct netfs_io_request *wreq =NULL ;struct netfs_folio *finfo;struct folio *folio;enum netfs_how_to_modify howto;@@ -143,6 +153,30 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,size_t max_chunk =PAGE_SIZE <<MAX_PAGECACHE_ORDER ;bool maybe_trouble = false; +if (unlikely (test_bit (NETFS_ICTX_WRITETHROUGH , &ctx->flags) || + iocb->ki_flags & (IOCB_DSYNC |IOCB_SYNC )) + ) { +if (pos <i_size_read (inode)) { + ret =filemap_write_and_wait_range (mapping, pos, pos + iter->count); +if (ret <0 ) { + goto out; + } + } + +wbc_attach_fdatawrite_inode (&wbc, mapping->host); + + wreq =netfs_begin_writethrough (iocb, iter->count); +if (IS_ERR (wreq)) { +wbc_detach_inode (&wbc); + ret =PTR_ERR (wreq); + wreq =NULL ; + goto out; + } +if (!is_sync_kiocb (iocb)) + wreq->iocb = iocb; + wreq->cleanup = netfs_cleanup_buffered_write; + } + do { size_t flen; size_t offset; /* Offset into pagecache folio */@@ -315,7 +349,25 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, } written += copied; -folio_mark_dirty (folio); +if (likely (!wreq)) { +folio_mark_dirty (folio); + }else { +if (folio_test_dirty (folio)) +/* Sigh. mmap. */ +folio_clear_dirty_for_io (folio); +/* We make multiple writes to the folio... */ +if (!folio_test_writeback (folio)) { +folio_wait_fscache (folio); +folio_start_writeback (folio); +folio_start_fscache (folio); +if (wreq->iter.count ==0 ) +trace_netfs_folio (folio, netfs_folio_trace_wthru); +else +trace_netfs_folio (folio, netfs_folio_trace_wthru_plus); + } +netfs_advance_writethrough (wreq, copied, + offset + copied == flen); + } retry:folio_unlock (folio);folio_put (folio);@@ -325,17 +377,14 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, }while (iov_iter_count (iter)); out: -if (likely (written)) { -/* Flush and wait for a write that requires immediate synchronisation. */ -if (iocb->ki_flags & (IOCB_DSYNC |IOCB_SYNC )) { -_debug ("dsync" ); - ret =filemap_fdatawait_range (mapping, iocb->ki_pos, - iocb->ki_pos + written); - } - - iocb->ki_pos += written; +if (unlikely (wreq)) { + ret =netfs_end_writethrough (wreq, iocb); +wbc_detach_inode (&wbc); +if (ret == -EIOCBQUEUED ) +return ret; } + iocb->ki_pos += written;_leave (" = %zd [%zd]" , written, ret);return written ? written : ret;fs/netfs/internal.h +3
-0@@ -101,6 +101,9 @@ static inline void netfs_see_request(struct netfs_io_request *rreq,*/ int netfs_begin_write (struct netfs_io_request *wreq,bool may_wait,enum netfs_write_trace what); +struct netfs_io_request *netfs_begin_writethrough (struct kiocb *iocb,size_t len); +int netfs_advance_writethrough (struct netfs_io_request *wreq,size_t copied,bool to_page_end); +int netfs_end_writethrough (struct netfs_io_request *wreq,struct kiocb *iocb);/* * stats.c fs/netfs/main.c +1
-0@@ -33,6 +33,7 @@ static const char *netfs_origins[nr__netfs_io_origin] = { [NETFS_READPAGE] = "RP", [NETFS_READ_FOR_WRITE] = "RW", [NETFS_WRITEBACK] = "WB", + [NETFS_WRITETHROUGH] = "WT", [NETFS_LAUNDER_WRITE] = "LW", [NETFS_UNBUFFERED_WRITE] = "UW", [NETFS_DIO_READ] = "DR",fs/netfs/objects.c +1
-0@@ -42,6 +42,7 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping, rreq->debug_id =atomic_inc_return (&debug_ids);xa_init (&rreq->bounce);INIT_LIST_HEAD (&rreq->subrequests); +INIT_WORK (&rreq->work,NULL );refcount_set (&rreq->ref,1 );__set_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags);fs/netfs/output.c +90
-0@@ -386,3 +386,93 @@ int netfs_begin_write(struct netfs_io_request *wreq, bool may_wait, TASK_UNINTERRUPTIBLE);return wreq->error; } + +/* +* Begin a write operation for writing through the pagecache. +*/ +struct netfs_io_request *netfs_begin_writethrough (struct kiocb *iocb,size_t len) +{ +struct netfs_io_request *wreq; +struct file *file = iocb->ki_filp; + + wreq =netfs_alloc_request (file->f_mapping, file, iocb->ki_pos, len, +NETFS_WRITETHROUGH ); +if (IS_ERR (wreq)) +return wreq; + +trace_netfs_write (wreq, netfs_write_trace_writethrough); + +__set_bit (NETFS_RREQ_UPLOAD_TO_SERVER , &wreq->flags); +iov_iter_xarray (&wreq->iter,ITER_SOURCE , &wreq->mapping->i_pages, wreq->start,0 ); + wreq->io_iter = wreq->iter; + +/* ->outstanding > 0 carries a ref */ +netfs_get_request (wreq, netfs_rreq_trace_get_for_outstanding); +atomic_set (&wreq->nr_outstanding,1 ); +return wreq; +} + +static void netfs_submit_writethrough (struct netfs_io_request *wreq,bool final) +{ +struct netfs_inode *ictx =netfs_inode (wreq->inode); +unsigned long long start; +size_t len; + +if (!test_bit (NETFS_RREQ_UPLOAD_TO_SERVER , &wreq->flags)) +return ; + + start = wreq->start + wreq->submitted; + len = wreq->iter.count - wreq->submitted; +if (!final) { + len /= wreq->wsize;/* Round to number of maximum packets */ + len *= wreq->wsize; + } + + ictx->ops->create_write_requests (wreq, start, len); + wreq->submitted += len; +} + +/* +* Advance the state of the write operation used when writing through the +* pagecache. Data has been copied into the pagecache that we need to append +* to the request. If we've added more than wsize then we need to create a new +* subrequest. +*/ +int netfs_advance_writethrough (struct netfs_io_request *wreq,size_t copied,bool to_page_end) +{ +_enter ("ic=%zu sb=%zu ws=%u cp=%zu tp=%u" , + wreq->iter.count, wreq->submitted, wreq->wsize, copied, to_page_end); + + wreq->iter.count += copied; + wreq->io_iter.count += copied; +if (to_page_end && wreq->io_iter.count - wreq->submitted >= wreq->wsize) +netfs_submit_writethrough (wreq, false); + +return wreq->error; +} + +/* +* End a write operation used when writing through the pagecache. +*/ +int netfs_end_writethrough (struct netfs_io_request *wreq,struct kiocb *iocb) +{ +int ret = -EIOCBQUEUED ; + +_enter ("ic=%zu sb=%zu ws=%u" , + wreq->iter.count, wreq->submitted, wreq->wsize); + +if (wreq->submitted < wreq->io_iter.count) +netfs_submit_writethrough (wreq, true); + +if (atomic_dec_and_test (&wreq->nr_outstanding)) +netfs_write_terminated (wreq, false); + +if (is_sync_kiocb (iocb)) { +wait_on_bit (&wreq->flags,NETFS_RREQ_IN_PROGRESS , +TASK_UNINTERRUPTIBLE ); + ret = wreq->error; + } + +netfs_put_request (wreq, false, netfs_rreq_trace_put_return); +return ret; +}include/linux/netfs.h +2
-0@@ -139,6 +139,7 @@ struct netfs_inode {unsigned long flags;#define NETFS_ICTX_ODIRECT 0/* The file has DIO in progress */ #define NETFS_ICTX_UNBUFFERED 1/* I/O should not use the pagecache */ +#define NETFS_ICTX_WRITETHROUGH 2/* Write-through caching */ };/* @@ -227,6 +228,7 @@ enum netfs_io_origin {NETFS_READPAGE ,/* This read is a synchronous read */ NETFS_READ_FOR_WRITE ,/* This read is to prepare a write */ NETFS_WRITEBACK ,/* This write was triggered by writepages */ +NETFS_WRITETHROUGH ,/* This write was made by netfs_perform_write() */ NETFS_LAUNDER_WRITE ,/* This is triggered by ->launder_folio() */ NETFS_UNBUFFERED_WRITE ,/* This is an unbuffered write */ NETFS_DIO_READ, /* This is a direct I/O read */include/trace/events/netfs.h +6
-2@@ -27,13 +27,15 @@ EM(netfs_write_trace_dio_write, "DIO-WRITE") \ EM(netfs_write_trace_launder, "LAUNDER ") \ EM(netfs_write_trace_unbuffered_write, "UNB-WRITE") \ - E_(netfs_write_trace_writeback, "WRITEBACK") + EM(netfs_write_trace_writeback, "WRITEBACK") \ + E_(netfs_write_trace_writethrough, "WRITETHRU")#define netfs_rreq_origins \ EM(NETFS_READAHEAD, "RA") \ EM(NETFS_READPAGE, "RP") \ EM(NETFS_READ_FOR_WRITE, "RW") \ EM(NETFS_WRITEBACK, "WB") \ + EM(NETFS_WRITETHROUGH, "WT") \ EM(NETFS_LAUNDER_WRITE, "LW") \ EM(NETFS_UNBUFFERED_WRITE, "UW") \ EM(NETFS_DIO_READ, "DR") \@@ -136,7 +138,9 @@ EM(netfs_folio_trace_redirty, "redirty") \ EM(netfs_folio_trace_redirtied, "redirtied") \ EM(netfs_folio_trace_store, "store") \ - E_(netfs_folio_trace_store_plus, "store+") + EM(netfs_folio_trace_store_plus, "store+") \ + EM(netfs_folio_trace_wthru, "wthru") \ + E_(netfs_folio_trace_wthru_plus, "wthru+")#ifndef __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY#define __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
Signature · 1 line
Jeff Layton <[email protected]>
David Howells
maintainerRe: [PATCH v4 36/39] netfs: Implement a write-through caching option
Quoted 11 lines · Jeff Layton
Quoted 8 lines
This can't be used with content encryption as that may require expansion of the write RPC beyond the write being made.
This doesn't affect writes via mmap - those are written back in the normal way; similarly failed writethrough writes are marked dirty and left to writeback to retry. Another option would be to simply invalidate them, but the contents can be simultaneously accessed by
read()and through mmap.I do wish Linux were less of a mess in this regard. Different filesystems behave differently when writeback fails.
Cifs is particularly, um, entertaining in this regard as it allows the write to fail on the server due to a checksum failure if the source data changes during the write and then just retries it later.
Quoted 11 lines
That said, the modern consensus with local filesystems is to just leave the pages clean when buffered writeback fails, but set a writeback error on the inode. That at least keeps dirty pages from stacking up in the cache. In the case of something like a netfs, we usually invalidate the inode and the pages -- netfs's usually have to spontaneously deal with that anyway, so we might as well.
Marking the pages dirty here should mean that they'll effectively get a second try at writeback, which is a change in behavior from most filesystems. I'm not sure it's a bad one, but writeback can take a long time if you have a laggy network.
I'm not sure what the best thing to do is. If everything is doing O_DSYNC/writethrough I/O on an inode and there is no mmap, then invalidating the pages is probably not a bad way to deal with failure here.
Quoted 2 lines
When a write has already failed once, why do you think it'll succeed on a second attempt (and probably with page-aligned I/O, I guess)?
See above with cifs. I wonder if the pages being written to should be made RO and page_mkwrite() forced to lock against DSYNC writethrough.
Quoted 3 lines
Another question: when the writeback is (re)attempted, will it end up just doing page-aligned I/O, or is the byte range still going to be limited to the written range?
At the moment, it then happens exactly as it would if it wasn't doing writethrough - so it will write partial folios if it's doing a streaming write and will do full folios otherwise.
Quoted 2 lines
The more I consider it, I think it might be a lot simpler to just "fail fast" here rather than remarking the write dirty.
You may be right - but, again, mmap:-/
David
Jeff Layton
maintainerRe: [PATCH v4 36/39] netfs: Implement a write-through caching option
Quoted 11 lines · David Howells
Quoted 9 lines · Jeff Layton
Quoted 8 lines
This can't be used with content encryption as that may require expansion of the write RPC beyond the write being made.
This doesn't affect writes via mmap - those are written back in the normal way; similarly failed writethrough writes are marked dirty and left to writeback to retry. Another option would be to simply invalidate them, but the contents can be simultaneously accessed by
read()and through mmap.
Quoted 7 lines
Quoted 2 lines
I do wish Linux were less of a mess in this regard. Different filesystems behave differently when writeback fails.
Cifs is particularly, um, entertaining in this regard as it allows the write to fail on the server due to a checksum failure if the source data changes during the write and then just retries it later.
Should they be using bounce pages here? Maybe that's more efficient in the common case though and worth the extra hit if it happens seldom enough.
Quoted 7 lines
Quoted 7 lines
That said, the modern consensus with local filesystems is to just leave the pages clean when buffered writeback fails, but set a writeback error on the inode. That at least keeps dirty pages from stacking up in the cache. In the case of something like a netfs, we usually invalidate the inode and the pages -- netfs's usually have to spontaneously deal with that anyway, so we might as well.
Quoted 9 lines
Quoted 4 lines
Marking the pages dirty here should mean that they'll effectively get a second try at writeback, which is a change in behavior from most filesystems. I'm not sure it's a bad one, but writeback can take a long time if you have a laggy network.
I'm not sure what the best thing to do is. If everything is doing O_DSYNC/writethrough I/O on an inode and there is no mmap, then invalidating the pages is probably not a bad way to deal with failure here.
That's a big if ;)
Quoted 6 lines
Quoted 2 lines
When a write has already failed once, why do you think it'll succeed on a second attempt (and probably with page-aligned I/O, I guess)?
See above with cifs. I wonder if the pages being written to should be made RO and
page_mkwrite()forced to lock against DSYNC writethrough.
That sounds pretty heavy handed, particularly if the server goes offline for a bit. Now you're stuck in some locking call in page_mkwrite...
Quoted 9 lines
Quoted 3 lines
Another question: when the writeback is (re)attempted, will it end up just doing page-aligned I/O, or is the byte range still going to be limited to the written range?
At the moment, it then happens exactly as it would if it wasn't doing writethrough - so it will write partial folios if it's doing a streaming write and will do full folios otherwise.
Quoted 5 lines
Quoted 2 lines
The more I consider it, I think it might be a lot simpler to just "fail fast" here rather than remarking the write dirty.
You may be right - but, again, mmap:-/
There's nothing we can do about mmap -- we're stuck page-sized I/Os there.
With normal buffered I/O I still think just leaving the pages clean is probably the least bad option. I think it's also sort of the Linux "standard" behavior (for better or worse).
Willy, do you have any thoughts here?
Signature · 1 line
Jeff Layton <[email protected]>
David Howells
maintainerPATCH v4 37/39 netfs: Optimise away reads above the point at which there can be no data
In reply to David HowellsTrack the file position above which the server is not expected to have any data (the "zero point") and preemptively assume that we can satisfy requests by filling them with zeroes locally rather than attempting to download them if they're over that line - even if we've written data back to the server. Assume that any data that was written back above that position is held in the local cache. Note that we have to split requests that straddle the line.
Make use of this to optimise away some reads from the server. We need to set the zero point in the following circumstances:
(1) When we see an extant remote inode and have no cache for it, we set the zero_point to i_size.
(2) On local inode creation, we set zero_point to 0.
(3) On local truncation down, we reduce zero_point to the new i_size if the new i_size is lower.
(4) On local truncation up, we don't change zero_point.
(5) On local modification, we don't change zero_point.
(6) On remote invalidation, we set zero_point to the new i_size.
(7) If stored data is discarded from the pagecache or culled from fscache, we must set zero_point above that if the data also got written to the server.
(8) If dirty data is written back to the server, but not fscache, we must set zero_point above that.
(9) If a direct I/O write is made, set zero_point above that.
Assuming the above, any read from the server at or above the zero_point position will return all zeroes.
The zero_point value can be stored in the cache, provided the above rules are applied to it by any code that culls part of the local cache.
--- fs/afs/inode.c | 22 +++++++++++++--------- fs/netfs/buffered_write.c | 2 +- fs/netfs/direct_write.c | 4 ++++ fs/netfs/io.c | 10 ++++++++++ fs/netfs/misc.c | 5 +++++ fs/smb/client/cifsfs.c | 4 ++-- include/linux/netfs.h | 14 ++++++++++++-- 7 files changed, 47 insertions(+), 14 deletions(-)
fs/afs/inode.c +13 -9
@@ -166,6 +166,7 @@ static void afs_apply_status(struct afs_operation *op,struct inode *inode = &vnode->netfs.inode;struct timespec64 t;umode_t mode; +bool unexpected_jump = false;bool data_changed = false;bool change_size = vp->set_size;
@@ -230,6 +231,7 @@ static void afs_apply_status(struct afs_operation *op, } change_size = true; data_changed = true; + unexpected_jump = true; }else if (vnode->status.type ==AFS_FTYPE_DIR ) {/* Expected directory change is handled elsewhere so * that we can locally edit the directory and save on a
@@ -251,6 +253,8 @@ static void afs_apply_status(struct afs_operation *op, vnode->netfs.remote_i_size = status->size;if (change_size || status->size >i_size_read (inode)) {afs_set_i_size (vnode, status->size); +if (unexpected_jump) + vnode->netfs.zero_point = status->size;inode_set_ctime_to_ts (inode, t);inode_set_atime_to_ts (inode, t); }
@@ -689,17 +693,17 @@ static void afs_setattr_success(struct afs_operation *op)static void afs_setattr_edit_file (struct afs_operation *op) {struct afs_vnode_param *vp = &op->file[0 ]; -struct inode *inode = &vp->vnode->netfs.inode; +struct afs_vnode *vnode = vp->vnode;if (op->setattr.attr->ia_valid &ATTR_SIZE ) {loff_t size = op->setattr.attr->ia_size;loff_t i_size = op->setattr.old_i_size; -if (size < i_size) -truncate_pagecache (inode, size); -if (size != i_size) -fscache_resize_cookie (afs_vnode_cache (vp->vnode), - vp->scb.status.size); +if (size != i_size) { +truncate_setsize (&vnode->netfs.inode, size); +netfs_resize_file (&vnode->netfs, size, true); +fscache_resize_cookie (afs_vnode_cache (vnode), size); + } } }
@@ -767,11 +771,11 @@ int afs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,*/ if (!(attr->ia_valid & (supported & ~ATTR_SIZE & ~ATTR_MTIME )) && attr->ia_size < i_size && - attr->ia_size > vnode->status.size) { -truncate_pagecache (inode, attr->ia_size); + attr->ia_size > vnode->netfs.remote_i_size) { +truncate_setsize (inode, attr->ia_size); +netfs_resize_file (&vnode->netfs, size, false);fscache_resize_cookie (afs_vnode_cache (vnode), attr->ia_size); -i_size_write (inode, attr->ia_size); ret =0 ; goto out_unlock; }
fs/netfs/buffered_write.c +1 -1
@@ -73,7 +73,7 @@ static enum netfs_how_to_modify netfs_how_to_modify(struct netfs_inode *ctx,if (folio_test_uptodate (folio))return NETFS_FOLIO_IS_UPTODATE ; -if (pos >= ctx->remote_i_size) +if (pos >= ctx->zero_point)return NETFS_MODIFY_AND_CLEAR ;if (!maybe_trouble && offset ==0 && len >= flen)
fs/netfs/direct_write.c +4 -0
@@ -134,6 +134,7 @@ ssize_t netfs_unbuffered_write_iter(struct kiocb *iocb, struct iov_iter *from)struct file *file = iocb->ki_filp;struct inode *inode = file->f_mapping->host;struct netfs_inode *ictx =netfs_inode (inode); +unsigned long long end;ssize_t ret;_enter ("%llx,%zx,%llx" , iocb->ki_pos,iov_iter_count (from),i_size_read (inode));
@@ -155,6 +156,9 @@ ssize_t netfs_unbuffered_write_iter(struct kiocb *iocb, struct iov_iter *from) ret =kiocb_invalidate_pages (iocb,iov_iter_count (from));if (ret <0 ) goto out; + end = iocb->ki_pos +iov_iter_count (from); +if (end > ictx->zero_point) + ictx->zero_point = end;fscache_invalidate (netfs_i_cookie (ictx),NULL ,i_size_read (inode),FSCACHE_INVAL_DIO_WRITE );
fs/netfs/io.c +10 -0
@@ -569,6 +569,7 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq, struct iov_iter *io_iter) {enum netfs_io_source source =NETFS_DOWNLOAD_FROM_SERVER ; +struct netfs_inode *ictx =netfs_inode (rreq->inode);size_t lsize;_enter ("%llx-%llx,%llx" , subreq->start, subreq->start + subreq->len, rreq->i_size);
@@ -586,6 +587,14 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq,* to make serial calls, it can indicate a short read and then * we will call it again. */ +if (rreq->origin !=NETFS_DIO_READ ) { +if (subreq->start >= ictx->zero_point) { + source =NETFS_FILL_WITH_ZEROES ; + goto set; + } +if (subreq->len > ictx->zero_point - subreq->start) + subreq->len = ictx->zero_point - subreq->start; + }if (subreq->len > rreq->i_size - subreq->start) subreq->len = rreq->i_size - subreq->start;if (rreq->rsize && subreq->len > rreq->rsize)
@@ -607,6 +616,7 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq, } } +set:if (subreq->len > rreq->len) pr_warn("R=%08x[%u] SREQ>RREQ %zx > %zx\n", rreq->debug_id, subreq->debug_index,
fs/netfs/misc.c +5 -0
@@ -240,6 +240,11 @@ EXPORT_SYMBOL(netfs_invalidate_folio);bool netfs_release_folio (struct folio *folio,gfp_t gfp) {struct netfs_inode *ctx =netfs_inode (folio_inode (folio)); +unsigned long long end; + + end =folio_pos (folio) +folio_size (folio); +if (end > ctx->zero_point) + ctx->zero_point = end;if (folio_test_private (folio))return false;
fs/smb/client/cifsfs.c +2 -2
@@ -1220,7 +1220,7 @@ static int cifs_precopy_set_eof(struct inode *src_inode, struct cifsInodeInfo *sif (rc <0 ) goto set_failed; -netfs_resize_file (&src_cifsi->netfs, src_end); +netfs_resize_file (&src_cifsi->netfs, src_end, true);fscache_resize_cookie (cifs_inode_cookie (src_inode), src_end);return 0 ;
@@ -1351,7 +1351,7 @@ static loff_t cifs_remap_file_range(struct file *src_file, loff_t off, smb_file_src, smb_file_target, off, len, destoff);if (rc ==0 && new_size >i_size_read (target_inode)) {truncate_setsize (target_inode, new_size); -netfs_resize_file (&target_cifsi->netfs, new_size); +netfs_resize_file (&target_cifsi->netfs, new_size, true);fscache_resize_cookie (cifs_inode_cookie (target_inode), new_size); }
include/linux/netfs.h +12 -2
@@ -136,6 +136,8 @@ struct netfs_inode {struct fscache_cookie *cache;#endif loff_t remote_i_size;/* Size of the remote file */ +loff_t zero_point;/* Size after which we assume there's no data +* on the server */ unsigned long flags;#define NETFS_ICTX_ODIRECT 0/* The file has DIO in progress */ #define NETFS_ICTX_UNBUFFERED 1/* I/O should not use the pagecache */
@@ -465,22 +467,30 @@ static inline void netfs_inode_init(struct netfs_inode *ctx, { ctx->ops = ops; ctx->remote_i_size =i_size_read (&ctx->inode); + ctx->zero_point = ctx->remote_i_size; ctx->flags =0 ;#if IS_ENABLED (CONFIG_FSCACHE ) ctx->cache =NULL ;#endif +/* ->releasepage() drives zero_point */ +mapping_set_release_always (ctx->inode.i_mapping); }/** * netfs_resize_file - Note that a file got resized * @ctx: The netfs inode being resized * @new_i_size: The new file size +* @changed_on_server: The change was applied to the server * * Inform the netfs lib that a file got resized so that it can adjust its state. */ -static inline void netfs_resize_file (struct netfs_inode *ctx,loff_t new_i_size) +static inline void netfs_resize_file (struct netfs_inode *ctx,loff_t new_i_size, +bool changed_on_server) { - ctx->remote_i_size = new_i_size; +if (changed_on_server) + ctx->remote_i_size = new_i_size; +if (new_i_size < ctx->zero_point) + ctx->zero_point = new_i_size; }/**
Jeff Layton
maintainerRe: [PATCH v4 37/39] netfs: Optimise away reads above the point at which there can be no data
Quoted 14 lines · David Howells
Track the file position above which the server is not expected to have any data (the "zero point") and preemptively assume that we can satisfy requests by filling them with zeroes locally rather than attempting to download them if they're over that line - even if we've written data back to the server. Assume that any data that was written back above that position is held in the local cache. Note that we have to split requests that straddle the line.
Make use of this to optimise away some reads from the server. We need to set the zero point in the following circumstances:
(1) When we see an extant remote inode and have no cache for it, we set the
zero_pointtoi_size.
Quoted 7 lines
(2) On local inode creation, we set
zero_pointto 0.(3) On local truncation down, we reduce
zero_pointto the newi_sizeif the newi_sizeis lower.(4) On local truncation up, we don't change
zero_point.
The above seems odd, but I guess the assumption is that if there are any writes by a 3rd party above the old zero point, that that would cause an invalidation?
Quoted 257 lines
(5) On local modification, we don't change
zero_point.(6) On remote invalidation, we set
zero_pointto the newi_size.(7) If stored data is discarded from the pagecache or culled from fscache, we must set
zero_pointabove that if the data also got written to the server.(8) If dirty data is written back to the server, but not fscache, we must set
zero_pointabove that.(9) If a direct I/O write is made, set
zero_pointabove that.Assuming the above, any read from the server at or above the
zero_pointposition will return all zeroes.The
zero_pointvalue can be stored in the cache, provided the above rules are applied to it by any code that culls part of the local cache.Signed-off-by David Howells <[email protected]>cc Jeff Layton <[email protected]>--- fs/afs/inode.c | 22 +++++++++++++--------- fs/netfs/buffered_write.c | 2 +- fs/netfs/direct_write.c | 4 ++++ fs/netfs/io.c | 10 ++++++++++ fs/netfs/misc.c | 5 +++++ fs/smb/client/cifsfs.c | 4 ++-- include/linux/netfs.h | 14 ++++++++++++-- 7 files changed, 47 insertions(+), 14 deletions(-)fs/afs/inode.c +13
-9@@ -166,6 +166,7 @@ static void afs_apply_status(struct afs_operation *op,struct inode *inode = &vnode->netfs.inode;struct timespec64 t;umode_t mode; +bool unexpected_jump = false;bool data_changed = false;bool change_size = vp->set_size;@@ -230,6 +231,7 @@ static void afs_apply_status(struct afs_operation *op, } change_size = true; data_changed = true; + unexpected_jump = true; }else if (vnode->status.type ==AFS_FTYPE_DIR ) {/* Expected directory change is handled elsewhere so * that we can locally edit the directory and save on a @@ -251,6 +253,8 @@ static void afs_apply_status(struct afs_operation *op, vnode->netfs.remote_i_size = status->size;if (change_size || status->size >i_size_read (inode)) {afs_set_i_size (vnode, status->size); +if (unexpected_jump) + vnode->netfs.zero_point = status->size;inode_set_ctime_to_ts (inode, t);inode_set_atime_to_ts (inode, t); }@@ -689,17 +693,17 @@ static void afs_setattr_success(struct afs_operation *op)static void afs_setattr_edit_file (struct afs_operation *op) {struct afs_vnode_param *vp = &op->file[0 ]; -struct inode *inode = &vp->vnode->netfs.inode; +struct afs_vnode *vnode = vp->vnode;if (op->setattr.attr->ia_valid &ATTR_SIZE ) {loff_t size = op->setattr.attr->ia_size;loff_t i_size = op->setattr.old_i_size; -if (size < i_size) -truncate_pagecache (inode, size); -if (size != i_size) -fscache_resize_cookie (afs_vnode_cache (vp->vnode), - vp->scb.status.size); +if (size != i_size) { +truncate_setsize (&vnode->netfs.inode, size); +netfs_resize_file (&vnode->netfs, size, true); +fscache_resize_cookie (afs_vnode_cache (vnode), size); + } } }@@ -767,11 +771,11 @@ int afs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,*/ if (!(attr->ia_valid & (supported & ~ATTR_SIZE & ~ATTR_MTIME )) && attr->ia_size < i_size && - attr->ia_size > vnode->status.size) { -truncate_pagecache (inode, attr->ia_size); + attr->ia_size > vnode->netfs.remote_i_size) { +truncate_setsize (inode, attr->ia_size); +netfs_resize_file (&vnode->netfs, size, false);fscache_resize_cookie (afs_vnode_cache (vnode), attr->ia_size); -i_size_write (inode, attr->ia_size); ret =0 ; goto out_unlock; }fs/netfs/buffered_write.c +1
-1@@ -73,7 +73,7 @@ static enum netfs_how_to_modify netfs_how_to_modify(struct netfs_inode *ctx,if (folio_test_uptodate (folio))return NETFS_FOLIO_IS_UPTODATE ; -if (pos >= ctx->remote_i_size) +if (pos >= ctx->zero_point)return NETFS_MODIFY_AND_CLEAR ;if (!maybe_trouble && offset ==0 && len >= flen)fs/netfs/direct_write.c +4
-0@@ -134,6 +134,7 @@ ssize_t netfs_unbuffered_write_iter(struct kiocb *iocb, struct iov_iter *from)struct file *file = iocb->ki_filp;struct inode *inode = file->f_mapping->host;struct netfs_inode *ictx =netfs_inode (inode); +unsigned long long end;ssize_t ret;_enter ("%llx,%zx,%llx" , iocb->ki_pos,iov_iter_count (from),i_size_read (inode));@@ -155,6 +156,9 @@ ssize_t netfs_unbuffered_write_iter(struct kiocb *iocb, struct iov_iter *from) ret =kiocb_invalidate_pages (iocb,iov_iter_count (from));if (ret <0 ) goto out; + end = iocb->ki_pos +iov_iter_count (from); +if (end > ictx->zero_point) + ictx->zero_point = end;fscache_invalidate (netfs_i_cookie (ictx),NULL ,i_size_read (inode),FSCACHE_INVAL_DIO_WRITE );fs/netfs/io.c +10
-0@@ -569,6 +569,7 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq, struct iov_iter *io_iter) {enum netfs_io_source source =NETFS_DOWNLOAD_FROM_SERVER ; +struct netfs_inode *ictx =netfs_inode (rreq->inode);size_t lsize;_enter ("%llx-%llx,%llx" , subreq->start, subreq->start + subreq->len, rreq->i_size);@@ -586,6 +587,14 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq,* to make serial calls, it can indicate a short read and then * we will call it again. */ +if (rreq->origin !=NETFS_DIO_READ ) { +if (subreq->start >= ictx->zero_point) { + source =NETFS_FILL_WITH_ZEROES ; + goto set; + } +if (subreq->len > ictx->zero_point - subreq->start) + subreq->len = ictx->zero_point - subreq->start; + }if (subreq->len > rreq->i_size - subreq->start) subreq->len = rreq->i_size - subreq->start;if (rreq->rsize && subreq->len > rreq->rsize)@@ -607,6 +616,7 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq, } } +set:if (subreq->len > rreq->len) pr_warn("R=%08x[%u] SREQ>RREQ %zx > %zx\n", rreq->debug_id, subreq->debug_index,fs/netfs/misc.c +5
-0@@ -240,6 +240,11 @@ EXPORT_SYMBOL(netfs_invalidate_folio);bool netfs_release_folio (struct folio *folio,gfp_t gfp) {struct netfs_inode *ctx =netfs_inode (folio_inode (folio)); +unsigned long long end; + + end =folio_pos (folio) +folio_size (folio); +if (end > ctx->zero_point) + ctx->zero_point = end;if (folio_test_private (folio))return false;fs/smb/client/cifsfs.c +2
-2@@ -1220,7 +1220,7 @@ static int cifs_precopy_set_eof(struct inode *src_inode, struct cifsInodeInfo *sif (rc <0 ) goto set_failed; -netfs_resize_file (&src_cifsi->netfs, src_end); +netfs_resize_file (&src_cifsi->netfs, src_end, true);fscache_resize_cookie (cifs_inode_cookie (src_inode), src_end);return 0 ;@@ -1351,7 +1351,7 @@ static loff_t cifs_remap_file_range(struct file *src_file, loff_t off, smb_file_src, smb_file_target, off, len, destoff);if (rc ==0 && new_size >i_size_read (target_inode)) {truncate_setsize (target_inode, new_size); -netfs_resize_file (&target_cifsi->netfs, new_size); +netfs_resize_file (&target_cifsi->netfs, new_size, true);fscache_resize_cookie (cifs_inode_cookie (target_inode), new_size); }include/linux/netfs.h +12
-2@@ -136,6 +136,8 @@ struct netfs_inode {struct fscache_cookie *cache;#endif loff_t remote_i_size;/* Size of the remote file */ +loff_t zero_point;/* Size after which we assume there's no data +* on the server */ unsigned long flags;#define NETFS_ICTX_ODIRECT 0/* The file has DIO in progress */ #define NETFS_ICTX_UNBUFFERED 1/* I/O should not use the pagecache */ @@ -465,22 +467,30 @@ static inline void netfs_inode_init(struct netfs_inode *ctx, { ctx->ops = ops; ctx->remote_i_size =i_size_read (&ctx->inode); + ctx->zero_point = ctx->remote_i_size; ctx->flags =0 ;#if IS_ENABLED (CONFIG_FSCACHE ) ctx->cache =NULL ;#endif +/* ->releasepage() drives zero_point */ +mapping_set_release_always (ctx->inode.i_mapping); }/** * netfs_resize_file - Note that a file got resized * @ctx: The netfs inode being resized * @new_i_size: The new file size +* @changed_on_server: The change was applied to the server * * Inform the netfs lib that a file got resized so that it can adjust its state. */ -static inline void netfs_resize_file (struct netfs_inode *ctx,loff_t new_i_size) +static inline void netfs_resize_file (struct netfs_inode *ctx,loff_t new_i_size, +bool changed_on_server) { - ctx->remote_i_size = new_i_size; +if (changed_on_server) + ctx->remote_i_size = new_i_size; +if (new_i_size < ctx->zero_point) + ctx->zero_point = new_i_size; }/**
Signature · 1 line
Jeff Layton <[email protected]>
David Howells
maintainerRe: [PATCH v4 37/39] netfs: Optimise away reads above the point at which there can be no data
Quoted 6 lines · Jeff Layton
Quoted 2 lines
(4) On local truncation up, we don't change
zero_point.The above seems odd, but I guess the assumption is that if there are any writes by a 3rd party above the old zero point, that that would cause an invalidation?
All truncating up does is extend the region from which reading would return zeros, so it doesn't affect the zero_point.
If a third party interferes, then we have to invalidate the local caches and reset zero_point to the EOF. But if a third party is writing to the file at the same time as you without both of you using locking or exclusive direct writes, your data is probably screwed anyway...
Something cifs and ceph can use leasing to make this work; afs uses the data version number, notifications and the principle that you should use file locks.
David
David Howells
maintainerPATCH v4 38/39 afs: Use the netfs write helpers
In reply to David HowellsMake afs use the netfs write helpers.
--- fs/afs/file.c | 70 +++- fs/afs/internal.h | 10 +- fs/afs/write.c | 705 ++----------------------------------- include/trace/events/afs.h | 23 -- 4 files changed, 84 insertions(+), 724 deletions(-)
fs/afs/file.c +54 -16
@@ -34,7 +34,7 @@ const struct file_operations afs_file_operations = { .release = afs_release, .llseek = generic_file_llseek, .read_iter = afs_file_read_iter, - .write_iter = afs_file_write, + .write_iter = netfs_file_write_iter, .mmap = afs_file_mmap, .splice_read = afs_file_splice_read, .splice_write = iter_file_splice_write,
@@ -50,16 +50,15 @@ const struct inode_operations afs_file_inode_operations = { };const struct address_space_operations afs_file_aops = { + .direct_IO = noop_direct_IO, .read_folio = netfs_read_folio, .readahead = netfs_readahead, .dirty_folio = netfs_dirty_folio, - .launder_folio = afs_launder_folio, + .launder_folio = netfs_launder_folio, .release_folio = netfs_release_folio, .invalidate_folio = netfs_invalidate_folio, - .write_begin = afs_write_begin, - .write_end = afs_write_end, - .writepages = afs_writepages, .migrate_folio = filemap_migrate_folio, + .writepages = afs_writepages, };const struct address_space_operations afs_symlink_aops = {
@@ -352,7 +351,10 @@ static int afs_symlink_read_folio(struct file *file, struct folio *folio)static int afs_init_request (struct netfs_io_request *rreq,struct file *file) { - rreq->netfs_priv =key_get (afs_file_key (file)); +if (file) + rreq->netfs_priv =key_get (afs_file_key (file)); + rreq->rsize =256 *1024 ; + rreq->wsize =256 *1024 ;return 0 ; }
@@ -369,11 +371,36 @@ static void afs_free_request(struct netfs_io_request *rreq)key_put (rreq->netfs_priv); } +static void afs_update_i_size (struct inode *inode,loff_t new_i_size) +{ +struct afs_vnode *vnode =AFS_FS_I (inode); +loff_t i_size; + +write_seqlock (&vnode->cb_lock); + i_size =i_size_read (&vnode->netfs.inode); +if (new_i_size > i_size) { +i_size_write (&vnode->netfs.inode, new_i_size); +inode_set_bytes (&vnode->netfs.inode, new_i_size); + } +write_sequnlock (&vnode->cb_lock); +fscache_update_cookie (afs_vnode_cache (vnode),NULL , &new_i_size); +} + +static void afs_netfs_invalidate_cache (struct netfs_io_request *wreq) +{ +struct afs_vnode *vnode =AFS_FS_I (wreq->inode); + +afs_invalidate_cache (vnode,0 ); +} +const struct netfs_request_ops afs_req_ops = { .init_request = afs_init_request, .free_request = afs_free_request, .check_write_begin = afs_check_write_begin, .issue_read = afs_issue_read, + .update_i_size = afs_update_i_size, + .invalidate_cache = afs_netfs_invalidate_cache, + .create_write_requests = afs_create_write_requests, };static void afs_add_open_mmap (struct afs_vnode *vnode)
@@ -441,28 +468,39 @@ static vm_fault_t afs_vm_map_pages(struct vm_fault *vmf, pgoff_t start_pgoff, pgstatic ssize_t afs_file_read_iter (struct kiocb *iocb,struct iov_iter *iter) { -struct afs_vnode *vnode =AFS_FS_I (file_inode (iocb->ki_filp)); +struct inode *inode =file_inode (iocb->ki_filp); +struct afs_vnode *vnode =AFS_FS_I (inode);struct afs_file *af = iocb->ki_filp->private_data; -int ret; +ssize_t ret; - ret =afs_validate (vnode, af->key); +if (iocb->ki_flags &IOCB_DIRECT ) +return netfs_unbuffered_read_iter (iocb, iter); + + ret =netfs_start_io_read (inode);if (ret <0 )return ret; - -return generic_file_read_iter (iocb, iter); + ret =afs_validate (vnode, af->key); +if (ret ==0 ) + ret =filemap_read (iocb, iter,0 ); +netfs_end_io_read (inode); +return ret; }static ssize_t afs_file_splice_read (struct file *in,loff_t *ppos,struct pipe_inode_info *pipe,size_t len,unsigned int flags) { -struct afs_vnode *vnode =AFS_FS_I (file_inode (in)); +struct inode *inode =file_inode (in); +struct afs_vnode *vnode =AFS_FS_I (inode);struct afs_file *af = in->private_data; -int ret; +ssize_t ret; - ret =afs_validate (vnode, af->key); + ret =netfs_start_io_read (inode);if (ret <0 )return ret; - -return filemap_splice_read (in, ppos, pipe, len, flags); + ret =afs_validate (vnode, af->key); +if (ret ==0 ) + ret =filemap_splice_read (in, ppos, pipe, len, flags); +netfs_end_io_read (inode); +return ret; }
fs/afs/internal.h +1 -9
@@ -1601,19 +1601,11 @@ bool afs_try_get_volume(struct afs_volume *volume, enum afs_volume_trace reason)/* * write.c */ -extern int afs_write_begin (struct file *file,struct address_space *mapping, -loff_t pos,unsigned len, -struct page **pagep,void **fsdata); -extern int afs_write_end (struct file *file,struct address_space *mapping, -loff_t pos,unsigned len,unsigned copied, -struct page *page,void *fsdata); -extern int afs_writepage (struct page *,struct writeback_control *);extern int afs_writepages (struct address_space *,struct writeback_control *); -extern ssize_t afs_file_write (struct kiocb *,struct iov_iter *);extern int afs_fsync (struct file *,loff_t ,loff_t ,int );extern vm_fault_t afs_page_mkwrite (struct vm_fault *vmf);extern void afs_prune_wb_keys (struct afs_vnode *); -int afs_launder_folio (struct folio *); +void afs_create_write_requests (struct netfs_io_request *wreq,loff_t start,size_t len);/* * xattr.c
fs/afs/write.c +29 -676
771 lines not on this page · raw message
include/trace/events/afs.h +0 -23
@@ -902,29 +902,6 @@ TRACE_EVENT(afs_dir_check_failed, __entry->vnode, __entry->off, __entry->i_size) ); -TRACE_EVENT (afs_folio_dirty, - TP_PROTO(struct afs_vnode *vnode, const char *where, struct folio *folio), - -TP_ARGS (vnode, where, folio), - -TP_STRUCT__entry ( - __field(struct afs_vnode *, vnode) - __field(const char *, where) - __field(pgoff_t, index) -__field (size_t, size) - ), - -TP_fast_assign ( - __entry->vnode = vnode; - __entry->where = where; - __entry->index = folio_index(folio); - __entry->size = folio_size(folio); - ), - -TP_printk ("vn=%p ix=%05lx s=%05lx %s" , - __entry->vnode, __entry->index, __entry->size, __entry->where) - ); - TRACE_EVENT(afs_call_state, TP_PROTO(struct afs_call *call, enum afs_call_state from,
David Howells
maintainerPATCH v4 39/39 9p: Use netfslib read/write_iter
In reply to David HowellsUse netfslib's read and write iteration helpers, allowing netfslib to take over the management of the page cache for 9p files and to manage local disk caching. In particular, this eliminates write_begin, write_end, writepage and all mentions of struct page and struct folio from 9p.
Note that netfslib now offers the possibility of write-through caching if that is desirable for 9p: just set the NETFS_ICTX_WRITETHROUGH flag in v9inode->netfs.flags in v9fs_set_netfs_context().
Note also this is untested as I can't get ganesha.nfsd to correctly parse the config to turn on 9p support.
--- fs/9p/vfs_addr.c | 292 +++++++++++----------------------------------- fs/9p/vfs_file.c | 89 ++------------ fs/9p/vfs_inode.c | 2 - 3 files changed, 77 insertions(+), 306 deletions(-)
fs/9p/vfs_addr.c +68 -224
@@ -19,12 +19,48 @@#include <linux/netfs.h> #include <net/9p/9p.h> #include <net/9p/client.h> +#include <trace/events/netfs.h> #include "v9fs.h" #include "v9fs_vfs.h" #include "cache.h" #include "fid.h" +static void v9fs_upload_to_server (struct netfs_io_subrequest *subreq) +{ +struct inode *inode = subreq->rreq->inode; +struct v9fs_inode __maybe_unused *v9inode =V9FS_I (inode); +struct p9_fid *fid = subreq->rreq->netfs_priv; +int err; + +trace_netfs_sreq (subreq, netfs_sreq_trace_submit); +p9_client_write (fid, subreq->start, &subreq->io_iter, &err); +netfs_write_subrequest_terminated (subreq, err <0 ? err : subreq->len, + false); +} + +static void v9fs_upload_to_server_worker (struct work_struct *work) +{ +struct netfs_io_subrequest *subreq = + container_of(work, struct netfs_io_subrequest, work); + +v9fs_upload_to_server (subreq); +} + +/* +* Set up write requests for a writeback slice. We need to add a write request +* for each write we want to make. +*/ +static void v9fs_create_write_requests (struct netfs_io_request *wreq,loff_t start,size_t len) +{ +struct netfs_io_subrequest *subreq; + + subreq =netfs_create_write_request (wreq,NETFS_UPLOAD_TO_SERVER , + start, len, v9fs_upload_to_server_worker); +if (subreq) +netfs_queue_write_request (subreq); +} +/** * v9fs_issue_read - Issue a read from 9P * @subreq: The read to make
@@ -33,14 +69,10 @@ static void v9fs_issue_read(struct netfs_io_subrequest *subreq) {struct netfs_io_request *rreq = subreq->rreq;struct p9_fid *fid = rreq->netfs_priv; -struct iov_iter to; -loff_t pos = subreq->start + subreq->transferred; -size_t len = subreq->len - subreq->transferred;int total, err; -iov_iter_xarray (&to,ITER_DEST , &rreq->mapping->i_pages, pos, len); - - total =p9_client_read (fid, pos, &to, &err); + total =p9_client_read (fid, subreq->start + subreq->transferred, + &subreq->io_iter, &err);/* if we just extended the file size, any portion not in * cache won't be on server and is zeroes */
@@ -50,23 +82,37 @@ static void v9fs_issue_read(struct netfs_io_subrequest *subreq) }/** -* v9fs_init_request - Initialise a read request +* v9fs_init_request - Initialise a request * @rreq: The read request * @file: The file being read from */ static int v9fs_init_request (struct netfs_io_request *rreq,struct file *file) { -struct p9_fid *fid = file->private_data; - -BUG_ON (!fid); +struct p9_fid *fid; +bool writing = (rreq->origin ==NETFS_READ_FOR_WRITE || + rreq->origin ==NETFS_WRITEBACK || + rreq->origin ==NETFS_WRITETHROUGH || + rreq->origin ==NETFS_LAUNDER_WRITE || + rreq->origin ==NETFS_UNBUFFERED_WRITE || + rreq->origin ==NETFS_DIO_WRITE ); + +if (file) { + fid = file->private_data; +BUG_ON (!fid); +p9_fid_get (fid); + }else { + fid =v9fs_fid_find_inode (rreq->inode, writing,INVALID_UID , true); +if (!fid) { +WARN_ONCE (1 ,"folio expected an open fid inode->i_private=%p\n" , + rreq->inode->i_private); +return -EINVAL ; + } + }/* we might need to read from a fid that was opened write-only * for read-modify-write of page cache, use the writeback fid * for that */ -WARN_ON (rreq->origin ==NETFS_READ_FOR_WRITE && - !(fid->mode &P9_ORDWR )); - -p9_fid_get (fid); +WARN_ON (writing && !(fid->mode &P9_ORDWR )); rreq->netfs_priv = fid;return 0 ; }
@@ -86,217 +132,15 @@ const struct netfs_request_ops v9fs_req_ops = { .init_request = v9fs_init_request, .free_request = v9fs_free_request, .issue_read = v9fs_issue_read, + .create_write_requests = v9fs_create_write_requests, }; -#ifdef CONFIG_9P_FSCACHE -static void v9fs_write_to_cache_done (void *priv,ssize_t transferred_or_error, -bool was_async) -{ -struct v9fs_inode *v9inode = priv; -__le32 version; - -if (IS_ERR_VALUE (transferred_or_error) && - transferred_or_error != -ENOBUFS ) { - version =cpu_to_le32 (v9inode->qid.version); -fscache_invalidate (v9fs_inode_cookie (v9inode), &version, -i_size_read (&v9inode->netfs.inode),0 ); - } -} -#endif - -static int v9fs_vfs_write_folio_locked (struct folio *folio) -{ -struct inode *inode =folio_inode (folio); -loff_t start =folio_pos (folio); -loff_t i_size =i_size_read (inode); -struct iov_iter from; -size_t len =folio_size (folio); -struct p9_fid *writeback_fid; -int err; -struct v9fs_inode __maybe_unused *v9inode =V9FS_I (inode); -struct fscache_cookie __maybe_unused *cookie =v9fs_inode_cookie (v9inode); - -if (start >= i_size) -return 0 ;/* Simultaneous truncation occurred */ - - len =min_t (loff_t, i_size - start, len); - -iov_iter_xarray (&from,ITER_SOURCE , &folio_mapping (folio)->i_pages, start, len); - - writeback_fid =v9fs_fid_find_inode (inode, true,INVALID_UID , true); -if (!writeback_fid) { -WARN_ONCE (1 ,"folio expected an open fid inode->i_private=%p\n" , - inode->i_private); -return -EINVAL ; - } - -folio_wait_fscache (folio); -folio_start_writeback (folio); - -p9_client_write (writeback_fid, start, &from, &err); - -#ifdef CONFIG_9P_FSCACHE -if (err ==0 && -fscache_cookie_enabled (cookie) && -test_bit (FSCACHE_COOKIE_IS_CACHING , &cookie->flags)) { -folio_start_fscache (folio); -fscache_write_to_cache (v9fs_inode_cookie (v9inode), -folio_mapping (folio), start, len, i_size, - v9fs_write_to_cache_done, v9inode, - true); - } -#endif - -folio_end_writeback (folio); -p9_fid_put (writeback_fid); - -return err; -} - -static int v9fs_vfs_writepage (struct page *page,struct writeback_control *wbc) -{ -struct folio *folio =page_folio (page); -int retval; - -p9_debug (P9_DEBUG_VFS ,"folio %p\n" , folio); - - retval =v9fs_vfs_write_folio_locked (folio); -if (retval <0 ) { -if (retval == -EAGAIN ) { -folio_redirty_for_writepage (wbc, folio); - retval =0 ; - }else { -mapping_set_error (folio_mapping (folio), retval); - } - }else - retval =0 ; - -folio_unlock (folio); -return retval; -} - -static int v9fs_launder_folio (struct folio *folio) -{ -int retval; - -if (folio_clear_dirty_for_io (folio)) { - retval =v9fs_vfs_write_folio_locked (folio); -if (retval) -return retval; - } -folio_wait_fscache (folio); -return 0 ; -} - -/** -* v9fs_direct_IO - 9P address space operation for direct I/O -* @iocb: target I/O control block -* @iter: The data/buffer to use -* -* The presence of v9fs_direct_IO() in the address space ops vector -* allowes open() O_DIRECT flags which would have failed otherwise. -* -* In the non-cached mode, we shunt off direct read and write requests before -* the VFS gets them, so this method should never be called. -* -* Direct IO is not 'yet' supported in the cached mode. Hence when -* this routine is called through generic_file_aio_read(), the read/write fails -* with an error. -* -*/ -static ssize_t -v9fs_direct_IO (struct kiocb *iocb,struct iov_iter *iter) -{ -struct file *file = iocb->ki_filp; -loff_t pos = iocb->ki_pos; -ssize_t n; -int err =0 ; - -if (iov_iter_rw (iter) ==WRITE ) { - n =p9_client_write (file->private_data, pos, iter, &err); -if (n) { -struct inode *inode =file_inode (file); -loff_t i_size =i_size_read (inode); - -if (pos + n > i_size) -inode_add_bytes (inode, pos + n - i_size); - } - }else { - n =p9_client_read (file->private_data, pos, iter, &err); - } -return n ? n : err; -} - -static int v9fs_write_begin (struct file *filp,struct address_space *mapping, -loff_t pos,unsigned int len, -struct page **subpagep,void **fsdata) -{ -int retval; -struct folio *folio; -struct v9fs_inode *v9inode =V9FS_I (mapping->host); - -p9_debug (P9_DEBUG_VFS ,"filp %p, mapping %p\n" , filp, mapping); - -/* Prefetch area to be written into the cache if we're caching this -* file. We need to do this before we get a lock on the page in case -* there's more than one writer competing for the same cache block. -*/ - retval =netfs_write_begin (&v9inode->netfs, filp, mapping, pos, len, &folio, fsdata); -if (retval <0 ) -return retval; - - *subpagep = &folio->page; -return retval; -} - -static int v9fs_write_end (struct file *filp,struct address_space *mapping, -loff_t pos,unsigned int len,unsigned int copied, -struct page *subpage,void *fsdata) -{ -loff_t last_pos = pos + copied; -struct folio *folio =page_folio (subpage); -struct inode *inode = mapping->host; - -p9_debug (P9_DEBUG_VFS ,"filp %p, mapping %p\n" , filp, mapping); - -if (!folio_test_uptodate (folio)) { -if (unlikely (copied < len)) { - copied =0 ; - goto out; - } - -folio_mark_uptodate (folio); - } - -/* -* No need to use i_size_read() here, the i_size -* cannot change under us because we hold the i_mutex. -*/ -if (last_pos > inode->i_size) { -inode_add_bytes (inode, last_pos - inode->i_size); -i_size_write (inode, last_pos); -#ifdef CONFIG_9P_FSCACHE -fscache_update_cookie (v9fs_inode_cookie (V9FS_I (inode)),NULL , - &last_pos); -#endif - } -folio_mark_dirty (folio); -out: -folio_unlock (folio); -folio_put (folio); - -return copied; -} -const struct address_space_operations v9fs_addr_operations = { - .read_folio = netfs_read_folio, - .readahead = netfs_readahead, - .dirty_folio = netfs_dirty_folio, - .writepage = v9fs_vfs_writepage, - .write_begin = v9fs_write_begin, - .write_end = v9fs_write_end, - .release_folio = netfs_release_folio, - .invalidate_folio = netfs_invalidate_folio, - .launder_folio = v9fs_launder_folio, - .direct_IO = v9fs_direct_IO, + .read_folio = netfs_read_folio, + .readahead = netfs_readahead, + .dirty_folio = netfs_dirty_folio, + .release_folio = netfs_release_folio, + .invalidate_folio = netfs_invalidate_folio, + .launder_folio = netfs_launder_folio, + .direct_IO = noop_direct_IO, };
fs/9p/vfs_file.c +9 -80
116 lines not on this page · raw message
fs/9p/vfs_inode.c +0 -2
@@ -374,10 +374,8 @@ void v9fs_evict_inode(struct inode *inode)truncate_inode_pages_final (&inode->i_data); -#ifdef CONFIG_9P_FSCACHE version =cpu_to_le32 (v9inode->qid.version);netfs_clear_inode_writeback (inode, &version); -#endif clear_inode (inode);filemap_fdatawrite (&inode->i_data);
Christian Schoenebeck
reviewerRe: [PATCH v4 39/39] 9p: Use netfslib read/write_iter
Quoted 11 lines · CET David Howells
Use netfslib's read and write iteration helpers, allowing netfslib to take over the management of the page cache for 9p files and to manage local disk caching. In particular, this eliminates
write_begin,write_end, writepage and all mentions of struct page and struct folio from 9p.Note that netfslib now offers the possibility of write-through caching if that is desirable for 9p: just set the
NETFS_ICTX_WRITETHROUGHflag inv9inode->netfs.flagsinv9fs_set_netfs_context().Note also this is untested as I can't get ganesha.nfsd to correctly parse the config to turn on 9p support.
Do you have a chance to test this 9p patch with QEMU instead maybe?
/Christian
Quoted 262 lines · David Howells
Hi Jeff, Steve, Dominique,
I have been working on my netfslib helpers to the point that I can run xfstests on AFS to completion (both with write-back buffering and, with a small patch, write-through buffering in the pagecache). I have a patch for 9P, but am currently unable to test it.
The patches remove a little over 800 lines from AFS, 300 from 9P, albeit with around 3000 lines added to netfs. Hopefully, I will be able to remove a bunch of lines from Ceph too.
I've split the CIFS patches out to a separate branch, cifs-netfs, where a further 2000+ lines are removed. I can run a certain amount of xfstests on CIFS, though I'm running into ksmbd issues and not all the tests work correctly because of issues between fallocate and what the SMB protocol actually supports.
I've also dropped the content-crypto patches out for the moment as they're only usable by the ceph changes which I'm still working on.
The patch to use
PG_writebackinstead ofPG_fscachefor writing to the cache has also been deferred, pending 9p, afs, ceph and cifs all being converted.The main aims of these patches are to get high-level I/O and knowledge of the pagecache out of the filesystem drivers as much as possible and to get rid, as much of possible, of the knowledge that pages/folios exist.
Further, I would like to see ->write_begin, ->write_end and ->launder_folio go away.
Features that are added by these patches to that which is already there in netfslib:
(1) NFS-style (and Ceph-style) locking around DIO vs buffered I/O calls to prevent these from happening at the same time. mmap'd I/O can, of necessity, happen at any time ignoring these locks.
(2) Support for unbuffered I/O. The data is kept in the bounce buffer and the pagecache is not used. This can be turned on with an inode flag.
(3) Support for direct I/O. This is basically unbuffered I/O with some extra restrictions and no RMW.
(4) Support for using a bounce buffer in an operation. The bounce buffer may be bigger than the target data/buffer, allowing for crypto rounding.
(5) ->write_begin() and ->write_end() are ignored in favour of merging all of that into one function,
netfs_perform_write(), thereby avoiding the function pointer traversals.(6) Support for write-through caching in the pagecache.
netfs_perform_write()adds the pages is modifies to an I/O operation as it goes and directly marks them writeback rather than dirty. When writing back from write-through, it limits the range written back. This should allow CIFS to deal with byte-range mandatory locks correctly.(7) O_*SYNC and RWF_*SYNC writes use write-through rather than writing to the pagecache and then flushing afterwards. An AIO O_*SYNC write will notify of completion when the sub-writes all complete.
(8) Support for write-streaming where modifed data is held in !uptodate folios, with a private struct attached indicating the range that is valid.
(9) Support for write grouping, multiplexing a pointer to a group in the folio private data with the write-streaming data. The writepages algorithm only writes stuff back that's in the nominated group. This is intended for use by Ceph to write is snaps in order.
(10) Skipping reads for which we know the server could only supply zeros or EOF (for instance if we've done a local write that leaves a hole in the file and extends the local inode size).
General notes:
(1) The fscache module is merged into the netfslib module to avoid cyclic exported symbol usage that prevents either module from being loaded.
(2) Some helpers from fscache are reassigned to netfslib by name.
(3) netfslib now makes use of
folio->private, which means the filesystem can't use it.(4) The filesystem provides wrappers to call the write helpers, allowing it to do pre-validation, oplock/capability fetching and the passing in of write group info.
(5) I want to try flushing the data when tearing down an inode before invalidating it to try and render
launder_foliounnecessary.(6) Write-through caching will generate and dispatch write subrequests as it gathers enough data to hit wsize and has whole pages that at least span that size. This needs to be a bit more flexible, allowing for a filesystem such as CIFS to have a variable wsize.
(7) The filesystem driver is just given read and write calls with an
iov_iterdescribing the data/buffer to use. Ideally, they don't see pages or folios at all. A function,extract_iter_to_sg(), is already available to decant part of an iterator into a scatterlist for crypto purposes.9P notes:
(1) I haven't managed to test this as I haven't been able to get Ganesha to work correctly with 9P.
(2) Writes should now occur in larger-than-page-sized chunks.
(3) It should be possible to turn on multipage folio support in 9P now.
Changes
=======
ver #4)
- Slimmed down the branch:
- Split the cifs-related patches off to a separate branch (cifs-netfs)
- Deferred the content-encryption to the in-progress ceph changes.
- Deferred the use-PG_writeback rather thanPG_fscachepatch
- Rebased on a later linux-next with afs-rotation patches.ver #3)
- Moved the fscache module into netfslib to avoid export cycles.
- Fixed a bunch of bugs.
- Got CIFS to pass as much of xfstests as possible.
- Added a patch to make 9P use all the helpers.
- Added a patch to stop usingPG_fscache, but rather dirty pages on reading and have writepages write to the cache.ver #2)
- Folded the addition of NETFS_RREQ_NONBLOCK/BLOCKED into first patch that uses them.
- Folded addition of rsize member into first user.
- Don't set rsize in ceph (yet) and set it in kafs to 256KiB. cifs sets it dynamically.
- Moveddirect_bvnext todirect_bv_countin structnetfs_io_requestand labelled it with a__counted_by().
- Passed flags intonetfs_xa_store_and_mark()rather than two bools.
- Removednetfs_set_up_buffer()as it wasn't used.David
David Howells (39):
netfs, fscache: Movefs/fscache/*intofs/netfs/
netfs, fscache: Combine fscache with netfs
netfs, fscache: Remove ->begin_cache_operation
netfs, fscache: Move/proc/fs/fscacheto/proc/fs/netfsand put in a
symlink
netfs: Move pinning-for-writeback from fscache to netfs
netfs: Add a procfile to list in-progress requests
netfs: Allow the netfs to make the io (sub)request alloc larger
netfs: Add a ->free_subrequest() op
afs: Don't usefolio->privateto record partial modification
netfs: Provideinvalidate_folioandrelease_foliocalls
netfs: Implement unbuffered/DIO vs buffered I/O locking
netfs: Addiov_itersto (sub)requests to describe various buffers
netfs: Add support for DIO buffering
netfs: Provide tools to create a buffer in an xarray
netfs: Add bounce buffering support
netfs: Add func to calculate pagecount/size-limited span of an
iterator
netfs: Limit subrequest by size or number of segments
netfs: Exportnetfs_put_subrequest()and some tracepoints
netfs: Extend the netfs_io_*request structs to handle writes
netfs: Add a hook to allow tell the netfs to update itsi_size
netfs: Makenetfs_put_request()handle a NULL pointer
netfs: Make the refcounting ofnetfs_begin_read()easier to use
netfs: Prep to usefolio->privatefor write grouping and streaming
write
netfs: Dispatch write requests to process a writeback slice
netfs: Provide func to copy data to pagecache for buffered write
netfs: Makenetfs_read_folio()handle streaming-write pages
netfs: Allocate multipage folios in the writepath
netfs: Implement support for unbuffered/DIO read
netfs: Implement unbuffered/DIO write support
netfs: Implement buffered write API
netfs: Allow buffered shared-writeable mmap through
netfs_page_mkwrite()
netfs: Providenetfs_file_read_iter()
netfs, cachefiles: Pass upper bound length to allow expansion
netfs: Provide a writepages implementation
netfs: Provide alaunder_folioimplementation
netfs: Implement a write-through caching option
netfs: Optimise away reads above the point at which there can be no
data
afs: Use the netfs write helpers
9p: Use netfslib read/write_iterDocumentation/filesystems/netfs_library.rst | 23 +- MAINTAINERS | 2 +- fs/9p/vfs_addr.c | 352 +---- fs/9p/vfs_file.c | 89 +- fs/9p/vfs_inode.c | 5 +- fs/9p/vfs_super.c | 14 +- fs/Kconfig | 1 - fs/Makefile | 1 - fs/afs/file.c | 213 +-- fs/afs/inode.c | 26 +- fs/afs/internal.h | 72 +- fs/afs/super.c | 2 +- fs/afs/write.c | 826 +---------- fs/cachefiles/internal.h | 2 +- fs/cachefiles/io.c | 10 +- fs/cachefiles/ondemand.c | 2 +- fs/ceph/addr.c | 25 +- fs/ceph/cache.h | 35 +- fs/ceph/inode.c | 2 +- fs/fs-writeback.c | 10 +- fs/fscache/Kconfig | 40 - fs/fscache/Makefile | 16 - fs/fscache/internal.h | 277 ---- fs/netfs/Kconfig | 39 + fs/netfs/Makefile | 22 +- fs/netfs/buffered_read.c | 229 ++- fs/netfs/buffered_write.c | 1247 +++++++++++++++++ fs/netfs/direct_read.c | 252 ++++ fs/netfs/direct_write.c | 170 +++ fs/{fscache/cache.c => netfs/fscache_cache.c} | 0 .../cookie.c => netfs/fscache_cookie.c} | 0 fs/netfs/fscache_internal.h | 14 + fs/{fscache/io.c => netfs/fscache_io.c} | 42 +- fs/{fscache/main.c => netfs/fscache_main.c} | 25 +- fs/{fscache/proc.c => netfs/fscache_proc.c} | 23 +- fs/{fscache/stats.c => netfs/fscache_stats.c} | 4 +- .../volume.c => netfs/fscache_volume.c} | 0 fs/netfs/internal.h | 288 ++++ fs/netfs/io.c | 214 ++- fs/netfs/iterator.c | 97 ++ fs/netfs/locking.c | 215 +++ fs/netfs/main.c | 110 ++ fs/netfs/misc.c | 260 ++++ fs/netfs/objects.c | 63 +- fs/netfs/output.c | 478 +++++++ fs/netfs/stats.c | 31 +- fs/nfs/Kconfig | 4 +- fs/nfs/fscache.c | 7 - fs/smb/client/cifsfs.c | 9 +- fs/smb/client/file.c | 18 +- fs/smb/client/fscache.c | 2 +- include/linux/fs.h | 2 +- include/linux/fscache.h | 45 - include/linux/netfs.h | 176 ++- include/linux/writeback.h | 2 +- include/trace/events/afs.h | 31 - include/trace/events/netfs.h | 155 +- mm/filemap.c | 1 + 58 files changed, 4197 insertions(+), 2123 deletions(-) delete mode 100644 fs/fscache/Kconfig delete mode 100644 fs/fscache/Makefile delete mode 100644 fs/fscache/internal.h create mode 100644 fs/netfs/buffered_write.c create mode 100644 fs/netfs/direct_read.c create mode 100644 fs/netfs/direct_write.c rename fs/{fscache/cache.c => netfs/fscache_cache.c} (100%) rename fs/{fscache/cookie.c => netfs/fscache_cookie.c} (100%) create mode 100644 fs/netfs/fscache_internal.h
Quoted 9 lines
rename fs/{fscache/io.c => netfs/fscache_io.c} (86%)
rename fs/{fscache/main.c => netfs/fscache_main.c} (84%)
rename fs/{fscache/proc.c => netfs/fscache_proc.c} (58%)
rename fs/{fscache/stats.c => netfs/fscache_stats.c} (97%)
rename fs/{fscache/volume.c => netfs/fscache_volume.c} (100%)
create mode 100644 fs/netfs/locking.c
create mode 100644 fs/netfs/misc.c
create mode 100644 fs/netfs/output.cThis all looks pretty great, David. Nice work! I had a few comments on a few of them, but most are no big deal. It'd be nice to get this into linux-next soon.
On the ones where I didn't have comments, you can add:
Quoted 10 lines · David Howells
I have been working on my netfslib helpers to the point that I can run xfstests on AFS to completion (both with write-back buffering and, with a small patch, write-through buffering in the pagecache). I have a patch for 9P, but am currently unable to test it.
The patches remove a little over 800 lines from AFS, 300 from 9P, albeit with around 3000 lines added to netfs. Hopefully, I will be able to remove a bunch of lines from Ceph too.
[...]
Ok, that's on vfs.netfs for now. It's based on vfs.rw as that has splice changes that would cause needless conflicts. It helps to not have such series based on -next.
Fwiw, I'd rather have this based on a mainline tag in the future. Linus has stated loads of times that he doesn't mind handling merge conflicts and for me it's a lot easier if I have a stable mainline tag. linux-next is too volatile. Thanks!
---
Applied to the vfs.netfs branch of the vfs/vfs.git tree. Patches in the vfs.netfs branch should appear in linux-next soon.
Please report any outstanding bugs that were missed during review in a new review to the original patch series allowing us to drop it.
It's encouraged to provide Acked-bys and Reviewed-bys even though the patch has now been applied. If possible patch trailers will be updated.
Note that commit hashes shown below are subject to change due to rebase, trailer updates or similar. If in doubt, please check the listed branch.
tree: https://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs.git branch: vfs.netfs
[01/39] netfs, fscache: Move fs/fscache/* into fs/netfs/
https://git.kernel.org/vfs/vfs/c/94029f4c6459 [02/39] netfs, fscache: Combine fscache with netfs https://git.kernel.org/vfs/vfs/c/77eb7aa4805e [03/39] netfs, fscache: Remove ->begin_cache_operation https://git.kernel.org/vfs/vfs/c/a7f70e4b4ebf [04/39] netfs, fscache: Move /proc/fs/fscache to /proc/fs/netfs and put in a symlink https://git.kernel.org/vfs/vfs/c/131e9eb7bd1f [05/39] netfs: Move pinning-for-writeback from fscache to netfs https://git.kernel.org/vfs/vfs/c/1792e1940f54 [06/39] netfs: Add a procfile to list in-progress requests https://git.kernel.org/vfs/vfs/c/1491057f69dc [07/39] netfs: Allow the netfs to make the io (sub)request alloc larger https://git.kernel.org/vfs/vfs/c/6c3efd20150f [08/39] netfs: Add a ->free_subrequest() op https://git.kernel.org/vfs/vfs/c/e0b44a08ac20 [09/39] afs: Don't use folio->private to record partial modification https://git.kernel.org/vfs/vfs/c/9d2a996de9a2 [10/39] netfs: Provide invalidate_folio and release_folio calls https://git.kernel.org/vfs/vfs/c/6136f4723a2e [11/39] netfs: Implement unbuffered/DIO vs buffered I/O locking https://git.kernel.org/vfs/vfs/c/1243d122feca [12/39] netfs: Add iov_iters to (sub)requests to describe various buffers https://git.kernel.org/vfs/vfs/c/a164fd03f073 [13/39] netfs: Add support for DIO buffering https://git.kernel.org/vfs/vfs/c/669e8c33691d [14/39] netfs: Provide tools to create a buffer in an xarray https://git.kernel.org/vfs/vfs/c/c554dc89292d [15/39] netfs: Add bounce buffering support https://git.kernel.org/vfs/vfs/c/476c24c3e80b [16/39] netfs: Add func to calculate pagecount/size-limited span of an iterator https://git.kernel.org/vfs/vfs/c/25d0f84de71d [17/39] netfs: Limit subrequest by size or number of segments https://git.kernel.org/vfs/vfs/c/53ee4e38619a [18/39] netfs: Export netfs_put_subrequest() and some tracepoints https://git.kernel.org/vfs/vfs/c/ac3fc1846a06 [19/39] netfs: Extend the netfs_io_*request structs to handle writes https://git.kernel.org/vfs/vfs/c/90999722fa0b [20/39] netfs: Add a hook to allow tell the netfs to update its i_size https://git.kernel.org/vfs/vfs/c/27dfd078db66 [21/39] netfs: Make netfs_put_request() handle a NULL pointer https://git.kernel.org/vfs/vfs/c/0ffd2319fb64 [22/39] netfs: Make the refcounting of netfs_begin_read() easier to use https://git.kernel.org/vfs/vfs/c/f7125395caba [23/39] netfs: Prep to use folio->private for write grouping and streaming write https://git.kernel.org/vfs/vfs/c/acadf22234e3 [24/39] netfs: Dispatch write requests to process a writeback slice https://git.kernel.org/vfs/vfs/c/17c2b775e3f4 [25/39] netfs: Provide func to copy data to pagecache for buffered write https://git.kernel.org/vfs/vfs/c/dd6ed9717a0b [26/39] netfs: Make netfs_read_folio() handle streaming-write pages https://git.kernel.org/vfs/vfs/c/c958b464f07f [27/39] netfs: Allocate multipage folios in the writepath https://git.kernel.org/vfs/vfs/c/6076cc863769 [28/39] netfs: Implement support for unbuffered/DIO read https://git.kernel.org/vfs/vfs/c/9409fe70ca46 [29/39] netfs: Implement unbuffered/DIO write support https://git.kernel.org/vfs/vfs/c/7acd7b902241 [30/39] netfs: Implement buffered write API https://git.kernel.org/vfs/vfs/c/7b1321366337 [31/39] netfs: Allow buffered shared-writeable mmap through netfs_page_mkwrite() https://git.kernel.org/vfs/vfs/c/d156da6e235c [32/39] netfs: Provide netfs_file_read_iter() https://git.kernel.org/vfs/vfs/c/899ae1e25a64 [33/39] netfs, cachefiles: Pass upper bound length to allow expansion https://git.kernel.org/vfs/vfs/c/52882c158a30 [34/39] netfs: Provide a writepages implementation https://git.kernel.org/vfs/vfs/c/02bf7b4afdba [35/39] netfs: Provide a launder_folio implementation https://git.kernel.org/vfs/vfs/c/cf4e16d98659 [36/39] netfs: Implement a write-through caching option https://git.kernel.org/vfs/vfs/c/7bf6f13f4a63 [37/39] netfs: Optimise away reads above the point at which there can be no data https://git.kernel.org/vfs/vfs/c/fad15293bd0d [38/39] afs: Use the netfs write helpers https://git.kernel.org/vfs/vfs/c/0095df30ad7b [39/39] 9p: Use netfslib read/write_iter https://git.kernel.org/vfs/vfs/c/361e79613421
Dominique Martinet
maintainerChristian Brauner wrote on Fri, Dec 15, 2023 at 01:03:14PM +0100:
Quoted 2 lines
tree: https://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs.git branch: vfs.netfs
This doesn't seem to build:
-------
CC [M] fs/netfs/buffered_write.ofs/netfs/buffered_write.c: In function ‘netfs_kill_pages’:fs/netfs/buffered_write.c:569:17: error: implicit declaration of function ‘generic_error_remove_folio’; did you mean ‘generic_error_remove_page’? [-Werror=implicit-function-declaration]
569 | generic_error_remove_folio(mapping, folio);
| ^~~~~~~~~~~~~~~~~~~~~~~~~~
| generic_error_remove_pagecc1: some warnings being treated as errors
-------
This helper is present in -next as commit af7628d6ec19 ("fs: convert error_remove_page to error_remove_folio") (as of now's next), apparently from akpm's mm-stable:git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm mm-stable
(which obviously have some conflict in afs when trying to merge...)
I'll go back to dhowell's tree to finally test 9p a bit, sorry for lack of involvement just low on time all around.
Good luck (?),
Signature · 1 line
Dominique Martinet | Asmadeus
Christian Brauner
maintainerQuoted 5 lines · Dominique Martinet
Christian Brauner wrote on Fri, Dec 15, 2023 at 01:03:14PM +0100:
Quoted 2 lines
tree: https://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs.git branch: vfs.netfsThis doesn't seem to build:
Yeah, I'm aware. That's why I didn't push it out. I couldn't finish the rebase completely on Friday.
David Howells
maintainerQuoted 2 lines · Dominique Martinet
I'll go back to dhowell's tree to finally test 9p a bit, sorry for lack of involvement just low on time all around.
I've rebased my tree on -rc6 rather than linux-next for Christian to pull.
Ganesha keeps falling over:
[root@carina build]# valgrind ./ganesha.nfsd -L /var/log/ganesha/ganesha.log -f /etc/ganesha/ganesha.conf -N NIV_EVENT -F ==38960== Memcheck, a memory error detector
==38960== Copyright (C) 2002-2022, and GNU GPL'd, by Julian Seward et al.
==38960== Using Valgrind-3.22.0 and LibVEX; rerun with -h for copyright info
==38960== Command: ./ganesha.nfsd -L /var/log/ganesha/ganesha.log -f /etc/ganesha/ganesha.conf -N NIV_EVENT -F ==38960==
==38960== Thread 138:
==38960== Invalid read of size 4
==38960== at 0x4DC32D6: pthread_cond_signal@@GLIBC_2.3.2 (pthread_cond_signal.c:41) ==38960== by 0x489700C: sync_cb (fsal_helper.c:1837) ==38960== by 0x49D79DF: mdc_read_super_cb (mdcache_file.c:559) ==38960== by 0x49D7AC5: mdc_read_cb (mdcache_file.c:582) ==38960== by 0x7B4B81F: vfs_read2 (file.c:1317) ==38960== by 0x49D7BCF: mdcache_read2 (mdcache_file.c:617) ==38960== by 0x4897173: fsal_read (fsal_helper.c:1849) ==38960== by 0x4A10FD4: _9p_read (9p_read.c:134) ==38960== by 0x4A0A024: _9p_process_buffer (9p_interpreter.c:181) ==38960== by 0x4A09DCB: _9p_tcp_process_request (9p_interpreter.c:133) ==38960== by 0x48CE182: _9p_execute (9p_dispatcher.c:315) ==38960== by 0x48CE508: _9p_worker_run (9p_dispatcher.c:412)
==38960== Address 0x24 is not stack'd, malloc'd or (recently) free'd ==38960==
==38960==
==38960== Process terminating with default action of signal 11 (SIGSEGV): dumping core ==38960== Access not within mapped region at address 0x24
==38960== at 0x4DC32D6: pthread_cond_signal@@GLIBC_2.3.2 (pthread_cond_signal.c:41) ==38960== by 0x489700C: sync_cb (fsal_helper.c:1837) ==38960== by 0x49D79DF: mdc_read_super_cb (mdcache_file.c:559) ==38960== by 0x49D7AC5: mdc_read_cb (mdcache_file.c:582) ==38960== by 0x7B4B81F: vfs_read2 (file.c:1317) ==38960== by 0x49D7BCF: mdcache_read2 (mdcache_file.c:617) ==38960== by 0x4897173: fsal_read (fsal_helper.c:1849) ==38960== by 0x4A10FD4: _9p_read (9p_read.c:134) ==38960== by 0x4A0A024: _9p_process_buffer (9p_interpreter.c:181) ==38960== by 0x4A09DCB: _9p_tcp_process_request (9p_interpreter.c:133) ==38960== by 0x48CE182: _9p_execute (9p_dispatcher.c:315) ==38960== by 0x48CE508: _9p_worker_run (9p_dispatcher.c:412)
David
Christian Brauner
maintainerQuoted 6 lines · David Howells
Quoted 2 lines · Dominique Martinet
I'll go back to dhowell's tree to finally test 9p a bit, sorry for lack of involvement just low on time all around.
I've rebased my tree on -rc6 rather than linux-next for Christian to pull.
Pulled. Thank you, David. It's on vfs.netfs.