netfs, cachefiles: More additional patches
Subsystems (11)
David Howells
maintainercover netfs, cachefiles: More additional patches
Hi Christian, Jeff, Gao,
Here are some additional patches for my netfs-lib tree:
(1) Mark netfs_unbuffered_write_iter_locked() static as it's only used in the file in which it is defined.
(2) Display a counter for DIO writes in /proc/fs/netfs/stats.
(3) Fix the interaction between write-streaming (dirty data in non-uptodate pages) and the culling of a cache file trying to write that to the cache.
(4) Fix the loop that unmarks folios after writing to the cache. The xarray iterator only advances the index by 1, so if we unmarked a multipage folio and that got split before we advance to the next folio, we see a repeat of a fragment of the folio.
(5) Fix a mixup with signed/unsigned offsets when prepping for writing to the cache that leads to missing error detection.
(6) Fix a wrong ifdef hiding a wait.
David
The netfslib postings:
David Howells (6):
netfs: Mark netfs_unbuffered_write_iter_locked() static
netfs: Count DIO writes
netfs: Fix interaction between write-streaming and cachefiles culling
netfs: Fix the loop that unmarks folios after writing to the cache
cachefiles: Fix signed/unsigned mixup
netfs: Fix wrong #ifdef hiding wait
fs/cachefiles/io.c | 18 +++++++++--------- fs/netfs/buffered_write.c | 27 ++++++++++++++++++++++----- fs/netfs/direct_write.c | 5 +++-- fs/netfs/fscache_stats.c | 9 ++++++--- fs/netfs/internal.h | 8 ++------ fs/netfs/io.c | 2 +- fs/netfs/stats.c | 13 +++++++++---- include/linux/fscache-cache.h | 3 +++ include/linux/netfs.h | 1 + 9 files changed, 56 insertions(+), 30 deletions(-)
David Howells
maintainerPATCH 1/6 netfs: Mark netfs_unbuffered_write_iter_locked() static
Mark netfs_unbuffered_write_iter_locked() static as it's only called from the file in which it is defined.
--- fs/netfs/direct_write.c | 4 ++-- fs/netfs/internal.h | 6 ------ 2 files changed, 2 insertions(+), 8 deletions(-)
fs/netfs/direct_write.c +2 -2
@@ -27,8 +27,8 @@ static void netfs_cleanup_dio_write(struct netfs_io_request *wreq)* Perform an unbuffered write where we may have to do an RMW operation on an * encrypted file. This can also be used for direct I/O writes. */ -ssize_t netfs_unbuffered_write_iter_locked (struct kiocb *iocb,struct iov_iter *iter, -struct netfs_group *netfs_group) +static ssize_t netfs_unbuffered_write_iter_locked (struct kiocb *iocb,struct iov_iter *iter, +struct netfs_group *netfs_group) {struct netfs_io_request *wreq;unsigned long long start = iocb->ki_pos;
fs/netfs/internal.h +0 -6
@@ -26,12 +26,6 @@ void netfs_rreq_unlock_folios(struct netfs_io_request *rreq);int netfs_prefetch_for_write (struct file *file,struct folio *folio,size_t offset,size_t len); -/* -* direct_write.c -*/ -ssize_t netfs_unbuffered_write_iter_locked (struct kiocb *iocb,struct iov_iter *iter, -struct netfs_group *netfs_group); -/* * io.c */
David Howells
maintainerPATCH 2/6 netfs: Count DIO writes
In reply to David HowellsProvide a counter for DIO writes to match that for DIO reads.
--- fs/netfs/direct_write.c | 1 + fs/netfs/internal.h | 1 + fs/netfs/stats.c | 11 +++++++---- 3 files changed, 9 insertions(+), 4 deletions(-)
fs/netfs/direct_write.c +1 -0
@@ -140,6 +140,7 @@ ssize_t netfs_unbuffered_write_iter(struct kiocb *iocb, struct iov_iter *from)_enter ("%llx,%zx,%llx" , iocb->ki_pos,iov_iter_count (from),i_size_read (inode));trace_netfs_write_iter (iocb, from); +netfs_stat (&netfs_n_rh_dio_write); ret =netfs_start_io_direct (inode);if (ret <0 )
fs/netfs/internal.h +1 -0
@@ -104,6 +104,7 @@ int netfs_end_writethrough(struct netfs_io_request *wreq, struct kiocb *iocb);*/ #ifdef CONFIG_NETFS_STATS extern atomic_t netfs_n_rh_dio_read; +extern atomic_t netfs_n_rh_dio_write;extern atomic_t netfs_n_rh_readahead;extern atomic_t netfs_n_rh_readpage;extern atomic_t netfs_n_rh_rreq;
fs/netfs/stats.c +7 -4
@@ -10,6 +10,7 @@#include "internal.h" atomic_t netfs_n_rh_dio_read; +atomic_t netfs_n_rh_dio_write;atomic_t netfs_n_rh_readahead;atomic_t netfs_n_rh_readpage;atomic_t netfs_n_rh_rreq;
@@ -37,14 +38,13 @@ 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 RP=%u WB=%u WBZ=%u rr=%u sr=%u\n" , +seq_printf (m,"Netfs : DR=%u DW=%u RA=%u RP=%u WB=%u WBZ=%u\n" ,atomic_read (&netfs_n_rh_dio_read), +atomic_read (&netfs_n_rh_dio_write),atomic_read (&netfs_n_rh_readahead),atomic_read (&netfs_n_rh_readpage),atomic_read (&netfs_n_rh_write_begin), -atomic_read (&netfs_n_rh_write_zskip), -atomic_read (&netfs_n_rh_rreq), -atomic_read (&netfs_n_rh_sreq)); +atomic_read (&netfs_n_rh_write_zskip)); seq_printf(m, "Netfs : ZR=%u sh=%u sk=%u\n", atomic_read(&netfs_n_rh_zero), atomic_read(&netfs_n_rh_short_read),
@@ -66,6 +66,9 @@ 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,"Netfs : rr=%u sr=%u\n" , +atomic_read (&netfs_n_rh_rreq), +atomic_read (&netfs_n_rh_sreq));return fscache_stats_show (m); }EXPORT_SYMBOL (netfs_stats_show);
David Howells
maintainerPATCH 3/6 netfs: Fix interaction between write-streaming and cachefiles culling
In reply to David HowellsAn issue can occur between write-streaming (storing dirty data in partial non-uptodate pages) and a cachefiles object being culled to make space. The problem occurs because the cache object is only marked in use while there are files open using it. Once it has been released, it can be culled and the cookie marked disabled.
At this point, a streaming write is permitted to occur (if the cache is active, we require pages to be prefetched and cached), but the cache can become active again before this gets flushed out - and then two effects can occur:
(1) The cache may be asked to write out a region that's less than its DIO block size (assumed by cachefiles to be PAGE_SIZE) - and this causes one of two debugging statements to be emitted.
(2) netfs_how_to_modify() gets confused because it sees a page that isn't allowed to be non-uptodate being uptodate and tries to prefetch it - leading to a warning that PG_fscache is set twice.
Fix this by the following means:
(1) Add a netfs_inode flag to disallow write-streaming to an inode and set it if we ever do local caching of that inode. It remains set for the lifetime of that inode - even if the cookie becomes disabled.
(2) If the no-write-streaming flag is set, then make netfs_how_to_modify() always want to prefetch instead.
(3) If netfs_how_to_modify() decides it wants to prefetch a folio, but that folio has write-streamed data in it, then it requires the folio be flushed first.
(4) Export a counter of the number of times we wanted to prefetch a non-uptodate page, but found it had write-streamed data in it.
(5) Export a counter of the number of times we cancelled a write to the cache because it didn't DIO align and remove the debug statements.
--- fs/cachefiles/io.c | 12 ++++++------ fs/netfs/buffered_write.c | 24 ++++++++++++++++++++---- fs/netfs/fscache_stats.c | 9 ++++++--- fs/netfs/internal.h | 1 + fs/netfs/stats.c | 6 ++++-- include/linux/fscache-cache.h | 3 +++ include/linux/netfs.h | 1 + 7 files changed, 41 insertions(+), 15 deletions(-)
fs/cachefiles/io.c +6 -6
@@ -528,12 +528,12 @@ int __cachefiles_prepare_write(struct cachefiles_object *object,/* Round to DIO size */ start =round_down (*_start,PAGE_SIZE ); -if (start != *_start) { -kleave (" = -ENOBUFS [down]" ); -return -ENOBUFS ; - } -if (*_len > upper_len) { -kleave (" = -ENOBUFS [up]" ); +if (start != *_start || *_len > upper_len) { +/* Probably asked to cache a streaming write written into the +* pagecache when the cookie was temporarily out of service to +* culling. +*/ +fscache_count_dio_misfit ();return -ENOBUFS ; }
fs/netfs/buffered_write.c +20 -4
@@ -80,10 +80,19 @@ static enum netfs_how_to_modify netfs_how_to_modify(struct netfs_inode *ctx,return NETFS_WHOLE_FOLIO_MODIFY ;if (file->f_mode &FMODE_READ ) -return NETFS_JUST_PREFETCH ; - -if (netfs_is_cache_enabled (ctx)) -return NETFS_JUST_PREFETCH ; + goto no_write_streaming; +if (test_bit (NETFS_ICTX_NO_WRITE_STREAMING , &ctx->flags)) + 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. +*/ +if (!test_bit (NETFS_ICTX_NO_WRITE_STREAMING , &ctx->flags)) +set_bit (NETFS_ICTX_NO_WRITE_STREAMING , &ctx->flags); + goto no_write_streaming; + }if (!finfo)return NETFS_STREAMING_WRITE ;
@@ -95,6 +104,13 @@ static enum netfs_how_to_modify netfs_how_to_modify(struct netfs_inode *ctx,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 ; + } +return NETFS_JUST_PREFETCH ; }/*
fs/netfs/fscache_stats.c +6 -3
@@ -48,13 +48,15 @@ atomic_t fscache_n_no_create_space;EXPORT_SYMBOL (fscache_n_no_create_space);atomic_t fscache_n_culled;EXPORT_SYMBOL (fscache_n_culled); +atomic_t fscache_n_dio_misfit; +EXPORT_SYMBOL (fscache_n_dio_misfit);/* * display the general statistics */ int fscache_stats_show (struct seq_file *m) { -seq_puts (m,"FS-Cache statistics\n" ); +seq_puts (m,"-- FS-Cache statistics --\n" ); seq_printf(m, "Cookies: n=%d v=%d vcol=%u voom=%u\n", atomic_read(&fscache_n_cookies), atomic_read(&fscache_n_volumes),
@@ -93,8 +95,9 @@ int fscache_stats_show(struct seq_file *m)atomic_read (&fscache_n_no_create_space), atomic_read(&fscache_n_culled)); -seq_printf (m,"IO : rd=%u wr=%u\n" , +seq_printf (m,"IO : rd=%u wr=%u mis=%u\n" ,atomic_read (&fscache_n_read), -atomic_read (&fscache_n_write)); +atomic_read (&fscache_n_write), +atomic_read (&fscache_n_dio_misfit));return 0 ; }
fs/netfs/internal.h +1 -0
@@ -123,6 +123,7 @@ extern atomic_t netfs_n_rh_write_begin;extern atomic_t netfs_n_rh_write_done;extern atomic_t netfs_n_rh_write_failed;extern atomic_t netfs_n_rh_write_zskip; +extern atomic_t netfs_n_wh_wstream_conflict;extern atomic_t netfs_n_wh_upload;extern atomic_t netfs_n_wh_upload_done;extern atomic_t netfs_n_wh_upload_failed;
fs/netfs/stats.c +4 -2
@@ -29,6 +29,7 @@ atomic_t netfs_n_rh_write_begin;atomic_t netfs_n_rh_write_done;atomic_t netfs_n_rh_write_failed;atomic_t netfs_n_rh_write_zskip; +atomic_t netfs_n_wh_wstream_conflict;atomic_t netfs_n_wh_upload;atomic_t netfs_n_wh_upload_done;atomic_t netfs_n_wh_upload_failed;
@@ -66,9 +67,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,"Netfs : rr=%u sr=%u\n" , +seq_printf (m,"Netfs : rr=%u sr=%u wsc=%u\n" ,atomic_read (&netfs_n_rh_rreq), -atomic_read (&netfs_n_rh_sreq)); +atomic_read (&netfs_n_rh_sreq), +atomic_read (&netfs_n_wh_wstream_conflict));return fscache_stats_show (m); }EXPORT_SYMBOL (netfs_stats_show);
include/linux/fscache-cache.h +3 -0
@@ -189,17 +189,20 @@ extern atomic_t fscache_n_write;extern atomic_t fscache_n_no_write_space;extern atomic_t fscache_n_no_create_space;extern atomic_t fscache_n_culled; +extern atomic_t fscache_n_dio_misfit;#define fscache_count_read () atomic_inc(&fscache_n_read)#define fscache_count_write () atomic_inc(&fscache_n_write)#define fscache_count_no_write_space () atomic_inc(&fscache_n_no_write_space)#define fscache_count_no_create_space () atomic_inc(&fscache_n_no_create_space)#define fscache_count_culled () atomic_inc(&fscache_n_culled) +#define fscache_count_dio_misfit () atomic_inc(&fscache_n_dio_misfit)#else #define fscache_count_read () do {} while(0)#define fscache_count_write () do {} while(0)#define fscache_count_no_write_space () do {} while(0)#define fscache_count_no_create_space () do {} while(0)#define fscache_count_culled () do {} while(0) +#define fscache_count_dio_misfit () do {} while(0)#endif #endif /* _LINUX_FSCACHE_CACHE_H */
include/linux/netfs.h +1 -0
@@ -142,6 +142,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_NO_WRITE_STREAMING 3/* Don't engage in write-streaming */ };/*
David Howells
maintainerPATCH 4/6 netfs: Fix the loop that unmarks folios after writing to the cache
In reply to David HowellsIn the loop in netfs_rreq_unmark_after_write() that removes the PG_fscache from folios after they've been written to the cache, as soon as we remove the mark from a multipage folio, it can get split - and then we might see a fragment of folio again.
Guard against this by advancing the 'unlocked' tracker to the index of the last page in the folio to avoid a double removal of the PG_fscache mark.
--- fs/netfs/buffered_write.c | 1 + fs/netfs/io.c | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-)
fs/netfs/buffered_write.c +1 -0
@@ -698,6 +698,7 @@ static void netfs_pages_written_back(struct netfs_io_request *wreq) end_wb:if (folio_test_fscache (folio))folio_end_fscache (folio); +xas_advance (&xas,folio_next_index (folio) -1 );folio_end_writeback (folio); }
fs/netfs/io.c +1 -1
@@ -126,7 +126,7 @@ static void netfs_rreq_unmark_after_write(struct netfs_io_request *rreq,*/ if (have_unlocked &&folio_index (folio) <= unlocked)continue ; - unlocked =folio_index (folio); + unlocked =folio_next_index (folio) -1 ;trace_netfs_folio (folio, netfs_folio_trace_end_copy);folio_end_fscache (folio); have_unlocked = true;
David Howells
maintainerPATCH 5/6 cachefiles: Fix signed/unsigned mixup
In reply to David HowellsIn __cachefiles_prepare_write(), the start and pos variables were made unsigned 64-bit so that the casts in the checking could be got rid of - which should be fine since absolute file offsets can't be negative, except that an error code may be obtained from vfs_llseek(), which *would* be negative. This breaks the error check.
Fix this for now by reverting pos and start to be signed and putting back the casts. Unfortunately, the error value checks cannot be replaced with IS_ERR_VALUE() as long might be 32-bits.
--- fs/cachefiles/io.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
fs/cachefiles/io.c +3 -3
@@ -522,7 +522,7 @@ int __cachefiles_prepare_write(struct cachefiles_object *object, bool no_space_allocated_yet) {struct cachefiles_cache *cache = object->volume->cache; -unsigned long long start = *_start, pos; +loff_t start = *_start, pos;size_t len = *_len;int ret;
@@ -556,7 +556,7 @@ int __cachefiles_prepare_write(struct cachefiles_object *object, cachefiles_trace_seek_error);return pos; } -if (pos >= start + *_len) +if ((u64 )pos >= (u64 )start + *_len) goto check_space;/* Unallocated region */ /* We have a block that's at least partially filled - if we're low on
@@ -575,7 +575,7 @@ int __cachefiles_prepare_write(struct cachefiles_object *object, cachefiles_trace_seek_error);return pos; } -if (pos >= start + *_len) +if ((u64 )pos >= (u64 )start + *_len)return 0 ;/* Fully allocated */ /* Partially allocated, but insufficient space: cull. */
Re: [PATCH 5/6] cachefiles: Fix signed/unsigned mixup
Quoted 10 lines · David Howells
In
__cachefiles_prepare_write(), the start and pos variables were made unsigned 64-bit so that the casts in the checking could be got rid of - which should be fine since absolute file offsets can't be negative, except that an error code may be obtained fromvfs_llseek(), which *would* be negative. This breaks the error check.Fix this for now by reverting pos and start to be signed and putting back the casts. Unfortunately, the error value checks cannot be replaced with
IS_ERR_VALUE()as long might be 32-bits.
Quoted 14 lines
Fixes 7097c96411d2 ("cachefiles: Fix __cachefiles_prepare_write()")Reported-by Simon Horman <[email protected]>Reported-by kernel test robot <[email protected]>Signed-off-by David Howells <[email protected]>Reviewed-by Simon Horman <[email protected]>cc Gao Xiang <[email protected]>cc Yiqun Leng <[email protected]>cc Jia Zhu <[email protected]>cc Jeff Layton <[email protected]>
It looks good to me,
Thanks,
Gao Xiang
Re: [External] [PATCH 5/6] cachefiles: Fix signed/unsigned mixup
In reply to David HowellsQuoted 60 lines · David Howells
In
__cachefiles_prepare_write(), the start and pos variables were made unsigned 64-bit so that the casts in the checking could be got rid of - which should be fine since absolute file offsets can't be negative, except that an error code may be obtained fromvfs_llseek(), which *would* be negative. This breaks the error check.Fix this for now by reverting pos and start to be signed and putting back the casts. Unfortunately, the error value checks cannot be replaced with
IS_ERR_VALUE()as long might be 32-bits.Fixes 7097c96411d2 ("cachefiles: Fix __cachefiles_prepare_write()")Reported-by Simon Horman <[email protected]>Reported-by kernel test robot <[email protected]>Signed-off-by David Howells <[email protected]>Reviewed-by Simon Horman <[email protected]>cc Gao Xiang <[email protected]>cc Yiqun Leng <[email protected]>cc Jia Zhu <[email protected]>cc Jeff Layton <[email protected]>--- fs/cachefiles/io.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)fs/cachefiles/io.c +3
-3@@ -522,7 +522,7 @@ int __cachefiles_prepare_write(struct cachefiles_object *object, bool no_space_allocated_yet) {struct cachefiles_cache *cache = object->volume->cache; -unsigned long long start = *_start, pos; +loff_t start = *_start, pos;size_t len = *_len;int ret;@@ -556,7 +556,7 @@ int __cachefiles_prepare_write(struct cachefiles_object *object, cachefiles_trace_seek_error);return pos; } -if (pos >= start + *_len) +if ((u64 )pos >= (u64 )start + *_len) goto check_space;/* Unallocated region */ /* We have a block that's at least partially filled - if we're low on @@ -575,7 +575,7 @@ int __cachefiles_prepare_write(struct cachefiles_object *object, cachefiles_trace_seek_error);return pos; } -if (pos >= start + *_len) +if ((u64 )pos >= (u64 )start + *_len)return 0 ;/* Fully allocated */ /* Partially allocated, but insufficient space: cull. */
David Howells
maintainerPATCH 6/6 netfs: Fix wrong #ifdef hiding wait
In reply to David Howellsnetfs_writepages_begin() has the wait on the fscache folio conditional on CONFIG_NETFS_FSCACHE - which doesn't exist.
Fix it to be conditional on CONFIG_FSCACHE instead.
--- fs/netfs/buffered_write.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/netfs/buffered_write.c +1 -1
@@ -1076,7 +1076,7 @@ static ssize_t netfs_writepages_begin(struct address_space *mapping,folio_unlock (folio);if (wbc->sync_mode !=WB_SYNC_NONE ) {folio_wait_writeback (folio); -#ifdef CONFIG_NETFS_FSCACHE +#ifdef CONFIG_FSCACHE folio_wait_fscache (folio);#endif goto lock_again;
Quoted 53 lines · David Howells
Hi Christian, Jeff, Gao,
Here are some additional patches for my netfs-lib tree:
(1) Mark
netfs_unbuffered_write_iter_locked()static as it's only used in the file in which it is defined.(2) Display a counter for DIO writes in
/proc/fs/netfs/stats.(3) Fix the interaction between write-streaming (dirty data in non-uptodate pages) and the culling of a cache file trying to write that to the cache.
(4) Fix the loop that unmarks folios after writing to the cache. The xarray iterator only advances the index by 1, so if we unmarked a multipage folio and that got split before we advance to the next folio, we see a repeat of a fragment of the folio.
(5) Fix a mixup with signed/unsigned offsets when prepping for writing to the cache that leads to missing error detection.
(6) Fix a wrong ifdef hiding a wait.
David
The netfslib postings:
Link https://lore.kernel.org/r/[email protected]/ # added patches open hereDavid Howells (6):
netfs: Marknetfs_unbuffered_write_iter_locked()static
netfs: Count DIO writes
netfs: Fix interaction between write-streaming and cachefiles culling
netfs: Fix the loop that unmarks folios after writing to the cache
cachefiles: Fix signed/unsigned mixup
netfs: Fix wrong #ifdef hiding waitfs/cachefiles/io.c | 18 +++++++++--------- fs/netfs/buffered_write.c | 27 ++++++++++++++++++++++----- fs/netfs/direct_write.c | 5 +++-- fs/netfs/fscache_stats.c | 9 ++++++--- fs/netfs/internal.h | 8 ++------ fs/netfs/io.c | 2 +- fs/netfs/stats.c | 13 +++++++++---- include/linux/fscache-cache.h | 3 +++ include/linux/netfs.h | 1 + 9 files changed, 56 insertions(+), 30 deletions(-)
Quoted 3 lines
--
You received this message because you are subscribed to the Google Groups "[email protected]" group. To unsubscribe from this group and stop receiving emails from it, send an email to [email protected].
This passes our kafs tests where a few of the issues fixed here had been seen. I made the framework use 9p and no related issues were seen there either.
Marc
Quoted 41 lines · David Howells
Hi Christian, Jeff, Gao,
Here are some additional patches for my netfs-lib tree:
(1) Mark
netfs_unbuffered_write_iter_locked()static as it's only used in the file in which it is defined.(2) Display a counter for DIO writes in
/proc/fs/netfs/stats.(3) Fix the interaction between write-streaming (dirty data in non-uptodate pages) and the culling of a cache file trying to write that to the cache.
(4) Fix the loop that unmarks folios after writing to the cache. The xarray iterator only advances the index by 1, so if we unmarked a multipage folio and that got split before we advance to the next folio, we see a repeat of a fragment of the folio.
(5) Fix a mixup with signed/unsigned offsets when prepping for writing to the cache that leads to missing error detection.
(6) Fix a wrong ifdef hiding a wait.
David
The netfslib postings:
Link https://lore.kernel.org/r/[email protected]/ # added patches open hereDavid Howells (6):
netfs: Marknetfs_unbuffered_write_iter_locked()static
netfs: Count DIO writes
netfs: Fix interaction between write-streaming and cachefiles culling
netfs: Fix the loop that unmarks folios after writing to the cache
cachefiles: Fix signed/unsigned mixup
netfs: Fix wrong #ifdef hiding wait
Quoted 11 lines
fs/cachefiles/io.c | 18 +++++++++--------- fs/netfs/buffered_write.c | 27 ++++++++++++++++++++++----- fs/netfs/direct_write.c | 5 +++-- fs/netfs/fscache_stats.c | 9 ++++++--- fs/netfs/internal.h | 8 ++------ fs/netfs/io.c | 2 +- fs/netfs/stats.c | 13 +++++++++---- include/linux/fscache-cache.h | 3 +++ include/linux/netfs.h | 1 + 9 files changed, 56 insertions(+), 30 deletions(-)
These all look fine to me. You can add: