netfs: Read/write improvements
Subsystems (18)
David Howells
maintainercover netfs: Read/write improvements
Hi Christian, Steve, Willy,
This set of patches includes one fscache fix and one cachefiles fix
(1) Fix a cookie access race in fscache.
(2) Fix the setxattr/removexattr syscalls to pull their arguments into kernel space before taking the sb_writers lock to avoid a deadlock against mm->mmap_lock.
A couple of adjustments to the /proc/fs/netfs/stats file:
(3) All the netfs stats lines begin 'Netfs:'. Change this to something a bit more useful.
(4) Add a couple of stats counters to track the numbers of skips and waits on the per-inode writeback serialisation lock to make it easier to check for this as a source of performance loss.
Some miscellaneous bits:
(5) Reduce the number of conditional branches in netfs_perform_write().
(6) Move the CIFS_INO_MODIFIED_ATTR flag to the netfs_inode struct and remove cifs_post_modify().
(7) Move the max_len/max_nr_segs members from netfs_io_subrequest to netfs_io_request as they're only needed for one subreq at a time.
(8) Add an 'unknown' source value for tracing purposes.
(9) Remove NETFS_COPY_TO_CACHE as it's no longer used.
(10) Set the request work function up front at allocation time.
(11) Use bh-disabling spinlocks for rreq->lock as cachefiles completion may be run from block-filesystem DIO completion in softirq context.
Then there's the main performance enhancing changes:
(12) Define a structure, struct folio_queue, and a new iterator type, ITER_FOLIOQ, to hold a buffer as a replacement for ITER_XARRAY. See that patch for questions about naming and form.
(13) Make cifs RDMA support ITER_FOLIOQ.
(14) Add a function to reset the iterator in a subrequest.
(15) Use folio queues in the write-side helpers instead of xarrays.
(16) Simplify the write-side helpers to use sheaves to skip gaps rather than trying to work out where gaps are.
(17) In afs, make the read subrequests asynchronous, putting them into work items to allow the next patch to do progressive unlocking/reading.
(18) Overhaul the read-side helpers to improve performance.
(19) Remove fs/netfs/io.c.
(20) Fix the caching of a partial block at the end of a file.
(21) Allow a store to be cancelled.
Then some changes for cifs to make it use folio queues instead of xarrays for crypto bufferage:
(22) Use raw iteration functions rather than manually coding iteration when hashing data.
(23) Switch to using folio_queue for crypto buffers.
(24) Remove the xarray bits.
David
David Howells (23):
cachefiles: Fix non-taking of sb_writers around set/removexattr
netfs: Adjust labels in /proc/fs/netfs/stats
netfs: Record contention stats for writeback lock
netfs: Reduce number of conditional branches in netfs_perform_write() netfs, cifs: Move CIFS_INO_MODIFIED_ATTR to netfs_inode
netfs: Move max_len/max_nr_segs from netfs_io_subrequest to
netfs_io_stream
netfs: Reserve netfs_sreq_source 0 as unset/unknown
netfs: Remove NETFS_COPY_TO_CACHE
netfs: Set the request work function upon allocation
netfs: Use bh-disabling spinlocks for rreq->lock
mm: Define struct folio_queue and ITER_FOLIOQ to handle a sequence of
folios
cifs: Provide the capability to extract from ITER_FOLIOQ to RDMA SGEs
netfs: Use new folio_queue data type and iterator instead of xarray
iter
netfs: Provide an iterator-reset function
netfs: Simplify the writeback code
afs: Make read subreqs async
netfs: Speed up buffered reading
netfs: Remove fs/netfs/io.c
cachefiles, netfs: Fix write to partial block at EOF
netfs: Cancel dirty folios that have no storage destination
cifs: Use iterate_and_advance*() routines directly for hashing
cifs: Switch crypto buffer to use a folio_queue rather than an xarray
cifs: Don't support ITER_XARRAY
Max Kellermann (1):
fs/netfs/fscache_cookie: add missing "n_accesses" check
fs/9p/vfs_addr.c | 5 +- fs/afs/file.c | 29 +- fs/afs/fsclient.c | 9 +- fs/afs/write.c | 4 +- fs/afs/yfsclient.c | 9 +- fs/cachefiles/io.c | 19 +- fs/cachefiles/xattr.c | 34 +- fs/ceph/addr.c | 72 ++-- fs/netfs/Makefile | 3 +- fs/netfs/buffered_read.c | 677 ++++++++++++++++++++++++----------- fs/netfs/buffered_write.c | 309 ++++++++-------- fs/netfs/direct_read.c | 147 +++++++- fs/netfs/fscache_cookie.c | 4 + fs/netfs/internal.h | 33 +- fs/netfs/io.c | 647 --------------------------------- fs/netfs/iterator.c | 50 +++ fs/netfs/main.c | 6 +- fs/netfs/misc.c | 94 +++++ fs/netfs/objects.c | 16 +- fs/netfs/read_collect.c | 540 ++++++++++++++++++++++++++++ fs/netfs/read_retry.c | 256 +++++++++++++ fs/netfs/stats.c | 23 +- fs/netfs/write_collect.c | 243 ++++--------- fs/netfs/write_issue.c | 92 ++--- fs/nfs/fscache.c | 19 +- fs/nfs/fscache.h | 7 +- fs/smb/client/cifsencrypt.c | 144 +------- fs/smb/client/cifsglob.h | 3 +- fs/smb/client/cifssmb.c | 6 +- fs/smb/client/file.c | 71 ++-- fs/smb/client/smb2ops.c | 218 ++++++----- fs/smb/client/smb2pdu.c | 10 +- fs/smb/client/smbdirect.c | 82 +++-- include/linux/folio_queue.h | 138 +++++++ include/linux/iov_iter.h | 104 ++++++ include/linux/netfs.h | 44 ++- include/linux/uio.h | 18 + include/trace/events/netfs.h | 140 ++++++-- lib/iov_iter.c | 229 +++++++++++- lib/kunit_iov_iter.c | 259 ++++++++++++++ lib/scatterlist.c | 69 +++- 41 files changed, 3175 insertions(+), 1707 deletions(-) delete mode 100644 fs/netfs/io.c create mode 100644 fs/netfs/read_collect.c create mode 100644 fs/netfs/read_retry.c create mode 100644 include/linux/folio_queue.h
David Howells
maintainerPATCH 1/24 fs/netfs/fscache_cookie: add missing "n_accesses" check
From: Max Kellermann <[email protected]>
This fixes a NULL pointer dereference bug due to a data race which looks like this:
BUG: kernel NULL pointer dereference, address: 0000000000000008 #PF: supervisor read access in kernel mode #PF: error_code(0x0000) - not-present page PGD 0 P4D 0 Oops: 0000 [#1] SMP PTI CPU: 33 PID: 16573 Comm: kworker/u97:799 Not tainted 6.8.7-cm4all1-hp+ #43 Hardware name: HP ProLiant DL380 Gen9/ProLiant DL380 Gen9, BIOS P89 10/17/2018 Workqueue: events_unbound netfs_rreq_write_to_cache_work RIP: 0010:cachefiles_prepare_write+0x30/0xa0 Code: 57 41 56 45 89 ce 41 55 49 89 cd 41 54 49 89 d4 55 53 48 89 fb 48 83 ec 08 48 8b 47 08 48 83 7f 10 00 48 89 34 24 48 8b 68 20 <48> 8b 45 08 4c 8b 38 74 45 49 8b 7f 50 e8 4e a9 b0 ff 48 8b 73 10 RSP: 0018:ffffb4e78113bde0 EFLAGS: 00010286 RAX: ffff976126be6d10 RBX: ffff97615cdb8438 RCX: 0000000000020000 RDX: ffff97605e6c4c68 RSI: ffff97605e6c4c60 RDI: ffff97615cdb8438 RBP: 0000000000000000 R08: 0000000000278333 R09: 0000000000000001 R10: ffff97605e6c4600 R11: 0000000000000001 R12: ffff97605e6c4c68 R13: 0000000000020000 R14: 0000000000000001 R15: ffff976064fe2c00 FS: 0000000000000000(0000) GS:ffff9776dfd40000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 0000000000000008 CR3: 000000005942c002 CR4: 00000000001706f0 Call Trace: <TASK> ? __die+0x1f/0x70 ? page_fault_oops+0x15d/0x440 ? search_module_extables+0xe/0x40 ? fixup_exception+0x22/0x2f0 ? exc_page_fault+0x5f/0x100 ? asm_exc_page_fault+0x22/0x30 ? cachefiles_prepare_write+0x30/0xa0 netfs_rreq_write_to_cache_work+0x135/0x2e0 process_one_work+0x137/0x2c0 worker_thread+0x2e9/0x400 ? __pfx_worker_thread+0x10/0x10 kthread+0xcc/0x100 ? __pfx_kthread+0x10/0x10 ret_from_fork+0x30/0x50 ? __pfx_kthread+0x10/0x10 ret_from_fork_asm+0x1b/0x30 </TASK> Modules linked in: CR2: 0000000000000008 ---[ end trace 0000000000000000 ]---
This happened because fscache_cookie_state_machine() was slow and was still running while another process invoked fscache_unuse_cookie(); this led to a fscache_cookie_lru_do_one() call, setting the FSCACHE_COOKIE_DO_LRU_DISCARD flag, which was picked up by fscache_cookie_state_machine(), withdrawing the cookie via cachefiles_withdraw_cookie(), clearing cookie->cache_priv.
At the same time, yet another process invoked cachefiles_prepare_write(), which found a NULL pointer in this code line:
struct cachefiles_object *object = cachefiles_cres_object(cres);
The next line crashes, obviously:
struct cachefiles_cache *cache = object->volume->cache;
During cachefiles_prepare_write(), the "n_accesses" counter is non-zero (via fscache_begin_operation()). The cookie must not be withdrawn until it drops to zero.
The counter is checked by fscache_cookie_state_machine() before switching to FSCACHE_COOKIE_STATE_RELINQUISHING and FSCACHE_COOKIE_STATE_WITHDRAWING (in "case FSCACHE_COOKIE_STATE_FAILED"), but not for FSCACHE_COOKIE_STATE_LRU_DISCARDING ("case FSCACHE_COOKIE_STATE_ACTIVE").
This patch adds the missing check. With a non-zero access counter, the function returns and the next fscache_end_cookie_access() call will queue another fscache_cookie_state_machine() call to handle the still-pending FSCACHE_COOKIE_DO_LRU_DISCARD.
--- fs/netfs/fscache_cookie.c | 4 ++++ 1 file changed, 4 insertions(+)
fs/netfs/fscache_cookie.c +4 -0
@@ -741,6 +741,10 @@ static void fscache_cookie_state_machine(struct fscache_cookie *cookie)spin_lock (&cookie->lock); }if (test_bit (FSCACHE_COOKIE_DO_LRU_DISCARD , &cookie->flags)) { +if (atomic_read (&cookie->n_accesses) !=0 ) +/* still being accessed: postpone it */ +break ; +__fscache_set_cookie_state (cookie,FSCACHE_COOKIE_STATE_LRU_DISCARDING ); wake = true;
David Howells
maintainerPATCH 2/24 cachefiles: Fix non-taking of sb_writers around set/removexattr
In reply to David HowellsUnlike other vfs_xxxx() calls, vfs_setxattr() and vfs_removexattr() don't take the sb_writers lock, so the caller should do it for them.
Fix cachefiles to do this.
--- fs/cachefiles/xattr.c | 34 ++++++++++++++++++++++++++-------- 1 file changed, 26 insertions(+), 8 deletions(-)
fs/cachefiles/xattr.c +26 -8
@@ -64,9 +64,15 @@ int cachefiles_set_object_xattr(struct cachefiles_object *object)memcpy (buf->data,fscache_get_aux (object->cookie), len); ret =cachefiles_inject_write_error (); -if (ret ==0 ) - ret =vfs_setxattr (&nop_mnt_idmap, dentry, cachefiles_xattr_cache, - buf,sizeof (struct cachefiles_xattr ) + len,0 ); +if (ret ==0 ) { + ret =mnt_want_write_file (file); +if (ret ==0 ) { + ret =vfs_setxattr (&nop_mnt_idmap, dentry, + cachefiles_xattr_cache, buf, +sizeof (struct cachefiles_xattr ) + len,0 ); +mnt_drop_write_file (file); + } + }if (ret <0 ) {trace_cachefiles_vfs_error (object,file_inode (file), ret, cachefiles_trace_setxattr_error);
@@ -151,8 +157,14 @@ int cachefiles_remove_object_xattr(struct cachefiles_cache *cache,int ret; ret =cachefiles_inject_remove_error (); -if (ret ==0 ) - ret =vfs_removexattr (&nop_mnt_idmap, dentry, cachefiles_xattr_cache); +if (ret ==0 ) { + ret =mnt_want_write (cache->mnt); +if (ret ==0 ) { + ret =vfs_removexattr (&nop_mnt_idmap, dentry, + cachefiles_xattr_cache); +mnt_drop_write (cache->mnt); + } + }if (ret <0 ) {trace_cachefiles_vfs_error (object,d_inode (dentry), ret, cachefiles_trace_remxattr_error);
@@ -208,9 +220,15 @@ bool cachefiles_set_volume_xattr(struct cachefiles_volume *volume)memcpy (buf->data, p, volume->vcookie->coherency_len); ret =cachefiles_inject_write_error (); -if (ret ==0 ) - ret =vfs_setxattr (&nop_mnt_idmap, dentry, cachefiles_xattr_cache, - buf, len,0 ); +if (ret ==0 ) { + ret =mnt_want_write (volume->cache->mnt); +if (ret ==0 ) { + ret =vfs_setxattr (&nop_mnt_idmap, dentry, + cachefiles_xattr_cache, + buf, len,0 ); +mnt_drop_write (volume->cache->mnt); + } + }if (ret <0 ) {trace_cachefiles_vfs_error (NULL ,d_inode (dentry), ret, cachefiles_trace_setxattr_error);
David Howells
maintainerPATCH 3/24 netfs: Adjust labels in /proc/fs/netfs/stats
In reply to David HowellsAdjust the labels in /proc/fs/netfs/stats that refer to netfs-specific counters. These currently all begin with "Netfs", but change them to begin with more specific labels.
--- fs/netfs/stats.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
fs/netfs/stats.c +8 -8
@@ -42,39 +42,39 @@ atomic_t netfs_n_wh_write_failed;int netfs_stats_show (struct seq_file *m,void *v) { -seq_printf (m,"Netfs : DR=%u RA=%u RF=%u WB=%u WBZ=%u\n" , +seq_printf (m,"Reads : DR=%u RA=%u RF=%u WB=%u WBZ=%u\n" ,atomic_read (&netfs_n_rh_dio_read),atomic_read (&netfs_n_rh_readahead),atomic_read (&netfs_n_rh_read_folio),atomic_read (&netfs_n_rh_write_begin),atomic_read (&netfs_n_rh_write_zskip)); -seq_printf (m,"Netfs : BW=%u WT=%u DW=%u WP=%u\n" , +seq_printf (m,"Writes : BW=%u WT=%u DW=%u WP=%u\n" ,atomic_read (&netfs_n_wh_buffered_write),atomic_read (&netfs_n_wh_writethrough),atomic_read (&netfs_n_wh_dio_write),atomic_read (&netfs_n_wh_writepages)); -seq_printf (m,"Netfs : ZR=%u sh=%u sk=%u\n" , +seq_printf (m,"ZeroOps: 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,"Netfs : DL=%u ds=%u df=%u di=%u\n" , +seq_printf (m,"DownOps: 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,"Netfs : RD=%u rs=%u rf=%u\n" , +seq_printf (m,"CaRdOps: 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,"Netfs : UL=%u us=%u uf=%u\n" , +seq_printf (m,"UpldOps: 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" , +seq_printf (m,"CaWrOps: WR=%u ws=%u wf=%u\n" ,atomic_read (&netfs_n_wh_write),atomic_read (&netfs_n_wh_write_done),atomic_read (&netfs_n_wh_write_failed)); -seq_printf (m,"Netfs : rr=%u sr=%u wsc=%u\n" , +seq_printf (m,"Objs : rr=%u sr=%u wsc=%u\n" ,atomic_read (&netfs_n_rh_rreq),atomic_read (&netfs_n_rh_sreq),atomic_read (&netfs_n_wh_wstream_conflict));
David Howells
maintainerPATCH 4/24 netfs: Record contention stats for writeback lock
In reply to David HowellsRecord statistics for contention upon the writeback serialisation lock that prevents racing writeback calls from causing each other to interleave their writebacks. These can be viewed in /proc/fs/netfs/stats on the WbLock line, with skip=N indicating the number of non-SYNC writebacks skipped and wait=N indicating the number of SYNC writebacks that waited.
--- fs/netfs/internal.h | 2 ++ fs/netfs/stats.c | 5 +++++ fs/netfs/write_issue.c | 10 +++++++--- 3 files changed, 14 insertions(+), 3 deletions(-)
fs/netfs/internal.h +2 -0
@@ -117,6 +117,8 @@ 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; +extern atomic_t netfs_n_wb_lock_skip; +extern atomic_t netfs_n_wb_lock_wait;int netfs_stats_show (struct seq_file *m,void *v);
fs/netfs/stats.c +5 -0
@@ -39,6 +39,8 @@ 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; +atomic_t netfs_n_wb_lock_skip; +atomic_t netfs_n_wb_lock_wait;int netfs_stats_show (struct seq_file *m,void *v) {
@@ -78,6 +80,9 @@ int netfs_stats_show(struct seq_file *m, void *v)atomic_read (&netfs_n_rh_rreq),atomic_read (&netfs_n_rh_sreq), atomic_read(&netfs_n_wh_wstream_conflict)); +seq_printf (m,"WbLock : skip=%u wait=%u\n" , +atomic_read (&netfs_n_wb_lock_skip), +atomic_read (&netfs_n_wb_lock_wait));return fscache_stats_show (m); }EXPORT_SYMBOL (netfs_stats_show);
fs/netfs/write_issue.c +7 -3
@@ -503,10 +503,14 @@ int netfs_writepages(struct address_space *mapping,struct folio *folio;int error =0 ; -if (wbc->sync_mode ==WB_SYNC_ALL ) +if (!mutex_trylock (&ictx->wb_lock)) { +if (wbc->sync_mode ==WB_SYNC_NONE ) { +netfs_stat (&netfs_n_wb_lock_skip); +return 0 ; + } +netfs_stat (&netfs_n_wb_lock_wait);mutex_lock (&ictx->wb_lock); -else if (!mutex_trylock (&ictx->wb_lock)) -return 0 ; + }/* Need the first folio to be able to set up the op. */ folio =writeback_iter (mapping, wbc,NULL , &error);
David Howells
maintainerPATCH 5/24 netfs: Reduce number of conditional branches in netfs_perform_write()
In reply to David HowellsReduce the number of conditional branches in netfs_perform_write() by merging in netfs_how_to_modify() and then creating a separate if-statement for each way we might modify a folio. Note that this means replicating the data copy in each path.
--- fs/netfs/buffered_write.c | 299 ++++++++++++++++------------------- include/trace/events/netfs.h | 2 - 2 files changed, 134 insertions(+), 167 deletions(-)
fs/netfs/buffered_write.c +134 -165
@@ -13,91 +13,22 @@#include <linux/pagevec.h> #include "internal.h" -/* -* Determined write method. Adjust netfs_folio_traces if this is changed. -*/ -enum netfs_how_to_modify { -NETFS_FOLIO_IS_UPTODATE ,/* Folio is uptodate already */ -NETFS_JUST_PREFETCH ,/* We have to read the folio anyway */ -NETFS_WHOLE_FOLIO_MODIFY ,/* We're going to overwrite the whole folio */ -NETFS_MODIFY_AND_CLEAR ,/* We can assume there is no data to be downloaded. */ -NETFS_STREAMING_WRITE ,/* Store incomplete data in non-uptodate page. */ -NETFS_STREAMING_WRITE_CONT ,/* Continue streaming write. */ -NETFS_FLUSH_CONTENT ,/* Flush incompatible content. */ -}; - -static void netfs_set_group (struct folio *folio,struct netfs_group *netfs_group) +static void __netfs_set_group (struct folio *folio,struct netfs_group *netfs_group) { -void *priv =folio_get_private (folio); - -if (netfs_group && (!priv || priv ==NETFS_FOLIO_COPY_TO_CACHE )) +if (netfs_group)folio_attach_private (folio,netfs_get_group (netfs_group)); -else if (!netfs_group && priv ==NETFS_FOLIO_COPY_TO_CACHE ) -folio_detach_private (folio); } -/* -* 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 -* avoid it. If we're doing local caching or content crypto, we award that -* priority over avoiding RMW. If the file is open readably, then we also -* assume that we may want to read what we wrote. -*/ -static enum netfs_how_to_modify netfs_how_to_modify (struct netfs_inode *ctx, -struct file *file, -struct folio *folio, -void *netfs_group, -size_t flen, -size_t offset, -size_t len, -bool maybe_trouble) +static void netfs_set_group (struct folio *folio,struct netfs_group *netfs_group) { -struct netfs_folio *finfo =netfs_folio_info (folio); -struct netfs_group *group =netfs_folio_group (folio); -loff_t pos =folio_pos (folio); - -_enter ("" ); - -if (group != netfs_group && group !=NETFS_FOLIO_COPY_TO_CACHE ) -return NETFS_FLUSH_CONTENT ; - -if (folio_test_uptodate (folio)) -return NETFS_FOLIO_IS_UPTODATE ; - -if (pos >= ctx->zero_point) -return NETFS_MODIFY_AND_CLEAR ; - -if (!maybe_trouble && offset ==0 && len >= flen) -return NETFS_WHOLE_FOLIO_MODIFY ; - -if (file->f_mode &FMODE_READ ) - goto no_write_streaming; - -if (netfs_is_cache_enabled (ctx)) { -/* We don't want to get a streaming write on a file that loses -* caching service temporarily because the backing store got -* culled. -*/ - goto no_write_streaming; - } +void *priv =folio_get_private (folio); -if (!finfo) -return NETFS_STREAMING_WRITE ; - -/* We can continue a streaming write only if it continues on from the -* previous. If it overlaps, we must flush lest we suffer a partial -* copy and disjoint dirty regions. -*/ -if (offset == finfo->dirty_offset + finfo->dirty_len) -return NETFS_STREAMING_WRITE_CONT ; -return NETFS_FLUSH_CONTENT ; - -no_write_streaming: -if (finfo) { -netfs_stat (&netfs_n_wh_wstream_conflict); -return NETFS_FLUSH_CONTENT ; +if (unlikely (priv != netfs_group)) { +if (netfs_group && (!priv || priv ==NETFS_FOLIO_COPY_TO_CACHE )) +folio_attach_private (folio,netfs_get_group (netfs_group)); +else if (!netfs_group && priv ==NETFS_FOLIO_COPY_TO_CACHE ) +folio_detach_private (folio); } -return NETFS_JUST_PREFETCH ; }/*
@@ -177,13 +108,10 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, .range_end = iocb->ki_pos + iter->count, };struct netfs_io_request *wreq =NULL ; -struct netfs_folio *finfo; -struct folio *folio, *writethrough =NULL ; -enum netfs_how_to_modify howto; -enum netfs_folio_trace trace; +struct folio *folio =NULL , *writethrough =NULL ;unsigned int bdp_flags = (iocb->ki_flags &IOCB_NOWAIT ) ?BDP_ASYNC :0 ;ssize_t written =0 , ret, ret2; -loff_t i_size, pos = iocb->ki_pos, from, to; +loff_t i_size, pos = iocb->ki_pos;size_t max_chunk =PAGE_SIZE <<MAX_PAGECACHE_ORDER ;bool maybe_trouble = false;
@@ -213,15 +141,14 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, } do { + struct netfs_folio *finfo; + struct netfs_group *group; + unsigned long long fpos; size_t flen; size_t offset; /* Offset into pagecache folio */ size_t part; /* Bytes to write to folio */ size_t copied; /* Bytes copied from user */ - ret = balance_dirty_pages_ratelimited_flags(mapping, bdp_flags); - if (unlikely(ret < 0)) - break; - offset = pos & (max_chunk - 1); part = min(max_chunk - offset, iov_iter_count(iter));
@@ -247,7 +174,8 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, } flen =folio_size (folio); - offset = pos & (flen -1 ); + fpos =folio_pos (folio); + offset = pos - fpos; part =min_t (size_t, flen - offset, part);/* Wait for writeback to complete. The writeback engine owns
@@ -265,71 +193,52 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, goto error_folio_unlock; } -/* See if we need to prefetch the area we're going to modify. -* We need to do this before we get a lock on the folio in case -* there's more than one writer competing for the same cache -* block. +/* 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 avoid it. If we're doing local +* caching or content crypto, we award that priority over +* avoiding RMW. If the file is open readably, then we also +* assume that we may want to read what we wrote. */ - howto =netfs_how_to_modify (ctx, file, folio, netfs_group, - flen, offset, part, maybe_trouble); -_debug ("howto %u" , howto); -switch (howto) { -case NETFS_JUST_PREFETCH : - ret =netfs_prefetch_for_write (file, folio, offset, part); -if (ret <0 ) { -_debug ("prefetch = %zd" , ret); - goto error_folio_unlock; - } -break ; -case NETFS_FOLIO_IS_UPTODATE : -case NETFS_WHOLE_FOLIO_MODIFY : -case NETFS_STREAMING_WRITE_CONT : -break ; -case NETFS_MODIFY_AND_CLEAR : -zero_user_segment (&folio->page,0 , offset); -break ; -case NETFS_STREAMING_WRITE : - ret = -EIO ; -if (WARN_ON (folio_get_private (folio))) - goto error_folio_unlock; -break ; -case NETFS_FLUSH_CONTENT : -trace_netfs_folio (folio, netfs_flush_content); - from =folio_pos (folio); - to = from +folio_size (folio) -1 ; -folio_unlock (folio); -folio_put (folio); - ret =filemap_write_and_wait_range (mapping, from, to); -if (ret <0 ) - goto error_folio_unlock; -continue ; - } - -if (mapping_writably_mapped (mapping)) -flush_dcache_folio (folio); - - copied =copy_folio_from_iter_atomic (folio, offset, part, iter); - -flush_dcache_folio (folio); - -/* Deal with a (partially) failed copy */ -if (copied ==0 ) { - ret = -EFAULT ; - goto error_folio_unlock; + finfo =netfs_folio_info (folio); + group =netfs_folio_group (folio); + +if (unlikely (group != netfs_group) && + group !=NETFS_FOLIO_COPY_TO_CACHE ) + goto flush_content; + +if (folio_test_uptodate (folio)) { +if (mapping_writably_mapped (mapping)) +flush_dcache_folio (folio); + copied =copy_folio_from_iter_atomic (folio, offset, part, iter); +if (unlikely (copied ==0 )) + goto copy_failed; +netfs_set_group (folio, netfs_group); +trace_netfs_folio (folio, netfs_folio_is_uptodate); + goto copied; } - trace = (enum netfs_folio_trace )howto; -switch (howto) { -case NETFS_FOLIO_IS_UPTODATE : -case NETFS_JUST_PREFETCH : -netfs_set_group (folio, netfs_group); -break ; -case NETFS_MODIFY_AND_CLEAR : +/* If the page is above the zero-point then we assume that the +* server would just return a block of zeros or a short read if +* we try to read it. +*/ +if (fpos >= ctx->zero_point) { +zero_user_segment (&folio->page,0 , offset); + copied =copy_folio_from_iter_atomic (folio, offset, part, iter); +if (unlikely (copied ==0 )) + goto copy_failed;zero_user_segment (&folio->page, offset + copied, flen); -netfs_set_group (folio, netfs_group); +__netfs_set_group (folio, netfs_group);folio_mark_uptodate (folio); -break ; -case NETFS_WHOLE_FOLIO_MODIFY : +trace_netfs_folio (folio, netfs_modify_and_clear); + goto copied; + } + +/* See if we can write a whole folio in one go. */ +if (!maybe_trouble && offset ==0 && part >= flen) { + copied =copy_folio_from_iter_atomic (folio, offset, part, iter); +if (unlikely (copied ==0 )) + goto copy_failed;if (unlikely (copied < part)) { maybe_trouble = true;iov_iter_revert (iter, copied);
@@ -337,16 +246,53 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,folio_unlock (folio); goto retry; } -netfs_set_group (folio, netfs_group); +__netfs_set_group (folio, netfs_group);folio_mark_uptodate (folio); -break ; -case NETFS_STREAMING_WRITE : +trace_netfs_folio (folio, netfs_whole_folio_modify); + goto copied; + } + +/* We don't want to do a streaming write on a file that loses +* caching service temporarily because the backing store got +* culled and we don't really want to get a streaming write on +* a file that's open for reading as ->read_folio() then has to +* be able to flush it. +*/ +if ((file->f_mode &FMODE_READ ) || +netfs_is_cache_enabled (ctx)) { +if (finfo) { +netfs_stat (&netfs_n_wh_wstream_conflict); + goto flush_content; + } + ret =netfs_prefetch_for_write (file, folio, offset, part); +if (ret <0 ) { +_debug ("prefetch = %zd" , ret); + goto error_folio_unlock; + } +/* Note that copy-to-cache may have been set. */ + + copied =copy_folio_from_iter_atomic (folio, offset, part, iter); +if (unlikely (copied ==0 )) + goto copy_failed; +netfs_set_group (folio, netfs_group); +trace_netfs_folio (folio, netfs_just_prefetch); + goto copied; + } + +if (!finfo) { + ret = -EIO ; +if (WARN_ON (folio_get_private (folio))) + goto error_folio_unlock; + copied =copy_folio_from_iter_atomic (folio, offset, part, iter); +if (unlikely (copied ==0 )) + goto copy_failed;if (offset ==0 && copied == flen) { -netfs_set_group (folio, netfs_group); +__netfs_set_group (folio, netfs_group);folio_mark_uptodate (folio); - trace = netfs_streaming_filled_page; -break ; +trace_netfs_folio (folio, netfs_streaming_filled_page); + goto copied; } + finfo =kzalloc (sizeof (*finfo),GFP_KERNEL );if (!finfo) {iov_iter_revert (iter, copied);
@@ -358,9 +304,18 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, finfo->dirty_len = copied;folio_attach_private (folio, (void *)((unsigned long )finfo |NETFS_FOLIO_INFO )); -break ; -case NETFS_STREAMING_WRITE_CONT : - finfo =netfs_folio_info (folio); +trace_netfs_folio (folio, netfs_streaming_write); + goto copied; + } + +/* We can continue a streaming write only if it continues on +* from the previous. If it overlaps, we must flush lest we +* suffer a partial copy and disjoint dirty regions. +*/ +if (offset == finfo->dirty_offset + finfo->dirty_len) { + copied =copy_folio_from_iter_atomic (folio, offset, part, iter); +if (unlikely (copied ==0 )) + goto copy_failed; finfo->dirty_len += copied;if (finfo->dirty_offset ==0 && finfo->dirty_len == flen) {if (finfo->netfs_group)
@@ -369,17 +324,25 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,folio_detach_private (folio);folio_mark_uptodate (folio);kfree (finfo); - trace = netfs_streaming_cont_filled_page; +trace_netfs_folio (folio, netfs_streaming_cont_filled_page); + }else { +trace_netfs_folio (folio, netfs_streaming_write_cont); } -break ; -default : -WARN (true,"Unexpected modify type %u ix=%lx\n" , - howto, folio->index); - ret = -EIO ; - goto error_folio_unlock; + goto copied; } -trace_netfs_folio (folio, trace); +/* Incompatible write; flush the folio and try again. */ + flush_content: +trace_netfs_folio (folio, netfs_flush_content); +folio_unlock (folio); +folio_put (folio); + ret =filemap_write_and_wait_range (mapping, fpos, fpos + flen -1 ); +if (ret <0 ) + goto error_folio_unlock; +continue ; + + copied: +flush_dcache_folio (folio);/* Update the inode size if we moved the EOF marker */ pos += copied;
@@ -401,6 +364,10 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,folio_put (folio); folio =NULL ; + ret =balance_dirty_pages_ratelimited_flags (mapping, bdp_flags); +if (unlikely (ret <0 )) +break ; +cond_resched (); }while (iov_iter_count (iter));
@@ -421,6 +388,8 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,_leave (" = %zd [%zd]" , written, ret);return written ? written : ret; +copy_failed: + ret = -EFAULT ; error_folio_unlock:folio_unlock (folio);folio_put (folio);
include/trace/events/netfs.h +0 -2
@@ -128,7 +128,6 @@ E_(netfs_sreq_trace_put_terminated, "PUT TERM ")#define netfs_folio_traces \ -/* The first few correspond to enum netfs_how_to_modify */ \ EM(netfs_folio_is_uptodate, "mod-uptodate") \ EM(netfs_just_prefetch, "mod-prefetch") \ EM(netfs_whole_folio_modify, "mod-whole-f") \
@@ -138,7 +137,6 @@ EM(netfs_flush_content, "flush") \ EM(netfs_streaming_filled_page, "mod-streamw-f") \ EM(netfs_streaming_cont_filled_page, "mod-streamw-f+") \ - /* The rest are for writeback */ \ EM(netfs_folio_trace_cancel_copy, "cancel-copy") \ EM(netfs_folio_trace_clear, "clear") \EM (netfs_folio_trace_clear_cc,"clear-cc" ) \
David Howells
maintainerPATCH 6/24 netfs, cifs: Move CIFS_INO_MODIFIED_ATTR to netfs_inode
In reply to David HowellsMove CIFS_INO_MODIFIED_ATTR to netfs_inode as NETFS_ICTX_MODIFIED_ATTR and then make netfs_perform_write() set it. This means that cifs doesn't need to implement the ->post_modify() hook.
--- fs/netfs/buffered_write.c | 10 ++++++++-- fs/smb/client/cifsglob.h | 1 - fs/smb/client/file.c | 9 +-------- include/linux/netfs.h | 1 + 4 files changed, 10 insertions(+), 11 deletions(-)
fs/netfs/buffered_write.c +8 -2
@@ -372,8 +372,14 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, }while (iov_iter_count (iter)); out: -if (likely (written) && ctx->ops->post_modify) - ctx->ops->post_modify (inode); +if (likely (written)) { +/* Set indication that ctime and mtime got updated in case +* close is deferred. +*/ +set_bit (NETFS_ICTX_MODIFIED_ATTR , &ctx->flags); +if (unlikely (ctx->ops->post_modify)) + ctx->ops->post_modify (inode); + }if (unlikely (wreq)) { ret2 =netfs_end_writethrough (wreq, &wbc, writethrough);
fs/smb/client/cifsglob.h +0 -1
@@ -1573,7 +1573,6 @@ struct cifsInodeInfo {#define CIFS_INO_DELETE_PENDING (3)/* delete pending on server */ #define CIFS_INO_INVALID_MAPPING (4)/* pagecache is invalid */ #define CIFS_INO_LOCK (5)/* lock bit for synchronization */ -#define CIFS_INO_MODIFIED_ATTR (6)/* Indicate change in mtime/ctime */ #define CIFS_INO_CLOSE_ON_LOCK (7)/* Not to defer the close when lock is set */ unsigned long flags;spinlock_t writers_lock;
fs/smb/client/file.c +1 -8
@@ -286,12 +286,6 @@ static void cifs_rreq_done(struct netfs_io_request *rreq)inode_set_atime_to_ts (inode,inode_get_mtime (inode)); } -static void cifs_post_modify (struct inode *inode) -{ -/* Indication to update ctime and mtime as close is deferred */ -set_bit (CIFS_INO_MODIFIED_ATTR , &CIFS_I (inode)->flags); -} -static void cifs_free_request (struct netfs_io_request *rreq) { struct cifs_io_request *req = container_of(rreq, struct cifs_io_request, rreq);
@@ -338,7 +332,6 @@ const struct netfs_request_ops cifs_req_ops = { .clamp_length = cifs_clamp_length, .issue_read = cifs_req_issue_read, .done = cifs_rreq_done, - .post_modify = cifs_post_modify, .begin_writeback = cifs_begin_writeback, .prepare_write = cifs_prepare_write, .issue_write = cifs_issue_write,
@@ -1362,7 +1355,7 @@ int cifs_close(struct inode *inode, struct file *file) dclose =kmalloc (sizeof (struct cifs_deferred_close ),GFP_KERNEL );if ((cfile->status_file_deleted == false) && (smb2_can_defer_close (inode, dclose))) { -if (test_and_clear_bit (CIFS_INO_MODIFIED_ATTR , &cinode->flags)) { +if (test_and_clear_bit (NETFS_ICTX_MODIFIED_ATTR , &cinode->netfs.flags)) {inode_set_mtime_to_ts (inode,inode_set_ctime_current (inode)); }
include/linux/netfs.h +1 -0
@@ -73,6 +73,7 @@ struct netfs_inode {#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 */ +#define NETFS_ICTX_MODIFIED_ATTR 3/* Indicate change in mtime/ctime */ #define NETFS_ICTX_USE_PGPRIV2 31/* [DEPRECATED] Use PG_private_2 to mark * write to cache on read */ };
David Howells
maintainerPATCH 7/24 netfs: Move max_len/max_nr_segs from netfs_io_subrequest to netfs_io_stream
In reply to David HowellsMove max_len/max_nr_segs from struct netfs_io_subrequest to struct netfs_io_stream as we only issue one subreq at a time and then don't need these values again for that subreq unless and until we have to retry it - in which case we want to renegotiate them.
--- fs/afs/write.c | 4 +++- fs/cachefiles/io.c | 5 +++-- fs/netfs/io.c | 4 ++-- fs/netfs/write_collect.c | 10 +++++----- fs/netfs/write_issue.c | 14 +++++++------- fs/smb/client/file.c | 15 ++++++++------- include/linux/netfs.h | 4 ++-- 7 files changed, 30 insertions(+), 26 deletions(-)
fs/afs/write.c +3 -1
@@ -89,10 +89,12 @@ static const struct afs_operation_ops afs_store_data_operation = {*/ void afs_prepare_write (struct netfs_io_subrequest *subreq) { +struct netfs_io_stream *stream = &subreq->rreq->io_streams[subreq->stream_nr]; +//if (test_bit(NETFS_SREQ_RETRYING, &subreq->flags)) // subreq->max_len = 512 * 1024; //else - subreq->max_len =256 *1024 *1024 ; + stream->sreq_max_len =256 *1024 *1024 ; }/*
fs/cachefiles/io.c +3 -2
@@ -627,11 +627,12 @@ static void cachefiles_prepare_write_subreq(struct netfs_io_subrequest *subreq) {struct netfs_io_request *wreq = subreq->rreq;struct netfs_cache_resources *cres = &wreq->cache_resources; +struct netfs_io_stream *stream = &wreq->io_streams[subreq->stream_nr];_enter ("W=%x[%x] %llx" , wreq->debug_id, subreq->debug_index, subreq->start); - subreq->max_len =MAX_RW_COUNT ; - subreq->max_nr_segs =BIO_MAX_VECS ; + stream->sreq_max_len =MAX_RW_COUNT ; + stream->sreq_max_segs =BIO_MAX_VECS ;if (!cachefiles_cres_file (cres)) {if (!fscache_wait_for_operation (cres,FSCACHE_WANT_WRITE ))
fs/netfs/io.c +2 -2
@@ -469,9 +469,9 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq, goto out; } -if (subreq->max_nr_segs) { +if (rreq->io_streams[0 ].sreq_max_segs) { lsize =netfs_limit_iter (io_iter,0 , subreq->len, - subreq->max_nr_segs); + rreq->io_streams[0 ].sreq_max_segs);if (subreq->len > lsize) { subreq->len = lsize;trace_netfs_sreq (subreq, netfs_sreq_trace_limited);
fs/netfs/write_collect.c +5 -5
@@ -231,7 +231,7 @@ static void netfs_retry_write_stream(struct netfs_io_request *wreq,__set_bit (NETFS_SREQ_RETRYING , &subreq->flags); stream->prepare_write (subreq); - part =min (len, subreq->max_len); + part =min (len, stream->sreq_max_len); subreq->len = part; subreq->start = start; subreq->transferred =0 ;
@@ -271,8 +271,6 @@ static void netfs_retry_write_stream(struct netfs_io_request *wreq, subreq =netfs_alloc_subrequest (wreq); subreq->source = to->source; subreq->start = start; - subreq->max_len = len; - subreq->max_nr_segs =INT_MAX ; subreq->debug_index =atomic_inc_return (&wreq->subreq_counter); subreq->stream_nr = to->stream_nr;__set_bit (NETFS_SREQ_RETRYING , &subreq->flags);
@@ -286,10 +284,12 @@ static void netfs_retry_write_stream(struct netfs_io_request *wreq, to =list_next_entry (to, rreq_link);trace_netfs_sreq (subreq, netfs_sreq_trace_retry); + stream->sreq_max_len = len; + stream->sreq_max_segs =INT_MAX ;switch (stream->source) {case NETFS_UPLOAD_TO_SERVER :netfs_stat (&netfs_n_wh_upload); - subreq->max_len =min (len, wreq->wsize); + stream->sreq_max_len =umin (len, wreq->wsize);break ;case NETFS_WRITE_TO_CACHE :netfs_stat (&netfs_n_wh_write);
@@ -300,7 +300,7 @@ static void netfs_retry_write_stream(struct netfs_io_request *wreq, stream->prepare_write (subreq); - part =min (len, subreq->max_len); + part =umin (len, stream->sreq_max_len); subreq->len = subreq->transferred + part; len -= part; start += part;
fs/netfs/write_issue.c +7 -7
@@ -156,8 +156,6 @@ static void netfs_prepare_write(struct netfs_io_request *wreq, subreq =netfs_alloc_subrequest (wreq); subreq->source = stream->source; subreq->start = start; - subreq->max_len =ULONG_MAX ; - subreq->max_nr_segs =INT_MAX ; subreq->stream_nr = stream->stream_nr;_enter ("R=%x[%x]" , wreq->debug_id, subreq->debug_index);
@@ -168,10 +166,12 @@ static void netfs_prepare_write(struct netfs_io_request *wreq,trace_netfs_sreq (subreq, netfs_sreq_trace_prepare); + stream->sreq_max_len =UINT_MAX ; + stream->sreq_max_segs =INT_MAX ;switch (stream->source) {case NETFS_UPLOAD_TO_SERVER :netfs_stat (&netfs_n_wh_upload); - subreq->max_len = wreq->wsize; + stream->sreq_max_len = wreq->wsize;break ;case NETFS_WRITE_TO_CACHE :netfs_stat (&netfs_n_wh_write);
@@ -288,13 +288,13 @@ int netfs_advance_write(struct netfs_io_request *wreq,netfs_prepare_write (wreq, stream, start); subreq = stream->construct; - part =min (subreq->max_len - subreq->len, len); -_debug ("part %zx/%zx %zx/%zx" , subreq->len, subreq->max_len, part, len); + part =umin (stream->sreq_max_len - subreq->len, len); +_debug ("part %zx/%zx %zx/%zx" , subreq->len, stream->sreq_max_len, part, len); subreq->len += part; subreq->nr_segs++; -if (subreq->len >= subreq->max_len || - subreq->nr_segs >= subreq->max_nr_segs || +if (subreq->len >= stream->sreq_max_len || + subreq->nr_segs >= stream->sreq_max_segs || to_eof) {netfs_issue_write (wreq, stream); subreq =NULL ;
fs/smb/client/file.c +8 -7
@@ -49,6 +49,7 @@ static void cifs_prepare_write(struct netfs_io_subrequest *subreq)struct cifs_io_subrequest *wdata = container_of(subreq, struct cifs_io_subrequest, subreq);struct cifs_io_request *req = wdata->req; +struct netfs_io_stream *stream = &req->rreq.io_streams[subreq->stream_nr];struct TCP_Server_Info *server;struct cifsFileInfo *open_file = req->cfile;size_t wsize = req->rreq.wsize;
@@ -73,7 +74,7 @@ static void cifs_prepare_write(struct netfs_io_subrequest *subreq) } } - rc = server->ops->wait_mtu_credits (server, wsize, &wdata->subreq.max_len, + rc = server->ops->wait_mtu_credits (server, wsize, &stream->sreq_max_len, &wdata->credits);if (rc <0 ) { subreq->error = rc;
@@ -92,7 +93,7 @@ static void cifs_prepare_write(struct netfs_io_subrequest *subreq)#ifdef CONFIG_CIFS_SMB_DIRECT if (server->smbd_conn) - subreq->max_nr_segs = server->smbd_conn->max_frmr_depth; + stream->sreq_max_segs = server->smbd_conn->max_frmr_depth;#endif }
@@ -149,11 +150,11 @@ static void cifs_netfs_invalidate_cache(struct netfs_io_request *wreq)static bool cifs_clamp_length (struct netfs_io_subrequest *subreq) {struct netfs_io_request *rreq = subreq->rreq; +struct netfs_io_stream *stream = &rreq->io_streams[subreq->stream_nr]; struct cifs_io_subrequest *rdata = container_of(subreq, struct cifs_io_subrequest, subreq); struct cifs_io_request *req = container_of(subreq->rreq, struct cifs_io_request, rreq);struct TCP_Server_Info *server = req->server;struct cifs_sb_info *cifs_sb =CIFS_SB (rreq->inode->i_sb); -size_t rsize =0 ;int rc; rdata->xid =get_xid ();
@@ -166,8 +167,8 @@ static bool cifs_clamp_length(struct netfs_io_subrequest *subreq) cifs_sb->ctx); - rc = server->ops->wait_mtu_credits (server, cifs_sb->ctx->rsize, &rsize, - &rdata->credits); + rc = server->ops->wait_mtu_credits (server, cifs_sb->ctx->rsize, + &stream->sreq_max_len, &rdata->credits);if (rc) { subreq->error = rc;return false;
@@ -183,11 +184,11 @@ static bool cifs_clamp_length(struct netfs_io_subrequest *subreq) server->credits, server->in_flight,0 , cifs_trace_rw_credits_read_submit); - subreq->len =min_t (size_t, subreq->len, rsize); + subreq->len =umin (subreq->len, stream->sreq_max_len);#ifdef CONFIG_CIFS_SMB_DIRECT if (server->smbd_conn) - subreq->max_nr_segs = server->smbd_conn->max_frmr_depth; + stream->sreq_max_segs = server->smbd_conn->max_frmr_depth;#endif return true; }
include/linux/netfs.h +2 -2
@@ -136,6 +136,8 @@ static inline struct netfs_group *netfs_folio_group(struct folio *folio)struct netfs_io_stream {/* Submission tracking */ struct netfs_io_subrequest *construct;/* Op being constructed */ +size_t sreq_max_len;/* Maximum size of a subrequest */ +unsigned int sreq_max_segs;/* 0 or max number of segments in an iterator */ unsigned int submit_off;/* Folio offset we're submitting from */ unsigned int submit_len;/* Amount of data left to submit */ unsigned int submit_max_len;/* Amount I/O can be rounded up to */
@@ -179,14 +181,12 @@ struct netfs_io_subrequest {struct list_head rreq_link;/* Link in rreq->subrequests */ struct iov_iter io_iter;/* Iterator for this subrequest */ unsigned long long start;/* Where to start the I/O */ -size_t max_len;/* Maximum size of the I/O */ size_t len;/* Size of the I/O */ size_t transferred;/* Amount of data transferred */ refcount_t ref;short error;/* 0 or error that occurred */ unsigned short debug_index;/* Index in list (for debugging output) */ unsigned int nr_segs;/* Number of segs in io_iter */ -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 char stream_nr;/* I/O stream this belongs to */ unsigned long flags;
David Howells
maintainerPATCH 8/24 netfs: Reserve netfs_sreq_source 0 as unset/unknown
In reply to David HowellsReserve the 0-valued netfs_sreq_source to mean unset or unknown so that it can be seen in the trace as such rather than appearing as download-from-server when it's going to get switched to something else.
--- include/linux/netfs.h | 1 + include/trace/events/netfs.h | 1 + 2 files changed, 2 insertions(+)
include/linux/netfs.h +1 -0
@@ -43,6 +43,7 @@ static inline void folio_start_private_2(struct folio *folio)#define NETFS_BUF_PAGECACHE_MARK XA_MARK_1/* - Page needs wb/dirty flag wrangling */ enum netfs_io_source { +NETFS_SOURCE_UNKNOWN ,NETFS_FILL_WITH_ZEROES ,NETFS_DOWNLOAD_FROM_SERVER ,NETFS_READ_FROM_CACHE ,
include/trace/events/netfs.h +1 -0
@@ -59,6 +59,7 @@ E_(netfs_rreq_trace_write_done, "WR-DONE")#define netfs_sreq_sources \ + EM(NETFS_SOURCE_UNKNOWN, "----") \ EM(NETFS_FILL_WITH_ZEROES, "ZERO") \ EM(NETFS_DOWNLOAD_FROM_SERVER, "DOWN") \ EM(NETFS_READ_FROM_CACHE, "READ") \
David Howells
maintainerPATCH 9/24 netfs: Remove NETFS_COPY_TO_CACHE
In reply to David HowellsRemove NETFS_COPY_TO_CACHE as it isn't used anymore.
--- fs/netfs/main.c | 3 +-- include/linux/netfs.h | 3 +-- include/trace/events/netfs.h | 3 +-- 3 files changed, 3 insertions(+), 6 deletions(-)
fs/netfs/main.c +1 -2
@@ -37,11 +37,10 @@ static const char *netfs_origins[nr__netfs_io_origin] = { [NETFS_READAHEAD] = "RA", [NETFS_READPAGE] = "RP", [NETFS_READ_FOR_WRITE] = "RW", - [NETFS_COPY_TO_CACHE] = "CC", + [NETFS_DIO_READ] = "DR", [NETFS_WRITEBACK] = "WB", [NETFS_WRITETHROUGH] = "WT", [NETFS_UNBUFFERED_WRITE] = "UW", - [NETFS_DIO_READ] = "DR", [NETFS_DIO_WRITE] = "DW", };
include/linux/netfs.h +1 -2
@@ -208,11 +208,10 @@ 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_COPY_TO_CACHE ,/* This write is to copy a read to the cache */ +NETFS_DIO_READ ,/* This is a direct I/O read */ NETFS_WRITEBACK ,/* This write was triggered by writepages */ NETFS_WRITETHROUGH ,/* This write was made by netfs_perform_write() */ 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);
include/trace/events/netfs.h +1 -2
@@ -34,11 +34,10 @@ EM(NETFS_READAHEAD, "RA") \ EM(NETFS_READPAGE, "RP") \ EM(NETFS_READ_FOR_WRITE, "RW") \ - EM(NETFS_COPY_TO_CACHE, "CC") \ + EM(NETFS_DIO_READ, "DR") \ EM(NETFS_WRITEBACK, "WB") \ EM(NETFS_WRITETHROUGH, "WT") \ EM(NETFS_UNBUFFERED_WRITE, "UW") \ - EM(NETFS_DIO_READ, "DR") \ E_(NETFS_DIO_WRITE, "DW")#define netfs_rreq_traces \
David Howells
maintainerPATCH 10/24 netfs: Set the request work function upon allocation
In reply to David HowellsSet the work function in the netfs_io_request work_struct when we allocate the request rather than doing this later. This reduces the number of places we need to set it in future code.
--- fs/netfs/internal.h | 1 + fs/netfs/io.c | 4 +--- fs/netfs/objects.c | 9 ++++++++- fs/netfs/write_issue.c | 1 - 4 files changed, 10 insertions(+), 5 deletions(-)
fs/netfs/internal.h +1 -0
@@ -29,6 +29,7 @@ int netfs_prefetch_for_write(struct file *file, struct folio *folio,/* * io.c */ +void netfs_rreq_work (struct work_struct *work);int netfs_begin_read (struct netfs_io_request *rreq,bool sync);/*
fs/netfs/io.c +1 -3
@@ -278,7 +278,7 @@ static void netfs_rreq_assess(struct netfs_io_request *rreq, bool was_async)netfs_rreq_completed (rreq, was_async); } -static void netfs_rreq_work (struct work_struct *work) +void netfs_rreq_work (struct work_struct *work) {struct netfs_io_request *rreq = container_of(work, struct netfs_io_request, work);
@@ -584,8 +584,6 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync)// TODO: Use bounce buffer if requested rreq->io_iter = rreq->iter; -INIT_WORK (&rreq->work, netfs_rreq_work); -/* Chop the read into slices according to what the cache and the netfs * want and submit each one. */
fs/netfs/objects.c +8 -1
@@ -52,9 +52,16 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,INIT_LIST_HEAD (&rreq->io_streams[0 ].subrequests);INIT_LIST_HEAD (&rreq->io_streams[1 ].subrequests);INIT_LIST_HEAD (&rreq->subrequests); -INIT_WORK (&rreq->work,NULL );refcount_set (&rreq->ref,1 ); +if (origin ==NETFS_READAHEAD || + origin ==NETFS_READPAGE || + origin ==NETFS_READ_FOR_WRITE || + origin ==NETFS_DIO_READ ) +INIT_WORK (&rreq->work, netfs_rreq_work); +else +INIT_WORK (&rreq->work, netfs_write_collection_worker); +__set_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags);if (cached) {__set_bit (NETFS_RREQ_WRITE_TO_CACHE , &rreq->flags);
fs/netfs/write_issue.c +0 -1
@@ -107,7 +107,6 @@ struct netfs_io_request *netfs_create_write_req(struct address_space *mapping, wreq->contiguity = wreq->start; wreq->cleaned_to = wreq->start; -INIT_WORK (&wreq->work, netfs_write_collection_worker); wreq->io_streams[0 ].stream_nr =0 ; wreq->io_streams[0 ].source =NETFS_UPLOAD_TO_SERVER ;
David Howells
maintainerPATCH 11/24 netfs: Use bh-disabling spinlocks for rreq->lock
In reply to David HowellsUse bh-disabling spinlocks when accessing rreq->lock because, in the future, it may be twiddled from softirq context when cleanup is driven from cache backend DIO completion.
--- fs/netfs/write_collect.c | 4 ++-- fs/netfs/write_issue.c | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-)
fs/netfs/write_collect.c +2 -2
@@ -466,7 +466,7 @@ static void netfs_collect_write_results(struct netfs_io_request *wreq) cancel:/* Remove if completely consumed. */ -spin_lock (&wreq->lock); +spin_lock_bh (&wreq->lock); remove = front;list_del_init (&front->rreq_link);
@@ -482,7 +482,7 @@ static void netfs_collect_write_results(struct netfs_io_request *wreq) } } -spin_unlock (&wreq->lock); +spin_unlock_bh (&wreq->lock); netfs_put_subrequest(remove, false, notes & SAW_FAILURE ? netfs_sreq_trace_put_cancel :
fs/netfs/write_issue.c +2 -2
@@ -189,7 +189,7 @@ static void netfs_prepare_write(struct netfs_io_request *wreq,* the list. The collector only goes nextwards and uses the lock to * remove entries off of the front. */ -spin_lock (&wreq->lock); +spin_lock_bh (&wreq->lock);list_add_tail (&subreq->rreq_link, &stream->subrequests);if (list_is_first (&subreq->rreq_link, &stream->subrequests)) { stream->front = subreq;
@@ -200,7 +200,7 @@ static void netfs_prepare_write(struct netfs_io_request *wreq, } } -spin_unlock (&wreq->lock); +spin_unlock_bh (&wreq->lock); stream->construct = subreq; }
David Howells
maintainerPATCH 12/24 mm: Define struct folio_queue and ITER_FOLIOQ to handle a sequence of folios
In reply to David HowellsDefine a data structure, struct folio_queue, to represent a sequence of folios and a kernel-internal I/O iterator type, ITER_FOLIOQ, to allow a list of folio_queue structures to be used to provide a buffer to iov_iter-taking functions, such as sendmsg and recvmsg.
The folio_queue structure looks like:
struct folio_queue {
struct folio_batch vec;
u8 orders[PAGEVEC_SIZE];
struct folio_queue *next;
struct folio_queue *prev;
unsigned long marks;
unsigned long marks2;
};It does not use a list_head so that next and/or prev can be set to NULL at the ends of the list, allowing iov_iter-handling routines to determine that they *are* the ends without needing to store a head pointer in the iov_iter struct.
A folio_batch struct is used to hold the folio pointers which allows the batch to be passed to batch handling functions. Two mark bits are available per slot. The intention is to use at least one of them to mark folios that need putting, but that might not be ultimately necessary. Accessor functions are used to access the slots to do the masking and an additional accessor function is used to indicate the size of the array.
The order of each folio is also stored in the structure to avoid the need for iov_iter_advance() and iov_iter_revert() to have to query each folio to find its size.
With careful barriering, this can be used as an extending buffer with new folios inserted and new folio_queue structs added without the need for a lock. Further, provided we always keep at least one struct in the buffer, we can also remove consumed folios and consumed structs from the head end as we without the need for locks.
[Questions/thoughts]
(1) To manage this, I need a head pointer, a tail pointer, a tail slot number (assuming insertion happens at the tail end and the next pointers point from head to tail). Should I put these into a struct of their own, say "folio_queue_head" or "rolling_buffer"?
I will end up with two of these in netfs_io_request eventually, one keeping track of the pagecache I'm dealing with for buffered I/O and the other to hold a bounce buffer when we need one.
(2) Should I make the slots {folio,off,len} or bio_vec?
(3) This is intended to replace ITER_XARRAY eventually. Using an xarray in I/O iteration requires the taking of the RCU read lock, doing copying under the RCU read lock, walking the xarray (which may change under us), handling retries and dealing with special values.
The advantage of ITER_XARRAY is that when we're dealing with the pagecache directly, we don't need any allocation - but if we're doing encrypted comms, there's a good chance we'd be using a bounce buffer anyway.
This will require afs, erofs, cifs, orangefs and fscache to be converted to not use this. afs still uses it for dirs and symlinks; some of erofs usages should be easy to change, but there's one which won't be so easy; ceph's use via fscache can be fixed by porting ceph to netfslib; cifs is using xarray as a bounce buffer - that can be moved to use sheaves instead; and orangefs has a similar problem to erofs - maybe orangefs could use netfslib?
--- include/linux/folio_queue.h | 138 +++++++++++++++++++ include/linux/iov_iter.h | 57 ++++++++ include/linux/uio.h | 12 ++ lib/iov_iter.c | 229 ++++++++++++++++++++++++++++++- lib/kunit_iov_iter.c | 259 ++++++++++++++++++++++++++++++++++++ lib/scatterlist.c | 69 +++++++++- 6 files changed, 760 insertions(+), 4 deletions(-) create mode 100644 include/linux/folio_queue.h
include/linux/folio_queue.h new file +138 -0
@@ -0,0 +1,138 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* Queue of folios definitions +* +* Copyright (C) 2024 Red Hat, Inc. All Rights Reserved. +* Written by David Howells ([email protected]) +*/ + +#ifndef _LINUX_FOLIO_QUEUE_H +#define _LINUX_FOLIO_QUEUE_H + +#include <linux/pagevec.h> + +/* +* Segment in a queue of running buffers. Each segment can hold a number of +* folios and a portion of the queue can be referenced with the ITER_FOLIOQ +* iterator. The possibility exists of inserting non-folio elements into the +* queue (such as gaps). +* +* Explicit prev and next pointers are used instead of a list_head to make it +* easier to add segments to tail and remove them from the head without the +* need for a lock. +*/ +struct folio_queue { +struct folio_batch vec;/* Folios in the queue segment */ +u8 orders[PAGEVEC_SIZE ];/* Order of each folio */ +struct folio_queue *next;/* Next queue segment or NULL */ +struct folio_queue *prev;/* Previous queue segment of NULL */ +unsigned long marks;/* 1-bit mark per folio */ +unsigned long marks2;/* Second 1-bit mark per folio */ +#if PAGEVEC_SIZE >BITS_PER_LONG +#error marks is not big enough +#endif +}; + +static inline void folioq_init (struct folio_queue *folioq) +{ +folio_batch_init (&folioq->vec); + folioq->next =NULL ; + folioq->prev =NULL ; + folioq->marks =0 ; + folioq->marks2 =0 ; +} + +static inline unsigned int folioq_nr_slots (const struct folio_queue *folioq) +{ +return PAGEVEC_SIZE ; +} + +static inline unsigned int folioq_count (struct folio_queue *folioq) +{ +return folio_batch_count (&folioq->vec); +} + +static inline bool folioq_full (struct folio_queue *folioq) +{ +//return !folio_batch_space(&folioq->vec); +return folioq_count (folioq) >=folioq_nr_slots (folioq); +} + +static inline bool folioq_is_marked (const struct folio_queue *folioq,unsigned int slot) +{ +return test_bit (slot, &folioq->marks); +} + +static inline void folioq_mark (struct folio_queue *folioq,unsigned int slot) +{ +set_bit (slot, &folioq->marks); +} + +static inline void folioq_unmark (struct folio_queue *folioq,unsigned int slot) +{ +clear_bit (slot, &folioq->marks); +} + +static inline bool folioq_is_marked2 (const struct folio_queue *folioq,unsigned int slot) +{ +return test_bit (slot, &folioq->marks2); +} + +static inline void folioq_mark2 (struct folio_queue *folioq,unsigned int slot) +{ +set_bit (slot, &folioq->marks2); +} + +static inline void folioq_unmark2 (struct folio_queue *folioq,unsigned int slot) +{ +clear_bit (slot, &folioq->marks2); +} + +static inline unsigned int __folio_order (struct folio *folio) +{ +if (!folio_test_large (folio)) +return 0 ; +return folio->_flags_1 &0xff ; +} + +static inline unsigned int folioq_append (struct folio_queue *folioq,struct folio *folio) +{ +unsigned int slot = folioq->vec.nr++; + + folioq->vec.folios[slot] = folio; + folioq->orders[slot] =__folio_order (folio); +return slot; +} + +static inline unsigned int folioq_append_mark (struct folio_queue *folioq,struct folio *folio) +{ +unsigned int slot = folioq->vec.nr++; + + folioq->vec.folios[slot] = folio; + folioq->orders[slot] =__folio_order (folio); +folioq_mark (folioq, slot); +return slot; +} + +static inline struct folio *folioq_folio (const struct folio_queue *folioq,unsigned int slot) +{ +return folioq->vec.folios[slot]; +} + +static inline unsigned int folioq_folio_order (const struct folio_queue *folioq,unsigned int slot) +{ +return folioq->orders[slot]; +} + +static inline size_t folioq_folio_size (const struct folio_queue *folioq,unsigned int slot) +{ +return PAGE_SIZE <<folioq_folio_order (folioq, slot); +} + +static inline void folioq_clear (struct folio_queue *folioq,unsigned int slot) +{ + folioq->vec.folios[slot] =NULL ; +folioq_unmark (folioq, slot); +folioq_unmark2 (folioq, slot); +} + +#endif /* _LINUX_FOLIO_QUEUE_H */
include/linux/iov_iter.h +57 -0
75 lines not on this page · raw message
include/linux/uio.h +12 -0
@@ -11,6 +11,7 @@#include <uapi/linux/uio.h> struct page ; +struct folio_queue ;typedef unsigned int __bitwise iov_iter_extraction_t ;
@@ -25,6 +26,7 @@ enum iter_type {ITER_IOVEC ,ITER_BVEC ,ITER_KVEC , +ITER_FOLIOQ ,ITER_XARRAY , ITER_DISCARD, };
@@ -66,6 +68,7 @@ struct iov_iter {const struct iovec *__iov;const struct kvec *kvec;const struct bio_vec *bvec; +const struct folio_queue *folioq;struct xarray *xarray;void __user *ubuf; };
@@ -74,6 +77,7 @@ struct iov_iter { };union {unsigned long nr_segs; +u8 folioq_slot;loff_t xarray_start; }; };
@@ -126,6 +130,11 @@ static inline bool iov_iter_is_discard(const struct iov_iter *i)return iov_iter_type (i) ==ITER_DISCARD ; } +static inline bool iov_iter_is_folioq (const struct iov_iter *i) +{ +return iov_iter_type (i) ==ITER_FOLIOQ ; +} +static inline bool iov_iter_is_xarray (const struct iov_iter *i) {return iov_iter_type (i) ==ITER_XARRAY ;
@@ -273,6 +282,9 @@ void iov_iter_kvec(struct iov_iter *i, unsigned int direction, const struct kvecvoid iov_iter_bvec (struct iov_iter *i,unsigned int direction,const struct bio_vec *bvec,unsigned long nr_segs,size_t count);void iov_iter_discard (struct iov_iter *i,unsigned int direction,size_t count); +void iov_iter_folio_queue (struct iov_iter *i,unsigned int direction, +const struct folio_queue *folioq, +unsigned int first_slot,unsigned int offset,size_t count);void iov_iter_xarray (struct iov_iter *i,unsigned int direction,struct xarray *xarray,loff_t start,size_t count); ssize_t iov_iter_get_pages2(struct iov_iter *i, struct page **pages,
lib/iov_iter.c +227 -2
319 lines not on this page · raw message
lib/kunit_iov_iter.c +259 -0
293 lines not on this page · raw message
lib/scatterlist.c +67 -2
93 lines not on this page · raw message
David Howells
maintainerPATCH 13/24 cifs: Provide the capability to extract from ITER_FOLIOQ to RDMA SGEs
In reply to David HowellsMake smb_extract_iter_to_rdma() extract page fragments from an ITER_FOLIOQ iterator into RDMA SGEs.
--- fs/smb/client/smbdirect.c | 71 +++++++++++++++++++++++++++++++++++++-- 1 file changed, 68 insertions(+), 3 deletions(-)
fs/smb/client/smbdirect.c +68 -3
@@ -6,6 +6,7 @@*/ #include <linux/module.h> #include <linux/highmem.h> +#include <linux/folio_queue.h> #include "smbdirect.h" #include "cifs_debug.h" #include "cifsproto.h"
@@ -2463,6 +2464,8 @@ static ssize_t smb_extract_bvec_to_rdma(struct iov_iter *iter, start =0 ; } +if (ret >0 ) +iov_iter_advance (iter, ret);return ret; }
@@ -2519,6 +2522,65 @@ static ssize_t smb_extract_kvec_to_rdma(struct iov_iter *iter, start =0 ; } +if (ret >0 ) +iov_iter_advance (iter, ret); +return ret; +} + +/* +* Extract folio fragments from a FOLIOQ-class iterator and add them to an RDMA +* list. The folios are not pinned. +*/ +static ssize_t smb_extract_folioq_to_rdma (struct iov_iter *iter, +struct smb_extract_to_rdma *rdma, +ssize_t maxsize) +{ +const struct folio_queue *folioq = iter->folioq; +unsigned int slot = iter->folioq_slot; +ssize_t ret =0 ; +size_t offset = iter->iov_offset; + +BUG_ON (!folioq); + +if (slot >=folioq_nr_slots (folioq)) { + folioq = folioq->next; +if (WARN_ON_ONCE (!folioq)) +return -EIO ; + slot =0 ; + } + +do { +struct folio *folio =folioq_folio (folioq, slot); +size_t fsize =folioq_folio_size (folioq, slot); + +if (offset < fsize) { +size_t part =umin (maxsize - ret, fsize - offset); + +if (!smb_set_sge (rdma,folio_page (folio,0 ), offset, part)) +return -EIO ; + + offset += part; + ret += part; + } + +if (offset >= fsize) { + offset =0 ; + slot++; +if (slot >=folioq_nr_slots (folioq)) { +if (!folioq->next) { +WARN_ON_ONCE (ret < iter->count); +break ; + } + folioq = folioq->next; + slot =0 ; + } + } + }while (rdma->nr_sge < rdma->max_sge || maxsize >0 ); + + iter->folioq = folioq; + iter->folioq_slot = slot; + iter->iov_offset = offset; + iter->count -= ret;return ret; }
@@ -2563,6 +2625,8 @@ static ssize_t smb_extract_xarray_to_rdma(struct iov_iter *iter, }rcu_read_unlock (); +if (ret >0 ) +iov_iter_advance (iter, ret);return ret; }
@@ -2590,6 +2654,9 @@ static ssize_t smb_extract_iter_to_rdma(struct iov_iter *iter, size_t len,case ITER_KVEC : ret =smb_extract_kvec_to_rdma (iter, rdma, len);break ; +case ITER_FOLIOQ : + ret =smb_extract_folioq_to_rdma (iter, rdma, len); +break ;case ITER_XARRAY : ret =smb_extract_xarray_to_rdma (iter, rdma, len);break ;
@@ -2598,9 +2665,7 @@ static ssize_t smb_extract_iter_to_rdma(struct iov_iter *iter, size_t len,return -EIO ; } -if (ret >0 ) { -iov_iter_advance (iter, ret); - }else if (ret <0 ) { +if (ret <0 ) {while (rdma->nr_sge > before) {struct ib_sge *sge = &rdma->sge[rdma->nr_sge--];
David Howells
maintainerPATCH 14/24 netfs: Use new folio_queue data type and iterator instead of xarray iter
In reply to David HowellsMake the netfs write-side routines use the new folio_queue struct to hold a rolling buffer of folios, with the issuer adding folios at the tail and the collector removing them from the head as they're processed instead of using an xarray.
This will allow a subsequent patch to simplify the write collector.
The primary mark (as tested by folioq_is_marked()) is used to note if the corresponding folio needs putting.
--- fs/netfs/internal.h | 9 +++- fs/netfs/misc.c | 76 ++++++++++++++++++++++++++++++++ fs/netfs/objects.c | 1 + fs/netfs/stats.c | 4 +- fs/netfs/write_collect.c | 84 +++++++++++++++++++----------------- fs/netfs/write_issue.c | 28 ++++++------ include/linux/netfs.h | 8 ++-- include/trace/events/netfs.h | 1 + 8 files changed, 150 insertions(+), 61 deletions(-)
fs/netfs/internal.h +8 -1
@@ -7,6 +7,7 @@#include <linux/slab.h> #include <linux/seq_file.h> +#include <linux/folio_queue.h> #include <linux/netfs.h> #include <linux/fscache.h> #include <linux/fscache-cache.h>
@@ -64,6 +65,10 @@ static inline void netfs_proc_del_rreq(struct netfs_io_request *rreq) {}/* * misc.c */ +int netfs_buffer_append_folio (struct netfs_io_request *rreq,struct folio *folio, +bool needs_put); +struct folio_queue *netfs_delete_buffer_head (struct netfs_io_request *wreq); +void netfs_clear_buffer (struct netfs_io_request *rreq);/* * objects.c
@@ -120,6 +125,7 @@ extern atomic_t netfs_n_wh_write_done;extern atomic_t netfs_n_wh_write_failed;extern atomic_t netfs_n_wb_lock_skip;extern atomic_t netfs_n_wb_lock_wait; +extern atomic_t netfs_n_folioq;int netfs_stats_show (struct seq_file *m,void *v);
@@ -153,7 +159,8 @@ struct netfs_io_request *netfs_create_write_req(struct address_space *mapping,loff_t start, enum netfs_io_origin origin);void netfs_reissue_write (struct netfs_io_stream *stream, -struct netfs_io_subrequest *subreq); +struct netfs_io_subrequest *subreq, +struct iov_iter *source);int netfs_advance_write (struct netfs_io_request *wreq,struct netfs_io_stream *stream,loff_t start,size_t len,bool to_eof);
fs/netfs/misc.c +76 -0
82 lines not on this page · raw message
fs/netfs/objects.c +1 -0
@@ -151,6 +151,7 @@ static void netfs_free_request(struct work_struct *work) }kvfree (rreq->direct_bv); } +netfs_clear_buffer (rreq);if (atomic_dec_and_test (&ictx->io_count))wake_up_var (&ictx->io_count);
fs/netfs/stats.c +3 -1
@@ -41,6 +41,7 @@ atomic_t netfs_n_wh_write_done;atomic_t netfs_n_wh_write_failed;atomic_t netfs_n_wb_lock_skip;atomic_t netfs_n_wb_lock_wait; +atomic_t netfs_n_folioq;int netfs_stats_show (struct seq_file *m,void *v) {
@@ -76,9 +77,10 @@ int netfs_stats_show(struct seq_file *m, void *v)atomic_read (&netfs_n_wh_write),atomic_read (&netfs_n_wh_write_done), atomic_read(&netfs_n_wh_write_failed)); -seq_printf (m,"Objs : rr=%u sr=%u wsc=%u\n" , +seq_printf (m,"Objs : rr=%u sr=%u foq=%u wsc=%u\n" ,atomic_read (&netfs_n_rh_rreq),atomic_read (&netfs_n_rh_sreq), +atomic_read (&netfs_n_folioq),atomic_read (&netfs_n_wh_wstream_conflict)); seq_printf(m, "WbLock : skip=%u wait=%u\n", atomic_read(&netfs_n_wb_lock_skip),
fs/netfs/write_collect.c +44 -40
143 lines not on this page · raw message
fs/netfs/write_issue.c +13 -15
@@ -211,9 +211,11 @@ static void netfs_prepare_write(struct netfs_io_request *wreq,* netfs_write_subrequest_terminated() when complete. */ static void netfs_do_issue_write (struct netfs_io_stream *stream, -struct netfs_io_subrequest *subreq) +struct netfs_io_subrequest *subreq, +struct iov_iter *source) {struct netfs_io_request *wreq = subreq->rreq; +size_t size = subreq->len - subreq->transferred;_enter ("R=%x[%x],%zx" , wreq->debug_id, subreq->debug_index, subreq->len);
@@ -221,27 +223,20 @@ static void netfs_do_issue_write(struct netfs_io_stream *stream,return netfs_write_subrequest_terminated (subreq, subreq->error, false);// TODO: Use encrypted buffer -if (test_bit (NETFS_RREQ_USE_IO_ITER , &wreq->flags)) { - subreq->io_iter = wreq->io_iter; -iov_iter_advance (&subreq->io_iter, - subreq->start + subreq->transferred - wreq->start); -iov_iter_truncate (&subreq->io_iter, - subreq->len - subreq->transferred); - }else { -iov_iter_xarray (&subreq->io_iter,ITER_SOURCE , &wreq->mapping->i_pages, - subreq->start + subreq->transferred, - subreq->len - subreq->transferred); - } + subreq->io_iter = *source; +iov_iter_advance (source, size); +iov_iter_truncate (&subreq->io_iter, size);trace_netfs_sreq (subreq, netfs_sreq_trace_submit); stream->issue_write (subreq); }void netfs_reissue_write (struct netfs_io_stream *stream, -struct netfs_io_subrequest *subreq) +struct netfs_io_subrequest *subreq, +struct iov_iter *source) {__set_bit (NETFS_SREQ_IN_PROGRESS , &subreq->flags); -netfs_do_issue_write (stream, subreq); +netfs_do_issue_write (stream, subreq, source); } static void netfs_issue_write(struct netfs_io_request *wreq,
@@ -255,7 +250,7 @@ static void netfs_issue_write(struct netfs_io_request *wreq,if (subreq->start + subreq->len > wreq->start + wreq->submitted)WRITE_ONCE (wreq->submitted, subreq->start + subreq->len - wreq->start); -netfs_do_issue_write (stream, subreq); +netfs_do_issue_write (stream, subreq, &wreq->io_iter); }/*
@@ -420,6 +415,9 @@ static int netfs_write_folio(struct netfs_io_request *wreq,trace_netfs_folio (folio, netfs_folio_trace_store_plus); } +/* Attach the folio to the rolling buffer. */ +netfs_buffer_append_folio (wreq, folio, false); +/* Move the submission point forward to allow for write-streaming data * not starting at the front of the page. We don't do write-streaming * with the cache as the cache requires DIO alignment.
include/linux/netfs.h +4 -4
@@ -38,10 +38,6 @@ static inline void folio_start_private_2(struct folio *folio)folio_set_private_2 (folio); } -/* 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_SOURCE_UNKNOWN ,NETFS_FILL_WITH_ZEROES ,
@@ -234,6 +230,8 @@ struct netfs_io_request {struct netfs_io_stream io_streams[2 ];/* Streams of parallel I/O operations */ #define NR_IO_STREAMS 2 //wreq->nr_io_streamsstruct netfs_group *group;/* Writeback group being written back */ +struct folio_queue *buffer;/* Head of I/O buffer */ +struct folio_queue *buffer_tail;/* Tail of I/O buffer */ 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 */
@@ -255,6 +253,8 @@ struct netfs_io_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 */ +u8 buffer_head_slot;/* First slot in ->buffer */ +u8 buffer_tail_slot;/* Next slot in ->buffer_tail */ unsigned long long i_size;/* Size of the file */ unsigned long long start;/* Start position */ atomic64_t issued_to;/* Write issuer folio cursor */
include/trace/events/netfs.h +1 -0
@@ -151,6 +151,7 @@ EM(netfs_folio_trace_mkwrite, "mkwrite") \ EM(netfs_folio_trace_mkwrite_plus, "mkwrite+") \ EM(netfs_folio_trace_not_under_wback, "!wback") \ + EM(netfs_folio_trace_put, "put") \ EM(netfs_folio_trace_read_gaps, "read-gaps") \ EM(netfs_folio_trace_redirtied, "redirtied") \EM (netfs_folio_trace_store,"store" ) \
David Howells
maintainerPATCH 15/24 netfs: Provide an iterator-reset function
In reply to David Howells--- fs/netfs/internal.h | 4 +--- fs/netfs/misc.c | 18 ++++++++++++++++++ fs/netfs/write_collect.c | 3 +-- fs/netfs/write_issue.c | 6 +++--- 4 files changed, 23 insertions(+), 8 deletions(-)
fs/netfs/internal.h +1 -3
@@ -69,6 +69,7 @@ int netfs_buffer_append_folio(struct netfs_io_request *rreq, struct folio *folio bool needs_put);struct folio_queue *netfs_delete_buffer_head (struct netfs_io_request *wreq);void netfs_clear_buffer (struct netfs_io_request *rreq); +void netfs_reset_iter (struct netfs_io_subrequest *subreq);/* * objects.c
@@ -161,9 +162,6 @@ struct netfs_io_request *netfs_create_write_req(struct address_space *mapping,void netfs_reissue_write (struct netfs_io_stream *stream,struct netfs_io_subrequest *subreq,struct iov_iter *source); -int netfs_advance_write (struct netfs_io_request *wreq, -struct netfs_io_stream *stream, -loff_t start,size_t len,bool to_eof);struct netfs_io_request *netfs_begin_writethrough (struct kiocb *iocb,size_t len); int netfs_advance_writethrough(struct netfs_io_request *wreq, struct writeback_control *wbc, struct folio *folio, size_t copied, bool to_page_end,
fs/netfs/misc.c +18 -0
@@ -84,6 +84,24 @@ void netfs_clear_buffer(struct netfs_io_request *rreq) } } +/* +* Reset the subrequest iterator to refer just to the region remaining to be +* read. The iterator may or may not have been advanced by socket ops or +* extraction ops to an extent that may or may not match the amount actually +* read. +*/ +void netfs_reset_iter (struct netfs_io_subrequest *subreq) +{ +struct iov_iter *io_iter = &subreq->io_iter; +size_t remain = subreq->len - subreq->transferred; + +if (io_iter->count > remain) +iov_iter_advance (io_iter, io_iter->count - remain); +else if (io_iter->count < remain) +iov_iter_revert (io_iter, remain - io_iter->count); +iov_iter_truncate (&subreq->io_iter, remain); +} +/** * netfs_dirty_folio - Mark folio dirty and pin a cache object for writeback * @mapping: The mapping the folio belongs to.
fs/netfs/write_collect.c +1 -2
@@ -219,9 +219,8 @@ static void netfs_retry_write_stream(struct netfs_io_request *wreq,/* Determine the set of buffers we're going to use. Each * subreq gets a subset of a single overall contiguous buffer. */ +netfs_reset_iter (from); source = from->io_iter; -iov_iter_revert (&source, subreq->len - source.count); -iov_iter_advance (&source, from->transferred); source.count = len;/* Work through the sublist. */
fs/netfs/write_issue.c +3 -3
@@ -259,9 +259,9 @@ static void netfs_issue_write(struct netfs_io_request *wreq,* we can avoid overrunning the credits obtained (cifs) and try to parallelise * content-crypto preparation with network writes. */ -int netfs_advance_write (struct netfs_io_request *wreq, -struct netfs_io_stream *stream, -loff_t start,size_t len,bool to_eof) +static int netfs_advance_write (struct netfs_io_request *wreq, +struct netfs_io_stream *stream, +loff_t start,size_t len,bool to_eof) {struct netfs_io_subrequest *subreq = stream->construct;size_t part;
David Howells
maintainerPATCH 16/24 netfs: Simplify the writeback code
In reply to David HowellsUse the new folio_queue structures to simplify the writeback code. The problem with referring to the i_pages xarray directly is that we may have gaps in the sequence of folios we're writing from that we need to skip when we're removing the writeback mark from the folios we're writing back from.
At the moment the code tries to deal with this by carefully tracking the gaps in each writeback stream (eg. write to server and write to cache) and divining when there's a gap that spans folios (something that's not helped by folios not being a consistent size).
Instead, the folio_queue buffer contains pointers only the folios we're dealing with, has them in ascending order and indicates a gap by placing non-consequitive folios next to each other. This makes it possible to track where we need to clean up to by just keeping track of where we've processed to on each stream and taking the minimum.
Note that the I/O iterator is always rounded up to the end of the folio, even if that is beyond the EOF position, so that the cache can do DIO from the page. The excess space is cleared, though mmapped writes clobber it.
--- fs/netfs/write_collect.c | 146 ++++++----------------------------- fs/netfs/write_issue.c | 36 +++++---- include/linux/netfs.h | 1 - include/trace/events/netfs.h | 33 +------- 4 files changed, 45 insertions(+), 171 deletions(-)
fs/netfs/write_collect.c +24 -122
@@ -15,15 +15,11 @@/* Notes made in the collector */ #define HIT_PENDING 0x01/* A front op was still pending */ -#define SOME_EMPTY 0x02/* One of more streams are empty */ -#define ALL_EMPTY 0x04/* All streams are empty */ -#define MAYBE_DISCONTIG 0x08/* A front op may be discontiguous (rounded to PAGE_SIZE) */ -#define NEED_REASSESS 0x10/* Need to loop round and reassess */ -#define REASSESS_DISCONTIG 0x20/* Reassess discontiguity if contiguity advances */ -#define MADE_PROGRESS 0x40/* Made progress cleaning up a stream or the folio set */ -#define BUFFERED 0x80/* The pagecache needs cleaning up */ -#define NEED_RETRY 0x100/* A front op requests retrying */ -#define SAW_FAILURE 0x200/* One stream or hit a permanent failure */ +#define NEED_REASSESS 0x02/* Need to loop round and reassess */ +#define MADE_PROGRESS 0x04/* Made progress cleaning up a stream or the folio set */ +#define BUFFERED 0x08/* The pagecache needs cleaning up */ +#define NEED_RETRY 0x10/* A front op requests retrying */ +#define SAW_FAILURE 0x20/* One stream or hit a permanent failure */ /* * Successful completion of write of a folio to the server and/or cache. Note
@@ -78,10 +74,10 @@ int netfs_folio_written_back(struct folio *folio)* Unlock any folios we've finished with. */ static void netfs_writeback_unlock_folios (struct netfs_io_request *wreq, -unsigned long long collected_to,unsigned int *notes) {struct folio_queue *folioq = wreq->buffer; +unsigned long long collected_to = wreq->collected_to;unsigned int slot = wreq->buffer_head_slot;if (slot >=folioq_nr_slots (folioq)) {
@@ -110,12 +106,6 @@ static void netfs_writeback_unlock_folios(struct netfs_io_request *wreq,trace_netfs_collect_folio (wreq, folio, fend, collected_to); -if (fpos + fsize > wreq->contiguity) { -trace_netfs_collect_contig (wreq, fpos + fsize, - netfs_contig_trace_unlock); - wreq->contiguity = fpos + fsize; - } -/* Unlock any folio we've transferred all of. */ if (collected_to < fend)break ;
@@ -373,7 +363,7 @@ static void netfs_collect_write_results(struct netfs_io_request *wreq) {struct netfs_io_subrequest *front, *remove;struct netfs_io_stream *stream; -unsigned long long collected_to; +unsigned long long collected_to, issued_to;unsigned int notes;int s;
@@ -382,28 +372,21 @@ static void netfs_collect_write_results(struct netfs_io_request *wreq)trace_netfs_rreq (wreq, netfs_rreq_trace_collect); reassess_streams: + issued_to =atomic64_read (&wreq->issued_to);smp_rmb (); collected_to =ULLONG_MAX ; -if (wreq->origin ==NETFS_WRITEBACK ) - notes =ALL_EMPTY |BUFFERED |MAYBE_DISCONTIG ; -else if (wreq->origin ==NETFS_WRITETHROUGH ) - notes =ALL_EMPTY |BUFFERED ; +if (wreq->origin ==NETFS_WRITEBACK || + wreq->origin ==NETFS_WRITETHROUGH ) + notes =BUFFERED ;else - notes =ALL_EMPTY ; + notes =0 ;/* Remove completed subrequests from the front of the streams and * advance the completion point on each stream. We stop when we hit * something that's in progress. The issuer thread may be adding stuff * to the tail whilst we're doing this. -* -* We must not, however, merge in discontiguities that span whole -* folios that aren't under writeback. This is made more complicated -* by the folios in the gap being of unpredictable sizes - if they even -* exist - but we don't want to look them up. */ for (s =0 ; s <NR_IO_STREAMS ; s++) { -loff_t rstart, rend; - stream = &wreq->io_streams[s];/* Read active flag before list pointers */ if (!smp_load_acquire (&stream->active))
@@ -415,26 +398,10 @@ static void netfs_collect_write_results(struct netfs_io_request *wreq)//_debug("sreq [%x] %llx %zx/%zx", // front->debug_index, front->start, front->transferred, front->len); -/* Stall if there may be a discontinuity. */ - rstart =round_down (front->start,PAGE_SIZE ); -if (rstart > wreq->contiguity) { -if (wreq->contiguity > stream->collected_to) { -trace_netfs_collect_gap (wreq, stream, - wreq->contiguity,'D' ); - stream->collected_to = wreq->contiguity; - } - notes |=REASSESS_DISCONTIG ; -break ; +if (stream->collected_to < front->start) { +trace_netfs_collect_gap (wreq, stream, issued_to,'F' ); + stream->collected_to = front->start; } - rend =round_up (front->start + front->len,PAGE_SIZE ); -if (rend > wreq->contiguity) { -trace_netfs_collect_contig (wreq, rend, - netfs_contig_trace_collect); - wreq->contiguity = rend; -if (notes &REASSESS_DISCONTIG ) - notes |=NEED_REASSESS ; - } - notes &= ~MAYBE_DISCONTIG ;/* Stall if the front is still undergoing I/O. */ if (test_bit (NETFS_SREQ_IN_PROGRESS , &front->flags)) {
@@ -476,15 +443,6 @@ static void netfs_collect_write_results(struct netfs_io_request *wreq) front =list_first_entry_or_null (&stream->subrequests, struct netfs_io_subrequest, rreq_link); stream->front = front; -if (!front) { -unsigned long long jump_to =atomic64_read (&wreq->issued_to); - -if (stream->collected_to < jump_to) { -trace_netfs_collect_gap (wreq, stream, jump_to,'A' ); - stream->collected_to = jump_to; - } - } -spin_unlock_bh (&wreq->lock); netfs_put_subrequest(remove, false, notes & SAW_FAILURE ?
@@ -492,10 +450,13 @@ static void netfs_collect_write_results(struct netfs_io_request *wreq) netfs_sreq_trace_put_done); } -if (front) - notes &= ~ALL_EMPTY ; -else - notes |=SOME_EMPTY ; +/* If we have an empty stream, we need to jump it forward +* otherwise the collection point will never advance. +*/ +if (!front && issued_to > stream->collected_to) { +trace_netfs_collect_gap (wreq, stream, issued_to,'E' ); + stream->collected_to = issued_to; + }if (stream->collected_to < collected_to) collected_to = stream->collected_to;
@@ -504,36 +465,6 @@ static void netfs_collect_write_results(struct netfs_io_request *wreq)if (collected_to !=ULLONG_MAX && collected_to > wreq->collected_to) wreq->collected_to = collected_to; -/* If we have an empty stream, we need to jump it forward over any gap -* otherwise the collection point will never advance. -* -* Note that the issuer always adds to the stream with the lowest -* so-far submitted start, so if we see two consecutive subreqs in one -* stream with nothing between then in another stream, then the second -* stream has a gap that can be jumped. -*/ -if (notes &SOME_EMPTY ) { -unsigned long long jump_to = wreq->start +READ_ONCE (wreq->submitted); - -for (s =0 ; s <NR_IO_STREAMS ; s++) { - stream = &wreq->io_streams[s]; -if (stream->active && - stream->front && - stream->front->start < jump_to) - jump_to = stream->front->start; - } - -for (s =0 ; s <NR_IO_STREAMS ; s++) { - stream = &wreq->io_streams[s]; -if (stream->active && - !stream->front && - stream->collected_to < jump_to) { -trace_netfs_collect_gap (wreq, stream, jump_to,'B' ); - stream->collected_to = jump_to; - } - } - } -for (s =0 ; s <NR_IO_STREAMS ; s++) { stream = &wreq->io_streams[s];if (stream->active)
@@ -544,43 +475,14 @@ static void netfs_collect_write_results(struct netfs_io_request *wreq)/* Unlock any folios that we have now finished with. */ if (notes &BUFFERED ) { -unsigned long long clean_to =min (wreq->collected_to, wreq->contiguity); - -if (wreq->cleaned_to < clean_to) -netfs_writeback_unlock_folios (wreq, clean_to, ¬es); +if (wreq->cleaned_to < wreq->collected_to) +netfs_writeback_unlock_folios (wreq, ¬es); }else { wreq->cleaned_to = wreq->collected_to; }// TODO: Discard encryption buffers -/* If all streams are discontiguous with the last folio we cleared, we -* may need to skip a set of folios. -*/ -if ((notes & (MAYBE_DISCONTIG |ALL_EMPTY )) ==MAYBE_DISCONTIG ) { -unsigned long long jump_to =ULLONG_MAX ; - -for (s =0 ; s <NR_IO_STREAMS ; s++) { - stream = &wreq->io_streams[s]; -if (stream->active && stream->front && - stream->front->start < jump_to) - jump_to = stream->front->start; - } - -trace_netfs_collect_contig (wreq, jump_to, netfs_contig_trace_jump); - wreq->contiguity = jump_to; - wreq->cleaned_to = jump_to; - wreq->collected_to = jump_to; -for (s =0 ; s <NR_IO_STREAMS ; s++) { - stream = &wreq->io_streams[s]; -if (stream->collected_to < jump_to) - stream->collected_to = jump_to; - } -//cond_resched(); - notes |=MADE_PROGRESS ; - goto reassess_streams; - } -if (notes &NEED_RETRY ) goto need_retry;if ((notes &MADE_PROGRESS ) &&test_bit (NETFS_RREQ_PAUSE , &wreq->flags)) {
fs/netfs/write_issue.c +19 -17
@@ -105,7 +105,6 @@ struct netfs_io_request *netfs_create_write_req(struct address_space *mapping,if (test_bit (NETFS_RREQ_WRITE_TO_CACHE , &wreq->flags))fscache_begin_write_operation (&wreq->cache_resources,netfs_i_cookie (ictx)); - wreq->contiguity = wreq->start; wreq->cleaned_to = wreq->start; wreq->io_streams[0 ].stream_nr =0 ;
@@ -156,6 +155,7 @@ static void netfs_prepare_write(struct netfs_io_request *wreq, subreq->source = stream->source; subreq->start = start; subreq->stream_nr = stream->stream_nr; + subreq->io_iter = wreq->io_iter;_enter ("R=%x[%x]" , wreq->debug_id, subreq->debug_index);
@@ -211,22 +211,15 @@ static void netfs_prepare_write(struct netfs_io_request *wreq,* netfs_write_subrequest_terminated() when complete. */ static void netfs_do_issue_write (struct netfs_io_stream *stream, -struct netfs_io_subrequest *subreq, -struct iov_iter *source) +struct netfs_io_subrequest *subreq) {struct netfs_io_request *wreq = subreq->rreq; -size_t size = subreq->len - subreq->transferred;_enter ("R=%x[%x],%zx" , wreq->debug_id, subreq->debug_index, subreq->len);if (test_bit (NETFS_SREQ_FAILED , &subreq->flags))return netfs_write_subrequest_terminated (subreq, subreq->error, false); -// TODO: Use encrypted buffer - subreq->io_iter = *source; -iov_iter_advance (source, size); -iov_iter_truncate (&subreq->io_iter, size); -trace_netfs_sreq (subreq, netfs_sreq_trace_submit); stream->issue_write (subreq); }
@@ -235,8 +228,15 @@ void netfs_reissue_write(struct netfs_io_stream *stream,struct netfs_io_subrequest *subreq, struct iov_iter *source) { + size_t size = subreq->len - subreq->transferred; + +// TODO: Use encrypted buffer + subreq->io_iter = *source; +iov_iter_advance (source, size); +iov_iter_truncate (&subreq->io_iter, size); +__set_bit (NETFS_SREQ_IN_PROGRESS , &subreq->flags); -netfs_do_issue_write (stream, subreq, source); +netfs_do_issue_write (stream, subreq); } static void netfs_issue_write(struct netfs_io_request *wreq,
@@ -247,10 +247,8 @@ static void netfs_issue_write(struct netfs_io_request *wreq,if (!subreq)return ; stream->construct =NULL ; - -if (subreq->start + subreq->len > wreq->start + wreq->submitted) -WRITE_ONCE (wreq->submitted, subreq->start + subreq->len - wreq->start); -netfs_do_issue_write (stream, subreq, &wreq->io_iter); + subreq->io_iter.count = subreq->len; +netfs_do_issue_write (stream, subreq); }/*
@@ -462,10 +460,11 @@ static int netfs_write_folio(struct netfs_io_request *wreq,if (choose_s <0 )break ; stream = &wreq->io_streams[choose_s]; + wreq->io_iter.iov_offset = stream->submit_off; +atomic64_set (&wreq->issued_to, fpos + stream->submit_off); part =netfs_advance_write (wreq, stream, fpos + stream->submit_off, stream->submit_len, to_eof); -atomic64_set (&wreq->issued_to, fpos + stream->submit_off); stream->submit_off += part; stream->submit_max_len -= part;if (part > stream->submit_len)
@@ -476,6 +475,8 @@ static int netfs_write_folio(struct netfs_io_request *wreq, debug = true; } + wreq->io_iter.iov_offset =0 ; +iov_iter_advance (&wreq->io_iter, fsize);atomic64_set (&wreq->issued_to, fpos + fsize);if (!debug)
@@ -524,10 +525,10 @@ int netfs_writepages(struct address_space *mapping,netfs_stat (&netfs_n_wh_writepages); do { - _debug("wbiter %lx %llx", folio->index, wreq->start + wreq->submitted); + _debug("wbiter %lx %llx", folio->index, atomic64_read(&wreq->issued_to)); /* It appears we don't have to handle cyclic writeback wrapping. */ - WARN_ON_ONCE(wreq && folio_pos(folio) < wreq->start + wreq->submitted); + WARN_ON_ONCE(wreq && folio_pos(folio) < atomic64_read(&wreq->issued_to)); if (netfs_folio_group(folio) != NETFS_FOLIO_COPY_TO_CACHE && unlikely(!test_bit(NETFS_RREQ_UPLOAD_TO_SERVER, &wreq->flags))) {
@@ -671,6 +672,7 @@ int netfs_unbuffered_write(struct netfs_io_request *wreq, bool may_wait, size_t part =netfs_advance_write (wreq, upload, start, len, false); start += part; len -= part; +iov_iter_advance (&wreq->io_iter, part);if (test_bit (NETFS_RREQ_PAUSE , &wreq->flags)) {trace_netfs_rreq (wreq, netfs_rreq_trace_wait_pause);wait_on_bit (&wreq->flags,NETFS_RREQ_PAUSE ,TASK_UNINTERRUPTIBLE );
include/linux/netfs.h +0 -1
@@ -258,7 +258,6 @@ struct netfs_io_request {unsigned long long i_size;/* Size of the file */ unsigned long long start;/* Start position */ atomic64_t issued_to;/* Write issuer folio cursor */ -unsigned long long contiguity;/* Tracking for gaps in the writeback sequence */ unsigned long long collected_to;/* Point we've collected to */ unsigned long long cleaned_to;/* Position we've cleaned folios to */ pgoff_t no_unlock_folio;/* Don't unlock this folio after read */
include/trace/events/netfs.h +2 -31
@@ -510,33 +510,6 @@ TRACE_EVENT(netfs_collect, __entry->start + __entry->len) ); -TRACE_EVENT (netfs_collect_contig, - TP_PROTO(const struct netfs_io_request *wreq, unsigned long long to, - enum netfs_collect_contig_trace type), - -TP_ARGS (wreq, to, type), - -TP_STRUCT__entry ( - __field(unsigned int, wreq) - __field(enum netfs_collect_contig_trace, type) - __field(unsigned long long, contiguity) - __field(unsigned long long, to) - ), - -TP_fast_assign ( - __entry->wreq = wreq->debug_id; - __entry->type = type; - __entry->contiguity = wreq->contiguity; - __entry->to = to; - ), - -TP_printk ("R=%08x %llx -> %llx %s" , - __entry->wreq, - __entry->contiguity, - __entry->to, -__print_symbolic (__entry->type, netfs_collect_contig_traces)) - ); - TRACE_EVENT(netfs_collect_sreq, TP_PROTO(const struct netfs_io_request *wreq, const struct netfs_io_subrequest *subreq),
@@ -608,7 +581,6 @@ TRACE_EVENT(netfs_collect_state, __field(unsigned int, notes ) __field(unsigned long long, collected_to ) __field(unsigned long long, cleaned_to ) -__field (unsigned long long , contiguity ) ), TP_fast_assign(
@@ -616,12 +588,11 @@ TRACE_EVENT(netfs_collect_state, __entry->notes = notes; __entry->collected_to = collected_to; __entry->cleaned_to = wreq->cleaned_to; - __entry->contiguity = wreq->contiguity; ), -TP_printk ("R=%08x cto=%llx fto=%llx ctg=%llx n=%x" , +TP_printk ("R=%08x col=%llx cln=%llx n=%x" , __entry->wreq, __entry->collected_to, - __entry->cleaned_to, __entry->contiguity, + __entry->cleaned_to, __entry->notes) );
David Howells
maintainerPATCH 17/24 afs: Make read subreqs async
In reply to David HowellsPerform AFS read subrequests in a work item rather than in the calling thread. For normal buffered reads, this will allow the calling thread to copy data from the pagecache to the application at the same time as the demarshalling thread is shovelling data from skbuffs into the pagecache.
This will also allow the RA mark to trigger a new read before we've finished shovelling the data from the current one.
Note: This would be a bit safer if the FS.FetchData RPC ops returned the metadata (including the data version number) before returning the data. This would allow me to flush the pagecache before installing the new data.
In future, it may be possible to asynchronously flush the pagecache either side of the region being read.
--- fs/afs/file.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)
fs/afs/file.c +8 -1
@@ -304,8 +304,9 @@ int afs_fetch_data(struct afs_vnode *vnode, struct afs_read *req)return afs_do_sync_operation (op); } -static void afs_issue_read (struct netfs_io_subrequest *subreq) +static void afs_read_worker (struct work_struct *work) { + struct netfs_io_subrequest *subreq = container_of(work, struct netfs_io_subrequest, work);struct afs_vnode *vnode =AFS_FS_I (subreq->rreq->inode);struct afs_read *fsreq;
@@ -324,6 +325,12 @@ static void afs_issue_read(struct netfs_io_subrequest *subreq)afs_put_read (fsreq); } +static void afs_issue_read (struct netfs_io_subrequest *subreq) +{ +INIT_WORK (&subreq->work, afs_read_worker); +queue_work (system_long_wq, &subreq->work); +} +static int afs_symlink_read_folio (struct file *file,struct folio *folio) {struct afs_vnode *vnode =AFS_FS_I (folio->mapping->host);
David Howells
maintainerPATCH 18/24 netfs: Speed up buffered reading
In reply to David HowellsImprove the efficiency of buffered reads in a number of ways:
(1) Overhaul the algorithm in general so that it's a lot more compact and split the read submission code between buffered and unbuffered versions. The unbuffered version can be vastly simplified.
(2) Read-result collection is handed off to a work queue rather than being done in the I/O thread. Multiple subrequests can be processes simultaneously.
(3) When a subrequest is collected, any folios it fully spans are collected and "spare" data on either side is donated to either the previous or the next subrequest in the sequence.
Notes:
(*) Readahead expansion is massively slows down fio, presumably because it
causes a load of extra allocations, both folio and xarray, up front before RPC requests can be transmitted.
(*) RDMA with cifs does appear to work, both with SIW and RXE.
--- fs/9p/vfs_addr.c | 5 +- fs/afs/file.c | 20 +- fs/afs/fsclient.c | 9 +- fs/afs/yfsclient.c | 9 +- fs/ceph/addr.c | 72 ++-- fs/netfs/Makefile | 3 +- fs/netfs/buffered_read.c | 677 ++++++++++++++++++++++++----------- fs/netfs/direct_read.c | 147 +++++++- fs/netfs/internal.h | 19 +- fs/netfs/iterator.c | 50 +++ fs/netfs/main.c | 3 +- fs/netfs/objects.c | 8 +- fs/netfs/read_collect.c | 540 ++++++++++++++++++++++++++++ fs/netfs/read_retry.c | 256 +++++++++++++ fs/netfs/write_issue.c | 4 - fs/nfs/fscache.c | 19 +- fs/nfs/fscache.h | 7 +- fs/smb/client/cifssmb.c | 6 +- fs/smb/client/file.c | 57 +-- fs/smb/client/smb2pdu.c | 10 +- include/linux/netfs.h | 24 +- include/trace/events/netfs.h | 99 ++++- 22 files changed, 1707 insertions(+), 337 deletions(-) create mode 100644 fs/netfs/read_collect.c create mode 100644 fs/netfs/read_retry.c
fs/9p/vfs_addr.c +4 -1
@@ -77,7 +77,10 @@ static void v9fs_issue_read(struct netfs_io_subrequest *subreq)* cache won't be on server and is zeroes */ __set_bit (NETFS_SREQ_CLEAR_TAIL , &subreq->flags); -netfs_subreq_terminated (subreq, err ?: total, false); +if (!err) + subreq->transferred += total; + +netfs_read_subreq_terminated (subreq, err, false); }/**
fs/afs/file.c +15 -5
@@ -16,6 +16,7 @@#include <linux/mm.h> #include <linux/swap.h> #include <linux/netfs.h> +#include <trace/events/netfs.h> #include "internal.h" static int afs_file_mmap (struct file *file,struct vm_area_struct *vma);
@@ -242,8 +243,10 @@ static void afs_fetch_data_notify(struct afs_operation *op) req->error = error;if (subreq) { -__set_bit (NETFS_SREQ_CLEAR_TAIL , &subreq->flags); -netfs_subreq_terminated (subreq, error ?: req->actual_len, false); + subreq->rreq->i_size = req->file_size; +if (req->pos + req->actual_len >= req->file_size) +__set_bit (NETFS_SREQ_HIT_EOF , &subreq->flags); +netfs_read_subreq_terminated (subreq, error, false); req->subreq =NULL ; }else if (req->done) { req->done (req);
@@ -261,6 +264,12 @@ static void afs_fetch_data_success(struct afs_operation *op)afs_fetch_data_notify (op); } +static void afs_fetch_data_aborted (struct afs_operation *op) +{ +afs_check_for_remote_deletion (op); +afs_fetch_data_notify (op); +} +static void afs_fetch_data_put (struct afs_operation *op) { op->fetch.req->error =afs_op_error (op);
@@ -271,7 +280,7 @@ static const struct afs_operation_ops afs_fetch_data_operation = { .issue_afs_rpc = afs_fs_fetch_data, .issue_yfs_rpc = yfs_fs_fetch_data, .success = afs_fetch_data_success, - .aborted = afs_check_for_remote_deletion, + .aborted = afs_fetch_data_aborted, .failed = afs_fetch_data_notify, .put = afs_fetch_data_put, };
@@ -293,7 +302,7 @@ int afs_fetch_data(struct afs_vnode *vnode, struct afs_read *req) op =afs_alloc_operation (req->key, vnode->volume);if (IS_ERR (op)) {if (req->subreq) -netfs_subreq_terminated (req->subreq,PTR_ERR (op), false); +netfs_read_subreq_terminated (req->subreq,PTR_ERR (op), false);return PTR_ERR (op); }
@@ -312,7 +321,7 @@ static void afs_read_worker(struct work_struct *work) fsreq =afs_alloc_read (GFP_NOFS );if (!fsreq) -return netfs_subreq_terminated (subreq, -ENOMEM , false); +return netfs_read_subreq_terminated (subreq, -ENOMEM , false); fsreq->subreq = subreq; fsreq->pos = subreq->start + subreq->transferred;
@@ -321,6 +330,7 @@ static void afs_read_worker(struct work_struct *work) fsreq->vnode = vnode; fsreq->iter = &subreq->io_iter; +trace_netfs_sreq (subreq, netfs_sreq_trace_submit);afs_fetch_data (fsreq->vnode, fsreq);afs_put_read (fsreq); }
fs/afs/fsclient.c +7 -2
@@ -304,6 +304,7 @@ static int afs_deliver_fs_fetch_data(struct afs_call *call)struct afs_vnode_param *vp = &op->file[0 ];struct afs_read *req = op->fetch.req;const __be32 *bp; +size_t count_before;int ret; _enter("{%u,%zu,%zu/%llu}",
@@ -345,10 +346,14 @@ static int afs_deliver_fs_fetch_data(struct afs_call *call)/* extract the returned data */ case 2 : -_debug ("extract data %zu/%llu" , -iov_iter_count (call->iter), req->actual_len); + count_before = call->iov_len; +_debug ("extract data %zu/%llu" , count_before, req->actual_len); ret =afs_extract_data (call, true); +if (req->subreq) { + req->subreq->transferred += count_before - call->iov_len; +netfs_read_subreq_progress (req->subreq, false); + }if (ret <0 )return ret;
fs/afs/yfsclient.c +7 -2
@@ -355,6 +355,7 @@ static int yfs_deliver_fs_fetch_data64(struct afs_call *call)struct afs_vnode_param *vp = &op->file[0 ];struct afs_read *req = op->fetch.req;const __be32 *bp; +size_t count_before;int ret; _enter("{%u,%zu, %zu/%llu}",
@@ -391,10 +392,14 @@ static int yfs_deliver_fs_fetch_data64(struct afs_call *call)/* extract the returned data */ case 2 : -_debug ("extract data %zu/%llu" , -iov_iter_count (call->iter), req->actual_len); + count_before = call->iov_len; +_debug ("extract data %zu/%llu" , count_before, req->actual_len); ret =afs_extract_data (call, true); +if (req->subreq) { + req->subreq->transferred += count_before - call->iov_len; +netfs_read_subreq_progress (req->subreq, false); + }if (ret <0 )return ret;
fs/ceph/addr.c +42 -30
159 lines not on this page · raw message
fs/netfs/Makefile +2 -1
@@ -5,12 +5,13 @@ netfs-y := \ buffered_write.o \ direct_read.o \ direct_write.o \ - io.o \ iterator.o \ locking.o \ main.o \ misc.o \ objects.o \ + read_collect.o \ + read_retry.o \ write_collect.o \ write_issue.o
fs/netfs/buffered_read.c +464 -213
765 lines not on this page · raw message
fs/netfs/direct_read.c +141 -6
175 lines not on this page · raw message
fs/netfs/internal.h +12 -7
@@ -23,16 +23,9 @@/* * 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 -*/ -void netfs_rreq_work (struct work_struct *work); -int netfs_begin_read (struct netfs_io_request *rreq,bool sync); -/* * main.c */
@@ -90,6 +83,18 @@ static inline void netfs_see_request(struct netfs_io_request *rreq,trace_netfs_rreq_ref (rreq->debug_id,refcount_read (&rreq->ref), what); } +/* +* read_collect.c +*/ +void netfs_read_termination_worker (struct work_struct *work); +void netfs_rreq_terminated (struct netfs_io_request *rreq,bool was_async); + +/* +* read_retry.c +*/ +void netfs_retry_reads (struct netfs_io_request *rreq); +void netfs_unlock_abandoned_read_pages (struct netfs_io_request *rreq); +/* * stats.c */
fs/netfs/iterator.c +50 -0
59 lines not on this page · raw message
fs/netfs/main.c +2 -1
@@ -36,6 +36,7 @@ DEFINE_SPINLOCK(netfs_proc_lock);static const char *netfs_origins[nr__netfs_io_origin] = { [NETFS_READAHEAD ] ="RA" , [NETFS_READPAGE ] ="RP" , + [NETFS_READ_GAPS ] ="RG" , [NETFS_READ_FOR_WRITE ] ="RW" , [NETFS_DIO_READ ] ="DR" , [NETFS_WRITEBACK ] ="WB" ,
@@ -61,7 +62,7 @@ static int netfs_requests_seq_show(struct seq_file *m, void *v) rreq = list_entry(v, struct netfs_io_request, proc_link); seq_printf(m, - "%08x %s %3d %2lx %4d %3d @%04llx %llx/%llx", + "%08x %s %3d %2lx %4ld %3d @%04llx %llx/%llx", rreq->debug_id, netfs_origins[rreq->origin], refcount_read(&rreq->ref),
fs/netfs/objects.c +5 -3
@@ -40,7 +40,6 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,memset (rreq,0 ,kmem_cache_size (cache)); rreq->start = start; rreq->len = len; - rreq->upper_len = len; rreq->origin = origin; rreq->netfs_ops = ctx->ops; rreq->mapping = mapping;
@@ -48,6 +47,8 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping, rreq->i_size =i_size_read (inode); rreq->debug_id =atomic_inc_return (&debug_ids); rreq->wsize =INT_MAX ; + rreq->io_streams[0 ].sreq_max_len =ULONG_MAX ; + rreq->io_streams[0 ].sreq_max_segs =0 ;spin_lock_init (&rreq->lock);INIT_LIST_HEAD (&rreq->io_streams[0 ].subrequests);INIT_LIST_HEAD (&rreq->io_streams[1 ].subrequests);
@@ -56,9 +57,10 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,if (origin ==NETFS_READAHEAD || origin ==NETFS_READPAGE || + origin ==NETFS_READ_GAPS || origin ==NETFS_READ_FOR_WRITE || origin ==NETFS_DIO_READ ) -INIT_WORK (&rreq->work, netfs_rreq_work); +INIT_WORK (&rreq->work, netfs_read_termination_worker);else INIT_WORK (&rreq->work, netfs_write_collection_worker);
@@ -173,7 +175,7 @@ void netfs_put_request(struct netfs_io_request *rreq, bool was_async,if (was_async) { rreq->work.func = netfs_free_request;if (!queue_work (system_unbound_wq, &rreq->work)) -BUG (); +WARN_ON (1 ); }else {netfs_free_request (&rreq->work); }
fs/netfs/read_collect.c new file +540 -0
540 lines not on this page · raw message
fs/netfs/read_retry.c new file +256 -0
256 lines not on this page · raw message
fs/netfs/write_issue.c +0 -4
@@ -159,10 +159,6 @@ static void netfs_prepare_write(struct netfs_io_request *wreq,_enter ("R=%x[%x]" , wreq->debug_id, subreq->debug_index); -trace_netfs_sreq_ref (wreq->debug_id, subreq->debug_index, -refcount_read (&subreq->ref), - netfs_sreq_trace_new); -trace_netfs_sreq (subreq, netfs_sreq_trace_prepare); stream->sreq_max_len =UINT_MAX ;
fs/nfs/fscache.c +6 -13
@@ -265,6 +265,7 @@ static int nfs_netfs_init_request(struct netfs_io_request *rreq, struct file *fi { rreq->netfs_priv =get_nfs_open_context (nfs_file_open_context (file)); rreq->debug_id =atomic_inc_return (&nfs_netfs_debug_id); + rreq->io_streams[0 ].sreq_max_len =NFS_SB (rreq->inode->i_sb)->rsize;return 0 ; }
@@ -286,14 +287,6 @@ static struct nfs_netfs_io_data *nfs_netfs_alloc(struct netfs_io_subrequest *srereturn netfs; } -static bool nfs_netfs_clamp_length (struct netfs_io_subrequest *sreq) -{ -size_t rsize =NFS_SB (sreq->rreq->inode->i_sb)->rsize; - - sreq->len =min (sreq->len, rsize); -return true; -} -static void nfs_netfs_issue_read (struct netfs_io_subrequest *sreq) {struct nfs_netfs_io_data *netfs;
@@ -302,17 +295,18 @@ static void nfs_netfs_issue_read(struct netfs_io_subrequest *sreq)struct nfs_open_context *ctx = sreq->rreq->netfs_priv;struct page *page;unsigned long idx; +pgoff_t start, last;int err; -pgoff_t start = (sreq->start + sreq->transferred) >>PAGE_SHIFT ; -pgoff_t last = ((sreq->start + sreq->len - - sreq->transferred -1 ) >>PAGE_SHIFT ); + + start = (sreq->start + sreq->transferred) >>PAGE_SHIFT ; + last = ((sreq->start + sreq->len - sreq->transferred -1 ) >>PAGE_SHIFT );nfs_pageio_init_read (&pgio, inode, false, &nfs_async_read_completion_ops); netfs =nfs_netfs_alloc (sreq);if (!netfs) -return netfs_subreq_terminated (sreq, -ENOMEM , false); +return netfs_read_subreq_terminated (sreq, -ENOMEM , false); pgio.pg_netfs = netfs;/* used in completion */
@@ -377,5 +371,4 @@ const struct netfs_request_ops nfs_netfs_ops = { .init_request = nfs_netfs_init_request, .free_request = nfs_netfs_free_request, .issue_read = nfs_netfs_issue_read, - .clamp_length = nfs_netfs_clamp_length };
fs/nfs/fscache.h +3 -4
@@ -60,8 +60,6 @@ static inline void nfs_netfs_get(struct nfs_netfs_io_data *netfs)static inline void nfs_netfs_put (struct nfs_netfs_io_data *netfs) { -ssize_t final_len; -/* Only the last RPC completion should call netfs_subreq_terminated() */ if (!refcount_dec_and_test (&netfs->refcount))return ;
@@ -74,8 +72,9 @@ static inline void nfs_netfs_put(struct nfs_netfs_io_data *netfs)* Correct the final length here to be no larger than the netfs subrequest * length, and thus avoid netfs's "Subreq overread" warning message. */ - final_len =min_t (s64, netfs->sreq->len,atomic64_read (&netfs->transferred)); -netfs_subreq_terminated (netfs->sreq, netfs->error ?: final_len, false); + netfs->sreq->transferred =min_t (s64, netfs->sreq->len, +atomic64_read (&netfs->transferred)); +netfs_read_subreq_terminated (netfs->sreq, netfs->error, false);kfree (netfs); }static inline void nfs_netfs_inode_init (struct nfs_inode *nfsi)
fs/smb/client/cifssmb.c +2 -4
@@ -1309,10 +1309,8 @@ cifs_readv_callback(struct mid_q_entry *mid)if (rdata->result ==0 || rdata->result == -EAGAIN )iov_iter_advance (&rdata->subreq.io_iter, rdata->got_bytes); rdata->credits.value =0 ; -netfs_subreq_terminated (&rdata->subreq, - (rdata->result ==0 || rdata->result == -EAGAIN ) ? - rdata->got_bytes : rdata->result, - false); + rdata->subreq.transferred += rdata->got_bytes; +netfs_read_subreq_terminated (&rdata->subreq, rdata->result, false);release_mid (mid);add_credits (server, &credits,0 ); }
fs/smb/client/file.c +30 -27
120 lines not on this page · raw message
fs/smb/client/smb2pdu.c +7 -3
@@ -4495,9 +4495,7 @@ static void smb2_readv_worker(struct work_struct *work)struct cifs_io_subrequest *rdata = container_of(work, struct cifs_io_subrequest, subreq.work); -netfs_subreq_terminated (&rdata->subreq, - (rdata->result ==0 || rdata->result == -EAGAIN ) ? - rdata->got_bytes : rdata->result, true); +netfs_read_subreq_terminated (&rdata->subreq, rdata->result, false); } static void
@@ -4551,6 +4549,7 @@ smb2_readv_callback(struct mid_q_entry *mid)break ;case MID_REQUEST_SUBMITTED :case MID_RETRY_NEEDED : +__set_bit (NETFS_SREQ_NEED_RETRY , &rdata->subreq.flags); rdata->result = -EAGAIN ;if (server->sign && rdata->got_bytes)/* reset bytes number since we can not check a sign */
@@ -4604,6 +4603,10 @@ smb2_readv_callback(struct mid_q_entry *mid) server->credits, server->in_flight, 0, cifs_trace_rw_credits_read_response_clear); rdata->credits.value =0 ; + rdata->subreq.transferred += rdata->got_bytes; +if (rdata->subreq.start + rdata->subreq.transferred >= rdata->subreq.rreq->i_size) +__set_bit (NETFS_SREQ_HIT_EOF , &rdata->subreq.flags); +trace_netfs_sreq (&rdata->subreq, netfs_sreq_trace_io_progress);INIT_WORK (&rdata->subreq.work, smb2_readv_worker);queue_work (cifsiod_wq, &rdata->subreq.work);release_mid (mid);
@@ -4867,6 +4870,7 @@ smb2_writev_callback(struct mid_q_entry *mid) server->credits, server->in_flight, 0, cifs_trace_rw_credits_write_response_clear); wdata->credits.value =0 ; +trace_netfs_sreq (&wdata->subreq, netfs_sreq_trace_io_progress);cifs_write_subrequest_terminated (wdata, result ?: written, true);release_mid (mid); trace_smb3_rw_credits(rreq_debug_id, subreq_debug_index, 0,
include/linux/netfs.h +17 -7
@@ -180,20 +180,26 @@ struct netfs_io_subrequest {unsigned long long start;/* Where to start the I/O */ size_t len;/* Size of the I/O */ size_t transferred;/* Amount of data transferred */ +size_t consumed;/* Amount of read data consumed */ +size_t prev_donated;/* Amount of data donated from previous subreq */ +size_t next_donated;/* Amount of data donated from next subreq */ refcount_t ref;short error;/* 0 or error that occurred */ unsigned short debug_index;/* Index in list (for debugging output) */ unsigned int nr_segs;/* Number of segs in io_iter */ enum netfs_io_source source;/* Where to read from/write to */ unsigned char stream_nr;/* I/O stream this belongs to */ +unsigned char curr_folioq_slot;/* Folio currently being read */ +unsigned char curr_folio_order;/* Order of folio */ +struct folio_queue *curr_folioq;/* Queue segment in which current folio resides */ unsigned long flags;#define NETFS_SREQ_COPY_TO_CACHE 0/* Set if should copy the data to the cache */ #define NETFS_SREQ_CLEAR_TAIL 1/* Set if the rest of the read should be cleared */ -#define NETFS_SREQ_SHORT_IO 2/* Set if the I/O was short */ #define NETFS_SREQ_SEEK_DATA_READ 3/* Set if ->read() should SEEK_DATA first */ #define NETFS_SREQ_NO_PROGRESS 4/* Set if we didn't manage to read any data */ #define NETFS_SREQ_ONDEMAND 5/* Set if it's from on-demand read mode */ #define NETFS_SREQ_BOUNDARY 6/* Set if ends on hard boundary (eg. ceph object) */ +#define NETFS_SREQ_HIT_EOF 7/* Set if short due to EOF */ #define NETFS_SREQ_IN_PROGRESS 8/* Unlocked when the subrequest completes */ #define NETFS_SREQ_NEED_RETRY 9/* Set if the filesystem requests a retry */ #define NETFS_SREQ_RETRYING 10/* Set if we're retrying */
@@ -203,6 +209,7 @@ struct netfs_io_subrequest {enum netfs_io_origin {NETFS_READAHEAD ,/* This read was triggered by readahead */ NETFS_READPAGE ,/* This read is a synchronous read */ +NETFS_READ_GAPS ,/* This read is a synchronous read to fill gaps */ NETFS_READ_FOR_WRITE ,/* This read is to prepare a write */ NETFS_DIO_READ ,/* This is a direct I/O read */ NETFS_WRITEBACK ,/* This write was triggered by writepages */
@@ -225,6 +232,7 @@ struct netfs_io_request {struct address_space *mapping;/* The mapping being accessed */ struct kiocb *iocb;/* AIO completion vector */ struct netfs_cache_resources cache_resources; +struct readahead_control *ractl;/* Readahead descriptor */ struct list_head proc_link;/* Link in netfs_iorequests */ struct list_head subrequests;/* Contributory I/O operations */ struct netfs_io_stream io_streams[2 ];/* Streams of parallel I/O operations */
@@ -245,12 +253,10 @@ struct netfs_io_request {unsigned int nr_group_rel;/* Number of refs to release on ->group */ spinlock_t lock;/* Lock for queuing subreqs */ atomic_t nr_outstanding;/* Number of ops in progress */ -atomic_t nr_copy_ops;/* Number of copy-to-cache ops in progress */ -size_t upper_len;/* Length can be extended to here */ unsigned long long submitted;/* Amount submitted for I/O so far */ unsigned long long len;/* Length of the request */ size_t transferred;/* Amount to be indicated as transferred */ -short error;/* 0 or error that occurred */ +long 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 */ u8 buffer_head_slot;/* First slot in ->buffer */
@@ -261,9 +267,9 @@ struct netfs_io_request {unsigned long long collected_to;/* Point we've collected to */ unsigned long long cleaned_to;/* Position we've cleaned folios to */ pgoff_t no_unlock_folio;/* Don't unlock this folio after read */ +size_t prev_donated;/* Fallback for subreq->prev_donated */ refcount_t ref;unsigned long flags; -#define NETFS_RREQ_INCOMPLETE_IO 0/* Some ioreqs terminated short or with error */ #define NETFS_RREQ_COPY_TO_CACHE 1/* Need to write to the cache */ #define NETFS_RREQ_NO_UNLOCK_FOLIO 2/* Don't unlock no_unlock_folio on completion */ #define NETFS_RREQ_DONT_UNLOCK_FOLIOS 3/* Don't unlock the folios on completion */
@@ -276,6 +282,7 @@ struct netfs_io_request {#define NETFS_RREQ_PAUSE 11/* Pause subrequest generation */ #define NETFS_RREQ_USE_IO_ITER 12/* Use ->io_iter rather than ->i_pages */ #define NETFS_RREQ_ALL_QUEUED 13/* All subreqs are now queued */ +#define NETFS_RREQ_NEED_RETRY 14/* Need to try retrying */ #define NETFS_RREQ_USE_PGPRIV2 31/* [DEPRECATED] Use PG_private_2 to mark * write to cache on read */ const struct netfs_request_ops *netfs_ops;
@@ -294,7 +301,7 @@ struct netfs_request_ops {/* Read request handling */ void (*expand_readahead)(struct netfs_io_request *rreq); -bool (*clamp_length)(struct netfs_io_subrequest *subreq); +int (*prepare_read)(struct netfs_io_subrequest *subreq);void (*issue_read)(struct netfs_io_subrequest *subreq);bool (*is_still_valid)(struct netfs_io_request *rreq); int (*check_write_begin)(struct file *file, loff_t pos, unsigned len,
@@ -424,7 +431,10 @@ bool netfs_release_folio(struct folio *folio, gfp_t gfp);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_read_subreq_progress (struct netfs_io_subrequest *subreq, +bool was_async); +void netfs_read_subreq_terminated (struct netfs_io_subrequest *subreq, +int error,bool was_async);void netfs_get_subrequest (struct netfs_io_subrequest *subreq,enum netfs_sreq_ref_trace what); void netfs_put_subrequest(struct netfs_io_subrequest *subreq,
include/trace/events/netfs.h +95 -4
190 lines not on this page · raw message
Simon Horman
reviewerRe: [PATCH 18/24] netfs: Speed up buffered reading
On Mon, Jul 29, 2024 at 05:19:47PM +0100, David Howells wrote:
...
Quoted 1 line
fs/netfs/buffered_read.c +0
-0
...
Quoted 92 lines
fs/netfs/buffered_read.c +92
-0+/* +* Perform a read to the pagecache from a series of sources of different types, +* slicing up the region to be read according to available cache blocks and +* network rsize. +*/ +static void netfs_read_to_pagecache (struct netfs_io_request *rreq) +{ +struct netfs_inode *ictx =netfs_inode (rreq->inode); +unsigned long long start = rreq->start; +ssize_t size = rreq->len; +int ret =0 ; + +atomic_inc (&rreq->nr_outstanding); + + do { + struct netfs_io_subrequest *subreq; + enum netfs_io_source source = NETFS_DOWNLOAD_FROM_SERVER; + ssize_t slice; + + subreq = netfs_alloc_subrequest(rreq); + if (!subreq) { + ret = -ENOMEM; + break; + } + + subreq->start = start; + subreq->len = size; + + atomic_inc(&rreq->nr_outstanding); + spin_lock_bh(&rreq->lock); + list_add_tail(&subreq->rreq_link, &rreq->subrequests); + subreq->prev_donated = rreq->prev_donated; + rreq->prev_donated = 0; + trace_netfs_sreq(subreq, netfs_sreq_trace_added); + spin_unlock_bh(&rreq->lock); + + source = netfs_cache_prepare_read(rreq, subreq, rreq->i_size); + subreq->source = source; + if (source == NETFS_DOWNLOAD_FROM_SERVER) { + unsigned long long zp = umin(ictx->zero_point, rreq->i_size); + size_t len = subreq->len; + + if (subreq->start >= zp) { + subreq->source = source = NETFS_FILL_WITH_ZEROES; + goto fill_with_zeroes; + } + + if (len > zp - subreq->start) + len = zp - subreq->start; + if (len == 0) { + pr_err("ZERO-LEN READ: R=%08x[%x] l=%zx/%zx s=%llx z=%llx i=%llx", + rreq->debug_id, subreq->debug_index, + subreq->len, size, + subreq->start, ictx->zero_point, rreq->i_size); + break; + } + subreq->len = len; + + netfs_stat(&netfs_n_rh_download); + if (rreq->netfs_ops->prepare_read) { + ret = rreq->netfs_ops->prepare_read(subreq); + if (ret < 0) { + atomic_dec(&rreq->nr_outstanding); + netfs_put_subrequest(subreq, false, + netfs_sreq_trace_put_cancel); + break; + } + trace_netfs_sreq(subreq, netfs_sreq_trace_prepare); + } + + slice = netfs_prepare_read_iterator(subreq); + if (slice < 0) { + atomic_dec(&rreq->nr_outstanding); + netfs_put_subrequest(subreq, false, netfs_sreq_trace_put_cancel); + ret = slice; + break; + } + + rreq->netfs_ops->issue_read(subreq); + goto done; + } + + fill_with_zeroes: + if (source == NETFS_FILL_WITH_ZEROES) { + subreq->source = NETFS_FILL_WITH_ZEROES; + trace_netfs_sreq(subreq, netfs_sreq_trace_submit); + netfs_stat(&netfs_n_rh_zero); + slice = netfs_prepare_read_iterator(subreq); + __set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags); + netfs_read_subreq_terminated(subreq, 0, false); + goto done; + }
fs/netfs/buffered_read.c static int netfs_begin_cache_read(struct netfs_io_request *rreq, struct netfs_in · line 305
Quoted 10 lines
fs/netfs/buffered_read.c +10
-0+ +if (source ==NETFS_READ_FROM_CACHE ) { +trace_netfs_sreq (subreq, netfs_sreq_trace_submit); + slice =netfs_prepare_read_iterator (subreq); +netfs_read_cache_to_pagecache (rreq, subreq); + goto done; + } + +if (source ==NETFS_INVALID_READ ) +break ;
Hi David,
I feel a sense of deja vu here. So apologies if this was already discussed in the past.
If the code ever reaches this line, then slice will be used uninitialised below.
Flagged by W=1 allmodconfig builds on x86_64 with Clang 18.1.8.
Quoted 13 lines
fs/netfs/buffered_read.c +13
-0+ + done: + size -= slice; + start += slice; +cond_resched (); + }while (size >0 ); + +if (atomic_dec_and_test (&rreq->nr_outstanding)) +netfs_rreq_terminated (rreq, false); + +/* Defer error return as we may need to wait for outstanding I/O. */ +cmpxchg (&rreq->error,0 , ret); +}
...
Quoted 84 lines
fs/netfs/buffered_read.c +84
-0+/* +* Unlock any folios that are now completely read. Returns true if the +* subrequest is removed from the list. +*/ +static bool netfs_consume_read_data (struct netfs_io_subrequest *subreq,bool was_async) +{ +struct netfs_io_subrequest *prev, *next; +struct netfs_io_request *rreq = subreq->rreq; +struct folio_queue *folioq = subreq->curr_folioq; +size_t avail, prev_donated, next_donated, fsize, part, excess; +loff_t fpos, start; +loff_t fend; +int slot = subreq->curr_folioq_slot; + +if (WARN (subreq->transferred > subreq->len, +"Subreq overread: R%x[%x] %zu > %zu" , + rreq->debug_id, subreq->debug_index, + subreq->transferred, subreq->len)) + subreq->transferred = subreq->len; + +next_folio: + fsize =PAGE_SIZE << subreq->curr_folio_order; + fpos =round_down (subreq->start + subreq->consumed, fsize); + fend = fpos + fsize; + +if (WARN_ON_ONCE (!folioq) || +WARN_ON_ONCE (!folioq_folio (folioq, slot)) || +WARN_ON_ONCE (folioq_folio (folioq, slot)->index != fpos /PAGE_SIZE )) { +pr_err ("R=%08x[%x] s=%llx-%llx ctl=%zx/%zx/%zx sl=%u\n" , + rreq->debug_id, subreq->debug_index, + subreq->start, subreq->start + subreq->transferred -1 , + subreq->consumed, subreq->transferred, subreq->len, + slot); +if (folioq) { +struct folio *folio =folioq_folio (folioq, slot); + +pr_err ("folioq: %02x%02x%02x%02x\n" , + folioq->orders[0 ], folioq->orders[1 ], + folioq->orders[2 ], folioq->orders[3 ]); +if (folio) +pr_err ("folio: %llx-%llx ix=%llx o=%u qo=%u\n" , + fpos, fend -1 ,folio_pos (folio),folio_order (folio), +folioq_folio_order (folioq, slot)); + } + } + +donation_changed: +/* Try to consume the current folio if we've hit or passed the end of +* it. There's a possibility that this subreq doesn't start at the +* beginning of the folio, in which case we need to donate to/from the +* preceding subreq. +* +* We also need to include any potential donation back from the +* following subreq. +*/ + prev_donated =READ_ONCE (subreq->prev_donated); + next_donated =READ_ONCE (subreq->next_donated); +if (prev_donated || next_donated) { +spin_lock_bh (&rreq->lock); + prev_donated = subreq->prev_donated; + next_donated = subreq->next_donated; + subreq->start -= prev_donated; + subreq->len += prev_donated; + subreq->transferred += prev_donated; + prev_donated = subreq->prev_donated =0 ; +if (subreq->transferred == subreq->len) { + subreq->len += next_donated; + subreq->transferred += next_donated; + next_donated = subreq->next_donated =0 ; + } +trace_netfs_sreq (subreq, netfs_sreq_trace_add_donations); +spin_unlock_bh (&rreq->lock); + } + + avail = subreq->transferred; +if (avail == subreq->len) + avail += next_donated; + start = subreq->start; +if (subreq->consumed ==0 ) { + start -= prev_donated; + avail += prev_donated; + }else { + start += subreq->consumed; + avail -= subreq->consumed;
fs/netfs/buffered_read.c
Quoted 10 lines
fs/netfs/buffered_read.c +10
-0+ } + part =umin (avail, fsize); + +trace_netfs_progress (subreq, start, avail, part); + +if (start + avail >= fend) { +if (fpos == start) { +/* Flush, unlock and mark for caching any folio we've just read. */ + subreq->consumed = fend - subreq->start; +netfs_unlock_read_folio (subreq, rreq,folioq_folio (folioq, slot));
Earlier and later in this function it was assumed that folioq may be NULL. But here it appears to be used dereferenced unconditionally
by folioq_folio().
Flagged by Smatch.
Quoted 136 lines
fs/netfs/buffered_read.c +136
-0+folioq_mark2 (folioq, slot); +if (subreq->consumed >= subreq->len) + goto remove_subreq; + }else if (fpos < start) { + excess = fend - subreq->start; + +spin_lock_bh (&rreq->lock); +/* If we complete first on a folio split with the +* preceding subreq, donate to that subreq - otherwise +* we get the responsibility. +*/ +if (subreq->prev_donated != prev_donated) { +spin_unlock_bh (&rreq->lock); + goto donation_changed; + } + +if (list_is_first (&subreq->rreq_link, &rreq->subrequests)) { +spin_unlock_bh (&rreq->lock); +pr_err ("Can't donate prior to front\n" ); + goto bad; + } + + prev =list_prev_entry (subreq, rreq_link); +WRITE_ONCE (prev->next_donated, prev->next_donated + excess); + subreq->start += excess; + subreq->len -= excess; + subreq->transferred -= excess; +trace_netfs_donate (rreq, subreq, prev, excess, + netfs_trace_donate_tail_to_prev); +trace_netfs_sreq (subreq, netfs_sreq_trace_donate_to_prev); + +if (subreq->consumed >= subreq->len) + goto remove_subreq_locked; +spin_unlock_bh (&rreq->lock); + }else { +pr_err ("fpos > start\n" ); + goto bad; + } + +/* Advance the rolling buffer to the next folio. */ + slot++; +if (slot >=folioq_nr_slots (folioq)) { + slot =0 ; + folioq = folioq->next; + subreq->curr_folioq = folioq; + } + subreq->curr_folioq_slot = slot; +if (folioq &&folioq_folio (folioq, slot)) + subreq->curr_folio_order = folioq->orders[slot]; +if (!was_async) +cond_resched (); + goto next_folio; + } + +/* Deal with partial progress. */ +if (subreq->transferred < subreq->len) +return false; + +/* Donate the remaining downloaded data to one of the neighbouring +* subrequests. Note that we may race with them doing the same thing. +*/ +spin_lock_bh (&rreq->lock); + +if (subreq->prev_donated != prev_donated || + subreq->next_donated != next_donated) { +spin_unlock_bh (&rreq->lock); +cond_resched (); + goto donation_changed; + } + +/* Deal with the trickiest case: that this subreq is in the middle of a +* folio, not touching either edge, but finishes first. In such a +* case, we donate to the previous subreq, if there is one, so that the +* donation is only handled when that completes - and remove this +* subreq from the list. +* +* If the previous subreq finished first, we will have acquired their +* donation and should be able to unlock folios and/or donate nextwards. +*/ +if (!subreq->consumed && + !prev_donated && + !list_is_first (&subreq->rreq_link, &rreq->subrequests)) { + prev =list_prev_entry (subreq, rreq_link); +WRITE_ONCE (prev->next_donated, prev->next_donated + subreq->len); + subreq->start += subreq->len; + subreq->len =0 ; + subreq->transferred =0 ; +trace_netfs_donate (rreq, subreq, prev, subreq->len, + netfs_trace_donate_to_prev); +trace_netfs_sreq (subreq, netfs_sreq_trace_donate_to_prev); + goto remove_subreq_locked; + } + +/* If we can't donate down the chain, donate up the chain instead. */ + excess = subreq->len - subreq->consumed + next_donated; + +if (!subreq->consumed) + excess += prev_donated; + +if (list_is_last (&subreq->rreq_link, &rreq->subrequests)) { + rreq->prev_donated = excess; +trace_netfs_donate (rreq, subreq,NULL , excess, + netfs_trace_donate_to_deferred_next); + }else { + next =list_next_entry (subreq, rreq_link); +WRITE_ONCE (next->prev_donated, excess); +trace_netfs_donate (rreq, subreq, next, excess, + netfs_trace_donate_to_next); + } +trace_netfs_sreq (subreq, netfs_sreq_trace_donate_to_next); + subreq->len = subreq->consumed; + subreq->transferred = subreq->consumed; + goto remove_subreq_locked; + +remove_subreq: +spin_lock_bh (&rreq->lock); +remove_subreq_locked: + subreq->consumed = subreq->len; +list_del (&subreq->rreq_link); +spin_unlock_bh (&rreq->lock); +netfs_put_subrequest (subreq, false, netfs_sreq_trace_put_consumed); +return true; + +bad: +/* Errr... prev and next both donated to us, but insufficient to finish +* the folio. +*/ +printk ("R=%08x[%x] s=%llx-%llx %zx/%zx/%zx\n" , + rreq->debug_id, subreq->debug_index, + subreq->start, subreq->start + subreq->transferred -1 , + subreq->consumed, subreq->transferred, subreq->len); +printk ("folio: %llx-%llx\n" , fpos, fend -1 ); +printk ("donated: prev=%zx next=%zx\n" , prev_donated, next_donated); +printk ("s=%llx av=%zx part=%zx\n" , start, avail, part); +BUG (); +}
...
Re: [PATCH 18/24] netfs: Speed up buffered reading
Quoted 113 lines · Simon Horman
On Mon, Jul 29, 2024 at 05:19:47PM +0100, David Howells wrote:
...
Quoted 1 line
fs/netfs/buffered_read.c +0
-0...
Quoted 92 lines
fs/netfs/buffered_read.c +92
-0+/* +* Perform a read to the pagecache from a series of sources of different types, +* slicing up the region to be read according to available cache blocks and +* network rsize. +*/ +static void netfs_read_to_pagecache (struct netfs_io_request *rreq) +{ +struct netfs_inode *ictx =netfs_inode (rreq->inode); +unsigned long long start = rreq->start; +ssize_t size = rreq->len; +int ret =0 ; + +atomic_inc (&rreq->nr_outstanding); + + do { + struct netfs_io_subrequest *subreq; + enum netfs_io_source source = NETFS_DOWNLOAD_FROM_SERVER; + ssize_t slice; + + subreq = netfs_alloc_subrequest(rreq); + if (!subreq) { + ret = -ENOMEM; + break; + } + + subreq->start = start; + subreq->len = size; + + atomic_inc(&rreq->nr_outstanding); + spin_lock_bh(&rreq->lock); + list_add_tail(&subreq->rreq_link, &rreq->subrequests); + subreq->prev_donated = rreq->prev_donated; + rreq->prev_donated = 0; + trace_netfs_sreq(subreq, netfs_sreq_trace_added); + spin_unlock_bh(&rreq->lock); + + source = netfs_cache_prepare_read(rreq, subreq, rreq->i_size); + subreq->source = source; + if (source == NETFS_DOWNLOAD_FROM_SERVER) { + unsigned long long zp = umin(ictx->zero_point, rreq->i_size); + size_t len = subreq->len; + + if (subreq->start >= zp) { + subreq->source = source = NETFS_FILL_WITH_ZEROES; + goto fill_with_zeroes; + } + + if (len > zp - subreq->start) + len = zp - subreq->start; + if (len == 0) { + pr_err("ZERO-LEN READ: R=%08x[%x] l=%zx/%zx s=%llx z=%llx i=%llx", + rreq->debug_id, subreq->debug_index, + subreq->len, size, + subreq->start, ictx->zero_point, rreq->i_size); + break; + } + subreq->len = len; + + netfs_stat(&netfs_n_rh_download); + if (rreq->netfs_ops->prepare_read) { + ret = rreq->netfs_ops->prepare_read(subreq); + if (ret < 0) { + atomic_dec(&rreq->nr_outstanding); + netfs_put_subrequest(subreq, false, + netfs_sreq_trace_put_cancel); + break; + } + trace_netfs_sreq(subreq, netfs_sreq_trace_prepare); + } + + slice = netfs_prepare_read_iterator(subreq); + if (slice < 0) { + atomic_dec(&rreq->nr_outstanding); + netfs_put_subrequest(subreq, false, netfs_sreq_trace_put_cancel); + ret = slice; + break; + } + + rreq->netfs_ops->issue_read(subreq); + goto done; + } + + fill_with_zeroes: + if (source == NETFS_FILL_WITH_ZEROES) { + subreq->source = NETFS_FILL_WITH_ZEROES; + trace_netfs_sreq(subreq, netfs_sreq_trace_submit); + netfs_stat(&netfs_n_rh_zero); + slice = netfs_prepare_read_iterator(subreq); + __set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags); + netfs_read_subreq_terminated(subreq, 0, false); + goto done; + }fs/netfs/buffered_read.c static int netfs_begin_cache_read(struct netfs_io_request *rreq, struct netfs_in · line 305
Quoted 10 lines
fs/netfs/buffered_read.c +10
-0+ +if (source ==NETFS_READ_FROM_CACHE ) { +trace_netfs_sreq (subreq, netfs_sreq_trace_submit); + slice =netfs_prepare_read_iterator (subreq); +netfs_read_cache_to_pagecache (rreq, subreq); + goto done; + } + +if (source ==NETFS_INVALID_READ ) +break ;Hi David,
Quoted 7 lines
I feel a sense of deja vu here. So apologies if this was already discussed in the past.
If the code ever reaches this line, then slice will be used uninitialised below.
Flagged by W=1 allmodconfig builds on
x86_64with Clang 18.1.8.
which now breaks the build in next-20240801:
fs/netfs/buffered_read.c:304:7: error: variable 'slice' is used uninitialized whenever 'if' condition is false [-Werror,-Wsometimes-uninitialized]
304 | if (source == NETFS_INVALID_READ)
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/netfs/buffered_read.c:308:11: note: uninitialized use occurs here
308 | size -= slice;
| ^~~~~
fs/netfs/buffered_read.c:304:3: note: remove the 'if' if its condition is always true
304 | if (source == NETFS_INVALID_READ)
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
305 | break;
fs/netfs/buffered_read.c:221:16: note: initialize the variable 'slice' to silence this warning
221 | ssize_t slice;
| ^
| = 01 error generated.
If source has to be one of these values, perhaps switching to a switch statement and having a default with a WARN_ON() or something would convey that to the compiler?
Cheers,
Nathan
David Howells
maintainerRe: [PATCH 18/24] netfs: Speed up buffered reading
In reply to Simon HormanQuoted 2 lines · Simon Horman
If the code ever reaches this line, then slice will be used uninitialised below.
It can't actually happen (or, at least, it shouldn't). There are only three ways of obtaining data: downloading from the server (NETFS_DOWNLOAD_FROM_SERVER), reading from the cache (NETFS_READ_FROM_CACHE) and just clearing space (NETFS_FILL_WITH_ZEROES); each of those has its own if-statement that will set 'slice' or will switch the source to a different type that will set 'slice'.
The problem is that the compiler doesn't know this.
The check for NETFS_INVALID_READ is there just in case. Possibly:
if (source == NETFS_INVALID_READ) break;
could be replaced with a WARN_ON_ONCE() and an unconditional break.
David
Simon Horman
reviewerRe: [PATCH 18/24] netfs: Speed up buffered reading
Quoted 12 lines · David Howells
Quoted 2 lines · Simon Horman
If the code ever reaches this line, then slice will be used uninitialised below.
It can't actually happen (or, at least, it shouldn't). There are only three ways of obtaining data: downloading from the server (
NETFS_DOWNLOAD_FROM_SERVER), reading from the cache (NETFS_READ_FROM_CACHE) and just clearing space (NETFS_FILL_WITH_ZEROES); each of those has its own if-statement that will set 'slice' or will switch the source to a different type that will set 'slice'.
Quoted 8 lines
The problem is that the compiler doesn't know this.
The check for
NETFS_INVALID_READis there just in case. Possibly:if (source == NETFS_INVALID_READ) break;could be replaced with a
WARN_ON_ONCE()and an unconditional break.
Thanks, I think that should make the compiler happy without significantly altering the flow or readability of the code.
David Howells
maintainerPATCH 19/24 netfs: Remove fs/netfs/io.c
In reply to David HowellsRemove fs/netfs/io.c as it is no longer used.
--- fs/netfs/io.c | 645 -------------------------------------------------- 1 file changed, 645 deletions(-) delete mode 100644 fs/netfs/io.c
fs/netfs/io.c deleted +0 -645
@@ -1,645 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-or-later -/* Network filesystem high-level read support. -* -* Copyright (C) 2021 Red Hat, Inc. All Rights Reserved. -* Written by David Howells ([email protected]) -*/ - -#include <linux/module.h> -#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 "internal.h" - -/* -* Clear the unread part of an I/O request. -*/ -static void netfs_clear_unread (struct netfs_io_subrequest *subreq) -{ -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, -bool was_async) -{ -struct netfs_io_subrequest *subreq = priv; - -netfs_subreq_terminated (subreq, transferred_or_error, was_async); -} - -/* -* Issue a read against the cache. -* - Eats the caller's ref on subreq. -*/ -static void netfs_read_from_cache (struct netfs_io_request *rreq, -struct netfs_io_subrequest *subreq, -enum netfs_read_from_hole read_hole) -{ -struct netfs_cache_resources *cres = &rreq->cache_resources; - -netfs_stat (&netfs_n_rh_read); - cres->ops->read (cres, subreq->start, &subreq->io_iter, read_hole, - netfs_cache_read_terminated, subreq); -} - -/* -* Fill a subrequest region with zeroes. -*/ -static void netfs_fill_with_zeroes (struct netfs_io_request *rreq, -struct netfs_io_subrequest *subreq) -{ -netfs_stat (&netfs_n_rh_zero); -__set_bit (NETFS_SREQ_CLEAR_TAIL , &subreq->flags); -netfs_subreq_terminated (subreq,0 , false); -} - -/* -* Ask the netfs to issue a read request to the server for us. -* -* The netfs is expected to read from subreq->pos + subreq->transferred to -* subreq->pos + subreq->len - 1. It may not backtrack and write data into the -* buffer prior to the transferred point as it might clobber dirty data -* obtained from the cache. -* -* Alternatively, the netfs is allowed to indicate one of two things: -* -* - NETFS_SREQ_SHORT_READ: A short read - it will get called again to try and -* make progress. -* -* - NETFS_SREQ_CLEAR_TAIL: A short read - the rest of the buffer will be -* cleared. -*/ -static void netfs_read_from_server (struct netfs_io_request *rreq, -struct netfs_io_subrequest *subreq) -{ -netfs_stat (&netfs_n_rh_download); - -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, - subreq->transferred, subreq->flags); - rreq->netfs_ops->issue_read (subreq); -} - -/* -* Release those waiting. -*/ -static void netfs_rreq_completed (struct netfs_io_request *rreq,bool was_async) -{ -trace_netfs_rreq (rreq, netfs_rreq_trace_done); -netfs_clear_subrequests (rreq, was_async); -netfs_put_request (rreq, was_async, netfs_rreq_trace_put_complete); -} - -/* -* Handle a short read. -*/ -static void netfs_rreq_short_read (struct netfs_io_request *rreq, -struct netfs_io_subrequest *subreq) -{ -__clear_bit (NETFS_SREQ_SHORT_IO , &subreq->flags); -__set_bit (NETFS_SREQ_SEEK_DATA_READ , &subreq->flags); - -netfs_stat (&netfs_n_rh_short_read); -trace_netfs_sreq (subreq, netfs_sreq_trace_resubmit_short); - -netfs_get_subrequest (subreq, netfs_sreq_trace_get_short_read); -atomic_inc (&rreq->nr_outstanding); -if (subreq->source ==NETFS_READ_FROM_CACHE ) -netfs_read_from_cache (rreq, subreq,NETFS_READ_HOLE_CLEAR ); -else -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. -*/ -static bool netfs_rreq_perform_resubmissions (struct netfs_io_request *rreq) -{ -struct netfs_io_subrequest *subreq; - -WARN_ON (in_interrupt ()); - -trace_netfs_rreq (rreq, netfs_rreq_trace_resubmit); - -/* We don't want terminating submissions trying to wake us up whilst -* we're still going through the list. -*/ -atomic_inc (&rreq->nr_outstanding); - -__clear_bit (NETFS_RREQ_INCOMPLETE_IO , &rreq->flags); -list_for_each_entry (subreq, &rreq->subrequests, rreq_link) { -if (subreq->error) { -if (subreq->source !=NETFS_READ_FROM_CACHE ) -break ; - subreq->source =NETFS_DOWNLOAD_FROM_SERVER ; - subreq->error =0 ; -netfs_stat (&netfs_n_rh_download_instead); -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); - } - } - -/* If we decrement nr_outstanding to 0, the usage ref belongs to us. */ -if (atomic_dec_and_test (&rreq->nr_outstanding)) -return true; - -wake_up_var (&rreq->nr_outstanding); -return false; -} - -/* -* Check to see if the data read is still valid. -*/ -static void netfs_rreq_is_still_valid (struct netfs_io_request *rreq) -{ -struct netfs_io_subrequest *subreq; - -if (!rreq->netfs_ops->is_still_valid || - rreq->netfs_ops->is_still_valid (rreq)) -return ; - -list_for_each_entry (subreq, &rreq->subrequests, rreq_link) { -if (subreq->source ==NETFS_READ_FROM_CACHE ) { - subreq->error = -ESTALE ; -__set_bit (NETFS_RREQ_INCOMPLETE_IO , &rreq->flags); - } - } -} - -/* -* 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); -// TODO: cifs marks pages in the destination buffer -// dirty under some circumstances after a read. Do we -// need to do that too? -set_page_dirty (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. -* -* Note that we could be in an ordinary kernel thread, on a workqueue or in -* softirq context at this point. We inherit a ref from the caller. -*/ -static void netfs_rreq_assess (struct netfs_io_request *rreq,bool was_async) -{ -trace_netfs_rreq (rreq, netfs_rreq_trace_assess); - -again: -netfs_rreq_is_still_valid (rreq); - -if (!test_bit (NETFS_RREQ_FAILED , &rreq->flags) && -test_bit (NETFS_RREQ_INCOMPLETE_IO , &rreq->flags)) { -if (netfs_rreq_perform_resubmissions (rreq)) - goto again; -return ; - } - -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); -wake_up_bit (&rreq->flags,NETFS_RREQ_IN_PROGRESS ); - -netfs_rreq_completed (rreq, was_async); -} - -void netfs_rreq_work (struct work_struct *work) -{ -struct netfs_io_request *rreq = - container_of(work, struct netfs_io_request, work); -netfs_rreq_assess (rreq, false); -} - -/* -* Handle the completion of all outstanding I/O operations on a read request. -* We inherit a ref from the caller. -*/ -static void netfs_rreq_terminated (struct netfs_io_request *rreq, -bool was_async) -{ -if (test_bit (NETFS_RREQ_INCOMPLETE_IO , &rreq->flags) && - was_async) { -if (!queue_work (system_unbound_wq, &rreq->work)) -BUG (); - }else { -netfs_rreq_assess (rreq, was_async); - } -} - -/** -* netfs_subreq_terminated - Note the termination of an I/O operation. -* @subreq: The I/O request that has terminated. -* @transferred_or_error: The amount of data transferred or an error code. -* @was_async: The termination was asynchronous -* -* This tells the read helper that a contributory I/O operation has terminated, -* one way or another, and that it should integrate the results. -* -* The caller indicates in @transferred_or_error the outcome of the operation, -* supplying a positive value to indicate the number of bytes transferred, 0 to -* indicate a failure to transfer anything that should be retried or a negative -* error code. The helper will look after reissuing I/O operations as -* appropriate and writing downloaded data to the cache. -* -* If @was_async is true, the caller might be running in softirq or interrupt -* context and we can't sleep. -*/ -void netfs_subreq_terminated (struct netfs_io_subrequest *subreq, -ssize_t transferred_or_error, -bool was_async) -{ -struct netfs_io_request *rreq = subreq->rreq; -int u; - -_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 : -netfs_stat (&netfs_n_rh_read_done); -break ; -case NETFS_DOWNLOAD_FROM_SERVER : -netfs_stat (&netfs_n_rh_download_done); -break ; -default : -break ; - } - -if (IS_ERR_VALUE (transferred_or_error)) { - subreq->error = transferred_or_error; -trace_netfs_failure (rreq, subreq, transferred_or_error, - netfs_fail_read); - goto failed; - } - -if (WARN (transferred_or_error > subreq->len - subreq->transferred, -"Subreq overread: R%x[%x] %zd > %zu - %zu" , - rreq->debug_id, subreq->debug_index, - transferred_or_error, subreq->len, subreq->transferred)) - transferred_or_error = subreq->len - subreq->transferred; - - subreq->error =0 ; - subreq->transferred += transferred_or_error; -if (subreq->transferred < subreq->len) - goto incomplete; - -complete: -__clear_bit (NETFS_SREQ_NO_PROGRESS , &subreq->flags); -if (test_bit (NETFS_SREQ_COPY_TO_CACHE , &subreq->flags)) -set_bit (NETFS_RREQ_COPY_TO_CACHE , &rreq->flags); - -out: -trace_netfs_sreq (subreq, netfs_sreq_trace_terminated); - -/* If we decrement nr_outstanding to 0, the ref belongs to us. */ - u =atomic_dec_return (&rreq->nr_outstanding); -if (u ==0 ) -netfs_rreq_terminated (rreq, was_async); -else if (u ==1 ) -wake_up_var (&rreq->nr_outstanding); - -netfs_put_subrequest (subreq, was_async, netfs_sreq_trace_put_terminated); -return ; - -incomplete: -if (test_bit (NETFS_SREQ_CLEAR_TAIL , &subreq->flags)) { -netfs_clear_unread (subreq); - subreq->transferred = subreq->len; - goto complete; - } - -if (transferred_or_error ==0 ) { -if (__test_and_set_bit (NETFS_SREQ_NO_PROGRESS , &subreq->flags)) { - subreq->error = -ENODATA ; - goto failed; - } - }else { -__clear_bit (NETFS_SREQ_NO_PROGRESS , &subreq->flags); - } - -__set_bit (NETFS_SREQ_SHORT_IO , &subreq->flags); -set_bit (NETFS_RREQ_INCOMPLETE_IO , &rreq->flags); - goto out; - -failed: -if (subreq->source ==NETFS_READ_FROM_CACHE ) { -netfs_stat (&netfs_n_rh_read_failed); -set_bit (NETFS_RREQ_INCOMPLETE_IO , &rreq->flags); - }else { -netfs_stat (&netfs_n_rh_download_failed); -set_bit (NETFS_RREQ_FAILED , &rreq->flags); - rreq->error = subreq->error; - } - goto out; -} -EXPORT_SYMBOL (netfs_subreq_terminated); - -static enum netfs_io_source netfs_cache_prepare_read (struct netfs_io_subrequest *subreq, -loff_t i_size) -{ -struct netfs_io_request *rreq = subreq->rreq; -struct netfs_cache_resources *cres = &rreq->cache_resources; - -if (cres->ops) -return cres->ops->prepare_read (subreq, i_size); -if (subreq->start >= rreq->i_size) -return NETFS_FILL_WITH_ZEROES ; -return NETFS_DOWNLOAD_FROM_SERVER ; -} - -/* -* Work out what sort of subrequest the next one will be. -*/ -static enum netfs_io_source -netfs_rreq_prepare_read (struct netfs_io_request *rreq, -struct netfs_io_subrequest *subreq, -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); - -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 -* its own I/O sizes and boundaries. If it shinks it here, it -* will be called again to make simultaneous calls; if it wants -* 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) - subreq->len = rreq->rsize; - -if (rreq->netfs_ops->clamp_length && - !rreq->netfs_ops->clamp_length (subreq)) { - source =NETFS_INVALID_READ ; - goto out; - } - -if (rreq->io_streams[0 ].sreq_max_segs) { - lsize =netfs_limit_iter (io_iter,0 , subreq->len, - rreq->io_streams[0 ].sreq_max_segs); -if (subreq->len > lsize) { - subreq->len = lsize; -trace_netfs_sreq (subreq, netfs_sreq_trace_limited); - } - } - } - -set: -if (subreq->len > rreq->len) -pr_warn ("R=%08x[%u] SREQ>RREQ %zx > %llx\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); -out: - subreq->source = source; -trace_netfs_sreq (subreq, netfs_sreq_trace_prepare); -return source; -} - -/* -* 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) -{ -struct netfs_io_subrequest *subreq; -enum netfs_io_source source; - - subreq =netfs_alloc_subrequest (rreq); -if (!subreq) -return false; - - subreq->start = rreq->start + rreq->submitted; - subreq->len = io_iter->count; - -_debug ("slice %llx,%zx,%llx" , subreq->start, subreq->len, rreq->submitted); -list_add_tail (&subreq->rreq_link, &rreq->subrequests); - -/* Call out to the cache to find out what it can do with the remaining -* subset. It tells us in subreq->flags what it decided should be done -* and adjusts subreq->len down if the subset crosses a cache boundary. -* -* Then when we hand the subset, it can choose to take a subset of that -* (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, io_iter); -if (source ==NETFS_INVALID_READ ) - goto subreq_failed; - -atomic_inc (&rreq->nr_outstanding); - - rreq->submitted += subreq->len; - -trace_netfs_sreq (subreq, netfs_sreq_trace_submit); -switch (source) { -case NETFS_FILL_WITH_ZEROES : -netfs_fill_with_zeroes (rreq, subreq); -break ; -case NETFS_DOWNLOAD_FROM_SERVER : -netfs_read_from_server (rreq, subreq); -break ; -case NETFS_READ_FROM_CACHE : -netfs_read_from_cache (rreq, subreq,NETFS_READ_HOLE_IGNORE ); -break ; -default : -BUG (); - } - -return true; - -subreq_failed: - rreq->error = subreq->error; -netfs_put_subrequest (subreq, false, netfs_sreq_trace_put_failed); -return false; -} - -/* -* Begin the process of reading in a chunk of data, where that data may be -* stitched together from multiple sources, including multiple servers and the -* local cache. -*/ -int netfs_begin_read (struct netfs_io_request *rreq,bool sync) -{ -struct iov_iter io_iter; -int ret; - -_enter ("R=%x %llx-%llx" , - rreq->debug_id, rreq->start, rreq->start + rreq->len -1 ); - -if (rreq->len ==0 ) { -pr_err ("Zero-sized read [R=%x]\n" , rreq->debug_id); -return -EIO ; - } - -if (rreq->origin ==NETFS_DIO_READ ) -inode_dio_begin (rreq->inode); - -// TODO: Use bounce buffer if requested - rreq->io_iter = rreq->iter; - -/* 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 { -_debug ("submit %llx + %llx >= %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)) -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); -if (rreq->origin ==NETFS_DIO_READ ) -inode_dio_end (rreq->inode); - 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 -* random thread pool to process. Note that this might start -* further work, such as writing to the cache. -*/ -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); - -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 && - rreq->origin !=NETFS_DIO_READ ) { -trace_netfs_failure (rreq,NULL , ret, netfs_fail_short_read); - ret = -EIO ; - } - }else { -/* 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 = -EIOCBQUEUED ; - } - -out: -return ret; -}
David Howells
maintainerPATCH 20/24 cachefiles, netfs: Fix write to partial block at EOF
In reply to David HowellsBecause it uses DIO writes, cachefiles is unable to make a write to the backing file if that write is not aligned to and sized according to the backing file's DIO block alignment. This makes it tricky to handle a write to the cache where the EOF on the network file is not correctly aligned.
To get around this, netfslib attempts to tell the driver it is calling how much more data there is available beyond the EOF that it can use to pad the write (netfslib preclears the part of the folio above the EOF). However, it tries to tell the cache what the maximum length is, but doesn't calculate this correctly; and, in any case, cachefiles actually ignores the value and just skips the block.
Fix this by:
(1) Change the value passed to indicate the amount of extra data that can be added to the operation (now ->submit_extendable_to). This is much simpler to calculate as it's just the end of the folio minus the top of the data within the folio - rather than having to account for data spread over multiple folios.
(2) Make cachefiles add some of this data if the subrequest it is given ends at the network file's i_size if the extra data is sufficient to pad out to a whole block.
--- fs/cachefiles/io.c | 14 ++++++++++++++ fs/netfs/write_issue.c | 5 ++--- include/linux/netfs.h | 2 +- 3 files changed, 17 insertions(+), 4 deletions(-)
fs/cachefiles/io.c +14 -0
@@ -648,6 +648,7 @@ static void cachefiles_issue_write(struct netfs_io_subrequest *subreq)struct netfs_cache_resources *cres = &wreq->cache_resources;struct cachefiles_object *object =cachefiles_cres_object (cres);struct cachefiles_cache *cache = object->volume->cache; +struct netfs_io_stream *stream = &wreq->io_streams[subreq->stream_nr];const struct cred *saved_cred;size_t off, pre, post, len = subreq->len;loff_t start = subreq->start;
@@ -661,6 +662,7 @@ static void cachefiles_issue_write(struct netfs_io_subrequest *subreq)if (off) { pre =CACHEFILES_DIO_BLOCK_SIZE - off;if (pre >= len) { +fscache_count_dio_misfit ();netfs_write_subrequest_terminated (subreq, len, false);return ; }
@@ -671,10 +673,22 @@ static void cachefiles_issue_write(struct netfs_io_subrequest *subreq) }/* We also need to end on the cache granularity boundary */ +if (start + len == wreq->i_size) { +size_t part = len %CACHEFILES_DIO_BLOCK_SIZE ; +size_t need =CACHEFILES_DIO_BLOCK_SIZE - part; + +if (part && stream->submit_extendable_to >= need) { + len += need; + subreq->len += need; + subreq->io_iter.count += need; + } + } + post = len & (CACHEFILES_DIO_BLOCK_SIZE -1 );if (post) { len -= post;if (len ==0 ) { +fscache_count_dio_misfit ();netfs_write_subrequest_terminated (subreq, post, false);return ; }
fs/netfs/write_issue.c +2 -3
@@ -280,6 +280,7 @@ static int netfs_advance_write(struct netfs_io_request *wreq,_debug ("part %zx/%zx %zx/%zx" , subreq->len, stream->sreq_max_len, part, len); subreq->len += part; subreq->nr_segs++; + stream->submit_extendable_to -= part; if (subreq->len >= stream->sreq_max_len || subreq->nr_segs >= stream->sreq_max_segs ||
@@ -421,7 +422,6 @@ static int netfs_write_folio(struct netfs_io_request *wreq,*/ for (int s =0 ; s <NR_IO_STREAMS ; s++) { stream = &wreq->io_streams[s]; - stream->submit_max_len = fsize; stream->submit_off = foff; stream->submit_len = flen; if ((stream->source == NETFS_WRITE_TO_CACHE && streamw) ||
@@ -429,7 +429,6 @@ static int netfs_write_folio(struct netfs_io_request *wreq, fgroup == NETFS_FOLIO_COPY_TO_CACHE)) { stream->submit_off =UINT_MAX ; stream->submit_len =0 ; - stream->submit_max_len =0 ; } }
@@ -459,10 +458,10 @@ static int netfs_write_folio(struct netfs_io_request *wreq, wreq->io_iter.iov_offset = stream->submit_off;atomic64_set (&wreq->issued_to, fpos + stream->submit_off); + stream->submit_extendable_to = fsize - stream->submit_off; part =netfs_advance_write (wreq, stream, fpos + stream->submit_off, stream->submit_len, to_eof); stream->submit_off += part; - stream->submit_max_len -= part;if (part > stream->submit_len) stream->submit_len =0 ;else
include/linux/netfs.h +1 -1
@@ -137,7 +137,7 @@ struct netfs_io_stream {unsigned int sreq_max_segs;/* 0 or max number of segments in an iterator */ unsigned int submit_off;/* Folio offset we're submitting from */ unsigned int submit_len;/* Amount of data left to submit */ -unsigned int submit_max_len;/* Amount I/O can be rounded up to */ +unsigned int submit_extendable_to;/* Amount I/O can be rounded up to */ void (*prepare_write)(struct netfs_io_subrequest *subreq);void (*issue_write)(struct netfs_io_subrequest *subreq);/* Collection tracking */
David Howells
maintainerPATCH 21/24 netfs: Cancel dirty folios that have no storage destination
In reply to David HowellsKafs wants to be able to cache the contents of directories (and symlinks), but whilst these are downloaded from the server with the FS.FetchData RPC op and similar, the same as for regular files, they can't be updated by FS.StoreData, but rather have special operations (FS.MakeDir, etc.).
Now, rather than redownloading a directory's content after each change made to that directory, kafs modifies the local blob. This blob can be saved out to the cache, and since it's using netfslib, kafs just marks the folios dirty and lets ->writepages() on the directory take care of it, as for an regular file.
This is fine as long as there's a cache as although the upload stream is disabled, there's a cache stream to drive the procedure. But if the cache goes away in the meantime, suddenly there's no way do any writes and the code gets confused, complains "R=%x: No submit" to dmesg and leaves the dirty folio hanging.
Fix this by just cancelling the store of the folio if neither stream is active. (If there's no cache at the time of dirtying, we should just not mark the folio dirty).
--- fs/netfs/write_issue.c | 6 +++++- include/trace/events/netfs.h | 1 + 2 files changed, 6 insertions(+), 1 deletion(-)
fs/netfs/write_issue.c +5 -1
@@ -397,13 +397,17 @@ static int netfs_write_folio(struct netfs_io_request *wreq,folio_unlock (folio);if (fgroup ==NETFS_FOLIO_COPY_TO_CACHE ) { -if (!fscache_resources_valid (&wreq->cache_resources)) { +if (!cache->avail) {trace_netfs_folio (folio, netfs_folio_trace_cancel_copy);netfs_issue_write (wreq, upload);netfs_folio_written_back (folio);return 0 ; }trace_netfs_folio (folio, netfs_folio_trace_store_copy); + }else if (!upload->avail && !cache->avail) { +trace_netfs_folio (folio, netfs_folio_trace_cancel_store); +netfs_folio_written_back (folio); +return 0 ; }else if (!upload->construct) {trace_netfs_folio (folio, netfs_folio_trace_store); }else {
include/trace/events/netfs.h +1 -0
@@ -151,6 +151,7 @@ EM(netfs_streaming_cont_filled_page, "mod-streamw-f+") \ EM(netfs_folio_trace_abandon, "abandon") \ EM(netfs_folio_trace_cancel_copy, "cancel-copy") \ + EM(netfs_folio_trace_cancel_store, "cancel-store") \ EM(netfs_folio_trace_clear, "clear") \ EM(netfs_folio_trace_clear_cc, "clear-cc") \EM (netfs_folio_trace_clear_g,"clear-g" ) \
David Howells
maintainerPATCH 22/24 cifs: Use iterate_and_advance*() routines directly for hashing
In reply to David HowellsReplace the bespoke cifs iterators of ITER_BVEC and ITER_KVEC to do hashing with iterate_and_advance_kernel() - a variant on iterate_and_advance() that only supports kernel-internal ITER_* types and not UBUF/IOVEC types.
The bespoke ITER_XARRAY is left because we don't really want to be calling crypto_shash_update() under the RCU read lock for large amounts of data; besides, ITER_XARRAY is going to be phased out.
--- fs/smb/client/cifsencrypt.c | 109 ++++++++---------------------------- include/linux/iov_iter.h | 47 ++++++++++++++++ 2 files changed, 70 insertions(+), 86 deletions(-)
fs/smb/client/cifsencrypt.c +23 -86
@@ -21,82 +21,10 @@#include <linux/random.h> #include <linux/highmem.h> #include <linux/fips.h> +#include <linux/iov_iter.h> #include "../common/arc4.h" #include <crypto/aead.h> -/* -* Hash data from a BVEC-type iterator. -*/ -static int cifs_shash_bvec (const struct iov_iter *iter,ssize_t maxsize, -struct shash_desc *shash) -{ -const struct bio_vec *bv = iter->bvec; -unsigned long start = iter->iov_offset; -unsigned int i; -void *p; -int ret; - -for (i =0 ; i < iter->nr_segs; i++) { -size_t off, len; - - len = bv[i].bv_len; -if (start >= len) { - start -= len; -continue ; - } - - len =min_t (size_t, maxsize, len - start); - off = bv[i].bv_offset + start; - - p =kmap_local_page (bv[i].bv_page); - ret =crypto_shash_update (shash, p + off, len); -kunmap_local (p); -if (ret <0 ) -return ret; - - maxsize -= len; -if (maxsize <=0 ) -break ; - start =0 ; - } - -return 0 ; -} - -/* -* Hash data from a KVEC-type iterator. -*/ -static int cifs_shash_kvec (const struct iov_iter *iter,ssize_t maxsize, -struct shash_desc *shash) -{ -const struct kvec *kv = iter->kvec; -unsigned long start = iter->iov_offset; -unsigned int i; -int ret; - -for (i =0 ; i < iter->nr_segs; i++) { -size_t len; - - len = kv[i].iov_len; -if (start >= len) { - start -= len; -continue ; - } - - len =min_t (size_t, maxsize, len - start); - ret =crypto_shash_update (shash, kv[i].iov_base + start, len); -if (ret <0 ) -return ret; - maxsize -= len; - -if (maxsize <=0 ) -break ; - start =0 ; - } - -return 0 ; -} -/* * Hash data from an XARRAY-type iterator. */
@@ -145,27 +73,36 @@ static ssize_t cifs_shash_xarray(const struct iov_iter *iter, ssize_t maxsize,return 0 ; } +static size_t cifs_shash_step (void *iter_base,size_t progress,size_t len, +void *priv,void *priv2) +{ +struct shash_desc *shash = priv; +int ret, *pret = priv2; + + ret =crypto_shash_update (shash, iter_base, len); +if (ret <0 ) { + *pret = ret; +return len; + } +return 0 ; +} +/* * Pass the data from an iterator into a hash. */ static int cifs_shash_iter (const struct iov_iter *iter,size_t maxsize,struct shash_desc *shash) { -if (maxsize ==0 ) -return 0 ; +struct iov_iter tmp_iter = *iter; +int err = -EIO ; -switch (iov_iter_type (iter)) { -case ITER_BVEC : -return cifs_shash_bvec (iter, maxsize, shash); -case ITER_KVEC : -return cifs_shash_kvec (iter, maxsize, shash); -case ITER_XARRAY : +if (iov_iter_type (iter) ==ITER_XARRAY )return cifs_shash_xarray (iter, maxsize, shash); -default : -pr_err ("cifs_shash_iter(%u) unsupported\n" ,iov_iter_type (iter)); -WARN_ON_ONCE (1 ); -return -EIO ; - } + +if (iterate_and_advance_kernel (&tmp_iter, maxsize, shash, &err, + cifs_shash_step) != maxsize) +return err; +return 0 ; } int __cifs_calc_signature(struct smb_rqst *rqst,
include/linux/iov_iter.h +47 -0
51 lines not on this page · raw message
David Howells
maintainerPATCH 23/24 cifs: Switch crypto buffer to use a folio_queue rather than an xarray
In reply to David HowellsSwitch cifs from using an xarray to hold the transport crypto buffer to using a folio_queue and use ITER_FOLIOQ rather than ITER_XARRAY.
This is part of the process of phasing out ITER_XARRAY.
--- fs/smb/client/cifsglob.h | 2 +- fs/smb/client/smb2ops.c | 218 +++++++++++++++++++++------------------ include/linux/uio.h | 6 ++ 3 files changed, 127 insertions(+), 99 deletions(-)
fs/smb/client/cifsglob.h +1 -1
@@ -256,7 +256,7 @@ struct smb_rqst {unsigned int rq_nvec;/* number of kvecs in array */ size_t rq_iter_size;/* Amount of data in ->rq_iter */ struct iov_iter rq_iter;/* Data iterator */ -struct xarray rq_buffer;/* Page buffer for encryption */ +struct folio_queue *rq_buffer;/* Buffer for encryption */ };struct mid_q_entry ;
fs/smb/client/smb2ops.c +120 -98
363 lines not on this page · raw message
include/linux/uio.h +6 -0
@@ -189,6 +189,12 @@ static inline size_t copy_folio_to_iter(struct folio *folio, size_t offset,return copy_page_to_iter (&folio->page, offset, bytes, i); } +static inline size_t copy_folio_from_iter (struct folio *folio,size_t offset, +size_t bytes,struct iov_iter *i) +{ +return copy_page_from_iter (&folio->page, offset, bytes, i); +} +static inline size_t copy_folio_from_iter_atomic (struct folio *folio,size_t offset,size_t bytes,struct iov_iter *i) {
David Howells
maintainerPATCH 24/24 cifs: Don't support ITER_XARRAY
In reply to David HowellsThere's now no need to support ITER_XARRAY in cifs as netfslib hands down ITER_FOLIOQ instead - and that's simpler to use with iterate_and_advance() as it doesn't hold the RCU read lock over the step function.
This is part of the process of phasing out ITER_XARRAY.
--- fs/smb/client/cifsencrypt.c | 51 ------------------------------------- fs/smb/client/smbdirect.c | 49 ----------------------------------- 2 files changed, 100 deletions(-)
fs/smb/client/cifsencrypt.c +0 -51
@@ -25,54 +25,6 @@#include "../common/arc4.h" #include <crypto/aead.h> -/* -* Hash data from an XARRAY-type iterator. -*/ -static ssize_t cifs_shash_xarray (const struct iov_iter *iter,ssize_t maxsize, -struct shash_desc *shash) -{ -struct folio *folios[16 ], *folio; -unsigned int nr, i, j, npages; -loff_t start = iter->xarray_start + iter->iov_offset; -pgoff_t last, index = start /PAGE_SIZE ; -ssize_t ret =0 ; -size_t len, offset, foffset; -void *p; - -if (maxsize ==0 ) -return 0 ; - - last = (start + maxsize -1 ) /PAGE_SIZE ; -do { - nr =xa_extract (iter->xarray, (void **)folios, index, last, -ARRAY_SIZE (folios),XA_PRESENT ); -if (nr ==0 ) -return -EIO ; - -for (i =0 ; i < nr; i++) { - folio = folios[i]; - npages =folio_nr_pages (folio); - foffset = start -folio_pos (folio); - offset = foffset %PAGE_SIZE ; -for (j = foffset /PAGE_SIZE ; j < npages; j++) { - len =min_t (size_t, maxsize,PAGE_SIZE - offset); - p =kmap_local_page (folio_page (folio, j)); - ret =crypto_shash_update (shash, p, len); -kunmap_local (p); -if (ret <0 ) -return ret; - maxsize -= len; -if (maxsize <=0 ) -return 0 ; - start += len; - offset =0 ; - index++; - } - } - }while (nr ==ARRAY_SIZE (folios)); -return 0 ; -} -static size_t cifs_shash_step (void *iter_base,size_t progress,size_t len,void *priv,void *priv2) {
@@ -96,9 +48,6 @@ static int cifs_shash_iter(const struct iov_iter *iter, size_t maxsize,struct iov_iter tmp_iter = *iter;int err = -EIO ; -if (iov_iter_type (iter) ==ITER_XARRAY ) -return cifs_shash_xarray (iter, maxsize, shash); -if (iterate_and_advance_kernel (&tmp_iter, maxsize, shash, &err, cifs_shash_step) != maxsize)return err;
fs/smb/client/smbdirect.c +0 -49
61 lines not on this page · raw message
Re: (subset) [PATCH 00/24] netfs: Read/write improvements
In reply to David HowellsQuoted 4 lines · David Howells
This set of patches includes one fscache fix and one cachefiles fix
(1) Fix a cookie access race in fscache.
[...]
Applied to the vfs.fixes branch of the vfs/vfs.git tree. Patches in the vfs.fixes 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.fixes
[01/24] fs/netfs/fscache_cookie: add missing "n_accesses" check
https://git.kernel.org/vfs/vfs/c/965a561e4026
Re: (subset) [PATCH 00/24] netfs: Read/write improvements
In reply to David HowellsQuoted 9 lines · David Howells
This set of patches includes one fscache fix and one cachefiles fix
(1) Fix a cookie access race in fscache.
(2) Fix the setxattr/removexattr syscalls to pull their arguments into kernel space before taking the
sb_writerslock to avoid a deadlock againstmm->mmap_lock.[...]
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
[03/24] - [24/24]