Network fs helper library & fscache kiocb API [ver #3]
Subsystems (16)
David Howells
maintainercover Network fs helper library & fscache kiocb API [ver #3]
Here's a set of patches to do two things:
(1) Add a helper library to handle the new VM readahead interface. This is intended to be used unconditionally by the filesystem (whether or not caching is enabled) and provides a common framework for doing caching, transparent huge pages and, in the future, possibly fscrypt and read bandwidth maximisation. It also allows the netfs and the cache to align, expand and slice up a read request from the VM in various ways; the netfs need only provide a function to read a stretch of data to the pagecache and the helper takes care of the rest.
(2) Add an alternative fscache/cachfiles I/O API that uses the kiocb facility to do async DIO to transfer data to/from the netfs's pages, rather than using readpage with wait queue snooping on one side and vfs_write() on the other. It also uses less memory, since it doesn't do buffered I/O on the backing file.
Note that this uses SEEK_HOLE/SEEK_DATA to locate the data available to be read from the cache. Whilst this is an improvement from the bmap interface, it still has a problem with regard to a modern extent-based filesystem inserting or removing bridging blocks of zeros. Fixing that requires a much greater overhaul.
This is a step towards overhauling the fscache API. The change is opt-in on the part of the network filesystem. A netfs should not try to mix the old and the new API because of conflicting ways of handling pages and the PG_fscache page flag and because it would be mixing DIO with buffered I/O. Further, the helper library can't be used with the old API.
This does not change any of the fscache cookie handling APIs or the way invalidation is done.
In the near term, I intend to deprecate and remove the old I/O API (fscache_allocate_page{,s}(), fscache_read_or_alloc_page{,s}(), fscache_write_page() and fscache_uncache_page()) and eventually replace most of fscache/cachefiles with something simpler and easier to follow.
The patchset contains five parts:
(1) Some helper patches, including provision of an ITER_XARRAY iov iterator and a function to do readahead expansion.
(2) Patches to add the netfs helper library.
(3) A patch to add the fscache/cachefiles kiocb API.
(4) Patches to add support in AFS for this.
(5) Patches from Jeff Layton to add support in Ceph for this.
Dave Wysochanski also has patches for NFS for this, though they're not included on this branch as there's an issue with PNFS.
With this, AFS without a cache passes all expected xfstests; with a cache, there's an extra failure, but that's also there before these patches. Fixing that probably requires a greater overhaul. Ceph and NFS also pass the expected tests.
These patches can be found also on:
https://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs.git/log/?h=fscache-netfs-lib
For diffing reference, the tag for the 9th Feb pull request is fscache-ioapi-20210203 and can be found in the same repository.
Changes
=======
(v3) Rolled in the bug fixes.
Adjusted the functions that unlock and wait for PG_fscache according to Linus's suggestion.
Hold a ref on a page when PG_fscache is set as per Linus's suggestion.
Dropped NFS support and added Ceph support.
(v2) Fixed some bugs and added NFS support.
References
==========
These patches have been published for review before, firstly as part of a larger set:
Then as a cut-down set:
Proposals/information about the design has been published here:
And requests for information:
The NFS parts, though not included here, have been tested by someone who's using fscache in production:
I've posted partial patches to try and help 9p and cifs along:
David
---
David Howells (27):
iov_iter: Add ITER_XARRAY
mm: Add an unlock function for PG_private_2/PG_fscache
mm: Implement readahead_control pageset expansion
vfs: Export rw_verify_area() for use by cachefiles
netfs: Make a netfs helper module
netfs, mm: Move PG_fscache helper funcs to linux/netfs.h netfs, mm: Add unlock_page_fscache() and wait_on_page_fscache()
netfs: Provide readahead and readpage netfs helpers
netfs: Add tracepoints
netfs: Gather stats
netfs: Add write_begin helper
netfs: Define an interface to talk to a cache
netfs: Hold a ref on a page when PG_private_2 is set
fscache, cachefiles: Add alternate API to use kiocb for read/write to cache
afs: Disable use of the fscache I/O routines
afs: Pass page into dirty region helpers to provide THP size
afs: Print the operation debug_id when logging an unexpected data version
afs: Move key to afs_read struct
afs: Don't truncate iter during data fetch
afs: Log remote unmarshalling errors
afs: Set up the iov_iter before calling afs_extract_data()
afs: Use ITER_XARRAY for writing
afs: Wait on PG_fscache before modifying/releasing a page
afs: Extract writeback extension into its own function
afs: Prepare for use of THPs
afs: Use the fs operation ops to handle FetchData completion
afs: Use new fscache read helper API
Jeff Layton (6):
ceph: disable old fscache readpage handling
ceph: rework PageFsCache handling
ceph: fix fscache invalidation
ceph: convert readpage to fscache read helper
ceph: plug write_begin into read helper
ceph: convert ceph_readpages to ceph_readahead
fs/Kconfig | 1 + fs/Makefile | 1 + fs/afs/Kconfig | 1 + fs/afs/dir.c | 225 ++++--- fs/afs/file.c | 470 ++++--------- fs/afs/fs_operation.c | 4 +- fs/afs/fsclient.c | 108 +-- fs/afs/inode.c | 7 +- fs/afs/internal.h | 58 +- fs/afs/rxrpc.c | 150 ++--- fs/afs/write.c | 610 +++++++++-------- fs/afs/yfsclient.c | 82 +-- fs/cachefiles/Makefile | 1 + fs/cachefiles/interface.c | 5 +- fs/cachefiles/internal.h | 9 + fs/cachefiles/rdwr2.c | 412 ++++++++++++ fs/ceph/Kconfig | 1 + fs/ceph/addr.c | 535 ++++++--------- fs/ceph/cache.c | 125 ---- fs/ceph/cache.h | 101 +-- fs/ceph/caps.c | 10 +- fs/ceph/inode.c | 1 + fs/ceph/super.h | 1 + fs/fscache/Kconfig | 1 + fs/fscache/Makefile | 3 +- fs/fscache/internal.h | 3 + fs/fscache/page.c | 2 +- fs/fscache/page2.c | 117 ++++ fs/fscache/stats.c | 1 + fs/internal.h | 5 - fs/netfs/Kconfig | 23 + fs/netfs/Makefile | 5 + fs/netfs/internal.h | 97 +++ fs/netfs/read_helper.c | 1169 +++++++++++++++++++++++++++++++++ fs/netfs/stats.c | 59 ++ fs/read_write.c | 1 + include/linux/fs.h | 1 + include/linux/fscache-cache.h | 4 + include/linux/fscache.h | 40 +- include/linux/netfs.h | 195 ++++++ include/linux/pagemap.h | 3 + include/net/af_rxrpc.h | 2 +- include/trace/events/afs.h | 74 +-- include/trace/events/netfs.h | 201 ++++++ mm/filemap.c | 20 + mm/readahead.c | 70 ++ net/rxrpc/recvmsg.c | 9 +- 47 files changed, 3473 insertions(+), 1550 deletions(-) create mode 100644 fs/cachefiles/rdwr2.c create mode 100644 fs/fscache/page2.c create mode 100644 fs/netfs/Kconfig create mode 100644 fs/netfs/Makefile create mode 100644 fs/netfs/internal.h create mode 100644 fs/netfs/read_helper.c create mode 100644 fs/netfs/stats.c create mode 100644 include/linux/netfs.h create mode 100644 include/trace/events/netfs.h
David Howells
maintainerPATCH 1/33 iov_iter: Add ITER_XARRAY
Add an iterator, ITER_XARRAY, that walks through a set of pages attached to an xarray, starting at a given page and offset and walking for the specified amount of bytes. The iterator supports transparent huge pages.
The caller must guarantee that the pages are all present and they must be locked using PG_locked, PG_writeback or PG_fscache to prevent them from going away or being migrated whilst they're being accessed.
This is useful for copying data from socket buffers to inodes in network filesystems and for transferring data between those inodes and the cache using direct I/O.
Whilst it is true that ITER_BVEC could be used instead, that would require a bio_vec array to be allocated to refer to all the pages - which should be redundant if inode->i_pages also points to all these pages.
---
include/linux/uio.h | 11 ++ lib/iov_iter.c | 313 +++++++++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 301 insertions(+), 23 deletions(-)
include/linux/uio.h +11 -0
@@ -10,6 +10,7 @@#include <uapi/linux/uio.h> struct page ; +struct address_space ;struct pipe_inode_info ;struct kvec {
@@ -24,6 +25,7 @@ enum iter_type {ITER_BVEC =16 ,ITER_PIPE =32 ,ITER_DISCARD =64 , + ITER_XARRAY = 128, }; struct iov_iter {
@@ -39,6 +41,7 @@ struct iov_iter {const struct iovec *iov;const struct kvec *kvec;const struct bio_vec *bvec; +struct xarray *xarray;struct pipe_inode_info *pipe; };union {
@@ -47,6 +50,7 @@ struct iov_iter {unsigned int head;unsigned int start_head; }; +loff_t xarray_start; }; };
@@ -80,6 +84,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_xarray (const struct iov_iter *i) +{ +return iov_iter_type (i) ==ITER_XARRAY ; +} +static inline unsigned char iov_iter_rw (const struct iov_iter *i) {return i->type & (READ |WRITE );
@@ -221,6 +230,8 @@ void iov_iter_bvec(struct iov_iter *i, unsigned int direction, const struct bio_void iov_iter_pipe (struct iov_iter *i,unsigned int direction,struct pipe_inode_info *pipe,size_t count);void iov_iter_discard (struct iov_iter *i,unsigned int direction,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_pages (struct iov_iter *i,struct page **pages,size_t maxsize,unsigned maxpages,size_t *start); ssize_t iov_iter_get_pages_alloc(struct iov_iter *i, struct page ***pages,
lib/iov_iter.c +290 -23
518 lines not on this page · raw message
David Howells
maintainerPATCH 2/33 mm: Add an unlock function for PG_private_2/PG_fscache
In reply to David HowellsAdd a function, unlock_page_private_2(), to unlock PG_private_2 analogous to that of PG_lock. Add a kerneldoc banner to that indicating the example usage case.
A wrapper will need to be placed in the netfs header in the patch that adds that.
[This implements a suggestion by Linus to not mix the terminology of
PG_private_2 and PG_fscache in the mm core function]
---
include/linux/pagemap.h | 1 + mm/filemap.c | 20 ++++++++++++++++++++ 2 files changed, 21 insertions(+)
include/linux/pagemap.h +1 -0
@@ -591,6 +591,7 @@ extern int __lock_page_async(struct page *page, struct wait_page_queue *wait);extern int __lock_page_or_retry (struct page *page,struct mm_struct *mm,unsigned int flags);extern void unlock_page (struct page *page); +extern void unlock_page_private_2 (struct page *page);/* * Return true if the page was successfully locked
mm/filemap.c +20 -0
@@ -1466,6 +1466,26 @@ void unlock_page(struct page *page) }EXPORT_SYMBOL (unlock_page); +/** +* unlock_page_private_2 - Unlock a page that's locked with PG_private_2 +* @page: The page +* +* Unlocks a page that's locked with PG_private_2 and wakes up sleepers in +* wait_on_page_private_2(). +* +* This is, for example, used when a netfs page is being written to a local +* disk cache, thereby allowing writes to the cache for the same page to be +* serialised. +*/ +void unlock_page_private_2 (struct page *page) +{ + page =compound_head (page); +VM_BUG_ON_PAGE (!PagePrivate2 (page), page); +clear_bit_unlock (PG_private_2, &page->flags); +wake_up_page_bit (page, PG_private_2); +} +EXPORT_SYMBOL (unlock_page_private_2); +/** * end_page_writeback - end writeback against a page * @page: the page
Re: [PATCH 02/33] mm: Add an unlock function for PG_private_2/PG_fscache
Quoted 1 line
+extern void
unlock_page_private_2(struct page *page);
No need for the extern.
Otherwise this looks good:
David Howells
maintainerPATCH 3/33 mm: Implement readahead_control pageset expansion
In reply to David HowellsProvide a function, readahead_expand(), that expands the set of pages specified by a readahead_control object to encompass a revised area with a proposed size and length.
The proposed area must include all of the old area and may be expanded yet more by this function so that the edges align on (transparent huge) page boundaries as allocated.
The expansion will be cut short if a page already exists in either of the areas being expanded into. Note that any expansion made in such a case is not rolled back.
This will be used by fscache so that reads can be expanded to cache granule boundaries, thereby allowing whole granules to be stored in the cache, but there are other potential users also.
---
include/linux/pagemap.h | 2 + mm/readahead.c | 70 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 72 insertions(+)
include/linux/pagemap.h +2 -0
@@ -761,6 +761,8 @@ extern void __delete_from_page_cache(struct page *page, void *shadow);int replace_page_cache_page (struct page *old,struct page *new,gfp_t gfp_mask);void delete_from_page_cache_batch (struct address_space *mapping,struct pagevec *pvec); +void readahead_expand (struct readahead_control *ractl, +loff_t new_start,size_t new_len);/* * Like add_to_page_cache_locked, but used to add newly allocated pages:
mm/readahead.c +70 -0
73 lines not on this page · raw message
Re: [PATCH 03/33] mm: Implement readahead_control pageset expansion
Quoted 8 lines · David Howells
Provide a function,
readahead_expand(), that expands the set of pages specified by areadahead_controlobject to encompass a revised area with a proposed size and length.The proposed area must include all of the old area and may be expanded yet more by this function so that the edges align on (transparent huge) page boundaries as allocated.
Quoted 7 lines
The expansion will be cut short if a page already exists in either of the areas being expanded into. Note that any expansion made in such a case is not rolled back.
This will be used by fscache so that reads can be expanded to cache granule boundaries, thereby allowing whole granules to be stored in the cache, but there are other potential users also.
So looking at linux-next this seems to have a user, but that user is dead wood given that nothing implements ->expand_readahead.
Looking at the code structure I think netfs_readahead and netfs_rreq_expand is a complete mess and needs to be turned upside down, that is instead of calling back from netfs_readahead to the calling file system, split it into a few helpers called by the caller.
But even after this can't we just expose the cache granule boundary to the VM so that the read-ahead request gets setup correctly from the very beginning?
David Howells
maintainerRe: [PATCH 03/33] mm: Implement readahead_control pageset expansion
Quoted 7 lines · Christoph Hellwig
Quoted 3 lines · David Howells
Provide a function,
readahead_expand(), that expands the set of pages specified by areadahead_controlobject to encompass a revised area with a proposed size and length....
So looking at linux-next this seems to have a user, but that user is dead wood given that nothing implements ->expand_readahead.
Interesting question. Code on my fscache-iter branch does implement this, but I was asked to split the patchset up, so that's not in this subset.
Quoted 9 lines
Looking at the code structure I think
netfs_readaheadandnetfs_rreq_expandis a complete mess and needs to be turned upside down, that is instead of calling back fromnetfs_readaheadto the calling file system, split it into a few helpers called by the caller.But even after this can't we just expose the cache granule boundary to the VM so that the read-ahead request gets setup correctly from the very beginning?
You need to argue this one with Willy. In my opinion, the VM should ask the filesystem and the expansion be done before ->readahead() is called. Willy disagrees, however.
David
Matthew Wilcox
maintainerRe: [PATCH 03/33] mm: Implement readahead_control pageset expansion
In reply to Christoph HellwigQuoted 17 lines · Christoph Hellwig
Quoted 8 lines · David Howells
Provide a function,
readahead_expand(), that expands the set of pages specified by areadahead_controlobject to encompass a revised area with a proposed size and length.The proposed area must include all of the old area and may be expanded yet more by this function so that the edges align on (transparent huge) page boundaries as allocated.
Quoted 7 lines
The expansion will be cut short if a page already exists in either of the areas being expanded into. Note that any expansion made in such a case is not rolled back.
This will be used by fscache so that reads can be expanded to cache granule boundaries, thereby allowing whole granules to be stored in the cache, but there are other potential users also.
Quoted 8 lines
So looking at linux-next this seems to have a user, but that user is dead wood given that nothing implements ->expand_readahead.
Looking at the code structure I think
netfs_readaheadandnetfs_rreq_expandis a complete mess and needs to be turned upside down, that is instead of calling back fromnetfs_readaheadto the calling file system, split it into a few helpers called by the caller.
That's funny, we modelled it after iomap.
Quoted 3 lines
But even after this can't we just expose the cache granule boundary to the VM so that the read-ahead request gets setup correctly from the very beginning?
The intent is that this be usable by filesystems which want to (for example) compress variable sized blocks. So they won't know which pages they want to readahead until they're in their iomap actor routine, see that the extent they're in is compressed, and find out how large the extent is.
Re: [PATCH 03/33] mm: Implement readahead_control pageset expansion
I plan to try and use readahead_expand in Orangefs...
-Mike
Quoted 39 lines · Matthew Wilcox
Quoted 17 lines · Christoph Hellwig
Quoted 8 lines · David Howells
Provide a function,
readahead_expand(), that expands the set of pages specified by areadahead_controlobject to encompass a revised area with a proposed size and length.The proposed area must include all of the old area and may be expanded yet more by this function so that the edges align on (transparent huge) page boundaries as allocated.
Quoted 7 lines
The expansion will be cut short if a page already exists in either of the areas being expanded into. Note that any expansion made in such a case is not rolled back.
This will be used by fscache so that reads can be expanded to cache granule boundaries, thereby allowing whole granules to be stored in the cache, but there are other potential users also.
Quoted 8 lines
So looking at linux-next this seems to have a user, but that user is dead wood given that nothing implements ->expand_readahead.
Looking at the code structure I think
netfs_readaheadandnetfs_rreq_expandis a complete mess and needs to be turned upside down, that is instead of calling back fromnetfs_readaheadto the calling file system, split it into a few helpers called by the caller.That's funny, we modelled it after iomap.
Quoted 3 lines
But even after this can't we just expose the cache granule boundary to the VM so that the read-ahead request gets setup correctly from the very beginning?
The intent is that this be usable by filesystems which want to (for example) compress variable sized blocks. So they won't know which pages they want to readahead until they're in their iomap actor routine, see that the extent they're in is compressed, and find out how large the extent is.
David Howells
maintainerRe: [PATCH 03/33] mm: Implement readahead_control pageset expansion
Quoted 1 line · Mike Marshall
I plan to try and use
readahead_expandin Orangefs...
Would it help if I shuffled the readahead_expand patch to the bottom of the pack?
David
Re: [PATCH 03/33] mm: Implement readahead_control pageset expansion
Matthew has looked at how I'm fumbling about trying to deal with Orangefs's need for much larger than page-sized IO...
I think I need to implement orangefs_readahead and from there fire off an asynchronous read and while that's going I'll call readahead_page with a rac that I've cranked up with readahead_expand and when the read gets done I'll have plenty of pages for the large IO I did.
Even if what I think I need to do is somewhere near right, the async code in the Orangefs kernel module didn't make it into the upstream version, so I have to refurbish that. All that to
say: I don't need readahead_expand "tomorrow", but it fits into my plan to
get Orangefs the extra pages it needs
without me having open-coded page cache
code in orangefs_readpage.
-Mike
Quoted 10 lines · David Howells
Quoted 1 line · Mike Marshall
I plan to try and use
readahead_expandin Orangefs...Would it help if I shuffled the
readahead_expandpatch to the bottom of the pack?David
David Howells
maintainerRe: [PATCH 03/33] mm: Implement readahead_control pageset expansion
Quoted 10 lines · Mike Marshall
Matthew has looked at how I'm fumbling about trying to deal with Orangefs's need for much larger than page-sized IO...
I think I need to implement
orangefs_readaheadand from there fire off an asynchronous read and while that's going I'll callreadahead_pagewith a rac that I've cranked up withreadahead_expandand when the read gets done I'll have plenty of pages for the large IO I did.
Would the netfs helper lib in patches 5-13 here be of use to orangefs? Most of the information about it is on patch 8.
David
Matthew Wilcox
maintainerRe: [PATCH 03/33] mm: Implement readahead_control pageset expansion
In reply to David Howellsinclude/linux/pagemap.h extern void __delete_from_page_cache(struct page *page, void *shadow); · line 765
Quoted 7 lines · David Howells
+++
b/include/linux/pagemap.hinclude/linux/pagemap.h +2
-0@@ -761,6 +761,8 @@ extern void __delete_from_page_cache(struct page *page, void *shadow);int replace_page_cache_page (struct page *old,struct page *new,gfp_t gfp_mask);void delete_from_page_cache_batch (struct address_space *mapping,struct pagevec *pvec); +void readahead_expand (struct readahead_control *ractl, +loff_t new_start,size_t new_len);
If we're revising this patchset, I'd rather this lived with the other readahead declarations, ie after the definition of readahead_control.
Quoted 7 lines
mm/readahead.c +7
-0+/* Expand the trailing edge upwards */ +while (ractl->_nr_pages < new_nr_pages) { +unsigned long index = ractl->_index + ractl->_nr_pages; +struct page *page =xa_load (&mapping->i_pages, index); + +if (page && !xa_is_value (page)) +return ;/* Page apparently present */
mm/readahead.c SYSCALL_DEFINE3(readahead, int, fd, loff_t, offset, size_t, count) · line 708
Quoted 10 lines
mm/readahead.c +10
-0+ + page =__page_cache_alloc (gfp_mask); +if (!page) +return ; +if (add_to_page_cache_lru (page, mapping, index, gfp_mask) <0 ) { +put_page (page); +return ; + } + ractl->_nr_pages++; + }
We're defeating the ondemand_readahead() algorithm here. Let's suppose userspace is doing 64kB reads, the filesystem is OrangeFS which only wants to do 4MB reads, the page cache is initially empty and there's only one thread doing a sequential read. ondemand_readahead() calls get_init_ra_size() which tells it to allocate 128kB and set the async marker at 64kB. Then orangefs calls readahead_expand() to allocate the remainder of the 4MB. After the app has read the first 64kB, it comes back to read the next 64kB, sees the readahead marker and tries to trigger the next batch of readahead, but it's already present, so it does nothing (see page_cache_ra_unbounded() for what happens with pages present).
Then it keeps going through the 4MB that's been read, not seeing any more readahead markers, gets to 4MB and asks for ... 256kB? Not quite sure. Anyway, it then has to wait for the next 4MB because the readahead didn't overlap with the application processing.
So readahead_expand() needs to adjust the file's f_ra so that when the application gets to 64kB, it kicks off the readahead of 4MB-8MB chunk (and then when we get to 4MB+256kB, it kicks off the readahead of 8MB-12MB, and so on).
Unless someone sees a better way to do this? I don't want to inadvertently break POSIX_FADV_WILLNEED which calls force_page_cache_readahead() and should not perturb the kernel's ondemand algorithm. Perhaps we need to add an 'ra' pointer to the ractl to indicate whether the file_ra_state should be updated by readahead_expand()?
David Howells
maintainerRe: [PATCH 03/33] mm: Implement readahead_control pageset expansion
Quoted 10 lines · Matthew Wilcox
We're defeating the
ondemand_readahead()algorithm here. Let's suppose userspace is doing 64kB reads, the filesystem is OrangeFS which only wants to do 4MB reads, the page cache is initially empty and there's only one thread doing a sequential read.ondemand_readahead()callsget_init_ra_size()which tells it to allocate 128kB and set the async marker at 64kB. Then orangefs callsreadahead_expand()to allocate the remainder of the 4MB. After the app has read the first 64kB, it comes back to read the next 64kB, sees the readahead marker and tries to trigger the next batch of readahead, but it's already present, so it does nothing (seepage_cache_ra_unbounded()for what happens with pages present).
It sounds like Christoph is right on the right track and the vm needs to ask the filesystem (and by extension, the cache) before doing the allocation and before setting the trigger flag. Then we don't need to call back into the vm to expand the readahead.
Also, there's Steve's request to try and keep at least two requests in flight for CIFS/SMB at the same time to consider.
David
Matthew Wilcox
maintainerRe: [PATCH 03/33] mm: Implement readahead_control pageset expansion
Quoted 13 lines · David Howells
Quoted 10 lines · Matthew Wilcox
We're defeating the
ondemand_readahead()algorithm here. Let's suppose userspace is doing 64kB reads, the filesystem is OrangeFS which only wants to do 4MB reads, the page cache is initially empty and there's only one thread doing a sequential read.ondemand_readahead()callsget_init_ra_size()which tells it to allocate 128kB and set the async marker at 64kB. Then orangefs callsreadahead_expand()to allocate the remainder of the 4MB. After the app has read the first 64kB, it comes back to read the next 64kB, sees the readahead marker and tries to trigger the next batch of readahead, but it's already present, so it does nothing (seepage_cache_ra_unbounded()for what happens with pages present).
Quoted 4 lines
It sounds like Christoph is right on the right track and the vm needs to ask the filesystem (and by extension, the cache) before doing the allocation and before setting the trigger flag. Then we don't need to call back into the vm to expand the readahead.
Doesn't work. You could read my reply to Christoph, or try to figure out how to get rid of
https://evilpiepirate.org/git/bcachefs.git/tree/fs/bcachefs/fs-io.c#n742
for yourself.
Quoted 2 lines
Also, there's Steve's request to try and keep at least two requests in flight for CIFS/SMB at the same time to consider.
That's not relevant to this problem.
David Howells
maintainerRe: [PATCH 03/33] mm: Implement readahead_control pageset expansion
In reply to Matthew WilcoxQuoted 4 lines · Matthew Wilcox
So
readahead_expand()needs to adjust the file'sf_raso that when the application gets to 64kB, it kicks off the readahead of 4MB-8MB chunk (and then when we get to 4MB+256kB, it kicks off the readahead of 8MB-12MB, and so on).
Ummm... Two questions:
Firstly, how do I do that? Set ->async_size? And to what? The expansion could be 2MB from a ceph stripe, 256k from the cache. Just to add to the fun, the leading edge of the window might also be rounded downwards and the RA trigger could be before where the app is going to start reading.
Secondly, what happens if, say, a 4MB read is covered by a single 4MB THP?
David
David Howells
maintainerPATCH 4/33 vfs: Export rw_verify_area() for use by cachefiles
In reply to David HowellsExport rw_verify_area() for so that cachefiles can use it before issuing call_read_iter() and call_write_iter() to effect async DIO operations against the cache. This is analogous to aio_read() and aio_write().
---
fs/internal.h | 5 ----- fs/read_write.c | 1 + include/linux/fs.h | 1 + 3 files changed, 2 insertions(+), 5 deletions(-)
fs/internal.h +0 -5
@@ -164,11 +164,6 @@ extern char *simple_dname(struct dentry *, char *, int);extern void dput_to_list (struct dentry *,struct list_head *);extern void shrink_dentry_list (struct list_head *); -/* -* read_write.c -*/ -extern int rw_verify_area (int ,struct file *,const loff_t *,size_t ); -/* * pipe.c */
fs/read_write.c +1 -0
@@ -400,6 +400,7 @@ int rw_verify_area(int read_write, struct file *file, const loff_t *ppos, size_treturn security_file_permission (file, read_write ==READ ?MAY_READ :MAY_WRITE ); } +EXPORT_SYMBOL (rw_verify_area);static ssize_t new_sync_read (struct file *filp,char __user *buf,size_t len,loff_t *ppos) {
include/linux/fs.h +1 -0
@@ -2760,6 +2760,7 @@ extern int notify_change(struct dentry *, struct iattr *, struct inode **);extern int inode_permission (struct inode *,int );extern int generic_permission (struct inode *,int );extern int __check_sticky (struct inode *dir,struct inode *inode); +extern int rw_verify_area (int ,struct file *,const loff_t *,size_t );static inline bool execute_ok (struct inode *inode) {
Re: [PATCH 04/33] vfs: Export rw_verify_area() for use by cachefiles
Quoted 3 lines · David Howells
Export
rw_verify_area()for so that cachefiles can use it before issuingcall_read_iter()andcall_write_iter()to effect async DIO operations against the cache. This is analogous toaio_read()andaio_write().
I don't think this is the right thing to do. Instead of calling into ->read_iter / ->write_iter directly this should be using helpers.
What prevents you from using vfs_iocb_iter_read and vfs_iocb_iter_write which seem the right level of abstraction for this?
David Howells
maintainerRe: [PATCH 04/33] vfs: Export rw_verify_area() for use by cachefiles
Quoted 9 lines · Christoph Hellwig
Quoted 3 lines
Export
rw_verify_area()for so that cachefiles can use it before issuingcall_read_iter()andcall_write_iter()to effect async DIO operations against the cache. This is analogous toaio_read()andaio_write().I don't think this is the right thing to do. Instead of calling into ->read_iter / ->write_iter directly this should be using helpers.
What prevents you from using
vfs_iocb_iter_readandvfs_iocb_iter_writewhich seem the right level of abstraction for this?
I don't think they existed when I wrote this code. Should aio use that too, btw? I modelled my code on aio_read() and aio_write().
But I can certainly switch to using vfs_iocb_iter_read/write, though the trivial checks are redundant. The fsnotify call, I guess I'm missing though (and is that missing in aio_read/write() also?).
David
David Howells
maintainerPATCH 5/33 netfs: Make a netfs helper module
In reply to David HowellsMake a netfs helper module to manage read request segmentation, caching support and transparent huge page support on behalf of a network filesystem.
---
fs/netfs/Kconfig | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 fs/netfs/Kconfig
fs/netfs/Kconfig new file +8 -0
@@ -0,0 +1,8 @@ +# SPDX-License-Identifier: GPL-2.0-only + +config NETFS_SUPPORT + tristate "Support for network filesystem high-level I/O" + help + This option enables support for network filesystems, including + helpers for high-level buffered I/O, abstracting out read + segmentation, local caching and transparent huge page support.
David Howells
maintainerPATCH 6/33 netfs, mm: Move PG_fscache helper funcs to linux/netfs.h
In reply to David HowellsMove the PG_fscache related helper funcs (such as SetPageFsCache()) to linux/netfs.h rather than linux/fscache.h as the intention is to move to a model where they're used by the network filesystem and the helper library, but not by fscache/cachefiles itself.
---
include/linux/fscache.h | 11 +---------- include/linux/netfs.h | 25 +++++++++++++++++++++++++ 2 files changed, 26 insertions(+), 10 deletions(-) create mode 100644 include/linux/netfs.h
include/linux/fscache.h +1 -10
@@ -19,6 +19,7 @@#include <linux/pagemap.h> #include <linux/pagevec.h> #include <linux/list_bl.h> +#include <linux/netfs.h> #if defined(CONFIG_FSCACHE ) || defined(CONFIG_FSCACHE_MODULE )#define fscache_available () (1)
@@ -29,16 +30,6 @@#endif -/* -* overload PG_private_2 to give us PG_fscache - this is used to indicate that -* a page is currently backed by a local disk cache -*/ -#define PageFsCache (page) PagePrivate2((page)) -#define SetPageFsCache (page) SetPagePrivate2((page)) -#define ClearPageFsCache (page) ClearPagePrivate2((page)) -#define TestSetPageFsCache (page) TestSetPagePrivate2((page)) -#define TestClearPageFsCache (page) TestClearPagePrivate2((page)) -/* pattern used to fill dead space in an index entry */ #define FSCACHE_INDEX_DEADFILL_PATTERN 0x79
include/linux/netfs.h new file +25 -0
@@ -0,0 +1,25 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* Network filesystem support services. +* +* Copyright (C) 2021 Red Hat, Inc. All Rights Reserved. +* Written by David Howells ([email protected]) +* +* for a description of the network filesystem interface declared here. +*/ + +#ifndef _LINUX_NETFS_H +#define _LINUX_NETFS_H + +#include <linux/pagemap.h> + +/* +* Overload PG_private_2 to give us PG_fscache - this is used to indicate that +* a page is currently backed by a local disk cache +*/ +#define PageFsCache (page) PagePrivate2((page)) +#define SetPageFsCache (page) SetPagePrivate2((page)) +#define ClearPageFsCache (page) ClearPagePrivate2((page)) +#define TestSetPageFsCache (page) TestSetPagePrivate2((page)) +#define TestClearPageFsCache (page) TestClearPagePrivate2((page)) + +#endif /* _LINUX_NETFS_H */
David Howells
maintainerPATCH 7/33 netfs, mm: Add unlock_page_fscache() and wait_on_page_fscache()
In reply to David HowellsAdd unlock_page_fscache() as an alias of unlock_page_private_2(). This allows a page 'locked' with PG_fscache to be unlocked.
Add wait_on_page_fscache() to wait for PG_fscache to be unlocked.
[Linus suggested putting the fscache-themed functions into the
caching-specific headers rather than pagemap.h]
---
include/linux/netfs.h | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+)
include/linux/netfs.h +29 -0
@@ -22,4 +22,33 @@#define TestSetPageFsCache (page) TestSetPagePrivate2((page))#define TestClearPageFsCache (page) TestClearPagePrivate2((page)) +/** +* unlock_page_fscache - Unlock a page that's locked with PG_fscache +* @page: The page +* +* Unlocks a page that's locked with PG_fscache and wakes up sleepers in +* wait_on_page_fscache(). This page bit is used by the netfs helpers when a +* netfs page is being written to a local disk cache, thereby allowing writes +* to the cache for the same page to be serialised. +*/ +static inline void unlock_page_fscache (struct page *page) +{ +unlock_page_private_2 (page); +} + +/** +* wait_on_page_fscache - Wait for PG_fscache to be cleared on a page +* @page: The page +* +* Wait for the PG_fscache (PG_private_2) page bit to be removed from a page. +* This is, for example, used to handle a netfs page being written to a local +* disk cache, thereby allowing writes to the cache for the same page to be +* serialised. +*/ +static inline void wait_on_page_fscache (struct page *page) +{ +if (PageFsCache (page)) +wait_on_page_bit (compound_head (page), PG_fscache); +} +#endif /* _LINUX_NETFS_H */
David Howells
maintainerPATCH 8/33 netfs: Provide readahead and readpage netfs helpers
In reply to David HowellsAdd a pair of helper functions:
(*) netfs_readahead()
(*) netfs_readpage()
to do the work of handling a readahead or a readpage, where the page(s) that form part of the request may be split between the local cache, the server or just require clearing, and may be single pages and transparent huge pages. This is all handled within the helper.
Note that while both will read from the cache if there is data present, only netfs_readahead() will expand the request beyond what it was asked to do, and only netfs_readahead() will write back to the cache.
netfs_readpage(), on the other hand, is synchronous and only fetches the page (which might be a THP) it is asked for.
The netfs gives the helper parameters from the VM, the cache cookie it wants to use (or NULL) and a table of operations (only one of which is mandatory):
(*) expand_readahead() [optional]
Called to allow the netfs to request an expansion of a readahead request to meet its own alignment requirements. This is done by changing rreq->start and rreq->len.
(*) clamp_length() [optional]
Called to allow the netfs to cut down a subrequest to meet its own boundary requirements. If it does this, the helper will generate additional subrequests until the full request is satisfied.
(*) is_still_valid() [optional]
Called to find out if the data just read from the cache has been invalidated and must be reread from the server.
(*) issue_op() [required]
Called to ask the netfs to issue a read to the server. The subrequest describes the read. The read request holds information about the file being accessed.
The netfs can cache information in rreq->netfs_priv.
Upon completion, the netfs should set the error, transferred and can also set FSCACHE_SREQ_CLEAR_TAIL and then call fscache_subreq_terminated().
(*) done() [optional]
Called after the pages have been unlocked. The read request is still pinning the file and mapping and may still be pinning pages with PG_fscache. rreq->error indicates any error that has been accumulated.
(*) cleanup() [optional]
Called when the helper is disposing of a finished read request. This allows the netfs to clear rreq->netfs_priv.
Netfs support is enabled with CONFIG_NETFS_SUPPORT=y. It will be built even if CONFIG_FSCACHE=n and in this case much of it should be optimised away, allowing the filesystem to use it even when caching is disabled.
changes:
- Folded in a kerneldoc comment fix
- Folded in a fix for the error handling in the case that ENOMEM occurs.
---
fs/Kconfig | 1 fs/Makefile | 1 fs/netfs/Makefile | 6 fs/netfs/internal.h | 61 ++++ fs/netfs/read_helper.c | 717 ++++++++++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 82 +++++ 6 files changed, 868 insertions(+) create mode 100644 fs/netfs/Makefile create mode 100644 fs/netfs/internal.h create mode 100644 fs/netfs/read_helper.c
fs/Kconfig +1 -0
@@ -125,6 +125,7 @@ source "fs/overlayfs/Kconfig" menu "Caches" +source "fs/netfs/Kconfig" source "fs/fscache/Kconfig" source "fs/cachefiles/Kconfig"
fs/Makefile +1 -0
@@ -68,6 +68,7 @@ obj-$(CONFIG_PROFILING) += dcookies.o obj-$(CONFIG_DLM) += dlm/ # Do not add any filesystems before this line +obj-$(CONFIG_NETFS_SUPPORT) += netfs/ obj-$(CONFIG_FSCACHE) += fscache/ obj-$(CONFIG_REISERFS_FS) += reiserfs/ obj-$(CONFIG_EXT4_FS) += ext4/
fs/netfs/Makefile new file +6 -0
@@ -0,0 +1,6 @@ +# SPDX-License-Identifier: GPL-2.0 + +netfs-y := \ + read_helper.o + +obj-$(CONFIG_NETFS_SUPPORT) := netfs.o
fs/netfs/internal.h new file +61 -0
61 lines not on this page · raw message
fs/netfs/read_helper.c new file +717 -0
717 lines not on this page · raw message
include/linux/netfs.h +82 -0
92 lines not on this page · raw message
David Howells
maintainerPATCH 9/33 netfs: Add tracepoints
In reply to David HowellsAdd three tracepoints to track the activity of the read helpers:
(1) netfs/netfs_read
This logs entry to the read helpers and also expansion of the range in a readahead request.
(2) netfs/netfs_rreq
This logs the progress of netfs_read_request objects which track read requests. A read request may be a compound of multiple subrequests.
(3) netfs/netfs_sreq
This logs the progress of netfs_read_subrequest objects, which track the contributions from various sources to a read request.
---
fs/netfs/read_helper.c | 28 ++++++ include/linux/netfs.h | 2 include/trace/events/netfs.h | 199 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 229 insertions(+) create mode 100644 include/trace/events/netfs.h
fs/netfs/read_helper.c +28 -0
@@ -16,6 +16,8 @@#include <linux/task_io_accounting_ops.h> #include <linux/netfs.h> #include "internal.h" +#define CREATE_TRACE_POINTS +#include <trace/events/netfs.h> MODULE_DESCRIPTION ("Network fs support" );MODULE_AUTHOR ("Red Hat, Inc." );
@@ -38,6 +40,7 @@ static struct netfs_read_request *netfs_alloc_read_request( const struct netfs_read_request_ops *ops, void *netfs_priv, struct file *file) { + static atomic_t debug_ids;struct netfs_read_request *rreq; rreq =kzalloc (sizeof (struct netfs_read_request ),GFP_KERNEL );
@@ -46,6 +49,7 @@ static struct netfs_read_request *netfs_alloc_read_request( rreq->netfs_priv = netfs_priv; rreq->inode =file_inode (file); rreq->i_size =i_size_read (rreq->inode); + rreq->debug_id =atomic_inc_return (&debug_ids);INIT_LIST_HEAD (&rreq->subrequests);INIT_WORK (&rreq->work, netfs_rreq_work);refcount_set (&rreq->usage,1 );
@@ -80,6 +84,7 @@ static void netfs_free_read_request(struct work_struct *work)netfs_rreq_clear_subreqs (rreq);if (rreq->netfs_priv) rreq->netfs_ops->cleanup (rreq->mapping, rreq->netfs_priv); +trace_netfs_rreq (rreq, netfs_rreq_trace_free);kfree (rreq); }
@@ -122,6 +127,7 @@ static void netfs_get_read_subrequest(struct netfs_read_subrequest *subreq)static void __netfs_put_subrequest (struct netfs_read_subrequest *subreq) { +trace_netfs_sreq (subreq, netfs_sreq_trace_free);netfs_put_read_request (subreq->rreq);kfree (subreq); }
@@ -176,6 +182,7 @@ static void netfs_read_from_server(struct netfs_read_request *rreq,*/ static void netfs_rreq_completed (struct netfs_read_request *rreq) { +trace_netfs_rreq (rreq, netfs_rreq_trace_done);netfs_rreq_clear_subreqs (rreq);netfs_put_read_request (rreq); }
@@ -214,6 +221,8 @@ static void netfs_rreq_unlock(struct netfs_read_request *rreq) iopos =0 ; subreq_failed = (subreq->error <0 ); +trace_netfs_rreq (rreq, netfs_rreq_trace_unlock); +rcu_read_lock ();xas_for_each (&xas, page, last_page) {unsigned int pgpos = (page->index - start_page) *PAGE_SIZE ;
@@ -274,6 +283,8 @@ static void netfs_rreq_short_read(struct netfs_read_request *rreq,__clear_bit (NETFS_SREQ_SHORT_READ , &subreq->flags);__set_bit (NETFS_SREQ_SEEK_DATA_READ , &subreq->flags); +trace_netfs_sreq (subreq, netfs_sreq_trace_resubmit_short); +netfs_get_read_subrequest (subreq);atomic_inc (&rreq->nr_rd_ops);netfs_read_from_server (rreq, subreq);
@@ -289,6 +300,8 @@ static bool netfs_rreq_perform_resubmissions(struct netfs_read_request *rreq)WARN_ON (in_softirq ()); +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. */
@@ -301,6 +314,7 @@ static bool netfs_rreq_perform_resubmissions(struct netfs_read_request *rreq)break ; subreq->source =NETFS_DOWNLOAD_FROM_SERVER ; subreq->error =0 ; +trace_netfs_sreq (subreq, netfs_sreq_trace_download_instead);netfs_get_read_subrequest (subreq);atomic_inc (&rreq->nr_rd_ops);netfs_read_from_server (rreq, subreq);
@@ -325,6 +339,8 @@ static bool netfs_rreq_perform_resubmissions(struct netfs_read_request *rreq)*/ static void netfs_rreq_assess (struct netfs_read_request *rreq) { +trace_netfs_rreq (rreq, netfs_rreq_trace_assess); + again:if (!test_bit (NETFS_RREQ_FAILED , &rreq->flags) &&test_bit (NETFS_RREQ_INCOMPLETE_IO , &rreq->flags)) {
@@ -409,6 +425,8 @@ void netfs_subreq_terminated(struct netfs_read_subrequest *subreq,set_bit (NETFS_RREQ_WRITE_TO_CACHE , &rreq->flags); out: +trace_netfs_sreq (subreq, netfs_sreq_trace_terminated); +/* If we decrement nr_rd_ops to 0, the ref belongs to us. */ u =atomic_dec_return (&rreq->nr_rd_ops);if (u ==0 )
@@ -497,6 +515,7 @@ netfs_rreq_prepare_read(struct netfs_read_request *rreq, out: subreq->source = source; +trace_netfs_sreq (subreq, netfs_sreq_trace_prepare);return source; }
@@ -536,6 +555,7 @@ static bool netfs_rreq_submit_slice(struct netfs_read_request *rreq, 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);
@@ -578,6 +598,9 @@ static void netfs_rreq_expand(struct netfs_read_request *rreq,readahead_expand (ractl, rreq->start, rreq->len); rreq->start =readahead_pos (ractl); rreq->len =readahead_length (ractl); + +trace_netfs_read (rreq,readahead_pos (ractl),readahead_length (ractl), + netfs_read_trace_expanded); } }
@@ -619,6 +642,9 @@ void netfs_readahead(struct readahead_control *ractl, rreq->start =readahead_pos (ractl); rreq->len =readahead_length (ractl); +trace_netfs_read (rreq,readahead_pos (ractl),readahead_length (ractl), + netfs_read_trace_readahead); +netfs_rreq_expand (rreq, ractl);atomic_set (&rreq->nr_rd_ops,1 );
@@ -690,6 +716,8 @@ int netfs_readpage(struct file *file, rreq->start = page->index *PAGE_SIZE ; rreq->len =thp_size (page); +trace_netfs_read (rreq, rreq->start, rreq->len, netfs_read_trace_readpage); +netfs_get_read_request (rreq);atomic_set (&rreq->nr_rd_ops,1 );
include/linux/netfs.h +2 -0
@@ -91,6 +91,8 @@ struct netfs_read_request {struct address_space *mapping;/* The mapping being accessed */ struct list_head subrequests;/* Requests to fetch I/O from disk or net */ void *netfs_priv;/* Private data for the netfs */ +unsigned int debug_id; +unsigned int cookie_debug_id;atomic_t nr_rd_ops;/* Number of read ops in progress */ size_t submitted;/* Amount submitted for I/O so far */ size_t len;/* Length of the request */
include/trace/events/netfs.h new file +199 -0
199 lines not on this page · raw message
David Howells
maintainerPATCH 10/33 netfs: Gather stats
In reply to David HowellsGather statistics from the netfs interface that can be exported through a seqfile. This is intended to be called by a later patch when viewing /proc/fs/fscache/stats.
---
fs/netfs/Kconfig | 15 +++++++++++++ fs/netfs/Makefile | 3 +-- fs/netfs/internal.h | 34 ++++++++++++++++++++++++++++++ fs/netfs/read_helper.c | 23 ++++++++++++++++++++ fs/netfs/stats.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 1 + 6 files changed, 128 insertions(+), 2 deletions(-) create mode 100644 fs/netfs/stats.c
fs/netfs/Kconfig +15 -0
@@ -6,3 +6,18 @@ config NETFS_SUPPORT This option enables support for network filesystems, including helpers for high-level buffered I/O, abstracting out read segmentation, local caching and transparent huge page support. + +config NETFS_STATS + bool "Gather statistical information on local caching" + depends on NETFS_SUPPORT && PROC_FS + help + This option causes statistical information to be gathered on local + caching and exported through file: + + /proc/fs/fscache/stats + + The gathering of statistics adds a certain amount of overhead to + execution as there are a quite a few stats gathered, and on a + multi-CPU system these may be on cachelines that keep bouncing + between CPUs. On the other hand, the stats are very useful for + debugging purposes. Saying 'Y' here is recommended.
fs/netfs/Makefile +1 -2
@@ -1,6 +1,5 @@ # SPDX-License-Identifier: GPL-2.0 -netfs-y := \ - read_helper.o +netfs-y := read_helper.o stats.o obj-$(CONFIG_NETFS_SUPPORT) := netfs.o
fs/netfs/internal.h +34 -0
@@ -16,8 +16,42 @@*/ extern unsigned int netfs_debug; +/* +* stats.c +*/ +#ifdef CONFIG_NETFS_STATS +extern atomic_t netfs_n_rh_readahead; +extern atomic_t netfs_n_rh_readpage; +extern atomic_t netfs_n_rh_rreq; +extern atomic_t netfs_n_rh_sreq; +extern atomic_t netfs_n_rh_download; +extern atomic_t netfs_n_rh_download_done; +extern atomic_t netfs_n_rh_download_failed; +extern atomic_t netfs_n_rh_download_instead; +extern atomic_t netfs_n_rh_read; +extern atomic_t netfs_n_rh_read_done; +extern atomic_t netfs_n_rh_read_failed; +extern atomic_t netfs_n_rh_zero; +extern atomic_t netfs_n_rh_short_read; +extern atomic_t netfs_n_rh_write; +extern atomic_t netfs_n_rh_write_done; +extern atomic_t netfs_n_rh_write_failed; + + +static inline void netfs_stat (atomic_t *stat) +{ +atomic_inc (stat); +} + +static inline void netfs_stat_d (atomic_t *stat) +{ +atomic_dec (stat); +} + +#else #define netfs_stat (x) do {} while(0)#define netfs_stat_d (x) do {} while(0) +#endif /*****************************************************************************/ /*
fs/netfs/read_helper.c +23 -0
@@ -55,6 +55,7 @@ static struct netfs_read_request *netfs_alloc_read_request(refcount_set (&rreq->usage,1 );__set_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags); ops->init_rreq (rreq, file); +netfs_stat (&netfs_n_rh_rreq); }return rreq;
@@ -86,6 +87,7 @@ static void netfs_free_read_request(struct work_struct *work) rreq->netfs_ops->cleanup (rreq->mapping, rreq->netfs_priv);trace_netfs_rreq (rreq, netfs_rreq_trace_free);kfree (rreq); +netfs_stat_d (&netfs_n_rh_rreq); }static void netfs_put_read_request (struct netfs_read_request *rreq)
@@ -115,6 +117,7 @@ static struct netfs_read_subrequest *netfs_alloc_subrequest(refcount_set (&subreq->usage,2 ); subreq->rreq = rreq;netfs_get_read_request (rreq); +netfs_stat (&netfs_n_rh_sreq); }return subreq;
@@ -130,6 +133,7 @@ static void __netfs_put_subrequest(struct netfs_read_subrequest *subreq)trace_netfs_sreq (subreq, netfs_sreq_trace_free);netfs_put_read_request (subreq->rreq);kfree (subreq); +netfs_stat_d (&netfs_n_rh_sreq); }/*
@@ -151,6 +155,7 @@ static void netfs_clear_unread(struct netfs_read_subrequest *subreq)static void netfs_fill_with_zeroes (struct netfs_read_request *rreq,struct netfs_read_subrequest *subreq) { +netfs_stat (&netfs_n_rh_zero);__set_bit (NETFS_SREQ_CLEAR_TAIL , &subreq->flags);netfs_subreq_terminated (subreq,0 ); }
@@ -174,6 +179,7 @@ static void netfs_fill_with_zeroes(struct netfs_read_request *rreq,static void netfs_read_from_server (struct netfs_read_request *rreq,struct netfs_read_subrequest *subreq) { +netfs_stat (&netfs_n_rh_download); rreq->netfs_ops->issue_op (subreq); }
@@ -283,6 +289,7 @@ static void netfs_rreq_short_read(struct netfs_read_request *rreq,__clear_bit (NETFS_SREQ_SHORT_READ , &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_read_subrequest (subreq);
@@ -314,6 +321,7 @@ static bool netfs_rreq_perform_resubmissions(struct netfs_read_request *rreq)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_read_subrequest (subreq);atomic_inc (&rreq->nr_rd_ops);
@@ -406,6 +414,17 @@ void netfs_subreq_terminated(struct netfs_read_subrequest *subreq, 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; goto failed;
@@ -459,8 +478,10 @@ void netfs_subreq_terminated(struct netfs_read_subrequest *subreq, 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; }
@@ -642,6 +663,7 @@ void netfs_readahead(struct readahead_control *ractl, rreq->start =readahead_pos (ractl); rreq->len =readahead_length (ractl); +netfs_stat (&netfs_n_rh_readahead);trace_netfs_read (rreq,readahead_pos (ractl),readahead_length (ractl), netfs_read_trace_readahead);
@@ -716,6 +738,7 @@ int netfs_readpage(struct file *file, rreq->start = page->index *PAGE_SIZE ; rreq->len =thp_size (page); +netfs_stat (&netfs_n_rh_readpage);trace_netfs_read (rreq, rreq->start, rreq->len, netfs_read_trace_readpage);netfs_get_read_request (rreq);
fs/netfs/stats.c new file +54 -0
54 lines not on this page · raw message
include/linux/netfs.h +1 -0
@@ -134,5 +134,6 @@ extern int netfs_readpage(struct file *, void *);extern void netfs_subreq_terminated (struct netfs_read_subrequest *,ssize_t ); +extern void netfs_stats_show (struct seq_file *);#endif /* _LINUX_NETFS_H */
David Howells
maintainerPATCH 11/33 netfs: Add write_begin helper
In reply to David HowellsAdd a helper to do the pre-reading work for the netfs write_begin address space op.
---
fs/netfs/internal.h | 2 + fs/netfs/read_helper.c | 165 ++++++++++++++++++++++++++++++++++++++++++ fs/netfs/stats.c | 10 ++- include/linux/netfs.h | 8 ++ include/trace/events/netfs.h | 4 + 5 files changed, 185 insertions(+), 4 deletions(-)
fs/netfs/internal.h +2 -0
@@ -34,8 +34,10 @@ extern atomic_t netfs_n_rh_read_failed;extern atomic_t netfs_n_rh_zero;extern atomic_t netfs_n_rh_short_read;extern atomic_t netfs_n_rh_write; +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;static inline void netfs_stat (atomic_t *stat)
fs/netfs/read_helper.c +165 -0
168 lines not on this page · raw message
fs/netfs/stats.c +7 -3
@@ -24,19 +24,23 @@ atomic_t netfs_n_rh_read_failed;atomic_t netfs_n_rh_zero;atomic_t netfs_n_rh_short_read;atomic_t netfs_n_rh_write; +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;void netfs_stats_show (struct seq_file *m) { -seq_printf (m,"RdHelp : RA=%u RP=%u rr=%u sr=%u\n" , +seq_printf (m,"RdHelp : RA=%u RP=%u WB=%u rr=%u sr=%u\n" ,atomic_read (&netfs_n_rh_readahead),atomic_read (&netfs_n_rh_readpage), +atomic_read (&netfs_n_rh_write_begin),atomic_read (&netfs_n_rh_rreq),atomic_read (&netfs_n_rh_sreq)); -seq_printf (m,"RdHelp : ZR=%u sh=%u\n" , +seq_printf (m,"RdHelp : 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_short_read), +atomic_read (&netfs_n_rh_write_zskip)); seq_printf(m, "RdHelp : DL=%u ds=%u df=%u di=%u\n", atomic_read(&netfs_n_rh_download), atomic_read(&netfs_n_rh_download_done),
include/linux/netfs.h +8 -0
@@ -115,11 +115,14 @@ struct netfs_read_request {* Operations the network filesystem can/must provide to the helpers. */ struct netfs_read_request_ops { +bool (*is_cache_enabled)(struct inode *inode);void (*init_rreq)(struct netfs_read_request *rreq,struct file *file);void (*expand_readahead)(struct netfs_read_request *rreq);bool (*clamp_length)(struct netfs_read_subrequest *subreq);void (*issue_op)(struct netfs_read_subrequest *subreq);bool (*is_still_valid)(struct netfs_read_request *rreq); +int (*check_write_begin)(struct file *file,loff_t pos,unsigned len, +struct page *page,void **_fsdata);void (*done)(struct netfs_read_request *rreq);void (*cleanup)(struct address_space *mapping,void *netfs_priv); };
@@ -132,6 +135,11 @@ extern int netfs_readpage(struct file *, struct page *, const struct netfs_read_request_ops *, void *); +extern int netfs_write_begin (struct file *,struct address_space *, +loff_t ,unsigned int ,unsigned int ,struct page **, +void **, +const struct netfs_read_request_ops *, +void *);extern void netfs_subreq_terminated (struct netfs_read_subrequest *,ssize_t );extern void netfs_stats_show (struct seq_file *);
include/trace/events/netfs.h +3 -1
@@ -22,6 +22,7 @@ enum netfs_read_trace { netfs_read_trace_expanded, netfs_read_trace_readahead, netfs_read_trace_readpage, + netfs_read_trace_write_begin, }; enum netfs_rreq_trace {
@@ -50,7 +51,8 @@ enum netfs_sreq_trace {#define netfs_read_traces \ EM(netfs_read_trace_expanded, "EXPANDED ") \ EM(netfs_read_trace_readahead, "READAHEAD") \ - E_(netfs_read_trace_readpage, "READPAGE ") + EM(netfs_read_trace_readpage, "READPAGE ") \ + E_(netfs_read_trace_write_begin, "WRITEBEGN")#define netfs_rreq_traces \ EM(netfs_rreq_trace_assess, "ASSESS") \
David Howells
maintainerPATCH 12/33 netfs: Define an interface to talk to a cache
In reply to David HowellsAdd an interface to the netfs helper library for reading data from the cache instead of downloading it from the server and support for writing data just downloaded or cleared to the cache.
The API passes an iov_iter to the cache read/write routines to indicate the data/buffer to be used. This is done using the ITER_XARRAY type to provide direct access to the netfs inode's pagecache.
When the netfs's ->begin_cache_operation() method is called, this must fill in the cache_resources in the netfs_read_request struct, including the netfs_cache_ops used by the helper lib to talk to the cache. The helper lib does not directly access the cache.
---
fs/netfs/read_helper.c | 230 +++++++++++++++++++++++++++++++++++++++++ fs/netfs/stats.c | 3 - include/linux/fscache-cache.h | 4 + include/linux/fscache.h | 17 +++ include/linux/netfs.h | 48 +++++++++ 5 files changed, 300 insertions(+), 2 deletions(-)
fs/netfs/read_helper.c +229 -1
@@ -86,6 +86,8 @@ static void netfs_free_read_request(struct work_struct *work)if (rreq->netfs_priv) rreq->netfs_ops->cleanup (rreq->mapping, rreq->netfs_priv);trace_netfs_rreq (rreq, netfs_rreq_trace_free); +if (rreq->cache_resources.ops) + rreq->cache_resources.ops->end_operation (&rreq->cache_resources);kfree (rreq);netfs_stat_d (&netfs_n_rh_rreq); }
@@ -149,6 +151,32 @@ static void netfs_clear_unread(struct netfs_read_subrequest *subreq)iov_iter_zero (iov_iter_count (&iter), &iter); } +static void netfs_cache_read_terminated (void *priv,ssize_t transferred_or_error) +{ +struct netfs_read_subrequest *subreq = priv; + +netfs_subreq_terminated (subreq, transferred_or_error); +} + +/* +* Issue a read against the cache. +* - Eats the caller's ref on subreq. +*/ +static void netfs_read_from_cache (struct netfs_read_request *rreq, +struct netfs_read_subrequest *subreq, +bool seek_data) +{ +struct netfs_cache_resources *cres = &rreq->cache_resources; +struct iov_iter iter; + +iov_iter_xarray (&iter,READ , &rreq->mapping->i_pages, + subreq->start + subreq->transferred, + subreq->len - subreq->transferred); + + cres->ops->read (cres, subreq->start, &iter, seek_data, + netfs_cache_read_terminated, subreq); +} +/* * Fill a subrequest region with zeroes. */
@@ -193,6 +221,141 @@ static void netfs_rreq_completed(struct netfs_read_request *rreq)netfs_put_read_request (rreq); } +/* +* Deal with the completion of writing the data to the cache. We have to clear +* the PG_fscache bits on the pages involved and release the caller's ref. +* +* May be called in softirq mode and we inherit a ref from the caller. +*/ +static void netfs_rreq_unmark_after_write (struct netfs_read_request *rreq) +{ +struct netfs_read_subrequest *subreq; +struct page *page; +pgoff_t unlocked =0 ; +bool have_unlocked = false; + +rcu_read_lock (); + +list_for_each_entry (subreq, &rreq->subrequests, rreq_link) { +XA_STATE (xas, &rreq->mapping->i_pages, subreq->start /PAGE_SIZE ); + +xas_for_each (&xas, page, (subreq->start + subreq->len -1 ) /PAGE_SIZE ) { +/* We might have multiple writes from the same huge +* page, but we mustn't unlock a page more than once. +*/ +if (have_unlocked && page->index <= unlocked) +continue ; + unlocked = page->index; +unlock_page_fscache (page); + have_unlocked = true; + } + } + +rcu_read_unlock (); +netfs_rreq_completed (rreq); +} + +static void netfs_rreq_copy_terminated (void *priv,ssize_t transferred_or_error) +{ +struct netfs_read_subrequest *subreq = priv; +struct netfs_read_request *rreq = subreq->rreq; + +if (IS_ERR_VALUE (transferred_or_error)) { + subreq->error = transferred_or_error; +netfs_stat (&netfs_n_rh_write_failed); + }else { + subreq->error =0 ; +netfs_stat (&netfs_n_rh_write_done); + } + +trace_netfs_sreq (subreq, netfs_sreq_trace_write_term); + +/* If we decrement nr_wr_ops to 0, the ref belongs to us. */ +if (atomic_dec_and_test (&rreq->nr_wr_ops)) +netfs_rreq_unmark_after_write (rreq); + +netfs_put_subrequest (subreq); +} + +/* +* Perform any outstanding writes to the cache. We inherit a ref from the +* caller. +*/ +static void netfs_rreq_do_write_to_cache (struct netfs_read_request *rreq) +{ +struct netfs_cache_resources *cres = &rreq->cache_resources; +struct netfs_read_subrequest *subreq, *next, *p; +struct iov_iter iter; +loff_t pos; + +trace_netfs_rreq (rreq, netfs_rreq_trace_write); + +/* We don't want terminating writes trying to wake us up whilst we're +* still going through the list. +*/ +atomic_inc (&rreq->nr_wr_ops); + +list_for_each_entry_safe (subreq, p, &rreq->subrequests, rreq_link) { +if (!test_bit (NETFS_SREQ_WRITE_TO_CACHE , &subreq->flags)) { +list_del_init (&subreq->rreq_link); +netfs_put_subrequest (subreq); + } + } + +list_for_each_entry (subreq, &rreq->subrequests, rreq_link) { +/* Amalgamate adjacent writes */ + pos =round_down (subreq->start,PAGE_SIZE ); +if (pos != subreq->start) { + subreq->len += subreq->start - pos; + subreq->start = pos; + } + subreq->len =round_up (subreq->len,PAGE_SIZE ); + +while (!list_is_last (&subreq->rreq_link, &rreq->subrequests)) { + next =list_next_entry (subreq, rreq_link); +if (next->start > subreq->start + subreq->len) +break ; + subreq->len += next->len; + subreq->len =round_up (subreq->len,PAGE_SIZE ); +list_del_init (&next->rreq_link); +netfs_put_subrequest (next); + } + +iov_iter_xarray (&iter,WRITE , &rreq->mapping->i_pages, + subreq->start, subreq->len); + +atomic_inc (&rreq->nr_wr_ops); +netfs_stat (&netfs_n_rh_write); +netfs_get_read_subrequest (subreq); +trace_netfs_sreq (subreq, netfs_sreq_trace_write); + cres->ops->write (cres, subreq->start, &iter, + netfs_rreq_copy_terminated, subreq); + } + +/* If we decrement nr_wr_ops to 0, the usage ref belongs to us. */ +if (atomic_dec_and_test (&rreq->nr_wr_ops)) +netfs_rreq_unmark_after_write (rreq); +} + +static void netfs_rreq_write_to_cache_work (struct work_struct *work) +{ +struct netfs_read_request *rreq = + container_of(work, struct netfs_read_request, work); + +netfs_rreq_do_write_to_cache (rreq); +} + +static void netfs_rreq_write_to_cache (struct netfs_read_request *rreq) +{ +if (in_softirq ()) { + rreq->work.func = netfs_rreq_write_to_cache_work; +if (!queue_work (system_unbound_wq, &rreq->work)) +BUG (); + }else { +netfs_rreq_do_write_to_cache (rreq); + } +} +/* * Unlock the pages in a read operation. We need to set PG_fscache on any * pages we're going to write back before we unlock them.
@@ -294,7 +457,10 @@ static void netfs_rreq_short_read(struct netfs_read_request *rreq,netfs_get_read_subrequest (subreq);atomic_inc (&rreq->nr_rd_ops); -netfs_read_from_server (rreq, subreq); +if (subreq->source ==NETFS_READ_FROM_CACHE ) +netfs_read_from_cache (rreq, subreq, true); +else +netfs_read_from_server (rreq, subreq); }/*
@@ -339,6 +505,25 @@ static bool netfs_rreq_perform_resubmissions(struct netfs_read_request *rreq)return false; } +/* +* Check to see if the data read is still valid. +*/ +static void netfs_rreq_is_still_valid (struct netfs_read_request *rreq) +{ +struct netfs_read_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); + } + } +} +/* * Assess the state of a read request and decide what to do next. *
@@ -350,6 +535,8 @@ static void netfs_rreq_assess(struct netfs_read_request *rreq)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))
@@ -362,6 +549,9 @@ static void netfs_rreq_assess(struct netfs_read_request *rreq)clear_bit_unlock (NETFS_RREQ_IN_PROGRESS , &rreq->flags);wake_up_bit (&rreq->flags,NETFS_RREQ_IN_PROGRESS ); +if (test_bit (NETFS_RREQ_WRITE_TO_CACHE , &rreq->flags)) +return netfs_rreq_write_to_cache (rreq); +netfs_rreq_completed (rreq); }
@@ -493,7 +683,10 @@ static enum netfs_read_source netfs_cache_prepare_read(struct netfs_read_subrequ loff_t i_size) {struct netfs_read_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 ;
@@ -584,6 +777,9 @@ static bool netfs_rreq_submit_slice(struct netfs_read_request *rreq,case NETFS_DOWNLOAD_FROM_SERVER :netfs_read_from_server (rreq, subreq);break ; +case NETFS_READ_FROM_CACHE : +netfs_read_from_cache (rreq, subreq, false); +break ;default :BUG (); }
@@ -596,9 +792,23 @@ static bool netfs_rreq_submit_slice(struct netfs_read_request *rreq,return false; } +static void netfs_cache_expand_readahead (struct netfs_read_request *rreq, +loff_t *_start,size_t *_len,loff_t i_size) +{ +struct netfs_cache_resources *cres = &rreq->cache_resources; + +if (cres->ops && cres->ops->expand_readahead) + cres->ops->expand_readahead (cres, _start, _len, i_size); +} +static void netfs_rreq_expand (struct netfs_read_request *rreq,struct readahead_control *ractl) { +/* Give the cache a chance to change the request parameters. The +* resultant request must contain the original region. +*/ +netfs_cache_expand_readahead (rreq, &rreq->start, &rreq->len, rreq->i_size); +/* Give the netfs a chance to change the request parameters. The * resultant request must contain the original region. */
@@ -650,6 +860,7 @@ void netfs_readahead(struct readahead_control *ractl,struct netfs_read_request *rreq;struct page *page;unsigned int debug_index =0 ; +int ret;_enter ("%lx,%x" ,readahead_index (ractl),readahead_count (ractl));
@@ -667,6 +878,11 @@ void netfs_readahead(struct readahead_control *ractl,trace_netfs_read (rreq,readahead_pos (ractl),readahead_length (ractl), netfs_read_trace_readahead); +if (ops->begin_cache_operation) { + ret = ops->begin_cache_operation (rreq); +if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS ) + goto cleanup_free; + }netfs_rreq_expand (rreq, ractl);atomic_set (&rreq->nr_rd_ops,1 );
@@ -692,6 +908,9 @@ void netfs_readahead(struct readahead_control *ractl,netfs_rreq_assess (rreq);return ; +cleanup_free: +netfs_put_read_request (rreq); +return ; cleanup:if (netfs_priv) ops->cleanup (ractl->mapping, netfs_priv);
@@ -741,6 +960,14 @@ int netfs_readpage(struct file *file,netfs_stat (&netfs_n_rh_readpage);trace_netfs_read (rreq, rreq->start, rreq->len, netfs_read_trace_readpage); +if (ops->begin_cache_operation) { + ret = ops->begin_cache_operation (rreq); +if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS ) { +unlock_page (page); + goto out; + } + } +netfs_get_read_request (rreq);atomic_set (&rreq->nr_rd_ops,1 );
@@ -762,6 +989,7 @@ int netfs_readpage(struct file *file, ret = rreq->error;if (ret ==0 && rreq->submitted < rreq->len) ret = -EIO ; +out:netfs_put_read_request (rreq);return ret; }
fs/netfs/stats.c +2 -1
@@ -31,10 +31,11 @@ atomic_t netfs_n_rh_write_zskip;void netfs_stats_show (struct seq_file *m) { -seq_printf (m,"RdHelp : RA=%u RP=%u WB=%u rr=%u sr=%u\n" , +seq_printf (m,"RdHelp : RA=%u RP=%u WB=%u WBZ=%u rr=%u sr=%u\n" ,atomic_read (&netfs_n_rh_readahead),atomic_read (&netfs_n_rh_readpage),atomic_read (&netfs_n_rh_write_begin), +atomic_read (&netfs_n_rh_write_zskip),atomic_read (&netfs_n_rh_rreq),atomic_read (&netfs_n_rh_sreq)); seq_printf(m, "RdHelp : ZR=%u sh=%u sk=%u\n",
include/linux/fscache-cache.h +4 -0
@@ -304,6 +304,10 @@ struct fscache_cache_ops {/* dissociate a cache from all the pages it was backing */ void (*dissociate_pages)(struct fscache_cache *cache); + +/* Begin a read operation for the netfs lib */ +int (*begin_read_operation)(struct netfs_read_request *rreq, +struct fscache_retrieval *op); };extern struct fscache_cookie fscache_fsdef_index;
include/linux/fscache.h +17 -0
@@ -37,6 +37,7 @@ struct pagevec;struct fscache_cache_tag ;struct fscache_cookie ;struct fscache_netfs ; +struct netfs_read_request ; typedef void (*fscache_rw_complete_t)(struct page *page, void *context,
@@ -217,6 +218,7 @@ extern void __fscache_readpages_cancel(struct fscache_cookie *cookie,extern void __fscache_disable_cookie (struct fscache_cookie *,const void *,bool );extern void __fscache_enable_cookie (struct fscache_cookie *,const void *,loff_t ,bool (*)(void *),void *); +extern int __fscache_begin_read_operation (struct netfs_read_request *,struct fscache_cookie *);/** * fscache_register_netfs - Register a filesystem as desiring caching services
@@ -831,4 +833,19 @@ void fscache_enable_cookie(struct fscache_cookie *cookie, can_enable, data); } +/** +* fscache_begin_read_operation - Begin a read operation for the netfs lib +* @rreq: The read request being undertaken +* @cookie: The cookie representing the cache object +*/ +static inline +int fscache_begin_read_operation (struct netfs_read_request *rreq, +struct fscache_cookie *cookie) +{ +if (fscache_cookie_valid (cookie) &&fscache_cookie_enabled (cookie)) +return __fscache_begin_read_operation (rreq, cookie); +else +return -ENOBUFS ; +} +#endif /* _LINUX_FSCACHE_H */
include/linux/netfs.h +48 -0
77 lines not on this page · raw message
David Howells
maintainerPATCH 13/33 netfs: Hold a ref on a page when PG_private_2 is set
In reply to David HowellsTake a reference on a page when PG_private_2 is set and drop it once the bit is unlocked.
---
fs/netfs/read_helper.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-)
fs/netfs/read_helper.c +9 -1
@@ -10,6 +10,7 @@#include <linux/fs.h> #include <linux/mm.h> #include <linux/pagemap.h> +#include <linux/pagevec.h> #include <linux/slab.h> #include <linux/uio.h> #include <linux/sched/mm.h>
@@ -230,10 +231,13 @@ static void netfs_rreq_completed(struct netfs_read_request *rreq)static void netfs_rreq_unmark_after_write (struct netfs_read_request *rreq) {struct netfs_read_subrequest *subreq; +struct pagevec pvec;struct page *page;pgoff_t unlocked =0 ;bool have_unlocked = false; +pagevec_init (&pvec); +rcu_read_lock ();list_for_each_entry (subreq, &rreq->subrequests, rreq_link) {
@@ -247,6 +251,8 @@ static void netfs_rreq_unmark_after_write(struct netfs_read_request *rreq)continue ; unlocked = page->index;unlock_page_fscache (page); +if (pagevec_add (&pvec, page) ==0 ) +pagevec_release (&pvec); have_unlocked = true; } }
@@ -403,8 +409,10 @@ static void netfs_rreq_unlock(struct netfs_read_request *rreq) pg_failed = true;break ; } -if (test_bit (NETFS_SREQ_WRITE_TO_CACHE , &subreq->flags)) +if (test_bit (NETFS_SREQ_WRITE_TO_CACHE , &subreq->flags)) { +get_page (page);SetPageFsCache (page); + } pg_failed |= subreq_failed;if (pgend < iopos + subreq->len)break ;
David Howells
maintainerPATCH 14/33 fscache, cachefiles: Add alternate API to use kiocb for read/write to cache
In reply to David HowellsAdd an alternate API by which the cache can be accessed through a kiocb, doing async DIO, rather than using the current API that tells the cache where all the pages are.
The new API is intended to be used in conjunction with the netfs helper library. A filesystem must pick one or the other and not mix them.
Filesystems wanting to use the new API must #define FSCACHE_USE_NEW_IO_API before #including the header
---
fs/cachefiles/Makefile | 1 fs/cachefiles/interface.c | 5 - fs/cachefiles/internal.h | 9 + fs/cachefiles/rdwr2.c | 412 +++++++++++++++++++++++++++++++++++++++++++++ fs/fscache/Kconfig | 1 fs/fscache/Makefile | 3 fs/fscache/internal.h | 3 fs/fscache/page.c | 2 fs/fscache/page2.c | 117 +++++++++++++ fs/fscache/stats.c | 1 include/linux/fscache.h | 44 +++-- 11 files changed, 578 insertions(+), 20 deletions(-) create mode 100644 fs/cachefiles/rdwr2.c create mode 100644 fs/fscache/page2.c
fs/cachefiles/Makefile +1 -0
@@ -11,6 +11,7 @@ cachefiles-y := \ main.o \ namei.o \ rdwr.o \ + rdwr2.o \ security.o \ xattr.o
fs/cachefiles/interface.c +3 -2
@@ -319,8 +319,8 @@ static void cachefiles_drop_object(struct fscache_object *_object)/* * dispose of a reference to an object */ -static void cachefiles_put_object (struct fscache_object *_object, -enum fscache_obj_ref_trace why) +void cachefiles_put_object (struct fscache_object *_object, +enum fscache_obj_ref_trace why) {struct cachefiles_object *object;struct fscache_cache *cache;
@@ -568,4 +568,5 @@ const struct fscache_cache_ops cachefiles_cache_ops = { .uncache_page = cachefiles_uncache_page, .dissociate_pages = cachefiles_dissociate_pages, .check_consistency = cachefiles_check_consistency, + .begin_read_operation = cachefiles_begin_read_operation, };
fs/cachefiles/internal.h +9 -0
@@ -150,6 +150,9 @@ extern int cachefiles_has_space(struct cachefiles_cache *cache,*/ extern const struct fscache_cache_ops cachefiles_cache_ops; +extern void cachefiles_put_object (struct fscache_object *_object, +enum fscache_obj_ref_trace why); +/* * key.c */
@@ -217,6 +220,12 @@ extern int cachefiles_allocate_pages(struct fscache_retrieval *,extern int cachefiles_write_page (struct fscache_storage *,struct page *);extern void cachefiles_uncache_page (struct fscache_object *,struct page *); +/* +* rdwr2.c +*/ +extern int cachefiles_begin_read_operation (struct netfs_read_request *, +struct fscache_retrieval *); +/* * security.c */
fs/cachefiles/rdwr2.c new file +412 -0
412 lines not on this page · raw message
fs/fscache/Kconfig +1 -0
@@ -2,6 +2,7 @@ config FSCACHE tristate "General filesystem local caching manager" + select NETFS_SUPPORT help This option enables a generic filesystem caching manager that can be used by various network and other filesystems to cache data locally.
fs/fscache/Makefile +2 -1
@@ -11,7 +11,8 @@ fscache-y := \ netfs.o \ object.o \ operation.o \ - page.o + page.o \ + page2.o fscache-$(CONFIG_PROC_FS) += proc.o fscache-$(CONFIG_FSCACHE_STATS) += stats.o
fs/fscache/internal.h +3 -0
@@ -142,6 +142,9 @@ extern int fscache_wait_for_operation_activation(struct fscache_object *, atomic_t *, atomic_t *);extern void fscache_invalidate_writes (struct fscache_cookie *); +extern struct fscache_retrieval *fscache_alloc_retrieval (struct fscache_cookie *, +struct address_space *, +fscache_rw_complete_t ,void *);/* * proc.c
fs/fscache/page.c +1 -1
@@ -299,7 +299,7 @@ static void fscache_release_retrieval_op(struct fscache_operation *_op)/* * allocate a retrieval op */ -static struct fscache_retrieval *fscache_alloc_retrieval( +struct fscache_retrieval *fscache_alloc_retrieval( struct fscache_cookie *cookie, struct address_space *mapping, fscache_rw_complete_t end_io_func,
fs/fscache/page2.c new file +117 -0
117 lines not on this page · raw message
fs/fscache/stats.c +1 -0
@@ -278,5 +278,6 @@ int fscache_stats_show(struct seq_file *m, void *v)atomic_read (&fscache_n_cache_stale_objects),atomic_read (&fscache_n_cache_retired_objects), atomic_read(&fscache_n_cache_culled_objects)); +netfs_stats_show (m);return 0 ; }
include/linux/fscache.h +28 -16
75 lines not on this page · raw message
Re: [PATCH 14/33] fscache, cachefiles: Add alternate API to use kiocb for read/write to cache
Quoted 9 lines · David Howells
Add an alternate API by which the cache can be accessed through a kiocb, doing async DIO, rather than using the current API that tells the cache where all the pages are.
The new API is intended to be used in conjunction with the netfs helper library. A filesystem must pick one or the other and not mix them.
Filesystems wanting to use the new API must #define
FSCACHE_USE_NEW_IO_APIbefore #including the header
What exactly does this ifdef buys us? It seems like the old and new APIs don't even conflict. And if we really need an ifdef I'd rather use that for the old code to make grepping for that easier.
fs/cachefiles/internal.h extern int cachefiles_has_space(struct cachefiles_cache *cache, · line 154
Quoted 2 lines
fs/cachefiles/internal.h +2
-0+extern void cachefiles_put_object (struct fscache_object *_object, +enum fscache_obj_ref_trace why);
No need for the extern here on all the other function prototypes.
fs/cachefiles/rdwr2.c line 49
Quoted 5 lines
fs/cachefiles/rdwr2.c new file +5
-0+if (ki->term_func) { +if (ret <0 ) + ki->term_func (ki->term_func_priv, ret); +else + ki->term_func (ki->term_func_priv, ki->skipped + ret);
Why not simplify:
if (ret > 0) ret += ki->skipped; ki->term_func(ki->term_func_priv, ret);
fs/cachefiles/rdwr2.c line 77
Quoted 3 lines
fs/cachefiles/rdwr2.c new file +3
-0+/* If the caller asked us to seek for data before doing the read, then +* we should do that now. If we find a gap, we fill it with zeros. +*/
FYI, this is not the normal kernel comment style..
fs/cachefiles/rdwr2.c line 129
Quoted 9 lines
fs/cachefiles/rdwr2.c new file +9
-0+ ret =rw_verify_area (READ , file, &ki->iocb.ki_pos, len - skipped); +if (ret <0 ) + goto presubmission_error_free; + +get_file (ki->iocb.ki_filp); + + old_nofs =memalloc_nofs_save (); + ret =call_read_iter (file, &ki->iocb, iter); +memalloc_nofs_restore (old_nofs);
As mentioned before I think all this magic belongs in to a helper in the VFS.
fs/cachefiles/rdwr2.c line 367
Quoted 7 lines
fs/cachefiles/rdwr2.c new file +7
-0+static const struct netfs_cache_ops cachefiles_netfs_cache_ops = { + .end_operation = cachefiles_end_operation, + .read = cachefiles_read, + .write = cachefiles_write, + .expand_readahead =NULL , + .prepare_read = cachefiles_prepare_read, +};
No need to set any member in a static allocated structure to zero.
Also at least in linux-next ->read and ->write seem to never actually be called.
Quoted 7 lines
fs/cachefiles/rdwr2.c new file +7
-0+{ +struct cachefiles_object *object; +struct cachefiles_cache *cache; +struct path path; +struct file *file; + +_enter ("" );
fs/cachefiles/rdwr2.c line 390
Quoted 10 lines
fs/cachefiles/rdwr2.c new file +10
-0+ + object =container_of (op->op.object, + struct cachefiles_object, fscache); + cache =container_of (object->fscache.cache, + struct cachefiles_cache, cache); + + path.mnt = cache->mnt; + path.dentry = object->backer; + file =open_with_fake_path (&path,O_RDWR |O_LARGEFILE |O_DIRECT , +d_inode (object->backer), cache->cache_cred);
I think this should be plain old dentry_open?
fs/fscache/internal.h extern int fscache_wait_for_operation_activation(struct fscache_object *, · line 147
Quoted 3 lines
fs/fscache/internal.h +3
-0+extern struct fscache_retrieval *fscache_alloc_retrieval (struct fscache_cookie *, +struct address_space *, +fscache_rw_complete_t ,void *);
No need for the extern. And no need to indent the parameters totally out sight, a single tab should be enough. And it's always nice to spell out the parameter names.
fs/fscache/page2.c line 55
Quoted 4 lines
fs/fscache/page2.c new file +4
-0+ op =fscache_alloc_retrieval (cookie,NULL ,NULL ,NULL ); +if (!op) +return -ENOMEM ; +//atomic_set(&op->n_pages, 1);
???
include/linux/fscache.h int fscache_reserve_space(struct fscache_cookie *cookie, loff_t size) · line 517
Quoted 2 lines
include/linux/fscache.h +2
-0+static inline +int fscache_begin_read_operation(struct netfs_read_request *rreq,
Normal kernel style is to have the static and the inline on the same line as the return type.
include/linux/fscache.h int fscache_reserve_space(struct fscache_cookie *cookie, loff_t size) · line 524
Quoted 7 lines
include/linux/fscache.h +7
-0+ struct fscache_cookie *cookie) +{ +if (fscache_cookie_valid (cookie) &&fscache_cookie_enabled (cookie)) +return __fscache_begin_read_operation (rreq, cookie); +else +return -ENOBUFS ; +}
No need for an else after a return. I personally also prefer to always handle the error case first, ala:
if (!fscache_cookie_valid(cookie) || !fscache_cookie_enabled(cookie)) return -ENOBUFS; return __fscache_begin_read_operation(rreq, cookie);
Also do we really need this inline fast path to start with?
David Howells
maintainerRe: [PATCH 14/33] fscache, cachefiles: Add alternate API to use kiocb for read/write to cache
Quoted 5 lines · Christoph Hellwig
Quoted 2 lines
Filesystems wanting to use the new API must #define
FSCACHE_USE_NEW_IO_APIbefore #including the headerWhat exactly does this ifdef buys us? It seems like the old and new APIs don't even conflict.
I was asked to add this. The APIs look like they don't conflict, but you can't mix them for a given file because of the differing behaviour of the PG_fscache flag. It also makes it much easier to make sure you don't miss something. That has happened and it led to some strange effects before we worked out what was going on.
Quoted 2 lines
And if we really need an ifdef I'd rather use that for the old code to make grepping for that easier.
I can do it that way - but this doesn't require changing filesystems that aren't being changed. The intent would be to eliminate the #ifdef in a cycle or two anyway.
Besides, there are 5 filesystems that use this, and two of them are converted here. grep would only return three hits: one each in fs/9p/cache.h, fs/cifs/fscache.h and fs/nfs/fscache.h.
OTOH, I suppose it might dissuade people from adding new usages of the old API.
Quoted 11 lines
fs/cachefiles/rdwr2.c line 49
Quoted 5 lines
fs/cachefiles/rdwr2.c new file +5
-0+if (ki->term_func) { +if (ret <0 ) + ki->term_func (ki->term_func_priv, ret); +else + ki->term_func (ki->term_func_priv, ki->skipped + ret);Why not simplify:
if (ret > 0) ret += ki->skipped; ki->term_func(ki->term_func_priv, ret);
Could do that I suppose. The optimiser will make them the same anyway.
I still wonder if I should do something with ret2 as obtained from the kiocb completion function:
static void cachefiles_read_complete(struct kiocb *iocb, long ret, long ret2)
Can we consolidate to one return value?
Quoted 5 lines
fs/cachefiles/rdwr2.c line 77
Quoted 3 lines
fs/cachefiles/rdwr2.c new file +3
-0+/* If the caller asked us to seek for data before doing the read, then +* we should do that now. If we find a gap, we fill it with zeros. +*/ FYI, this is not the normal kernel comment style..
I've been following the network style.
Quoted 4 lines
Quoted 4 lines
fs/cachefiles/rdwr2.c new file +4
-0+ ret =rw_verify_area (READ , file, &ki->iocb.ki_pos, len - skipped); +if (ret <0 ) + goto presubmission_error_free; +
Quoted 8 lines
fs/cachefiles/rdwr2.c line 129
Quoted 5 lines
fs/cachefiles/rdwr2.c new file +5
-0+get_file (ki->iocb.ki_filp); + + old_nofs =memalloc_nofs_save (); + ret =call_read_iter (file, &ki->iocb, iter); +memalloc_nofs_restore (old_nofs);As mentioned before I think all this magic belongs in to a helper in the VFS.
You suggested vfs_iocb_iter_read() in your reply to another patch, but it occurs to me that that doesn't have memalloc_nofs_*() in it. I could hoist the memalloc_nofs stuff out and use those helpers.
Quoted 10 lines
fs/cachefiles/rdwr2.c line 367
Quoted 7 lines
fs/cachefiles/rdwr2.c new file +7
-0+static const struct netfs_cache_ops cachefiles_netfs_cache_ops = { + .end_operation = cachefiles_end_operation, + .read = cachefiles_read, + .write = cachefiles_write, + .expand_readahead =NULL , + .prepare_read = cachefiles_prepare_read, +};...
Also at least in linux-next ->read and ->write seem to never actually be called.
See netfs_read_from_cache() and netfs_rreq_do_write_to_cache() in fs/netfs/read_helper.c. Look for "cres->ops->".
Quoted 11 lines
Quoted 11 lines
fs/cachefiles/rdwr2.c new file +11
-0+{ +struct cachefiles_object *object; +struct cachefiles_cache *cache; +struct path path; +struct file *file; + +_enter ("" ); + + object =container_of (op->op.object, + struct cachefiles_object, fscache); + cache = container_of(object->fscache.cache,
Quoted 8 lines
fs/cachefiles/rdwr2.c line 390
Quoted 6 lines
fs/cachefiles/rdwr2.c new file +6
-0+ struct cachefiles_cache, cache); + + path.mnt = cache->mnt; + path.dentry = object->backer; + file =open_with_fake_path (&path,O_RDWR |O_LARGEFILE |O_DIRECT , +d_inode (object->backer), cache->cache_cred);I think this should be plain old
dentry_open?
open_with_fake_path() sets FMODE_NOACCOUNT. In the fscache-iter branch, the file is held open a lot longer and then ENFILE/EMFILE starts being a serious problem.
That said, I'm considering changing things so that all the data in the cache is held in one or a few files with an index to locate things - at which point this issue goes away.
Quoted 6 lines
fs/fscache/page2.c line 55
Quoted 4 lines
fs/fscache/page2.c new file +4
-0+ op =fscache_alloc_retrieval (cookie,NULL ,NULL ,NULL ); +if (!op) +return -ENOMEM ; +//atomic_set(&op->n_pages, 1); ???
I should remove that - it kind of got left behind. That was necessary for the old API, but a whole load of this code, including the fscache_retrieval struct will be going away when the cookie and operation handling get rewritten.
Quoted 9 lines
include/linux/fscache.h int fscache_reserve_space(struct fscache_cookie *cookie, loff_t size) · line 524
Quoted 6 lines
include/linux/fscache.h +6
-0+{ +if (fscache_cookie_valid (cookie) &&fscache_cookie_enabled (cookie)) +return __fscache_begin_read_operation (rreq, cookie); +else +return -ENOBUFS ; +}No need for an else after a return. I personally also prefer to always handle the error case first, ala:
It's not precisely an error case, more a "fallback required" case.
Quoted 5 lines
if (!fscache_cookie_valid(cookie) || !fscache_cookie_enabled(cookie)) return -ENOBUFS; return __fscache_begin_read_operation(rreq, cookie);Also do we really need this inline fast path to start with?
Yes. fscache might be compiled out, in which case we'll never go down the slow path. And the common case is that cookie == NULL, so let's not jump out of line if we don't have to.
David
David Howells
maintainerPATCH 15/33 afs: Disable use of the fscache I/O routines
In reply to David HowellsDisable use of the fscache I/O routined by the AFS filesystem. It's about to transition to passing iov_iters down and fscache is about to have its I/O path to use iov_iter, so all that needs to change.
---
fs/afs/file.c | 199 ++++++++++---------------------------------------------- fs/afs/inode.c | 2 - fs/afs/write.c | 10 --- 3 files changed, 36 insertions(+), 175 deletions(-)
fs/afs/file.c +35 -164
@@ -203,24 +203,6 @@ void afs_put_read(struct afs_read *req) } } -#ifdef CONFIG_AFS_FSCACHE -/* -* deal with notification that a page was read from the cache -*/ -static void afs_file_readpage_read_complete (struct page *page, -void *data, -int error) -{ -_enter ("%p,%p,%d" , page, data, error); - -/* if the read completes with an error, we just unlock the page and let -* the VM reissue the readpage */ -if (!error) -SetPageUptodate (page); -unlock_page (page); -} -#endif -static void afs_fetch_data_success (struct afs_operation *op) {struct afs_vnode *vnode = op->file[0 ].vnode;
@@ -288,89 +270,46 @@ int afs_page_filler(void *data, struct page *page)if (test_bit (AFS_VNODE_DELETED , &vnode->flags)) goto error; -/* is it cached? */ -#ifdef CONFIG_AFS_FSCACHE - ret =fscache_read_or_alloc_page (vnode->cache, - page, - afs_file_readpage_read_complete, -NULL , -GFP_KERNEL ); -#else - ret = -ENOBUFS ; -#endif -switch (ret) { -/* read BIO submitted (page in cache) */ -case 0 : -break ; - -/* page not yet cached */ -case -ENODATA : -_debug ("cache said ENODATA" ); - goto go_on; - -/* page will not be cached */ -case -ENOBUFS : -_debug ("cache said ENOBUFS" ); - - fallthrough; -default : - go_on: - req =kzalloc (struct_size (req, array,1 ),GFP_KERNEL ); -if (!req) - goto enomem; - -/* We request a full page. If the page is a partial one at the -* end of the file, the server will return a short read and the -* unmarshalling code will clear the unfilled space. -*/ -refcount_set (&req->usage,1 ); - req->pos = (loff_t )page->index <<PAGE_SHIFT ; - req->len =PAGE_SIZE ; - req->nr_pages =1 ; - req->pages = req->array; - req->pages[0 ] = page; -get_page (page); - -/* read the contents of the file from the server into the -* page */ - ret =afs_fetch_data (vnode, key, req); -afs_put_read (req); - -if (ret <0 ) { -if (ret == -ENOENT ) { -_debug ("got NOENT from server" -" - marking file deleted and stale" ); -set_bit (AFS_VNODE_DELETED , &vnode->flags); - ret = -ESTALE ; - } - -#ifdef CONFIG_AFS_FSCACHE -fscache_uncache_page (vnode->cache, page); -#endif -BUG_ON (PageFsCache (page)); - -if (ret == -EINTR || - ret == -ENOMEM || - ret == -ERESTARTSYS || - ret == -EAGAIN ) - goto error; - goto io_error; - } + req =kzalloc (struct_size (req, array,1 ),GFP_KERNEL ); +if (!req) + goto enomem; -SetPageUptodate (page); +/* We request a full page. If the page is a partial one at the +* end of the file, the server will return a short read and the +* unmarshalling code will clear the unfilled space. +*/ +refcount_set (&req->usage,1 ); + req->pos = (loff_t )page->index <<PAGE_SHIFT ; + req->len =PAGE_SIZE ; + req->nr_pages =1 ; + req->pages = req->array; + req->pages[0 ] = page; +get_page (page); + +/* read the contents of the file from the server into the +* page */ + ret =afs_fetch_data (vnode, key, req); +afs_put_read (req); -/* send the page to the cache */ -#ifdef CONFIG_AFS_FSCACHE -if (PageFsCache (page) && -fscache_write_page (vnode->cache, page, vnode->status.size, -GFP_KERNEL ) !=0 ) { -fscache_uncache_page (vnode->cache, page); -BUG_ON (PageFsCache (page)); +if (ret <0 ) { +if (ret == -ENOENT ) { +_debug ("got NOENT from server" +" - marking file deleted and stale" ); +set_bit (AFS_VNODE_DELETED , &vnode->flags); + ret = -ESTALE ; } -#endif -unlock_page (page); + +if (ret == -EINTR || + ret == -ENOMEM || + ret == -ERESTARTSYS || + ret == -EAGAIN ) + goto error; + goto io_error; } +SetPageUptodate (page); +unlock_page (page); +_leave (" = 0" );return 0 ;
@@ -416,23 +355,10 @@ static int afs_readpage(struct file *file, struct page *page)*/ static void afs_readpages_page_done (struct afs_read *req) { -#ifdef CONFIG_AFS_FSCACHE -struct afs_vnode *vnode = req->vnode; -#endif struct page *page = req->pages[req->index]; req->pages[req->index] =NULL ;SetPageUptodate (page); - -/* send the page to the cache */ -#ifdef CONFIG_AFS_FSCACHE -if (PageFsCache (page) && -fscache_write_page (vnode->cache, page, vnode->status.size, -GFP_KERNEL ) !=0 ) { -fscache_uncache_page (vnode->cache, page); -BUG_ON (PageFsCache (page)); - } -#endif unlock_page (page);put_page (page); }
@@ -491,9 +417,6 @@ static int afs_readpages_one(struct file *file, struct address_space *mapping, index = page->index;if (add_to_page_cache_lru (page, mapping, index,readahead_gfp_mask (mapping))) { -#ifdef CONFIG_AFS_FSCACHE -fscache_uncache_page (vnode->cache, page); -#endif put_page (page);break ; }
@@ -526,9 +449,6 @@ static int afs_readpages_one(struct file *file, struct address_space *mapping,for (i =0 ; i < req->nr_pages; i++) { page = req->pages[i];if (page) { -#ifdef CONFIG_AFS_FSCACHE -fscache_uncache_page (vnode->cache, page); -#endif SetPageError (page);unlock_page (page); }
@@ -560,37 +480,6 @@ static int afs_readpages(struct file *file, struct address_space *mapping, }/* attempt to read as many of the pages as possible */ -#ifdef CONFIG_AFS_FSCACHE - ret =fscache_read_or_alloc_pages (vnode->cache, - mapping, - pages, - &nr_pages, - afs_file_readpage_read_complete, -NULL , -mapping_gfp_mask (mapping)); -#else - ret = -ENOBUFS ; -#endif - -switch (ret) { -/* all pages are being read from the cache */ -case 0 : -BUG_ON (!list_empty (pages)); -BUG_ON (nr_pages !=0 ); -_leave (" = 0 [reading all]" ); -return 0 ; - -/* there were pages that couldn't be read from the cache */ -case -ENODATA : -case -ENOBUFS : -break ; - -/* other error */ -default : -_leave (" = %d" , ret); -return ret; - } -while (!list_empty (pages)) { ret =afs_readpages_one (file, mapping, pages);if (ret <0 )
@@ -670,17 +559,6 @@ static void afs_invalidatepage(struct page *page, unsigned int offset,BUG_ON (!PageLocked (page)); -#ifdef CONFIG_AFS_FSCACHE -/* we clean up only if the entire page is being invalidated */ -if (offset ==0 && length ==PAGE_SIZE ) { -if (PageFsCache (page)) { -struct afs_vnode *vnode =AFS_FS_I (page->mapping->host); -fscache_wait_on_page_write (vnode->cache, page); -fscache_uncache_page (vnode->cache, page); - } - } -#endif -if (PagePrivate (page))afs_invalidate_dirty (page, offset, length);
@@ -702,13 +580,6 @@ static int afs_releasepage(struct page *page, gfp_t gfp_flags)/* deny if page is being written to the cache and the caller hasn't * elected to wait */ -#ifdef CONFIG_AFS_FSCACHE -if (!fscache_maybe_release_page (vnode->cache, page, gfp_flags)) { -_leave (" = F [cache busy]" ); -return 0 ; - } -#endif -if (PagePrivate (page)) { priv = (unsigned long )detach_page_private (page); trace_afs_page_dirty(vnode, tracepoint_string("rel"),
fs/afs/inode.c +1 -1
@@ -428,7 +428,7 @@ static void afs_get_inode_cache(struct afs_vnode *vnode) }__packed key;struct afs_vnode_cache_aux aux; -if (vnode->status.type ==AFS_FTYPE_DIR ) { +if (vnode->status.type !=AFS_FTYPE_FILE ) { vnode->cache =NULL ;return ; }
fs/afs/write.c +0 -10
@@ -847,9 +847,6 @@ vm_fault_t afs_page_mkwrite(struct vm_fault *vmf)/* Wait for the page to be written to the cache before we allow it to * be modified. We then assume the entire page will need writing back. */ -#ifdef CONFIG_AFS_FSCACHE -fscache_wait_on_page_write (vnode->cache, vmf->page); -#endif if (PageWriteback (vmf->page) &&wait_on_page_bit_killable (vmf->page, PG_writeback) <0 )
@@ -936,12 +933,5 @@ int afs_launder_page(struct page *page) priv = (unsigned long )detach_page_private (page);trace_afs_page_dirty (vnode,tracepoint_string ("laundered" ), page->index, priv); - -#ifdef CONFIG_AFS_FSCACHE -if (PageFsCache (page)) { -fscache_wait_on_page_write (vnode->cache, page); -fscache_uncache_page (vnode->cache, page); - } -#endif return ret; }
David Howells
maintainerPATCH 16/33 afs: Pass page into dirty region helpers to provide THP size
In reply to David HowellsPass a pointer to the page being accessed into the dirty region helpers so that the size of the page can be determined in case it's a transparent huge page.
This also required the page to be passed into the afs_page_dirty trace point - so there's no need to specifically pass in the index or private data as these can be retrieved directly from the page struct.
---
fs/afs/file.c | 20 +++++++-------- fs/afs/internal.h | 16 ++++++------ fs/afs/write.c | 60 ++++++++++++++++++-------------------------- include/trace/events/afs.h | 23 ++++++++++------- 4 files changed, 55 insertions(+), 64 deletions(-)
fs/afs/file.c +9 -11
@@ -515,8 +515,8 @@ static void afs_invalidate_dirty(struct page *page, unsigned int offset,return ;/* We may need to shorten the dirty region */ - f =afs_page_dirty_from (priv); - t =afs_page_dirty_to (priv); + f =afs_page_dirty_from (page, priv); + t =afs_page_dirty_to (page, priv);if (t <= offset || f >= end)return ;/* Doesn't overlap */
@@ -534,17 +534,17 @@ static void afs_invalidate_dirty(struct page *page, unsigned int offset,if (f == t) goto undirty; - priv =afs_page_dirty (f, t); + priv =afs_page_dirty (page, f, t);set_page_private (page, priv); -trace_afs_page_dirty (vnode,tracepoint_string ("trunc" ), page->index, priv); +trace_afs_page_dirty (vnode,tracepoint_string ("trunc" ), page);return ; undirty: -trace_afs_page_dirty (vnode,tracepoint_string ("undirty" ), page->index, priv); +trace_afs_page_dirty (vnode,tracepoint_string ("undirty" ), page);clear_page_dirty_for_io (page); full_invalidate: - priv = (unsigned long )detach_page_private (page); -trace_afs_page_dirty (vnode,tracepoint_string ("inval" ), page->index, priv); +detach_page_private (page); +trace_afs_page_dirty (vnode,tracepoint_string ("inval" ), page); }/*
@@ -572,7 +572,6 @@ static void afs_invalidatepage(struct page *page, unsigned int offset,static int afs_releasepage (struct page *page,gfp_t gfp_flags) {struct afs_vnode *vnode =AFS_FS_I (page->mapping->host); -unsigned long priv; _enter("{{%llx:%llu}[%lu],%lx},%x", vnode->fid.vid, vnode->fid.vnode, page->index, page->flags,
@@ -581,9 +580,8 @@ static int afs_releasepage(struct page *page, gfp_t gfp_flags)/* deny if page is being written to the cache and the caller hasn't * elected to wait */ if (PagePrivate (page)) { - priv = (unsigned long )detach_page_private (page); -trace_afs_page_dirty (vnode,tracepoint_string ("rel" ), - page->index, priv); +detach_page_private (page); +trace_afs_page_dirty (vnode,tracepoint_string ("rel" ), page); }/* indicate that the page can be released */
fs/afs/internal.h +8 -8
@@ -875,31 +875,31 @@ struct afs_vnode_cache_aux {#define __AFS_PAGE_PRIV_MMAPPED 0x8000UL#endif -static inline unsigned int afs_page_dirty_resolution (void ) +static inline unsigned int afs_page_dirty_resolution (struct page *page) { -int shift =PAGE_SHIFT - (__AFS_PAGE_PRIV_SHIFT -1 ); +int shift =thp_order (page) +PAGE_SHIFT - (__AFS_PAGE_PRIV_SHIFT -1 );return (shift >0 ) ? shift :0 ; } -static inline size_t afs_page_dirty_from (unsigned long priv) +static inline size_t afs_page_dirty_from (struct page *page,unsigned long priv) {unsigned long x = priv & __AFS_PAGE_PRIV_MASK;/* The lower bound is inclusive */ -return x <<afs_page_dirty_resolution (); +return x <<afs_page_dirty_resolution (page); } -static inline size_t afs_page_dirty_to (unsigned long priv) +static inline size_t afs_page_dirty_to (struct page *page,unsigned long priv) {unsigned long x = (priv >> __AFS_PAGE_PRIV_SHIFT) & __AFS_PAGE_PRIV_MASK;/* The upper bound is immediately beyond the region */ -return (x +1 ) <<afs_page_dirty_resolution (); +return (x +1 ) <<afs_page_dirty_resolution (page); } -static inline unsigned long afs_page_dirty (size_t from,size_t to) +static inline unsigned long afs_page_dirty (struct page *page,size_t from,size_t to) { -unsigned int res =afs_page_dirty_resolution (); +unsigned int res =afs_page_dirty_resolution (page); from >>= res; to = (to -1 ) >> res;return (to << __AFS_PAGE_PRIV_SHIFT) | from;
fs/afs/write.c +25 -35
139 lines not on this page · raw message
include/trace/events/afs.h +13 -10
@@ -969,30 +969,33 @@ TRACE_EVENT(afs_dir_check_failed, );TRACE_EVENT (afs_page_dirty, - TP_PROTO(struct afs_vnode *vnode, const char *where, - pgoff_t page, unsigned long priv), + TP_PROTO(struct afs_vnode *vnode, const char *where, struct page *page), -TP_ARGS (vnode, where, page, priv), +TP_ARGS (vnode, where, page),TP_STRUCT__entry ( __field(struct afs_vnode *, vnode ) __field(const char *, where ) __field(pgoff_t, page ) - __field(unsigned long, priv ) + __field(unsigned long, from ) + __field(unsigned long, to ) ),TP_fast_assign ( __entry->vnode = vnode; __entry->where = where; - __entry->page = page; - __entry->priv = priv; + __entry->page = page->index; + __entry->from = afs_page_dirty_from(page, page->private); + __entry->to = afs_page_dirty_to(page, page->private); + __entry->to |= (afs_is_page_dirty_mmapped (page->private) ? + (1UL << (BITS_PER_LONG - 1)) : 0); ), -TP_printk ("vn=%p %lx %s %zx-%zx%s" , +TP_printk ("vn=%p %lx %s %lx-%lx%s" , __entry->vnode, __entry->page, __entry->where, -afs_page_dirty_from (__entry->priv), -afs_page_dirty_to (__entry->priv), -afs_is_page_dirty_mmapped (__entry->priv) ?" M" :"" ) + __entry->from, + __entry->to & ~(1UL << (BITS_PER_LONG -1 )), + __entry->to & (1UL << (BITS_PER_LONG -1 )) ?" M" :"" ) ); TRACE_EVENT(afs_call_state,
David Howells
maintainerPATCH 17/33 afs: Print the operation debug_id when logging an unexpected data version
In reply to David HowellsPrint the afs_operation debug_id when logging an unexpected change in the data version. This allows the logged message to be matched against tracelines.
---
fs/afs/inode.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
fs/afs/inode.c +3 -2
@@ -215,11 +215,12 @@ static void afs_apply_status(struct afs_operation *op,if (vp->dv_before + vp->dv_delta != status->data_version) {if (test_bit (AFS_VNODE_CB_PROMISED , &vnode->flags)) -pr_warn ("kAFS: vnode modified {%llx:%llu} %llx->%llx %s\n" , +pr_warn ("kAFS: vnode modified {%llx:%llu} %llx->%llx %s (op=%x)\n" , vnode->fid.vid, vnode->fid.vnode, (unsigned long long )vp->dv_before + vp->dv_delta, (unsigned long long )status->data_version, - op->type ? op->type->name :"???" ); + op->type ? op->type->name :"???" , + op->debug_id); vnode->invalid_before = status->data_version;if (vnode->status.type ==AFS_FTYPE_DIR ) {
David Howells
maintainerPATCH 18/33 afs: Move key to afs_read struct
In reply to David HowellsStash the key used to authenticate read operations in the afs_read struct. This will be necessary to reissue the operation against the server if a read from the cache fails in upcoming cache changes.
---
fs/afs/dir.c | 3 ++- fs/afs/file.c | 16 +++++++++------- fs/afs/internal.h | 3 ++- fs/afs/write.c | 12 ++++++------ 4 files changed, 19 insertions(+), 15 deletions(-)
fs/afs/dir.c +2 -1
@@ -241,6 +241,7 @@ static struct afs_read *afs_read_dir(struct afs_vnode *dvnode, struct key *key)return ERR_PTR (-ENOMEM );refcount_set (&req->usage,1 ); + req->key =key_get (key); req->nr_pages = nr_pages; req->actual_len = i_size;/* May change */ req->len = nr_pages *PAGE_SIZE ;/* We can ask for more than there is */
@@ -305,7 +306,7 @@ static struct afs_read *afs_read_dir(struct afs_vnode *dvnode, struct key *key)if (!test_bit (AFS_VNODE_DIR_VALID , &dvnode->flags)) {trace_afs_reload_dir (dvnode); - ret =afs_fetch_data (dvnode, key, req); + ret =afs_fetch_data (dvnode, req);if (ret <0 ) goto error_unlock;
fs/afs/file.c +9 -7
@@ -199,6 +199,7 @@ void afs_put_read(struct afs_read *req)if (req->pages != req->array)kfree (req->pages); } +key_put (req->key);kfree (req); } }
@@ -229,7 +230,7 @@ static const struct afs_operation_ops afs_fetch_data_operation = {/* * Fetch file data from the volume. */ -int afs_fetch_data (struct afs_vnode *vnode,struct key *key,struct afs_read *req) +int afs_fetch_data (struct afs_vnode *vnode,struct afs_read *req) {struct afs_operation *op;
@@ -238,9 +239,9 @@ int afs_fetch_data(struct afs_vnode *vnode, struct key *key, struct afs_read *re vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique, - key_serial(key)); + key_serial(req->key)); - op =afs_alloc_operation (key, vnode->volume); + op =afs_alloc_operation (req->key, vnode->volume);if (IS_ERR (op))return PTR_ERR (op);
@@ -279,6 +280,7 @@ int afs_page_filler(void *data, struct page *page)* unmarshalling code will clear the unfilled space. */ refcount_set (&req->usage,1 ); + req->key =key_get (key); req->pos = (loff_t )page->index <<PAGE_SHIFT ; req->len =PAGE_SIZE ; req->nr_pages =1 ;
@@ -288,7 +290,7 @@ int afs_page_filler(void *data, struct page *page)/* read the contents of the file from the server into the * page */ - ret =afs_fetch_data (vnode, key, req); + ret =afs_fetch_data (vnode, req);afs_put_read (req);if (ret <0 ) {
@@ -373,7 +375,6 @@ static int afs_readpages_one(struct file *file, struct address_space *mapping,struct afs_read *req;struct list_head *p;struct page *first, *page; -struct key *key =afs_file_key (file);pgoff_t index;int ret, n, i;
@@ -397,6 +398,7 @@ static int afs_readpages_one(struct file *file, struct address_space *mapping,refcount_set (&req->usage,1 ); req->vnode = vnode; + req->key =key_get (afs_file_key (file)); req->page_done = afs_readpages_page_done; req->pos = first->index; req->pos <<=PAGE_SHIFT ;
@@ -426,11 +428,11 @@ static int afs_readpages_one(struct file *file, struct address_space *mapping, }while (req->nr_pages < n);if (req->nr_pages ==0 ) { -kfree (req); +afs_put_read (req);return 0 ; } - ret =afs_fetch_data (vnode, key, req); + ret =afs_fetch_data (vnode, req);if (ret <0 ) goto error;
fs/afs/internal.h +2 -1
@@ -204,6 +204,7 @@ struct afs_read {loff_t actual_len;/* How much we're actually getting */ loff_t remain;/* Amount remaining */ loff_t file_size;/* File size returned by server */ +struct key *key;/* The key to use to reissue the read */ afs_dataversion_t data_version;/* Version number returned by server */ refcount_t usage;unsigned int index;/* Which page we're reading into */
@@ -1045,7 +1046,7 @@ extern int afs_cache_wb_key(struct afs_vnode *, struct afs_file *);extern void afs_put_wb_key (struct afs_wb_key *);extern int afs_open (struct inode *,struct file *);extern int afs_release (struct inode *,struct file *); -extern int afs_fetch_data (struct afs_vnode *,struct key *,struct afs_read *); +extern int afs_fetch_data (struct afs_vnode *,struct afs_read *);extern int afs_page_filler (void *,struct page *);extern void afs_put_read (struct afs_read *);
fs/afs/write.c +6 -6
@@ -25,9 +25,10 @@ int afs_set_page_dirty(struct page *page)/* * partly or wholly fill a page that's under preparation for writing */ -static int afs_fill_page (struct afs_vnode *vnode,struct key *key, +static int afs_fill_page (struct file *file,loff_t pos,unsigned int len,struct page *page) { +struct afs_vnode *vnode =AFS_FS_I (file_inode (file));struct afs_read *req;size_t p;void *data;
@@ -49,6 +50,7 @@ static int afs_fill_page(struct afs_vnode *vnode, struct key *key,return -ENOMEM ;refcount_set (&req->usage,1 ); + req->key =key_get (afs_file_key (file)); req->pos = pos; req->len = len; req->nr_pages =1 ;
@@ -56,7 +58,7 @@ static int afs_fill_page(struct afs_vnode *vnode, struct key *key, req->pages[0 ] = page;get_page (page); - ret =afs_fetch_data (vnode, key, req); + ret =afs_fetch_data (vnode, req);afs_put_read (req);if (ret <0 ) {if (ret == -ENOENT ) {
@@ -80,7 +82,6 @@ int afs_write_begin(struct file *file, struct address_space *mapping, {struct afs_vnode *vnode =AFS_FS_I (file_inode (file));struct page *page; -struct key *key =afs_file_key (file);unsigned long priv;unsigned f, from = pos & (PAGE_SIZE -1 );unsigned t, to = from + len;
@@ -95,7 +96,7 @@ int afs_write_begin(struct file *file, struct address_space *mapping,return -ENOMEM ;if (!PageUptodate (page) && len !=PAGE_SIZE ) { - ret =afs_fill_page (vnode, key, pos &PAGE_MASK ,PAGE_SIZE , page); + ret =afs_fill_page (file, pos &PAGE_MASK ,PAGE_SIZE , page);if (ret <0 ) {unlock_page (page);put_page (page);
@@ -163,7 +164,6 @@ int afs_write_end(struct file *file, struct address_space *mapping, struct page *page, void *fsdata) { struct afs_vnode *vnode = AFS_FS_I(file_inode(file)); -struct key *key =afs_file_key (file);unsigned long priv;unsigned int f, from = pos & (PAGE_SIZE -1 );unsigned int t, to = from + copied;
@@ -193,7 +193,7 @@ int afs_write_end(struct file *file, struct address_space *mapping,* unmarshalling routine will take care of clearing any * bits that are beyond the EOF. */ - ret =afs_fill_page (vnode, key, pos + copied, + ret =afs_fill_page (file, pos + copied, len - copied, page);if (ret <0 ) goto out;
David Howells
maintainerPATCH 19/33 afs: Don't truncate iter during data fetch
In reply to David HowellsDon't truncate the iterator to correspond to the actual data size when fetching the data from the server - rather, pass the length we want to read to rxrpc.
This will allow the clear-after-read code in future to simply clear the remaining iterator capacity rather than having to reinitialise the iterator.
---
fs/afs/fsclient.c | 6 ++++-- fs/afs/internal.h | 6 ++++++ fs/afs/rxrpc.c | 13 +++++++++---- fs/afs/yfsclient.c | 6 ++++-- include/net/af_rxrpc.h | 2 +- net/rxrpc/recvmsg.c | 9 +++++---- 6 files changed, 29 insertions(+), 13 deletions(-)
fs/afs/fsclient.c +4 -2
@@ -305,8 +305,9 @@ static int afs_deliver_fs_fetch_data(struct afs_call *call)unsigned int size;int ret; -_enter ("{%u,%zu/%llu}" , - call->unmarshall,iov_iter_count (call->iter), req->actual_len); +_enter ("{%u,%zu,%zu/%llu}" , + call->unmarshall, call->iov_len,iov_iter_count (call->iter), + req->actual_len);switch (call->unmarshall) {case 0 :
@@ -343,6 +344,7 @@ static int afs_deliver_fs_fetch_data(struct afs_call *call) size =PAGE_SIZE - req->offset; else size = req->remain; + call->iov_len = size; call->bvec[0 ].bv_len = size; call->bvec[0 ].bv_offset = req->offset; call->bvec[0 ].bv_page = req->pages[req->index];
fs/afs/internal.h +6 -0
@@ -104,6 +104,7 @@ struct afs_call {struct afs_server *server;/* The fileserver record if fs op (pins ref) */ struct afs_vlserver *vlserver;/* The vlserver record if vl op */ void *request;/* request data (first part) */ +size_t iov_len;/* Size of *iter to be used */ struct iov_iter def_iter;/* Default buffer/data iterator */ struct iov_iter *iter;/* Iterator currently in use */ union {/* Convenience for ->def_iter */
@@ -1270,6 +1271,7 @@ static inline void afs_make_op_call(struct afs_operation *op, struct afs_call *cstatic inline void afs_extract_begin (struct afs_call *call,void *buf,size_t size) { + call->iov_len = size; call->kvec[0 ].iov_base = buf; call->kvec[0 ].iov_len = size;iov_iter_kvec (&call->def_iter,READ , call->kvec,1 , size);
@@ -1277,21 +1279,25 @@ static inline void afs_extract_begin(struct afs_call *call, void *buf, size_t sistatic inline void afs_extract_to_tmp (struct afs_call *call) { + call->iov_len =sizeof (call->tmp);afs_extract_begin (call, &call->tmp,sizeof (call->tmp)); }static inline void afs_extract_to_tmp64 (struct afs_call *call) { + call->iov_len =sizeof (call->tmp64);afs_extract_begin (call, &call->tmp64,sizeof (call->tmp64)); }static inline void afs_extract_discard (struct afs_call *call,size_t size) { + call->iov_len = size;iov_iter_discard (&call->def_iter,READ , size); }static inline void afs_extract_to_buf (struct afs_call *call,size_t size) { + call->iov_len = size;afs_extract_begin (call, call->buffer, size); }
fs/afs/rxrpc.c +9 -4
@@ -363,6 +363,7 @@ void afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call, gfp_t gfp)struct rxrpc_call *rxcall;struct msghdr msg;struct kvec iov[1 ]; +size_t len;s64 tx_total_len;int ret;
@@ -466,9 +467,10 @@ void afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call, gfp_t gfp)rxrpc_kernel_abort_call (call->net->socket, rxcall,RX_USER_ABORT , ret,"KSD" ); }else { + len =0 ;iov_iter_kvec (&msg.msg_iter,READ ,NULL ,0 ,0 );rxrpc_kernel_recv_data (call->net->socket, rxcall, - &msg.msg_iter, false, + &msg.msg_iter, &len, false, &call->abort_code, &call->service_id); ac->abort_code = call->abort_code; ac->responded = true;
@@ -504,6 +506,7 @@ void afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call, gfp_t gfp)static void afs_deliver_to_call (struct afs_call *call) {enum afs_call_state state; +size_t len;u32 abort_code, remote_abort =0 ;int ret;
@@ -516,10 +519,11 @@ static void afs_deliver_to_call(struct afs_call *call) state == AFS_CALL_SV_AWAIT_ACK ) {if (state ==AFS_CALL_SV_AWAIT_ACK ) { + len =0 ;iov_iter_kvec (&call->def_iter,READ ,NULL ,0 ,0 ); ret =rxrpc_kernel_recv_data (call->net->socket, call->rxcall, &call->def_iter, - false, &remote_abort, + &len, false, &remote_abort, &call->service_id);trace_afs_receive_data (call, &call->def_iter, false, ret);
@@ -929,10 +933,11 @@ int afs_extract_data(struct afs_call *call, bool want_more)u32 remote_abort =0 ;int ret; -_enter ("{%s,%zu},%d" , call->type->name,iov_iter_count (iter), want_more); +_enter ("{%s,%zu,%zu},%d" , + call->type->name, call->iov_len,iov_iter_count (iter), want_more); ret =rxrpc_kernel_recv_data (net->socket, call->rxcall, iter, - want_more, &remote_abort, + &call->iov_len, want_more, &remote_abort, &call->service_id);if (ret ==0 || ret == -EAGAIN )return ret;
fs/afs/yfsclient.c +4 -2
@@ -363,8 +363,9 @@ static int yfs_deliver_fs_fetch_data64(struct afs_call *call)unsigned int size;int ret; -_enter ("{%u,%zu/%llu}" , - call->unmarshall,iov_iter_count (call->iter), req->actual_len); +_enter ("{%u,%zu, %zu/%llu}" , + call->unmarshall, call->iov_len,iov_iter_count (call->iter), + req->actual_len);switch (call->unmarshall) {case 0 :
@@ -396,6 +397,7 @@ static int yfs_deliver_fs_fetch_data64(struct afs_call *call) size =PAGE_SIZE - req->offset; else size = req->remain; + call->iov_len = size; call->bvec[0 ].bv_len = size; call->bvec[0 ].bv_offset = req->offset; call->bvec[0 ].bv_page = req->pages[req->index];
include/net/af_rxrpc.h +1 -1
@@ -53,7 +53,7 @@ int rxrpc_kernel_send_data(struct socket *, struct rxrpc_call *, struct msghdr *, size_t, rxrpc_notify_end_tx_t);int rxrpc_kernel_recv_data (struct socket *,struct rxrpc_call *, -struct iov_iter *,bool ,u32 *,u16 *); +struct iov_iter *,size_t *,bool ,u32 *,u16 *);bool rxrpc_kernel_abort_call (struct socket *,struct rxrpc_call *,u32 ,int ,const char *);void rxrpc_kernel_end_call (struct socket *,struct rxrpc_call *);
net/rxrpc/recvmsg.c +5 -4
@@ -669,6 +669,7 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,* @sock: The socket that the call exists on * @call: The call to send data through * @iter: The buffer to receive into +* @_len: The amount of data we want to receive (decreased on return) * @want_more: True if more data is expected to be read * @_abort: Where the abort code is stored if -ECONNABORTED is returned * @_service: Where to store the actual service ID (may be upgraded)
@@ -684,7 +685,7 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,* *_abort should also be initialised to 0. */ int rxrpc_kernel_recv_data (struct socket *sock,struct rxrpc_call *call, -struct iov_iter *iter, +struct iov_iter *iter,size_t *_len,bool want_more,u32 *_abort,u16 *_service) {size_t offset =0 ;
@@ -692,7 +693,7 @@ int rxrpc_kernel_recv_data(struct socket *sock, struct rxrpc_call *call,_enter ("{%d,%s},%zu,%d" , call->debug_id, rxrpc_call_states[call->state], -iov_iter_count (iter), want_more); + *_len, want_more); ASSERTCMP(call->state, !=, RXRPC_CALL_SERVER_SECURING);
@@ -703,8 +704,8 @@ int rxrpc_kernel_recv_data(struct socket *sock, struct rxrpc_call *call,case RXRPC_CALL_SERVER_RECV_REQUEST :case RXRPC_CALL_SERVER_ACK_REQUEST : ret =rxrpc_recvmsg_data (sock, call,NULL , iter, -iov_iter_count (iter),0 , - &offset); + *_len,0 , &offset); + *_len -= offset;if (ret <0 ) goto out;
David Howells
maintainerPATCH 20/33 afs: Log remote unmarshalling errors
In reply to David HowellsLog unmarshalling errors reported by the peer (ie. it can't parse what we sent it). Limit the maximum number of messages to 3.
---
fs/afs/rxrpc.c | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+)
fs/afs/rxrpc.c +34 -0
@@ -500,6 +500,39 @@ void afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call, gfp_t gfp)_leave (" = %d" , ret); } +/* +* Log remote abort codes that indicate that we have a protocol disagreement +* with the server. +*/ +static void afs_log_error (struct afs_call *call,s32 remote_abort) +{ +static int max =0 ; +const char *msg; +int m; + +switch (remote_abort) { +case RX_EOF : msg ="unexpected EOF" ;break ; +case RXGEN_CC_MARSHAL : msg ="client marshalling" ;break ; +case RXGEN_CC_UNMARSHAL : msg ="client unmarshalling" ;break ; +case RXGEN_SS_MARSHAL : msg ="server marshalling" ;break ; +case RXGEN_SS_UNMARSHAL : msg ="server unmarshalling" ;break ; +case RXGEN_DECODE : msg ="opcode decode" ;break ; +case RXGEN_SS_XDRFREE : msg ="server XDR cleanup" ;break ; +case RXGEN_CC_XDRFREE : msg ="client XDR cleanup" ;break ; +case -32 : msg ="insufficient data" ;break ; +default : +return ; + } + + m = max; +if (m <3 ) { + max = m +1 ; +pr_notice ("kAFS: Peer reported %s failure on %s [%pISp]\n" , + msg, call->type->name, + &call->alist->addrs[call->addr_ix].transport); + } +} +/* * deliver messages to a call */
@@ -563,6 +596,7 @@ static void afs_deliver_to_call(struct afs_call *call) goto out;case -ECONNABORTED : ASSERTCMP(state, ==, AFS_CALL_COMPLETE); +afs_log_error (call, call->abort_code); goto done;case -ENOTSUPP : abort_code =RXGEN_OPCODE ;
David Howells
maintainerPATCH 21/33 afs: Set up the iov_iter before calling afs_extract_data()
In reply to David Howellsafs_extract_data() sets up a temporary iov_iter and passes it to AF_RXRPC each time it is called to describe the remaining buffer to be filled.
Instead:
(1) Put an iterator in the afs_call struct.
(2) Set the iterator for each marshalling stage to load data into the appropriate places. A number of convenience functions are provided to this end (eg. afs_extract_to_buf()).
This iterator is then passed to afs_extract_data().
(3) Use the new ITER_MAPPING iterator when reading data to load directly into the inode's pages without needing to create a list of them.
This will allow O_DIRECT calls to be supported in future patches.
---
fs/afs/dir.c | 222 +++++++++++++++++++++++++++++++++++----------------- fs/afs/file.c | 190 ++++++++++++++++++++++++++------------------- fs/afs/fsclient.c | 54 +++---------- fs/afs/internal.h | 16 ++-- fs/afs/write.c | 27 ++++-- fs/afs/yfsclient.c | 54 +++---------- 6 files changed, 314 insertions(+), 249 deletions(-)
fs/afs/dir.c +149 -73
@@ -102,6 +102,35 @@ struct afs_lookup_cookie {struct afs_fid fids[50 ]; }; +/* +* Drop the refs that we're holding on the pages we were reading into. We've +* got refs on the first nr_pages pages. +*/ +static void afs_dir_read_cleanup (struct afs_read *req) +{ +struct address_space *mapping = req->vnode->vfs_inode.i_mapping; +struct page *page; +pgoff_t last = req->nr_pages -1 ; + +XA_STATE (xas, &mapping->i_pages,0 ); + +if (unlikely (!req->nr_pages)) +return ; + +rcu_read_lock (); +xas_for_each (&xas, page, last) { +if (xas_retry (&xas, page)) +continue ; +BUG_ON (xa_is_value (page)); +BUG_ON (PageCompound (page)); + ASSERTCMP(page->mapping, ==, mapping); + +put_page (page); + } + +rcu_read_unlock (); +} +/* * check that a directory page is valid */
@@ -127,7 +156,7 @@ static bool afs_dir_check_page(struct afs_vnode *dvnode, struct page *page, qty /=sizeof (union afs_xdr_dir_block );/* check them */ - dbuf =kmap (page); + dbuf =kmap_atomic (page);for (tmp =0 ; tmp < qty; tmp++) {if (dbuf->blocks[tmp].hdr.magic !=AFS_DIR_MAGIC ) { printk("kAFS: %s(%lx): bad magic %d/%d is %04hx\n",
@@ -146,7 +175,7 @@ static bool afs_dir_check_page(struct afs_vnode *dvnode, struct page *page, ((u8 *)&dbuf->blocks[tmp])[AFS_DIR_BLOCK_SIZE -1 ] =0 ; } -kunmap (page); +kunmap_atomic (dbuf); checked:afs_stat_v (dvnode, n_read_dir);
@@ -157,35 +186,74 @@ static bool afs_dir_check_page(struct afs_vnode *dvnode, struct page *page, }/* -* Check the contents of a directory that we've just read. +* Dump the contents of a directory. */ -static bool afs_dir_check_pages (struct afs_vnode *dvnode,struct afs_read *req) +static void afs_dir_dump (struct afs_vnode *dvnode,struct afs_read *req) {struct afs_xdr_dir_page *dbuf; -unsigned int i, j, qty =PAGE_SIZE /sizeof (union afs_xdr_dir_block ); +struct address_space *mapping = dvnode->vfs_inode.i_mapping; +struct page *page; +unsigned int i, qty =PAGE_SIZE /sizeof (union afs_xdr_dir_block ); +pgoff_t last = req->nr_pages -1 ; -for (i =0 ; i < req->nr_pages; i++) -if (!afs_dir_check_page (dvnode, req->pages[i], req->actual_len)) - goto bad; -return true; +XA_STATE (xas, &mapping->i_pages,0 ); -bad: -pr_warn ("DIR %llx:%llx f=%llx l=%llx al=%llx r=%llx\n" , +pr_warn ("DIR %llx:%llx f=%llx l=%llx al=%llx\n" , dvnode->fid.vid, dvnode->fid.vnode, - req->file_size, req->len, req->actual_len, req->remain); -pr_warn ("DIR %llx %x %x %x\n" , - req->pos, req->index, req->nr_pages, req->offset); + req->file_size, req->len, req->actual_len); +pr_warn ("DIR %llx %x %zx %zx\n" , + req->pos, req->nr_pages, + req->iter->iov_offset,iov_iter_count (req->iter)); -for (i =0 ; i < req->nr_pages; i++) { - dbuf =kmap (req->pages[i]); -for (j =0 ; j < qty; j++) { -union afs_xdr_dir_block *block = &dbuf->blocks[j]; +xas_for_each (&xas, page, last) { +if (xas_retry (&xas, page)) +continue ; + +BUG_ON (PageCompound (page)); +BUG_ON (page->mapping != mapping); + + dbuf =kmap_atomic (page); +for (i =0 ; i < qty; i++) { +union afs_xdr_dir_block *block = &dbuf->blocks[i]; -pr_warn ("[%02x] %32phN\n" , i * qty + j, block); +pr_warn ("[%02lx] %32phN\n" , page->index * qty + i, block); } -kunmap (req->pages[i]); +kunmap_atomic (dbuf); } -return false; +} + +/* +* Check all the pages in a directory. All the pages are held pinned. +*/ +static int afs_dir_check (struct afs_vnode *dvnode,struct afs_read *req) +{ +struct address_space *mapping = dvnode->vfs_inode.i_mapping; +struct page *page; +pgoff_t last = req->nr_pages -1 ; +int ret =0 ; + +XA_STATE (xas, &mapping->i_pages,0 ); + +if (unlikely (!req->nr_pages)) +return 0 ; + +rcu_read_lock (); +xas_for_each (&xas, page, last) { +if (xas_retry (&xas, page)) +continue ; + +BUG_ON (PageCompound (page)); +BUG_ON (page->mapping != mapping); + +if (!afs_dir_check_page (dvnode, page, req->file_size)) { +afs_dir_dump (dvnode, req); + ret = -EIO ; +break ; + } + } + +rcu_read_unlock (); +return ret; }/*
@@ -214,58 +282,57 @@ static struct afs_read *afs_read_dir(struct afs_vnode *dvnode, struct key *key) {struct afs_read *req;loff_t i_size; -int nr_pages, nr_inline, i, n; -int ret = -ENOMEM ; +int nr_pages, i, n; +int ret; + +_enter ("" ); -retry: + req =kzalloc (sizeof (*req),GFP_KERNEL ); +if (!req) +return ERR_PTR (-ENOMEM ); + +refcount_set (&req->usage,1 ); + req->vnode = dvnode; + req->key =key_get (key); + req->cleanup = afs_dir_read_cleanup; + +expand: i_size =i_size_read (&dvnode->vfs_inode); -if (i_size <2048 ) -return ERR_PTR (afs_bad (dvnode, afs_file_error_dir_small)); +if (i_size <2048 ) { + ret =afs_bad (dvnode, afs_file_error_dir_small); + goto error; + }if (i_size >2048 *1024 ) {trace_afs_file_error (dvnode, -EFBIG , afs_file_error_dir_big); -return ERR_PTR (-EFBIG ); + ret = -EFBIG ; + goto error; }_enter ("%llu" , i_size); -/* Get a request record to hold the page list. We want to hold it -* inline if we can, but we don't want to make an order 1 allocation. -*/ nr_pages = (i_size +PAGE_SIZE -1 ) /PAGE_SIZE ; - nr_inline = nr_pages; -if (nr_inline > (PAGE_SIZE -sizeof (*req)) /sizeof (struct page *)) - nr_inline =0 ; - req =kzalloc (struct_size (req, array, nr_inline),GFP_KERNEL ); -if (!req) -return ERR_PTR (-ENOMEM ); - -refcount_set (&req->usage,1 ); - req->key =key_get (key); - req->nr_pages = nr_pages; req->actual_len = i_size;/* May change */ req->len = nr_pages *PAGE_SIZE ;/* We can ask for more than there is */ req->data_version = dvnode->status.data_version;/* May change */ -if (nr_inline >0 ) { - req->pages = req->array; - }else { - req->pages =kcalloc (nr_pages,sizeof (struct page *), -GFP_KERNEL ); -if (!req->pages) - goto error; - } +iov_iter_xarray (&req->def_iter,READ , &dvnode->vfs_inode.i_mapping->i_pages, +0 , i_size); + req->iter = &req->def_iter; -/* Get a list of all the pages that hold or will hold the directory -* content. We need to fill in any gaps that we might find where the -* memory reclaimer has been at work. If there are any gaps, we will +/* Fill in any gaps that we might find where the memory reclaimer has +* been at work and pin all the pages. If there are any gaps, we will * need to reread the entire directory contents. */ - i =0 ; - do { + i = req->nr_pages; +while (i < nr_pages) { +struct page *pages[8 ], *page; + n =find_get_pages_contig (dvnode->vfs_inode.i_mapping, i, - req->nr_pages - i, - req->pages + i); - _debug("find %u at %u/%u", n, i, req->nr_pages); + min_t(unsigned int, nr_pages - i, +ARRAY_SIZE (pages)), + pages); +_debug ("find %u at %u/%u" , n, i, nr_pages); +if (n ==0 ) {gfp_t gfp = dvnode->vfs_inode.i_mapping->gfp_mask;
@@ -273,22 +340,24 @@ static struct afs_read *afs_read_dir(struct afs_vnode *dvnode, struct key *key)afs_stat_v (dvnode, n_inval); ret = -ENOMEM ; - req->pages[i] =__page_cache_alloc (gfp); -if (!req->pages[i]) + page =__page_cache_alloc (gfp); +if (!page) goto error; - ret =add_to_page_cache_lru (req->pages[i], + ret =add_to_page_cache_lru (page, dvnode->vfs_inode.i_mapping, i, gfp);if (ret <0 ) goto error; -attach_page_private (req->pages[i], (void *)1 ); -unlock_page (req->pages[i]); +attach_page_private (page, (void *)1 ); +unlock_page (page); + req->nr_pages++; i++; }else { + req->nr_pages += n; i += n; } - }while (i < req->nr_pages); + }/* If we're going to reload, we need to lock all the pages to prevent * races.
@@ -312,12 +381,17 @@ static struct afs_read *afs_read_dir(struct afs_vnode *dvnode, struct key *key)task_io_account_read (PAGE_SIZE * req->nr_pages); -if (req->len < req->file_size) - goto content_has_grown; +if (req->len < req->file_size) { +/* The content has grown, so we need to expand the +* buffer. +*/ +up_write (&dvnode->validate_lock); + goto expand; + }/* Validate the data we just read. */ - ret = -EIO ; -if (!afs_dir_check_pages (dvnode, req)) + ret =afs_dir_check (dvnode, req); +if (ret <0 ) goto error_unlock;// TODO: Trim excess pages
@@ -335,11 +409,6 @@ static struct afs_read *afs_read_dir(struct afs_vnode *dvnode, struct key *key)afs_put_read (req);_leave (" = %d" , ret);return ERR_PTR (ret); - -content_has_grown: -up_write (&dvnode->validate_lock); -afs_put_read (req); - goto retry; }/*
@@ -449,6 +518,7 @@ static int afs_dir_iterate(struct inode *dir, struct dir_context *ctx,struct afs_read *req;struct page *page;unsigned blkoff, limit; +void __rcu **slot;int ret;_enter ("{%lu},%u,," , dir->i_ino, (unsigned )ctx->pos);
@@ -473,9 +543,15 @@ static int afs_dir_iterate(struct inode *dir, struct dir_context *ctx, blkoff = ctx->pos & ~(sizeof (union afs_xdr_dir_block ) -1 );/* Fetch the appropriate page from the directory and re-add it -* to the LRU. +* to the LRU. We have all the pages pinned with an extra ref. */ - page = req->pages[blkoff /PAGE_SIZE ]; +rcu_read_lock (); + page =NULL ; + slot =radix_tree_lookup_slot (&dvnode->vfs_inode.i_mapping->i_pages, + blkoff /PAGE_SIZE ); +if (slot) + page =radix_tree_deref_slot (slot); +rcu_read_unlock ();if (!page) { ret =afs_bad (dvnode, afs_file_error_dir_missing_page);break ;
fs/afs/file.c +110 -80
287 lines not on this page · raw message
fs/afs/fsclient.c +14 -40
103 lines not on this page · raw message
fs/afs/internal.h +8 -8
@@ -31,6 +31,7 @@struct pagevec ;struct afs_call ; +struct afs_vnode ;/* * Partial file-locking emulation mode. (The problem being that AFS3 only
@@ -203,18 +204,18 @@ struct afs_read {loff_t pos;/* Where to start reading */ loff_t len;/* How much we're asking for */ loff_t actual_len;/* How much we're actually getting */ -loff_t remain;/* Amount remaining */ loff_t file_size;/* File size returned by server */ struct key *key;/* The key to use to reissue the read */ +struct afs_vnode *vnode;/* The file being read into. */ afs_dataversion_t data_version;/* Version number returned by server */ refcount_t usage; -unsigned int index;/* Which page we're reading into */ +unsigned int call_debug_id;unsigned int nr_pages; -unsigned int offset;/* offset into current page */ -struct afs_vnode *vnode; -void (*page_done)(struct afs_read *); -struct page **pages; -struct page *array[]; +int error; +void (*done)(struct afs_read *); +void (*cleanup)(struct afs_read *); +struct iov_iter *iter;/* Iterator representing the buffer */ +struct iov_iter def_iter;/* Default iterator */ };/*
@@ -1048,7 +1049,6 @@ extern void afs_put_wb_key(struct afs_wb_key *);extern int afs_open (struct inode *,struct file *);extern int afs_release (struct inode *,struct file *);extern int afs_fetch_data (struct afs_vnode *,struct afs_read *); -extern int afs_page_filler (void *,struct page *);extern void afs_put_read (struct afs_read *);static inline struct afs_read *afs_get_read (struct afs_read *req)
fs/afs/write.c +19 -8
@@ -22,6 +22,16 @@ int afs_set_page_dirty(struct page *page)return __set_page_dirty_nobuffers (page); } +/* +* Handle completion of a read operation to fill a page. +*/ +static void afs_fill_hole (struct afs_read *req) +{ +if (iov_iter_count (req->iter) >0 ) +/* The read was short - clear the excess buffer. */ +iov_iter_zero (iov_iter_count (req->iter), req->iter); +} +/* * partly or wholly fill a page that's under preparation for writing */
@@ -45,18 +55,19 @@ static int afs_fill_page(struct file *file,return 0 ; } - req =kzalloc (struct_size (req, array,1 ),GFP_KERNEL ); + req =kzalloc (sizeof (struct afs_read ),GFP_KERNEL );if (!req)return -ENOMEM ;refcount_set (&req->usage,1 ); - req->key =key_get (afs_file_key (file)); - req->pos = pos; - req->len = len; - req->nr_pages =1 ; - req->pages = req->array; - req->pages[0 ] = page; -get_page (page); + req->vnode = vnode; + req->done = afs_fill_hole; + req->key =key_get (afs_file_key (file)); + req->pos = pos; + req->len = len; + req->nr_pages =1 ; + req->iter = &req->def_iter; +iov_iter_xarray (&req->def_iter,READ , &file->f_mapping->i_pages, pos, len); ret =afs_fetch_data (vnode, req);afs_put_read (req);
fs/afs/yfsclient.c +14 -40
101 lines not on this page · raw message
David Howells
maintainerPATCH 22/33 afs: Use ITER_XARRAY for writing
In reply to David HowellsUse a single ITER_XARRAY iterator to describe the portion of a file to be transmitted to the server rather than generating a series of small ITER_BVEC iterators on the fly. This will make it easier to implement AIO in afs.
In theory we could maybe use one giant ITER_BVEC, but that means potentially allocating a huge array of bio_vec structs (max 256 per page) when in fact the pagecache already has a structure listing all the relevant pages (radix_tree/xarray) that can be walked over.
---
fs/afs/fsclient.c | 50 +++++++++------------ fs/afs/internal.h | 15 +++--- fs/afs/rxrpc.c | 103 ++++++-------------------------------------- fs/afs/write.c | 100 ++++++++++++++++++++++++------------------- fs/afs/yfsclient.c | 25 +++-------- include/trace/events/afs.h | 51 ++++++++-------------- 6 files changed, 126 insertions(+), 218 deletions(-)
fs/afs/fsclient.c +20 -30
@@ -1055,8 +1055,7 @@ static const struct afs_call_type afs_RXFSStoreData64 = {/* * store a set of pages to a very large file */ -static void afs_fs_store_data64 (struct afs_operation *op, -loff_t pos,loff_t size,loff_t i_size) +static void afs_fs_store_data64 (struct afs_operation *op) {struct afs_vnode_param *vp = &op->file[0 ];struct afs_call *call;
@@ -1071,7 +1070,7 @@ static void afs_fs_store_data64(struct afs_operation *op,if (!call)return afs_op_nomem (op); - call->send_pages = true; + call->write_iter = op->store.write_iter;/* marshall the parameters */ bp = call->request;
@@ -1087,47 +1086,38 @@ static void afs_fs_store_data64(struct afs_operation *op, *bp++ =0 ;/* unix mode */ *bp++ =0 ;/* segment size */ - *bp++ =htonl (upper_32_bits (pos)); - *bp++ =htonl (lower_32_bits (pos)); - *bp++ =htonl (upper_32_bits (size)); - *bp++ =htonl (lower_32_bits (size)); - *bp++ =htonl (upper_32_bits (i_size)); - *bp++ =htonl (lower_32_bits (i_size)); + *bp++ =htonl (upper_32_bits (op->store.pos)); + *bp++ =htonl (lower_32_bits (op->store.pos)); + *bp++ =htonl (upper_32_bits (op->store.size)); + *bp++ =htonl (lower_32_bits (op->store.size)); + *bp++ =htonl (upper_32_bits (op->store.i_size)); + *bp++ =htonl (lower_32_bits (op->store.i_size));trace_afs_make_fs_call (call, &vp->fid);afs_make_op_call (op, call,GFP_NOFS ); }/* -* store a set of pages +* Write data to a file on the server. */ void afs_fs_store_data (struct afs_operation *op) {struct afs_vnode_param *vp = &op->file[0 ];struct afs_call *call; -loff_t size, pos, i_size;__be32 *bp;_enter (",%x,{%llx:%llu},," ,key_serial (op->key), vp->fid.vid, vp->fid.vnode); - size = (loff_t )op->store.last_to - (loff_t )op->store.first_offset; -if (op->store.first != op->store.last) - size += (loff_t)(op->store.last - op->store.first) <<PAGE_SHIFT ; - pos = (loff_t )op->store.first <<PAGE_SHIFT ; - pos += op->store.first_offset; - - i_size =i_size_read (&vp->vnode->vfs_inode); -if (pos + size > i_size) - i_size = size + pos; -_debug ("size %llx, at %llx, i_size %llx" , - (unsigned long long ) size, (unsigned long long ) pos, - (unsigned long long ) i_size); + (unsigned long long )op->store.size, + (unsigned long long )op->store.pos, + (unsigned long long )op->store.i_size); -if (upper_32_bits (pos) ||upper_32_bits (i_size) ||upper_32_bits (size) || -upper_32_bits (pos + size)) -return afs_fs_store_data64 (op, pos, size, i_size); +if (upper_32_bits (op->store.pos) || +upper_32_bits (op->store.size) || +upper_32_bits (op->store.i_size)) +return afs_fs_store_data64 (op); call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData, (4 + 6 + 3) * 4,
@@ -1135,7 +1125,7 @@ void afs_fs_store_data(struct afs_operation *op)if (!call)return afs_op_nomem (op); - call->send_pages = true; + call->write_iter = op->store.write_iter;/* marshall the parameters */ bp = call->request;
@@ -1151,9 +1141,9 @@ void afs_fs_store_data(struct afs_operation *op) *bp++ =0 ;/* unix mode */ *bp++ =0 ;/* segment size */ - *bp++ =htonl (lower_32_bits (pos)); - *bp++ =htonl (lower_32_bits (size)); - *bp++ =htonl (lower_32_bits (i_size)); + *bp++ =htonl (lower_32_bits (op->store.pos)); + *bp++ =htonl (lower_32_bits (op->store.size)); + *bp++ =htonl (lower_32_bits (op->store.i_size));trace_afs_make_fs_call (call, &vp->fid);afs_make_op_call (op, call,GFP_NOFS );
fs/afs/internal.h +8 -7
@@ -107,6 +107,7 @@ struct afs_call {void *request;/* request data (first part) */ size_t iov_len;/* Size of *iter to be used */ struct iov_iter def_iter;/* Default buffer/data iterator */ +struct iov_iter *write_iter;/* Iterator defining write to be made */ struct iov_iter *iter;/* Iterator currently in use */ union {/* Convenience for ->def_iter */ struct kvec kvec[1 ];
@@ -133,7 +134,6 @@ struct afs_call {unsigned char unmarshall;/* unmarshalling phase */ unsigned char addr_ix;/* Address in ->alist */ bool drop_ref;/* T if need to drop ref for incoming call */ -bool send_pages;/* T if data from mapping should be sent */ bool need_attention;/* T if RxRPC poked us */ bool async;/* T if asynchronous */ bool upgrade;/* T to request service upgrade */
@@ -811,12 +811,13 @@ struct afs_operation {afs_lock_type_t type; } lock;struct { -struct address_space *mapping;/* Pages being written from */ -pgoff_t first;/* first page in mapping to deal with */ -pgoff_t last;/* last page in mapping to deal with */ -unsigned first_offset;/* offset into mapping[first] */ -unsigned last_to;/* amount of mapping[last] */ -bool laundering;/* Laundering page, PG_writeback not set */ +struct iov_iter *write_iter; +loff_t pos; +loff_t size; +loff_t i_size; +pgoff_t first;/* first page in mapping to deal with */ +pgoff_t last;/* last page in mapping to deal with */ +bool laundering;/* Laundering page, PG_writeback not set */ } store;struct {struct iattr *attr;
fs/afs/rxrpc.c +15 -88
133 lines not on this page · raw message
fs/afs/write.c +57 -43
176 lines not on this page · raw message
fs/afs/yfsclient.c +7 -18
@@ -1078,25 +1078,15 @@ void yfs_fs_store_data(struct afs_operation *op) {struct afs_vnode_param *vp = &op->file[0 ];struct afs_call *call; -loff_t size, pos, i_size;__be32 *bp;_enter (",%x,{%llx:%llu},," ,key_serial (op->key), vp->fid.vid, vp->fid.vnode); - size = (loff_t )op->store.last_to - (loff_t )op->store.first_offset; -if (op->store.first != op->store.last) - size += (loff_t)(op->store.last - op->store.first) <<PAGE_SHIFT ; - pos = (loff_t )op->store.first <<PAGE_SHIFT ; - pos += op->store.first_offset; - - i_size =i_size_read (&vp->vnode->vfs_inode); -if (pos + size > i_size) - i_size = size + pos; -_debug ("size %llx, at %llx, i_size %llx" , - (unsigned long long )size, (unsigned long long )pos, - (unsigned long long )i_size); + (unsigned long long )op->store.size, + (unsigned long long )op->store.pos, + (unsigned long long )op->store.i_size); call = afs_alloc_flat_call(op->net, &yfs_RXYFSStoreData64, sizeof(__be32) +
@@ -1109,8 +1099,7 @@ void yfs_fs_store_data(struct afs_operation *op)if (!call)return afs_op_nomem (op); - call->key = op->key; - call->send_pages = true; + call->write_iter = op->store.write_iter;/* marshall the parameters */ bp = call->request;
@@ -1118,9 +1107,9 @@ void yfs_fs_store_data(struct afs_operation *op) bp =xdr_encode_u32 (bp,0 );/* RPC flags */ bp =xdr_encode_YFSFid (bp, &vp->fid); bp =xdr_encode_YFSStoreStatus_mtime (bp, &op->mtime); - bp =xdr_encode_u64 (bp, pos); - bp =xdr_encode_u64 (bp, size); - bp =xdr_encode_u64 (bp, i_size); + bp =xdr_encode_u64 (bp, op->store.pos); + bp =xdr_encode_u64 (bp, op->store.size); + bp =xdr_encode_u64 (bp, op->store.i_size);yfs_check_req (call, bp);trace_afs_make_fs_call (call, &vp->fid);
include/trace/events/afs.h +19 -32
84 lines not on this page · raw message
David Howells
maintainerPATCH 23/33 afs: Wait on PG_fscache before modifying/releasing a page
In reply to David HowellsPG_fscache is going to be used to indicate that a page is being written to the cache, and that the page should not be modified or released until it's finished.
Make afs_invalidatepage() and afs_releasepage() wait for it.
---
fs/afs/file.c | 9 +++++++++ fs/afs/write.c | 10 ++++++++++ 2 files changed, 19 insertions(+)
fs/afs/file.c +9 -0
@@ -594,6 +594,7 @@ static void afs_invalidatepage(struct page *page, unsigned int offset,if (PagePrivate (page))afs_invalidate_dirty (page, offset, length); +wait_on_page_fscache (page);_leave ("" ); }
@@ -611,6 +612,14 @@ static int afs_releasepage(struct page *page, gfp_t gfp_flags)/* deny if page is being written to the cache and the caller hasn't * elected to wait */ +#ifdef CONFIG_AFS_FSCACHE +if (PageFsCache (page)) { +if (!(gfp_flags & __GFP_DIRECT_RECLAIM) || !(gfp_flags & __GFP_FS)) +return false; +wait_on_page_fscache (page); + } +#endif +if (PagePrivate (page)) {detach_page_private (page);trace_afs_page_dirty (vnode,tracepoint_string ("rel" ), page);
fs/afs/write.c +10 -0
@@ -117,6 +117,10 @@ int afs_write_begin(struct file *file, struct address_space *mapping,SetPageUptodate (page); } +#ifdef CONFIG_AFS_FSCACHE +wait_on_page_fscache (page); +#endif + try_again:/* See if this page is already partially written in a way that we can * merge the new write with.
@@ -857,6 +861,11 @@ vm_fault_t afs_page_mkwrite(struct vm_fault *vmf)/* Wait for the page to be written to the cache before we allow it to * be modified. We then assume the entire page will need writing back. */ +#ifdef CONFIG_AFS_FSCACHE +if (PageFsCache (vmf->page) && +wait_on_page_bit_killable (vmf->page, PG_fscache) <0 ) +return VM_FAULT_RETRY ; +#endif if (PageWriteback (vmf->page) &&wait_on_page_bit_killable (vmf->page, PG_writeback) <0 )
@@ -948,5 +957,6 @@ int afs_launder_page(struct page *page)detach_page_private (page);trace_afs_page_dirty (vnode,tracepoint_string ("laundered" ), page); +wait_on_page_fscache (page);return ret; }
David Howells
maintainerPATCH 24/33 afs: Extract writeback extension into its own function
In reply to David HowellsExtract writeback extension into its own function to break up the writeback function a bit.
---
fs/afs/write.c | 109 ++++++++++++++++++++++++++++++++++---------------------- 1 file changed, 67 insertions(+), 42 deletions(-)
fs/afs/write.c +67 -42
@@ -490,47 +490,25 @@ static int afs_store_data(struct afs_vnode *vnode, struct iov_iter *iter, }/* -* Synchronously write back the locked page and any subsequent non-locked dirty -* pages. +* Extend the region to be written back to include subsequent contiguously +* dirty pages if possible, but don't sleep while doing so. +* +* If this page holds new content, then we can include filler zeros in the +* writeback. */ -static int afs_write_back_from_locked_page (struct address_space *mapping, -struct writeback_control *wbc, -struct page *primary_page, -pgoff_t final_page) +static void afs_extend_writeback (struct address_space *mapping, +struct afs_vnode *vnode, +long *_count, +pgoff_t start, +pgoff_t final_page, +unsigned *_offset, +unsigned *_to, +bool new_content) { -struct afs_vnode *vnode =AFS_FS_I (mapping->host); -struct iov_iter iter;struct page *pages[8 ], *page; -unsigned long count, priv; -unsigned n, offset, to, f, t; -pgoff_t start, first, last; -loff_t i_size, pos, end; -int loop, ret; - -_enter (",%lx" , primary_page->index); - - count =1 ; -if (test_set_page_writeback (primary_page)) -BUG (); - -/* Find all consecutive lockable dirty pages that have contiguous -* written regions, stopping when we find a page that is not -* immediately lockable, is not dirty or is missing, or we reach the -* end of the range. -*/ - start = primary_page->index; - priv =page_private (primary_page); - offset =afs_page_dirty_from (primary_page, priv); - to =afs_page_dirty_to (primary_page, priv); -trace_afs_page_dirty (vnode,tracepoint_string ("store" ), primary_page); - -WARN_ON (offset == to); -if (offset == to) -trace_afs_page_dirty (vnode,tracepoint_string ("WARN" ), primary_page); - -if (start >= final_page || - (to <PAGE_SIZE && !test_bit (AFS_VNODE_NEW_CONTENT , &vnode->flags))) - goto no_more; +unsigned long count = *_count, priv; +unsigned offset = *_offset, to = *_to, n, f, t; +int loop; start++; do {
@@ -551,8 +529,7 @@ static int afs_write_back_from_locked_page(struct address_space *mapping,for (loop =0 ; loop < n; loop++) { page = pages[loop]; -if (to !=PAGE_SIZE && - !test_bit (AFS_VNODE_NEW_CONTENT , &vnode->flags)) +if (to !=PAGE_SIZE && !new_content)break ;if (page->index > final_page)break ;
@@ -566,8 +543,7 @@ static int afs_write_back_from_locked_page(struct address_space *mapping, priv =page_private (page); f =afs_page_dirty_from (page, priv); t =afs_page_dirty_to (page, priv); -if (f !=0 && - !test_bit (AFS_VNODE_NEW_CONTENT , &vnode->flags)) { +if (f !=0 && !new_content) {unlock_page (page);break ; }
@@ -593,6 +569,55 @@ static int afs_write_back_from_locked_page(struct address_space *mapping, }while (start <= final_page && count <65536 ); no_more: + *_count = count; + *_offset = offset; + *_to = to; +} + +/* +* Synchronously write back the locked page and any subsequent non-locked dirty +* pages. +*/ +static int afs_write_back_from_locked_page (struct address_space *mapping, +struct writeback_control *wbc, +struct page *primary_page, +pgoff_t final_page) +{ +struct afs_vnode *vnode =AFS_FS_I (mapping->host); +struct iov_iter iter; +unsigned long count, priv; +unsigned offset, to; +pgoff_t start, first, last; +loff_t i_size, pos, end; +bool new_content =test_bit (AFS_VNODE_NEW_CONTENT , &vnode->flags); +int ret; + +_enter (",%lx" , primary_page->index); + + count =1 ; +if (test_set_page_writeback (primary_page)) +BUG (); + +/* Find all consecutive lockable dirty pages that have contiguous +* written regions, stopping when we find a page that is not +* immediately lockable, is not dirty or is missing, or we reach the +* end of the range. +*/ + start = primary_page->index; + priv =page_private (primary_page); + offset =afs_page_dirty_from (primary_page, priv); + to =afs_page_dirty_to (primary_page, priv); +trace_afs_page_dirty (vnode,tracepoint_string ("store" ), primary_page); + +WARN_ON (offset == to); +if (offset == to) +trace_afs_page_dirty (vnode,tracepoint_string ("WARN" ), primary_page); + +if (start < final_page && + (to ==PAGE_SIZE || new_content)) +afs_extend_writeback (mapping, vnode, &count, start, final_page, + &offset, &to, new_content); +/* We now have a contiguous set of dirty pages, each with writeback * set; the first page is still locked at this point, but all the rest * have been unlocked.
David Howells
maintainerPATCH 25/33 afs: Prepare for use of THPs
In reply to David HowellsAs a prelude to supporting transparent huge pages, use thp_size() and similar rather than PAGE_SIZE/SHIFT.
Further, try and frame everything in terms of file positions and lengths rather than page indices and numbers of pages.
---
fs/afs/dir.c | 2 fs/afs/file.c | 8 - fs/afs/internal.h | 2 fs/afs/write.c | 436 +++++++++++++++++++++++++++++------------------------ 4 files changed, 245 insertions(+), 203 deletions(-)
fs/afs/dir.c +1 -1
@@ -2082,6 +2082,6 @@ static void afs_dir_invalidatepage(struct page *page, unsigned int offset,afs_stat_v (dvnode, n_inval);/* we clean up only if the entire page is being invalidated */ -if (offset ==0 && length ==PAGE_SIZE ) +if (offset ==0 && length ==thp_size (page))detach_page_private (page); }
fs/afs/file.c +4 -4
@@ -330,8 +330,8 @@ static int afs_page_filler(struct key *key, struct page *page) req->vnode = vnode; req->key =key_get (key); req->pos = (loff_t )page->index <<PAGE_SHIFT ; - req->len =PAGE_SIZE ; - req->nr_pages =1 ; + req->len =thp_size (page); + req->nr_pages =thp_nr_pages (page); req->done = afs_file_read_done; req->cleanup = afs_file_read_cleanup;
@@ -575,8 +575,8 @@ static void afs_invalidate_dirty(struct page *page, unsigned int offset,trace_afs_page_dirty (vnode,tracepoint_string ("undirty" ), page);clear_page_dirty_for_io (page); full_invalidate: -detach_page_private (page);trace_afs_page_dirty (vnode,tracepoint_string ("inval" ), page); +detach_page_private (page); }/*
@@ -621,8 +621,8 @@ static int afs_releasepage(struct page *page, gfp_t gfp_flags)#endif if (PagePrivate (page)) { -detach_page_private (page);trace_afs_page_dirty (vnode,tracepoint_string ("rel" ), page); +detach_page_private (page); }/* indicate that the page can be released */
fs/afs/internal.h +0 -2
@@ -815,8 +815,6 @@ struct afs_operation {loff_t pos;loff_t size;loff_t i_size; -pgoff_t first;/* first page in mapping to deal with */ -pgoff_t last;/* last page in mapping to deal with */ bool laundering;/* Laundering page, PG_writeback not set */ } store;struct {
fs/afs/write.c +240 -196
755 lines not on this page · raw message
David Howells
maintainerPATCH 26/33 afs: Use the fs operation ops to handle FetchData completion
In reply to David HowellsUse the 'success' and 'aborted' afs_operations_ops methods and add a 'failed' method to handle the completion of an AFS.FetchData, AFS.FetchData64 or YFS.FetchData64 RPC operation rather than directly calling the done func pointed to by the afs_read struct from the call delivery handler.
This means the done function will be called back on error also, not just on successful completion.
This allows motion towards asynchronous data reception on data fetch calls and allows any error to be handed off to the fscache read helper in the same place as a successful completion.
---
fs/afs/file.c | 15 +++++++++++++++ fs/afs/fs_operation.c | 4 +++- fs/afs/fsclient.c | 3 --- fs/afs/internal.h | 1 + fs/afs/yfsclient.c | 3 --- 5 files changed, 19 insertions(+), 7 deletions(-)
fs/afs/file.c +15 -0
@@ -255,6 +255,19 @@ void afs_put_read(struct afs_read *req) } } +static void afs_fetch_data_notify (struct afs_operation *op) +{ +struct afs_read *req = op->fetch.req; +int error = op->error; + +if (error == -ECONNABORTED ) + error =afs_abort_to_error (op->ac.abort_code); + req->error = error; + +if (req->done) + req->done (req); +} +static void afs_fetch_data_success (struct afs_operation *op) {struct afs_vnode *vnode = op->file[0 ].vnode;
@@ -263,6 +276,7 @@ static void afs_fetch_data_success(struct afs_operation *op)afs_vnode_commit_status (op, &op->file[0 ]);afs_stat_v (vnode, n_fetches);atomic_long_add (op->fetch.req->actual_len, &op->net->n_fetch_bytes); +afs_fetch_data_notify (op); }static void afs_fetch_data_put (struct afs_operation *op)
@@ -276,6 +290,7 @@ static const struct afs_operation_ops afs_fetch_data_operation = { .issue_yfs_rpc = yfs_fs_fetch_data, .success = afs_fetch_data_success, .aborted = afs_check_for_remote_deletion, + .failed = afs_fetch_data_notify, .put = afs_fetch_data_put, };
fs/afs/fs_operation.c +3 -1
@@ -195,8 +195,10 @@ void afs_wait_for_operation(struct afs_operation *op)case -ECONNABORTED :if (op->ops->aborted) op->ops->aborted (op); -break ; + fallthrough;default : +if (op->ops->failed) + op->ops->failed (op);break ; }
fs/afs/fsclient.c +0 -3
@@ -392,9 +392,6 @@ static int afs_deliver_fs_fetch_data(struct afs_call *call)break ; } -if (req->done) - req->done (req); -_leave (" = 0 [done]" );return 0 ; }
fs/afs/internal.h +1 -0
@@ -742,6 +742,7 @@ struct afs_operation_ops {void (*issue_yfs_rpc)(struct afs_operation *op);void (*success)(struct afs_operation *op);void (*aborted)(struct afs_operation *op); +void (*failed)(struct afs_operation *op);void (*edit_dir)(struct afs_operation *op);void (*put)(struct afs_operation *op); };
fs/afs/yfsclient.c +0 -3
@@ -449,9 +449,6 @@ static int yfs_deliver_fs_fetch_data64(struct afs_call *call)break ; } -if (req->done) - req->done (req); -_leave (" = 0 [done]" );return 0 ; }
David Howells
maintainerPATCH 27/33 afs: Use new fscache read helper API
In reply to David HowellsMake AFS use the new fscache read helpers to implement the VM read operations:
- afs_readpage() now hands off responsibility to fscache_readpage().
- afs_readpages() is gone and replaced with afs_readahead().
- afs_readahead() just hands off responsibility to fscache_readahead().
These make use of the cache if a cookie is supplied, otherwise just call the ->issue_op() method a sufficient number of times to complete the entire request.
Changes:
- Folded in error handling fixes to afs_req_issue_op().
---
fs/afs/Kconfig | 1 fs/afs/file.c | 321 ++++++++++++----------------------------------------- fs/afs/fsclient.c | 1 fs/afs/internal.h | 3 4 files changed, 80 insertions(+), 246 deletions(-)
fs/afs/Kconfig +1 -0
@@ -4,6 +4,7 @@ config AFS_FS depends on INET select AF_RXRPC select DNS_RESOLVER + select NETFS_SUPPORT help If you say Y here, you will get an experimental Andrew File System driver. It currently only supports unsecured read-only AFS access.
fs/afs/file.c +75 -246
393 lines not on this page · raw message
fs/afs/fsclient.c +1 -0
@@ -10,6 +10,7 @@#include <linux/sched.h> #include <linux/circ_buf.h> #include <linux/iversion.h> +#include <linux/netfs.h> #include "internal.h" #include "afs_fs.h" #include "xdr_fs.h"
fs/afs/internal.h +3 -0
@@ -14,6 +14,7 @@#include <linux/key.h> #include <linux/workqueue.h> #include <linux/sched.h> +#define FSCACHE_USE_NEW_IO_API #include <linux/fscache.h> #include <linux/backing-dev.h> #include <linux/uuid.h>
@@ -207,6 +208,7 @@ struct afs_read {loff_t file_size;/* File size returned by server */ struct key *key;/* The key to use to reissue the read */ struct afs_vnode *vnode;/* The file being read into. */ +struct netfs_read_subrequest *subreq;/* Fscache helper read request this belongs to */ afs_dataversion_t data_version;/* Version number returned by server */ refcount_t usage;unsigned int call_debug_id;
@@ -1049,6 +1051,7 @@ extern void afs_put_wb_key(struct afs_wb_key *);extern int afs_open (struct inode *,struct file *);extern int afs_release (struct inode *,struct file *);extern int afs_fetch_data (struct afs_vnode *,struct afs_read *); +extern struct afs_read *afs_alloc_read (gfp_t );extern void afs_put_read (struct afs_read *);static inline struct afs_read *afs_get_read (struct afs_read *req)
David Howells
maintainerPATCH 28/33 ceph: disable old fscache readpage handling
In reply to David HowellsFrom: Jeff Layton <[email protected]>
With the new netfs read helper functions, we won't need a lot of this infrastructure as it handles the pagecache pages itself. Rip out the read handling for now, and much of the old infrastructure that deals in individual pages.
The cookie handling is mostly unchanged, however.
---
fs/ceph/addr.c | 31 +------------- fs/ceph/cache.c | 125 ------------------------------------------------------- fs/ceph/cache.h | 91 ---------------------------------------- fs/ceph/caps.c | 9 ---- 4 files changed, 3 insertions(+), 253 deletions(-)
fs/ceph/addr.c +2 -29
@@ -155,8 +155,6 @@ static void ceph_invalidatepage(struct page *page, unsigned int offset,return ; } -ceph_invalidate_fscache_page (inode, page); -WARN_ON (!PageLocked (page));if (!PagePrivate (page))return ;
@@ -175,10 +173,6 @@ static int ceph_releasepage(struct page *page, gfp_t g)dout ("%p releasepage %p idx %lu (%sdirty)\n" , page->mapping->host, page, page->index,PageDirty (page) ?"" :"not " ); -/* Can we release the page from the cache? */ -if (!ceph_release_fscache_page (page, g)) -return 0 ; -return !PagePrivate (page); }
@@ -213,10 +207,6 @@ static int ceph_do_readpage(struct file *filp, struct page *page)return 0 ; } - err =ceph_readpage_from_fscache (inode, page); -if (err ==0 ) -return -EINPROGRESS ; -dout ("readpage ino %llx.%llx file %p off %llu len %llu page %p index %lu\n" , vino.ino, vino.snap, filp, off, len, page, page->index); req = ceph_osdc_new_request(osdc, &ci->i_layout, vino, off, &len, 0, 1,
@@ -241,7 +231,6 @@ static int ceph_do_readpage(struct file *filp, struct page *page)if (err == -ENOENT ) err =0 ;if (err <0 ) { -ceph_fscache_readpage_cancel (inode, page);if (err == -EBLOCKLISTED ) fsc->blocklisted = true; goto out;
@@ -253,8 +242,6 @@ static int ceph_do_readpage(struct file *filp, struct page *page)flush_dcache_page (page);SetPageUptodate (page); -ceph_readpage_to_fscache (inode, page); - out:return err <0 ? err :0 ; }
@@ -294,10 +281,8 @@ static void finish_read(struct ceph_osd_request *req)for (i =0 ; i < num_pages; i++) {struct page *page = osd_data->pages[i]; -if (rc <0 && rc != -ENOENT ) { -ceph_fscache_readpage_cancel (inode, page); +if (rc <0 && rc != -ENOENT ) goto unlock; - }if (bytes < (int )PAGE_SIZE ) {/* zero (remainder of) page */ int s = bytes <0 ?0 : bytes;
@@ -307,7 +292,6 @@ static void finish_read(struct ceph_osd_request *req) page->index);flush_dcache_page (page);SetPageUptodate (page); -ceph_readpage_to_fscache (inode, page); unlock:unlock_page (page);put_page (page);
@@ -408,7 +392,6 @@ static int start_read(struct inode *inode, struct ceph_rw_context *rw_ctx, page->index);if (add_to_page_cache_lru (page, &inode->i_data, page->index,GFP_KERNEL )) { -ceph_fscache_uncache_page (inode, page);put_page (page);dout ("start_read %p add_to_page_cache failed %p\n" , inode, page);
@@ -440,10 +423,8 @@ static int start_read(struct inode *inode, struct ceph_rw_context *rw_ctx,return nr_pages; out_pages: -for (i =0 ; i < nr_pages; ++i) { -ceph_fscache_readpage_cancel (inode, pages[i]); +for (i =0 ; i < nr_pages; ++i)unlock_page (pages[i]); - }ceph_put_page_vector (pages, nr_pages, false); out_put:ceph_osdc_put_request (req);
@@ -471,12 +452,6 @@ static int ceph_readpages(struct file *file, struct address_space *mapping,if (ceph_inode (inode)->i_inline_version !=CEPH_INLINE_NONE )return -EINVAL ; - rc =ceph_readpages_from_fscache (mapping->host, mapping, page_list, - &nr_pages); - -if (rc ==0 ) - goto out; - rw_ctx =ceph_find_rw_context (fi); max = fsc->mount_options->rsize >>PAGE_SHIFT ; dout("readpages %p file %p ctx %p nr_pages %d max %d\n",
@@ -487,8 +462,6 @@ static int ceph_readpages(struct file *file, struct address_space *mapping, goto out; } out: -ceph_fscache_readpages_cancel (inode, page_list); -dout ("readpages %p file %p ret %d\n" , inode, file, rc);return rc; }
fs/ceph/cache.c +0 -125
146 lines not on this page · raw message
fs/ceph/cache.h +1 -90
116 lines not on this page · raw message
fs/ceph/caps.c +0 -9
@@ -2730,10 +2730,6 @@ static int try_get_cap_refs(struct inode *inode, int need, int want, *got = need | want; else *got = need; -if (S_ISREG (inode->i_mode) && - (need &CEPH_CAP_FILE_RD ) && - !(*got &CEPH_CAP_FILE_CACHE )) -ceph_disable_fscache_readpage (ci);ceph_take_cap_refs (ci, *got, true); ret =1 ; }
@@ -2983,11 +2979,6 @@ int ceph_get_caps(struct file *filp, int need, int want, }break ; } - -if (S_ISREG (ci->vfs_inode.i_mode) && - (_got &CEPH_CAP_FILE_RD ) && (_got &CEPH_CAP_FILE_CACHE )) -ceph_fscache_revalidate_cookie (ci); - *got = _got;return 0 ; }
David Howells
maintainerPATCH 29/33 ceph: rework PageFsCache handling
In reply to David HowellsFrom: Jeff Layton <[email protected]>
With the new fscache API, the PageFsCache bit now indicates that the page is being written to the cache and shouldn't be modified or released until it's finished.
Change releasepage and invalidatepage to wait on that bit before returning.
Also define FSCACHE_USE_NEW_IO_API so that we opt into the new fscache API.
---
fs/ceph/addr.c | 9 ++++++++- fs/ceph/super.h | 1 + 2 files changed, 9 insertions(+), 1 deletion(-)
fs/ceph/addr.c +8 -1
@@ -146,6 +146,8 @@ static void ceph_invalidatepage(struct page *page, unsigned int offset,struct ceph_inode_info *ci;struct ceph_snap_context *snapc =page_snap_context (page); +wait_on_page_fscache (page); + inode = page->mapping->host; ci =ceph_inode (inode);
@@ -168,11 +170,16 @@ static void ceph_invalidatepage(struct page *page, unsigned int offset,ClearPagePrivate (page); } -static int ceph_releasepage (struct page *page,gfp_t g) +static int ceph_releasepage (struct page *page,gfp_t gfp_flags) {dout ("%p releasepage %p idx %lu (%sdirty)\n" , page->mapping->host, page, page->index,PageDirty (page) ?"" :"not " ); +if (PageFsCache (page)) { +if (!(gfp_flags & __GFP_DIRECT_RECLAIM) || !(gfp_flags & __GFP_FS)) +return 0 ; +wait_on_page_fscache (page); + }return !PagePrivate (page); }
fs/ceph/super.h +1 -0
@@ -21,6 +21,7 @@#include <linux/ceph/libceph.h> #ifdef CONFIG_CEPH_FSCACHE +#define FSCACHE_USE_NEW_IO_API #include <linux/fscache.h> #endif
David Howells
maintainerPATCH 30/33 ceph: fix fscache invalidation
In reply to David HowellsFrom: Jeff Layton <[email protected]>
Ensure that we invalidate the fscache whenever we invalidate the pagecache.
---
fs/ceph/caps.c | 1 + fs/ceph/inode.c | 1 + 2 files changed, 2 insertions(+)
fs/ceph/caps.c +1 -0
@@ -1867,6 +1867,7 @@ static int try_nonblocking_invalidate(struct inode *inode)u32 invalidating_gen = ci->i_rdcache_gen;spin_unlock (&ci->i_ceph_lock); +ceph_fscache_invalidate (inode);invalidate_mapping_pages (&inode->i_data,0 ,-1 );spin_lock (&ci->i_ceph_lock);
fs/ceph/inode.c +1 -0
@@ -1906,6 +1906,7 @@ static void ceph_do_invalidate_pages(struct inode *inode) orig_gen = ci->i_rdcache_gen;spin_unlock (&ci->i_ceph_lock); +ceph_fscache_invalidate (inode);if (invalidate_inode_pages2 (inode->i_mapping) <0 ) {pr_err ("invalidate_pages %p fails\n" , inode); }
David Howells
maintainerPATCH 31/33 ceph: convert readpage to fscache read helper
In reply to David HowellsFrom: Jeff Layton <[email protected]>
Have the ceph KConfig select NETFS_SUPPORT. Add a new netfs ops structure and the operations for it. Convert ceph_readpage to use the new netfs_readpage helper.
---
fs/ceph/Kconfig | 1 fs/ceph/addr.c | 149 +++++++++++++++++++++++++++++++++++++++++++++++++++---- fs/ceph/cache.h | 36 +++++++++++++ 3 files changed, 176 insertions(+), 10 deletions(-)
fs/ceph/Kconfig +1 -0
@@ -6,6 +6,7 @@ config CEPH_FS select LIBCRC32C select CRYPTO_AES select CRYPTO + select NETFS_SUPPORT default n help Choose Y or M here to include support for mounting the
fs/ceph/addr.c +139 -10
167 lines not on this page · raw message
fs/ceph/cache.h +36 -0
@@ -9,6 +9,8 @@#ifndef _CEPH_CACHE_H#define _CEPH_CACHE_H +#include <linux/netfs.h> +#ifdef CONFIG_CEPH_FSCACHE extern struct fscache_netfs ceph_cache_netfs;
@@ -35,11 +37,31 @@ static inline void ceph_fscache_inode_init(struct ceph_inode_info *ci) ci->fscache =NULL ; } +static inline struct fscache_cookie *ceph_fscache_cookie (struct ceph_inode_info *ci) +{ +return ci->fscache; +} +static inline void ceph_fscache_invalidate (struct inode *inode) {fscache_invalidate (ceph_inode (inode)->fscache); } +static inline bool ceph_is_cache_enabled (struct inode *inode) +{ +struct fscache_cookie *cookie =ceph_fscache_cookie (ceph_inode (inode)); + +if (!cookie) +return false; +return fscache_cookie_enabled (cookie); +} + +static inline int ceph_begin_cache_operation (struct netfs_read_request *rreq) +{ +struct fscache_cookie *cookie =ceph_fscache_cookie (ceph_inode (rreq->inode)); + +return fscache_begin_read_operation (rreq, cookie); +}#else static inline int ceph_fscache_register (void )
@@ -65,6 +87,11 @@ static inline void ceph_fscache_inode_init(struct ceph_inode_info *ci) { } +static inline struct fscache_cookie *ceph_fscache_cookie (struct ceph_inode_info *ci) +{ +return NULL ; +} +static inline void ceph_fscache_register_inode_cookie (struct inode *inode) { }
@@ -82,6 +109,15 @@ static inline void ceph_fscache_invalidate(struct inode *inode) { } +static inline bool ceph_is_cache_enabled (struct inode *inode) +{ +return false; +} + +static inline int ceph_begin_cache_operation (struct netfs_read_request *rreq) +{ +return -ENOBUFS ; +}#endif #endif /* _CEPH_CACHE_H */
David Howells
maintainerPATCH 32/33 ceph: plug write_begin into read helper
In reply to David HowellsFrom: Jeff Layton <[email protected]>
Convert ceph_write_begin to use the netfs_write_begin helper. Most of the ops we need for it are already in place from the readpage conversion but we do add a new check_write_begin op since ceph needs to be able to vet whether there is an incompatible writeback already in flight before reading in the page.
With this, we can also remove the old ceph_do_readpage helper.
---
fs/ceph/addr.c | 187 ++++++++++++++++++-------------------------------------- 1 file changed, 61 insertions(+), 126 deletions(-)
fs/ceph/addr.c +61 -126
@@ -322,76 +322,6 @@ static int ceph_readpage(struct file *file, struct page *page)return netfs_readpage (file, page, &ceph_readpage_netfs_ops,NULL ); } -/* read a single page, without unlocking it. */ -static int ceph_do_readpage (struct file *filp,struct page *page) -{ -struct inode *inode =file_inode (filp); -struct ceph_inode_info *ci =ceph_inode (inode); -struct ceph_fs_client *fsc =ceph_inode_to_client (inode); -struct ceph_osd_client *osdc = &fsc->client->osdc; -struct ceph_osd_request *req; -struct ceph_vino vino =ceph_vino (inode); -int err =0 ; -u64 off =page_offset (page); -u64 len =PAGE_SIZE ; - -if (off >=i_size_read (inode)) { -zero_user_segment (page,0 ,PAGE_SIZE ); -SetPageUptodate (page); -return 0 ; - } - -if (ci->i_inline_version !=CEPH_INLINE_NONE ) { -/* -* Uptodate inline data should have been added -* into page cache while getting Fcr caps. -*/ -if (off ==0 ) -return -EINVAL ; -zero_user_segment (page,0 ,PAGE_SIZE ); -SetPageUptodate (page); -return 0 ; - } - -dout ("readpage ino %llx.%llx file %p off %llu len %llu page %p index %lu\n" , - vino.ino, vino.snap, filp, off, len, page, page->index); - req =ceph_osdc_new_request (osdc, &ci->i_layout, vino, off, &len,0 ,1 , -CEPH_OSD_OP_READ ,CEPH_OSD_FLAG_READ ,NULL , - ci->i_truncate_seq, ci->i_truncate_size, - false); -if (IS_ERR (req)) -return PTR_ERR (req); - -osd_req_op_extent_osd_data_pages (req,0 , &page, len,0 , false, false); - - err =ceph_osdc_start_request (osdc, req, false); -if (!err) - err =ceph_osdc_wait_request (osdc, req); - -ceph_update_read_latency (&fsc->mdsc->metric, req->r_start_latency, - req->r_end_latency, err); - -ceph_osdc_put_request (req); -dout ("readpage result %d\n" , err); - -if (err == -ENOENT ) - err =0 ; -if (err <0 ) { -if (err == -EBLOCKLISTED ) - fsc->blocklisted = true; - goto out; - } -if (err <PAGE_SIZE ) -/* zero fill remainder of page */ -zero_user_segment (page, err,PAGE_SIZE ); -else -flush_dcache_page (page); - -SetPageUptodate (page); -out: -return err <0 ? err :0 ; -} -/* * Finish an async read(ahead) op. */
@@ -1411,6 +1341,40 @@ ceph_find_incompatible(struct page *page)return NULL ; } +static int ceph_netfs_check_write_begin (struct file *file,loff_t pos,unsigned int len, +struct page *page,void **_fsdata) +{ +struct inode *inode =file_inode (file); +struct ceph_inode_info *ci =ceph_inode (inode); +struct ceph_snap_context *snapc; + + snapc =ceph_find_incompatible (page); +if (snapc) { +int r; + +unlock_page (page); +put_page (page); +if (IS_ERR (snapc)) +return PTR_ERR (snapc); + +ceph_queue_writeback (inode); + r =wait_event_killable (ci->i_cap_wq, +context_is_writeable_or_written (inode, snapc)); +ceph_put_snap_context (snapc); +return r ==0 ? -EAGAIN : r; + } +return 0 ; +} + +const struct netfs_read_request_ops ceph_netfs_write_begin_ops = { + .init_rreq = ceph_init_rreq, + .is_cache_enabled = ceph_is_cache_enabled, + .begin_cache_operation = ceph_begin_cache_operation, + .issue_op = ceph_netfs_issue_op, + .clamp_length = ceph_netfs_clamp_length, + .check_write_begin = ceph_netfs_check_write_begin, +}; +/* * We are only allowed to write into/dirty the page if the page is * clean, or already dirty within the same snap context.
@@ -1421,75 +1385,46 @@ static int ceph_write_begin(struct file *file, struct address_space *mapping, {struct inode *inode =file_inode (file);struct ceph_inode_info *ci =ceph_inode (inode); -struct ceph_snap_context *snapc;struct page *page =NULL ;pgoff_t index = pos >>PAGE_SHIFT ; -int pos_in_page = pos & ~PAGE_MASK ; -int r =0 ; - -dout ("write_begin file %p inode %p page %p %d~%d\n" , file, inode, page, (int )pos, (int )len); - -for (;;) { - page =grab_cache_page_write_begin (mapping, index, flags); -if (!page) { - r = -ENOMEM ; -break ; - } - - snapc =ceph_find_incompatible (page); -if (snapc) { -if (IS_ERR (snapc)) { - r =PTR_ERR (snapc); -break ; - } -unlock_page (page); -put_page (page); - page =NULL ; -ceph_queue_writeback (inode); - r =wait_event_killable (ci->i_cap_wq, -context_is_writeable_or_written (inode, snapc)); -ceph_put_snap_context (snapc); -if (r !=0 ) -break ; -continue ; - } - -if (PageUptodate (page)) { -dout (" page %p already uptodate\n" , page); -break ; - } +int r; +if (ci->i_inline_version !=CEPH_INLINE_NONE ) {/* -* In some cases we don't need to read at all: -* - full page write -* - write that lies completely beyond EOF -* - write that covers the the page from start to EOF or beyond it +* In principle, we should never get here, as the inode should have been uninlined +* before we're allowed to write to the page (in write_iter or page_mkwrite). */ -if ((pos_in_page ==0 && len ==PAGE_SIZE ) || - (pos >=i_size_read (inode)) || - (pos_in_page ==0 && (pos + len) >=i_size_read (inode))) { -zero_user_segments (page,0 , pos_in_page, - pos_in_page + len,PAGE_SIZE ); -break ; - } +WARN_ONCE (1 ,"ceph: write_begin called on still-inlined inode!\n" );/* -* We need to read it. If we get back -EINPROGRESS, then the page was -* handed off to fscache and it will be unlocked when the read completes. -* Refind the page in that case so we can reacquire the page lock. Otherwise -* we got a hard error or the read was completed synchronously. +* Uptodate inline data should have been added +* into page cache while getting Fcr caps. */ - r =ceph_do_readpage (file, page); -if (r != -EINPROGRESS ) -break ; +if (index ==0 ) { + r = -EINVAL ; + goto out; + } + + page =grab_cache_page_write_begin (mapping, index, flags); +if (!page) +return -ENOMEM ; + +zero_user_segment (page,0 ,PAGE_SIZE ); +SetPageUptodate (page); + r =0 ; + goto out; } + r =netfs_write_begin (file, inode->i_mapping, pos, len,0 , &page,NULL , + &ceph_netfs_write_begin_ops,NULL ); +out: +if (r ==0 ) +wait_on_page_fscache (page);if (r <0 ) { -if (page) { -unlock_page (page); +if (page)put_page (page); - } }else { +WARN_ON_ONCE (!PageLocked (page)); *pagep = page; }return r;
David Howells
maintainerPATCH 33/33 ceph: convert ceph_readpages to ceph_readahead
In reply to David HowellsFrom: Jeff Layton <[email protected]>
Convert ceph_readpages to ceph_readahead and make it use netfs_readahead. With this we can rip out a lot of the old readpage/readpages infrastructure.
---
fs/ceph/addr.c | 229 ++++++++------------------------------------------------ 1 file changed, 34 insertions(+), 195 deletions(-)
fs/ceph/addr.c +34 -195
@@ -322,214 +322,53 @@ static int ceph_readpage(struct file *file, struct page *page)return netfs_readpage (file, page, &ceph_readpage_netfs_ops,NULL ); } -/* -* Finish an async read(ahead) op. -*/ -static void finish_read (struct ceph_osd_request *req) +static void ceph_readahead_cleanup (struct address_space *mapping,void *priv) { -struct inode *inode = req->r_inode; -struct ceph_fs_client *fsc =ceph_inode_to_client (inode); -struct ceph_osd_data *osd_data; -int rc = req->r_result <=0 ? req->r_result :0 ; -int bytes = req->r_result >=0 ? req->r_result :0 ; -int num_pages; -int i; - -dout ("finish_read %p req %p rc %d bytes %d\n" , inode, req, rc, bytes); -if (rc == -EBLOCKLISTED ) -ceph_inode_to_client (inode)->blocklisted = true; - -/* unlock all pages, zeroing any data we didn't read */ - osd_data =osd_req_op_extent_osd_data (req,0 ); -BUG_ON (osd_data->type !=CEPH_OSD_DATA_TYPE_PAGES ); - num_pages =calc_pages_for ((u64 )osd_data->alignment, - (u64 )osd_data->length); -for (i =0 ; i < num_pages; i++) { -struct page *page = osd_data->pages[i]; - -if (rc <0 && rc != -ENOENT ) - goto unlock; -if (bytes < (int )PAGE_SIZE ) { -/* zero (remainder of) page */ -int s = bytes <0 ?0 : bytes; -zero_user_segment (page, s,PAGE_SIZE ); - } -dout ("finish_read %p uptodate %p idx %lu\n" , inode, page, - page->index); -flush_dcache_page (page); -SetPageUptodate (page); -unlock: -unlock_page (page); -put_page (page); - bytes -=PAGE_SIZE ; - } - -ceph_update_read_latency (&fsc->mdsc->metric, req->r_start_latency, - req->r_end_latency, rc); - -kfree (osd_data->pages); -} - -/* -* start an async read(ahead) operation. return nr_pages we submitted -* a read for on success, or negative error code. -*/ -static int start_read (struct inode *inode,struct ceph_rw_context *rw_ctx, -struct list_head *page_list,int max) -{ -struct ceph_osd_client *osdc = - &ceph_inode_to_client (inode)->client->osdc; +struct inode *inode = mapping->host;struct ceph_inode_info *ci =ceph_inode (inode); -struct page *page =lru_to_page (page_list); -struct ceph_vino vino; -struct ceph_osd_request *req; -u64 off; -u64 len; -int i; -struct page **pages; -pgoff_t next_index; -int nr_pages =0 ; -int got =0 ; -int ret =0 ; - -if (!rw_ctx) { -/* caller of readpages does not hold buffer and read caps -* (fadvise, madvise and readahead cases) */ -int want =CEPH_CAP_FILE_CACHE ; - ret =ceph_try_get_caps (inode,CEPH_CAP_FILE_RD , want, - true, &got); -if (ret <0 ) { -dout ("start_read %p, error getting cap\n" , inode); - }else if (!(got & want)) { -dout ("start_read %p, no cache cap\n" , inode); - ret =0 ; - } -if (ret <=0 ) { -if (got) -ceph_put_cap_refs (ci, got); -while (!list_empty (page_list)) { - page =lru_to_page (page_list); -list_del (&page->lru); -put_page (page); - } -return ret; - } - } - - off = (u64 )page_offset (page); - -/* count pages */ - next_index = page->index; -list_for_each_entry_reverse (page, page_list, lru) { -if (page->index != next_index) -break ; - nr_pages++; - next_index++; -if (max && nr_pages == max) -break ; - } - len = nr_pages <<PAGE_SHIFT ; -dout ("start_read %p nr_pages %d is %lld~%lld\n" , inode, nr_pages, - off, len); - vino =ceph_vino (inode); - req =ceph_osdc_new_request (osdc, &ci->i_layout, vino, off, &len, -0 ,1 ,CEPH_OSD_OP_READ , -CEPH_OSD_FLAG_READ ,NULL , - ci->i_truncate_seq, ci->i_truncate_size, - false); -if (IS_ERR (req)) { - ret =PTR_ERR (req); - goto out; - } - -/* build page vector */ - nr_pages =calc_pages_for (0 , len); - pages =kmalloc_array (nr_pages,sizeof (*pages),GFP_KERNEL ); -if (!pages) { - ret = -ENOMEM ; - goto out_put; - } -for (i =0 ; i < nr_pages; ++i) { - page = list_entry(page_list->prev, struct page, lru); -BUG_ON (PageLocked (page)); -list_del (&page->lru); - -dout ("start_read %p adding %p idx %lu\n" , inode, page, - page->index); -if (add_to_page_cache_lru (page, &inode->i_data, page->index, -GFP_KERNEL )) { -put_page (page); -dout ("start_read %p add_to_page_cache failed %p\n" , - inode, page); - nr_pages = i; -if (nr_pages >0 ) { - len = nr_pages <<PAGE_SHIFT ; -osd_req_op_extent_update (req,0 , len); -break ; - } - goto out_pages; - } - pages[i] = page; - } -osd_req_op_extent_osd_data_pages (req,0 , pages, len,0 , false, false); - req->r_callback = finish_read; - req->r_inode = inode; - -dout ("start_read %p starting %p %lld~%lld\n" , inode, req, off, len); - ret =ceph_osdc_start_request (osdc, req, false); -if (ret <0 ) - goto out_pages; -ceph_osdc_put_request (req); +int got = (int )(uintptr_t )priv; -/* After adding locked pages to page cache, the inode holds cache cap. -* So we can drop our cap refs. */ if (got)ceph_put_cap_refs (ci, got); - -return nr_pages; - -out_pages: -for (i =0 ; i < nr_pages; ++i) -unlock_page (pages[i]); -ceph_put_page_vector (pages, nr_pages, false); -out_put: -ceph_osdc_put_request (req); -out: -if (got) -ceph_put_cap_refs (ci, got); -return ret; } +const struct netfs_read_request_ops ceph_readahead_netfs_ops = { + .init_rreq = ceph_init_rreq, + .is_cache_enabled = ceph_is_cache_enabled, + .begin_cache_operation = ceph_begin_cache_operation, + .issue_op = ceph_netfs_issue_op, + .clamp_length = ceph_netfs_clamp_length, + .cleanup = ceph_readahead_cleanup, +}; - -/* -* Read multiple pages. Leave pages we don't read + unlock in page_list; -* the caller (VM) cleans them up. -*/ -static int ceph_readpages (struct file *file,struct address_space *mapping, -struct list_head *page_list,unsigned nr_pages) +static void ceph_readahead (struct readahead_control *ractl) { -struct inode *inode =file_inode (file); -struct ceph_fs_client *fsc =ceph_inode_to_client (inode); -struct ceph_file_info *fi = file->private_data; +struct inode *inode =file_inode (ractl->file); +struct ceph_file_info *fi = ractl->file->private_data;struct ceph_rw_context *rw_ctx; -int rc =0 ; -int max =0 ; +int got =0 ; +int ret =0 ;if (ceph_inode (inode)->i_inline_version !=CEPH_INLINE_NONE ) -return -EINVAL ; +return ; rw_ctx =ceph_find_rw_context (fi); - max = fsc->mount_options->rsize >>PAGE_SHIFT ; -dout ("readpages %p file %p ctx %p nr_pages %d max %d\n" , - inode, file, rw_ctx, nr_pages, max); -while (!list_empty (page_list)) { - rc =start_read (inode, rw_ctx, page_list, max); -if (rc <0 ) - goto out; +if (!rw_ctx) { +/* +* readahead callers do not necessarily hold Fcb caps +* (e.g. fadvise, madvise). +*/ +int want =CEPH_CAP_FILE_CACHE ; + + ret =ceph_try_get_caps (inode,CEPH_CAP_FILE_RD , want, true, &got); +if (ret <0 ) +dout ("start_read %p, error getting cap\n" , inode); +else if (!(got & want)) +dout ("start_read %p, no cache cap\n" , inode); + +if (ret <=0 ) +return ; } -out: -dout ("readpages %p file %p ret %d\n" , inode, file, rc); -return rc; +netfs_readahead (ractl, &ceph_readahead_netfs_ops, (void *)(uintptr_t )got); }struct ceph_writeback_ctl
@@ -1482,7 +1321,7 @@ static ssize_t ceph_direct_io(struct kiocb *iocb, struct iov_iter *iter)const struct address_space_operations ceph_aops = { .readpage = ceph_readpage, - .readpages = ceph_readpages, + .readahead = ceph_readahead, .writepage = ceph_writepage, .writepages = ceph_writepages_start, .write_begin = ceph_write_begin,
Quoted 217 lines · David Howells
Here's a set of patches to do two things:
(1) Add a helper library to handle the new VM readahead interface. This is intended to be used unconditionally by the filesystem (whether or not caching is enabled) and provides a common framework for doing caching, transparent huge pages and, in the future, possibly fscrypt and read bandwidth maximisation. It also allows the netfs and the cache to align, expand and slice up a read request from the VM in various ways; the netfs need only provide a function to read a stretch of data to the pagecache and the helper takes care of the rest.
(2) Add an alternative fscache/cachfiles I/O API that uses the kiocb facility to do async DIO to transfer data to/from the netfs's pages, rather than using readpage with wait queue snooping on one side and
vfs_write()on the other. It also uses less memory, since it doesn't do buffered I/O on the backing file.Note that this uses SEEK_HOLE/SEEK_DATA to locate the data available to be read from the cache. Whilst this is an improvement from the bmap interface, it still has a problem with regard to a modern extent-based filesystem inserting or removing bridging blocks of zeros. Fixing that requires a much greater overhaul.
This is a step towards overhauling the fscache API. The change is opt-in on the part of the network filesystem. A netfs should not try to mix the old and the new API because of conflicting ways of handling pages and the
PG_fscachepage flag and because it would be mixing DIO with buffered I/O. Further, the helper library can't be used with the old API.This does not change any of the fscache cookie handling APIs or the way invalidation is done.
In the near term, I intend to deprecate and remove the old I/O API (fscache_allocate_page{,s}(), fscache_read_or_alloc_page{,s}(),
fscache_write_page()andfscache_uncache_page()) and eventually replace most of fscache/cachefiles with something simpler and easier to follow.The patchset contains five parts:
(1) Some helper patches, including provision of an
ITER_XARRAYiov iterator and a function to do readahead expansion.(2) Patches to add the netfs helper library.
(3) A patch to add the fscache/cachefiles kiocb API.
(4) Patches to add support in AFS for this.
(5) Patches from Jeff Layton to add support in Ceph for this.
Dave Wysochanski also has patches for NFS for this, though they're not included on this branch as there's an issue with PNFS.
With this, AFS without a cache passes all expected xfstests; with a cache, there's an extra failure, but that's also there before these patches. Fixing that probably requires a greater overhaul. Ceph and NFS also pass the expected tests.
These patches can be found also on:
https://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs.git/log/?h=fscache-netfs-lib
For diffing reference, the tag for the 9th Feb pull request is fscache-ioapi-20210203 and can be found in the same repository.
Changes
=======(v3) Rolled in the bug fixes.
Adjusted the functions that unlock and wait for
PG_fscacheaccording to Linus's suggestion.Hold a ref on a page when
PG_fscacheis set as per Linus's suggestion.Dropped NFS support and added Ceph support.
(v2) Fixed some bugs and added NFS support.
References
==========These patches have been published for review before, firstly as part of a larger set:
Link https://lore.kernel.org/linux-fsdevel/159465766378.1376105.11619976251039287525.stgit@warthog.procyon.org.uk/ open hereThen as a cut-down set:
Proposals/information about the design has been published here:
And requests for information:
The NFS parts, though not included here, have been tested by someone who's using fscache in production:
I've posted partial patches to try and help 9p and cifs along:
David
---
David Howells (27):
iov_iter: AddITER_XARRAY
mm: Add an unlock function for PG_private_2/PG_fscache
mm: Implementreadahead_controlpageset expansion
vfs: Exportrw_verify_area()for use by cachefiles
netfs: Make a netfs helper module
netfs, mm: MovePG_fscachehelper funcs tolinux/netfs.hnetfs, mm: Addunlock_page_fscache()andwait_on_page_fscache()
netfs: Provide readahead and readpage netfs helpers
netfs: Add tracepoints
netfs: Gather stats
netfs: Addwrite_beginhelper
netfs: Define an interface to talk to a cache
netfs: Hold a ref on a page whenPG_private_2is set
fscache, cachefiles: Add alternate API to use kiocb for read/write to cache
afs: Disable use of the fscache I/O routines
afs: Pass page into dirty region helpers to provide THP size
afs: Print the operationdebug_idwhen logging an unexpected data version
afs: Move key toafs_readstruct
afs: Don't truncate iter during data fetch
afs: Log remote unmarshalling errors
afs: Set up theiov_iterbefore callingafs_extract_data()
afs: UseITER_XARRAYfor writing
afs: Wait onPG_fscachebefore modifying/releasing a page
afs: Extract writeback extension into its own function
afs: Prepare for use of THPs
afs: Use the fs operation ops to handle FetchData completion
afs: Use new fscache read helper APIJeff Layton (6):
ceph: disable old fscache readpage handling
ceph: rework PageFsCache handling
ceph: fix fscache invalidation
ceph: convert readpage to fscache read helper
ceph: plugwrite_begininto read helper
ceph: convertceph_readpagestoceph_readaheadfs/Kconfig | 1 + fs/Makefile | 1 + fs/afs/Kconfig | 1 + fs/afs/dir.c | 225 ++++--- fs/afs/file.c | 470 ++++--------- fs/afs/fs_operation.c | 4 +- fs/afs/fsclient.c | 108 +-- fs/afs/inode.c | 7 +- fs/afs/internal.h | 58 +- fs/afs/rxrpc.c | 150 ++--- fs/afs/write.c | 610 +++++++++-------- fs/afs/yfsclient.c | 82 +-- fs/cachefiles/Makefile | 1 + fs/cachefiles/interface.c | 5 +- fs/cachefiles/internal.h | 9 + fs/cachefiles/rdwr2.c | 412 ++++++++++++ fs/ceph/Kconfig | 1 + fs/ceph/addr.c | 535 ++++++--------- fs/ceph/cache.c | 125 ---- fs/ceph/cache.h | 101 +-- fs/ceph/caps.c | 10 +- fs/ceph/inode.c | 1 + fs/ceph/super.h | 1 + fs/fscache/Kconfig | 1 + fs/fscache/Makefile | 3 +- fs/fscache/internal.h | 3 + fs/fscache/page.c | 2 +- fs/fscache/page2.c | 117 ++++ fs/fscache/stats.c | 1 + fs/internal.h | 5 - fs/netfs/Kconfig | 23 + fs/netfs/Makefile | 5 + fs/netfs/internal.h | 97 +++ fs/netfs/read_helper.c | 1169 +++++++++++++++++++++++++++++++++ fs/netfs/stats.c | 59 ++ fs/read_write.c | 1 + include/linux/fs.h | 1 + include/linux/fscache-cache.h | 4 + include/linux/fscache.h | 40 +- include/linux/netfs.h | 195 ++++++ include/linux/pagemap.h | 3 + include/net/af_rxrpc.h | 2 +- include/trace/events/afs.h | 74 +-- include/trace/events/netfs.h | 201 ++++++ mm/filemap.c | 20 + mm/readahead.c | 70 ++ net/rxrpc/recvmsg.c | 9 +- 47 files changed, 3473 insertions(+), 1550 deletions(-)
Quoted 11 lines
create mode 100644
fs/cachefiles/rdwr2.c
create mode 100644fs/fscache/page2.c
create mode 100644fs/netfs/Kconfig
create mode 100644fs/netfs/Makefile
create mode 100644fs/netfs/internal.h
create mode 100644fs/netfs/read_helper.c
create mode 100644fs/netfs/stats.c
create mode 100644include/linux/netfs.h
create mode 100644include/trace/events/netfs.h
Thanks David,
I did an xfstests run on ceph with a kernel based on this and it seemed to do fine. I'll plan to pull this into the ceph-client/testing branch and run it through the ceph kclient test harness. There are only a few differences from the last run we did, so I'm not expecting big changes, but I'll keep you posted.
Signature · 1 line
Jeff Layton <[email protected]>
Jeff,
What are the performance differences you are seeing (positive or negative) with ceph and netfs, especially with simple examples like file copy or grep of large files?
It could be good if netfs simplifies the problem experienced by network filesystems on Linux with readahead on large sequential reads
- where we don't get as much parallelism due to only having one readahead request at a time (thus in many cases there is 'dead time' on either the network or the file server while waiting for the next
readpages request to be issued). This can be a significant
performance problem for current readpages when network latency is long (or e.g. in cases when network encryption is enabled, and hardware offload not available so time consuming on the server or client to encrypt the packet).
Do you see netfs much faster than currentreadpages for ceph?
Have you been able to get much benefit from throttling readahead with ceph from the current netfs approach for clamping i/o?
Quoted 242 lines · Jeff Layton
Quoted 218 lines · David Howells
Here's a set of patches to do two things:
(1) Add a helper library to handle the new VM readahead interface. This is intended to be used unconditionally by the filesystem (whether or not caching is enabled) and provides a common framework for doing caching, transparent huge pages and, in the future, possibly fscrypt and read bandwidth maximisation. It also allows the netfs and the cache to align, expand and slice up a read request from the VM in various ways; the netfs need only provide a function to read a stretch of data to the pagecache and the helper takes care of the rest.
(2) Add an alternative fscache/cachfiles I/O API that uses the kiocb facility to do async DIO to transfer data to/from the netfs's pages, rather than using readpage with wait queue snooping on one side and
vfs_write()on the other. It also uses less memory, since it doesn't do buffered I/O on the backing file.Note that this uses SEEK_HOLE/SEEK_DATA to locate the data available to be read from the cache. Whilst this is an improvement from the bmap interface, it still has a problem with regard to a modern extent-based filesystem inserting or removing bridging blocks of zeros. Fixing that requires a much greater overhaul.
This is a step towards overhauling the fscache API. The change is opt-in on the part of the network filesystem. A netfs should not try to mix the old and the new API because of conflicting ways of handling pages and the
PG_fscachepage flag and because it would be mixing DIO with buffered I/O. Further, the helper library can't be used with the old API.This does not change any of the fscache cookie handling APIs or the way invalidation is done.
In the near term, I intend to deprecate and remove the old I/O API (fscache_allocate_page{,s}(), fscache_read_or_alloc_page{,s}(),
fscache_write_page()andfscache_uncache_page()) and eventually replace most of fscache/cachefiles with something simpler and easier to follow.The patchset contains five parts:
(1) Some helper patches, including provision of an
ITER_XARRAYiov iterator and a function to do readahead expansion.(2) Patches to add the netfs helper library.
(3) A patch to add the fscache/cachefiles kiocb API.
(4) Patches to add support in AFS for this.
(5) Patches from Jeff Layton to add support in Ceph for this.
Dave Wysochanski also has patches for NFS for this, though they're not included on this branch as there's an issue with PNFS.
With this, AFS without a cache passes all expected xfstests; with a cache, there's an extra failure, but that's also there before these patches. Fixing that probably requires a greater overhaul. Ceph and NFS also pass the expected tests.
These patches can be found also on:
https://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs.git/log/?h=fscache-netfs-lib
For diffing reference, the tag for the 9th Feb pull request is fscache-ioapi-20210203 and can be found in the same repository.
Changes
=======(v3) Rolled in the bug fixes.
Adjusted the functions that unlock and wait for
PG_fscacheaccording to Linus's suggestion.Hold a ref on a page when
PG_fscacheis set as per Linus's suggestion.Dropped NFS support and added Ceph support.
(v2) Fixed some bugs and added NFS support.
References
==========These patches have been published for review before, firstly as part of a larger set:
Link https://lore.kernel.org/linux-fsdevel/159465766378.1376105.11619976251039287525.stgit@warthog.procyon.org.uk/ open hereThen as a cut-down set:
Proposals/information about the design has been published here:
And requests for information:
The NFS parts, though not included here, have been tested by someone who's using fscache in production:
I've posted partial patches to try and help 9p and cifs along:
David
---
David Howells (27):
iov_iter: AddITER_XARRAY
mm: Add an unlock function for PG_private_2/PG_fscache
mm: Implementreadahead_controlpageset expansion
vfs: Exportrw_verify_area()for use by cachefiles
netfs: Make a netfs helper module
netfs, mm: MovePG_fscachehelper funcs tolinux/netfs.hnetfs, mm: Addunlock_page_fscache()andwait_on_page_fscache()
netfs: Provide readahead and readpage netfs helpers
netfs: Add tracepoints
netfs: Gather stats
netfs: Addwrite_beginhelper
netfs: Define an interface to talk to a cache
netfs: Hold a ref on a page whenPG_private_2is set
fscache, cachefiles: Add alternate API to use kiocb for read/write to cache
afs: Disable use of the fscache I/O routines
afs: Pass page into dirty region helpers to provide THP size
afs: Print the operationdebug_idwhen logging an unexpected data version
afs: Move key toafs_readstruct
afs: Don't truncate iter during data fetch
afs: Log remote unmarshalling errors
afs: Set up theiov_iterbefore callingafs_extract_data()
afs: UseITER_XARRAYfor writing
afs: Wait onPG_fscachebefore modifying/releasing a page
afs: Extract writeback extension into its own function
afs: Prepare for use of THPs
afs: Use the fs operation ops to handle FetchData completion
afs: Use new fscache read helper APIJeff Layton (6):
ceph: disable old fscache readpage handling
ceph: rework PageFsCache handling
ceph: fix fscache invalidation
ceph: convert readpage to fscache read helper
ceph: plugwrite_begininto read helper
ceph: convertceph_readpagestoceph_readaheadfs/Kconfig | 1 + fs/Makefile | 1 + fs/afs/Kconfig | 1 + fs/afs/dir.c | 225 ++++--- fs/afs/file.c | 470 ++++--------- fs/afs/fs_operation.c | 4 +- fs/afs/fsclient.c | 108 +-- fs/afs/inode.c | 7 +- fs/afs/internal.h | 58 +- fs/afs/rxrpc.c | 150 ++--- fs/afs/write.c | 610 +++++++++-------- fs/afs/yfsclient.c | 82 +-- fs/cachefiles/Makefile | 1 + fs/cachefiles/interface.c | 5 +- fs/cachefiles/internal.h | 9 + fs/cachefiles/rdwr2.c | 412 ++++++++++++ fs/ceph/Kconfig | 1 + fs/ceph/addr.c | 535 ++++++--------- fs/ceph/cache.c | 125 ---- fs/ceph/cache.h | 101 +-- fs/ceph/caps.c | 10 +- fs/ceph/inode.c | 1 + fs/ceph/super.h | 1 + fs/fscache/Kconfig | 1 + fs/fscache/Makefile | 3 +- fs/fscache/internal.h | 3 + fs/fscache/page.c | 2 +- fs/fscache/page2.c | 117 ++++ fs/fscache/stats.c | 1 + fs/internal.h | 5 - fs/netfs/Kconfig | 23 + fs/netfs/Makefile | 5 + fs/netfs/internal.h | 97 +++ fs/netfs/read_helper.c | 1169 +++++++++++++++++++++++++++++++++ fs/netfs/stats.c | 59 ++ fs/read_write.c | 1 + include/linux/fs.h | 1 + include/linux/fscache-cache.h | 4 + include/linux/fscache.h | 40 +- include/linux/netfs.h | 195 ++++++ include/linux/pagemap.h | 3 + include/net/af_rxrpc.h | 2 +- include/trace/events/afs.h | 74 +-- include/trace/events/netfs.h | 201 ++++++ mm/filemap.c | 20 + mm/readahead.c | 70 ++ net/rxrpc/recvmsg.c | 9 +- 47 files changed, 3473 insertions(+), 1550 deletions(-) create mode 100644 fs/cachefiles/rdwr2.cQuoted 10 lines
create mode 100644 fs/fscache/page2.c create mode 100644 fs/netfs/Kconfig create mode 100644 fs/netfs/Makefile create mode 100644 fs/netfs/internal.h create mode 100644 fs/netfs/read_helper.c create mode 100644 fs/netfs/stats.c create mode 100644 include/linux/netfs.h create mode 100644 include/trace/events/netfs.hThanks David,
I did an xfstests run on ceph with a kernel based on this and it seemed to do fine. I'll plan to pull this into the ceph-client/testing branch and run it through the ceph kclient test harness. There are only a few differences from the last run we did, so I'm not expecting big changes, but I'll keep you posted.
--
Jeff Layton <[email protected]>
Signature · 3 lines
Thanks, Steve
Matthew Wilcox
maintainerQuoted 11 lines · Steve French
It could be good if netfs simplifies the problem experienced by network filesystems on Linux with readahead on large sequential reads
- where we don't get as much parallelism due to only having one readahead request at a time (thus in many cases there is 'dead time' on either the network or the file server while waiting for the next
readpages request to be issued). This can be a significant
performance problem for current readpages when network latency is long (or e.g. in cases when network encryption is enabled, and hardware offload not available so time consuming on the server or client to encrypt the packet).
Quoted 4 lines
Do you see netfs much faster than currentreadpages for ceph?
Have you been able to get much benefit from throttling readahead with ceph from the current netfs approach for clamping i/o?
The switch from readpages to readahead does help in a couple of corner cases. For example, if you have two processes reading the same file at the same time, one will now block on the other (due to the page lock) rather than submitting a mess of overlapping and partial reads.
We're not there yet on having multiple outstanding reads. Bill and I had a chat recently about how to make the readahead code detect that it is in a "long fat pipe" situation (as opposed to just dealing with a slow device), and submit extra readahead requests to make best use of the bandwidth and minimise blocking of the application.
That's not something for the netfs code to do though; we can get into that situation with highly parallel SSDs.
Quoted 23 lines · Matthew Wilcox
Quoted 11 lines · Steve French
It could be good if netfs simplifies the problem experienced by network filesystems on Linux with readahead on large sequential reads
- where we don't get as much parallelism due to only having one readahead request at a time (thus in many cases there is 'dead time' on either the network or the file server while waiting for the next
readpages request to be issued). This can be a significant
performance problem for current readpages when network latency is long (or e.g. in cases when network encryption is enabled, and hardware offload not available so time consuming on the server or client to encrypt the packet).Quoted 4 lines
Do you see netfs much faster than currentreadpages for ceph?
Have you been able to get much benefit from throttling readahead with ceph from the current netfs approach for clamping i/o?
The switch from readpages to readahead does help in a couple of corner cases. For example, if you have two processes reading the same file at the same time, one will now block on the other (due to the page lock) rather than submitting a mess of overlapping and partial reads.
Quoted 8 lines
We're not there yet on having multiple outstanding reads. Bill and I had a chat recently about how to make the readahead code detect that it is in a "long fat pipe" situation (as opposed to just dealing with a slow device), and submit extra readahead requests to make best use of the bandwidth and minimise blocking of the application.
That's not something for the netfs code to do though; we can get into that situation with highly parallel SSDs.
This (readahead behavior improvements in Linux, on single large file sequential read workloads like cp or grep) gets particularly interesting
with SMB3 as multichannel becomes more common. With one channel having one readahead request pending on the network is suboptimal - but not as bad as when multichannel is negotiated. Interestingly in most cases two network connections
to the same server (different TCP sockets,but the same mount, even in cases where
only network adapter) can achieve better performance - but still significantly lags Windows (and probably other clients) as in Linux we don't keep multiple I/Os
in flight at one time (unless different files are being read at the same time
by different threads). As network adapters are added and removed from the
server (other client typically poll to detect interface changes, and SMB3 also leverages the "witness protocol" to get notification of adapter additions or removals) - it would be helpful to change the maximum number of readahead requests in flight. In addition, as the server throttles back (reducing the number of 'credits' granted to the client) it will be important to give hints to the readahead logic about reducing the number of
read ahead requests in flight. Keeping multiple readahead requests
is easier to imagine when multiple processes are copying or reading files, but there are many scenarios where we could do better with parallelizing a single process doing copy by ensuring that there is no 'dead time' on the network.
Signature · 3 lines
Thanks, Steve
David Howells
maintainerQuoted 10 lines · Steve French
This (readahead behavior improvements in Linux, on single large file sequential read workloads like cp or grep) gets particularly interesting with SMB3 as multichannel becomes more common. With one channel having one readahead request pending on the network is suboptimal - but not as bad as when multichannel is negotiated. Interestingly in most cases two network connections to the same server (different TCP sockets,but the same mount, even in cases where only network adapter) can achieve better performance - but still significantly lags Windows (and probably other clients) as in Linux we don't keep multiple I/Os in flight at one time (unless different files are being read at the same time by different threads).
I think it should be relatively straightforward to make the netfs_readahead() function generate multiple read requests. If I wasn't handed sufficient pages by the VM upfront to do two or more read requests, I would need to do extra expansion. There are a couple of ways this could be done:
(1) I could expand the readahead_control after fully starting a read request and then create another independent read request, and another for how ever many we want.
(2) I could expand the readahead_control first to cover however many requests I'm going to generate, then chop it up into individual read requests.
However, generating larger requests means we're more likely to run into a problem for the cache: if we can't allocate enough pages to fill out a cache block, we don't have enough data to write to the cache. Further, if the pages are just unlocked and abandoned, readpage will be called to read them individually - which means they likely won't get cached unless the cache granularity is PAGE_SIZE. But that's probably okay if ENOMEM occurred.
There are some other considerations too:
(*) I would need to query the filesystem to find out if I should create
another request. The fs would have to keep track of how many I/O reqs are in flight and what the limit is.
(*) How and where should the readahead triggers be emplaced? I'm guessing
that each block would need a trigger and that this should cause more requests to be generated until we hit the limit.
(*) I would probably need to shuffle the request generation for the second
and subsequent blocks in a single netfs_readahead() call to a worker thread because it'll probably be in a userspace kernel-side context and blocking an application from proceeding and consuming the pages already committed.
David
Matthew Wilcox
maintainerQuoted 13 lines · David Howells
Quoted 10 lines · Steve French
This (readahead behavior improvements in Linux, on single large file sequential read workloads like cp or grep) gets particularly interesting with SMB3 as multichannel becomes more common. With one channel having one readahead request pending on the network is suboptimal - but not as bad as when multichannel is negotiated. Interestingly in most cases two network connections to the same server (different TCP sockets,but the same mount, even in cases where only network adapter) can achieve better performance - but still significantly lags Windows (and probably other clients) as in Linux we don't keep multiple I/Os in flight at one time (unless different files are being read at the same time by different threads).
Quoted 4 lines
I think it should be relatively straightforward to make the
netfs_readahead()function generate multiple read requests. If I wasn't handed sufficient pages by the VM upfront to do two or more read requests, I would need to do extra expansion. There are a couple of ways this could be done:
I don't think this is a job for netfs_readahead(). We can get into a similar situation with SSDs or RAID arrays where ideally we would have several outstanding readahead requests.
If your drive is connected through a 1Gbps link (eg PCIe gen 1 x1) and has a latency of 10ms seek time, with one outstanding read, each read needs to be 12.5MB in size in order to saturate the bus. If the device supports 128 outstanding commands, each read need only be 100kB.
We need the core readahead code to handle this situation. My suggestion for doing this is to send off an extra readahead request every time we hit a !Uptodate page. It looks something like this (assuming the app is processing the data fast and always hits the !Uptodate case) ...
1. hit 0,
set readahead size to 64kB,
mark 32kB as Readahead, send read for 0-64kB wait for 0-64kB to complete
2. hit 32kB (Readahead), no reads outstanding
inc readahead size to 128kB,
mark 128kB as Readahead, send read for 64k-192kB
3. hit 64kB (!Uptodate), one read outstanding mark 256kB as Readahead, send read for 192-320kB mark 384kB as Readahead, send read for 320-448kB wait for 64-192kB to complete
4. hit 128kB (Readahead), two reads outstanding inc readahead size to 256kB,
mark 576kB as Readahead, send read for 448-704kB
5. hit 192kB (!Uptodate), three reads outstanding mark 832kB as Readahead, send read for 704-960kB mark 1088kB as Readahead, send read for 960-1216kB wait for 192-320kB to complete
6. hit 256kB (Readahead), four reads outstanding
mark 1344kB as Readahead, send read for 1216-1472kB 7. hit 320kB (!Uptodate), five reads outstanding mark 1600kB as Readahead, send read for 1472-1728kB mark 1856kB as Readahead, send read for 1728-1984kB wait for 320-448kB to complete 8. hit 384kB (Readahead), five reads outstanding mark 2112kB as Readahead, send read for 1984-2240kB 9. hit 448kB (!Uptodate), six reads outstanding mark 2368kB as Readahead, send read for 2240-2496kB mark 2624kB as Readahead, send read for 2496-2752kB wait for 448-704kB to complete 10. hit 576kB (Readahead), seven reads outstanding mark 2880kB as Readahead, send read for 2752-3008kB
...
Once we stop hitting !Uptodate pages, we'll maintain the number of pages marked as Readahead, and thus keep the number of readahead requests at the level it determined was necessary to keep the link saturated. I think we may need to put a parallelism cap in the bdi so that a device which is just slow instead of at the end of a long fat pipe doesn't get overwhelmed with requests.
Quoted 15 lines · Matthew Wilcox
Quoted 13 lines · Steve French
It could be good if netfs simplifies the problem experienced by network filesystems on Linux with readahead on large sequential reads
- where we don't get as much parallelism due to only having one readahead request at a time (thus in many cases there is 'dead time' on either the network or the file server while waiting for the next
readpages request to be issued). This can be a significant
performance problem for current readpages when network latency is long (or e.g. in cases when network encryption is enabled, and hardware offload not available so time consuming on the server or client to encrypt the packet).Do you see netfs much faster than currentreadpages for ceph?
Quoted 7 lines
Quoted 2 lines
Have you been able to get much benefit from throttling readahead with ceph from the current netfs approach for clamping i/o?
The switch from readpages to readahead does help in a couple of corner cases. For example, if you have two processes reading the same file at the same time, one will now block on the other (due to the page lock) rather than submitting a mess of overlapping and partial reads.
Do you have a simple repro example of this we could try (fio, dbench, iozone etc) to get some objective perf data?
My biggest worry is making sure that the switch to netfs doesn't degrade performance (which might be a low bar now since current network file copy perf seems to signifcantly lag at least Windows), and in some easy to understand scenarios want to make sure it actually helps perf.
Signature · 3 lines
Thanks, Steve
Matthew Wilcox
maintainerQuoted 8 lines · Steve French
Quoted 4 lines · Matthew Wilcox
The switch from readpages to readahead does help in a couple of corner cases. For example, if you have two processes reading the same file at the same time, one will now block on the other (due to the page lock) rather than submitting a mess of overlapping and partial reads.
Do you have a simple repro example of this we could try (fio, dbench, iozone etc) to get some objective perf data?
I don't. The problem was noted by the f2fs people, so maybe they have a reproducer.
Quoted 4 lines
My biggest worry is making sure that the switch to netfs doesn't degrade performance (which might be a low bar now since current network file copy perf seems to signifcantly lag at least Windows), and in some easy to understand scenarios want to make sure it actually helps perf.
I had a question about that ... you've mentioned having 4x4MB reads outstanding as being the way to get optimum performance. Is there a significant performance difference between 4x4MB, 16x1MB and 64x256kB? I'm concerned about having "too large" an I/O on the wire at a given time. For example, with a 1Gbps link, you get 250MB/s. That's a minimum latency of 16us for a 4kB page, but 16ms for a 4MB page.
"For very simple tasks, people can perceive latencies down to 2 ms or less"
(https://danluu.com/input-lag/)
so going all the way to 4MB I/Os takes us into the perceptible latency range, whereas a 256kB I/O is only 1ms.
So could you do some experiments with fio doing direct I/O to see if it takes significantly longer to do, say, 1TB of I/O in 4MB chunks vs 256kB chunks? Obviously use threads to keep lots of I/Os outstanding.
Quoted 26 lines · Matthew Wilcox
Quoted 8 lines · Steve French
Quoted 4 lines · Matthew Wilcox
The switch from readpages to readahead does help in a couple of corner cases. For example, if you have two processes reading the same file at the same time, one will now block on the other (due to the page lock) rather than submitting a mess of overlapping and partial reads.
Do you have a simple repro example of this we could try (fio, dbench, iozone etc) to get some objective perf data?
I don't. The problem was noted by the f2fs people, so maybe they have a reproducer.
Quoted 4 lines
My biggest worry is making sure that the switch to netfs doesn't degrade performance (which might be a low bar now since current network file copy perf seems to signifcantly lag at least Windows), and in some easy to understand scenarios want to make sure it actually helps perf.
I had a question about that ... you've mentioned having 4x4MB reads outstanding as being the way to get optimum performance. Is there a significant performance difference between 4x4MB, 16x1MB and 64x256kB? I'm concerned about having "too large" an I/O on the wire at a given time. For example, with a 1Gbps link, you get 250MB/s. That's a minimum latency of 16us for a 4kB page, but 16ms for a 4MB page.
Quoted 8 lines
"For very simple tasks, people can perceive latencies down to 2 ms or less"
(https://danluu.com/input-lag/)
so going all the way to 4MB I/Os takes us into the perceptible latency range, whereas a 256kB I/O is only 1ms.So could you do some experiments with fio doing direct I/O to see if it takes significantly longer to do, say, 1TB of I/O in 4MB chunks vs 256kB chunks? Obviously use threads to keep lots of I/Os outstanding.
That is a good question and it has been months since I have done experiments
with something similar. Obviously this will vary depending on RDMA or not and
multichannel or not - but assuming the 'normal' low end network configuration - ie a 1Gbps link and no RDMA or multichannel I could do some more recent experiments.
In the past what I had noticed was that server performance for simple workloads like cp or grep increased with network I/O size to a point:
smaller than 256K packet size was bad. Performance improved significantly from 256K to 512K to 1MB, but only very slightly from 1MB to 2MB to 4MB and sometimes degraded at 8MB (IIRC 8MB is the max commonly supported by SMB3 servers), but this is with only one adapter (no multichannel) and 1Gb adapters.
But in those examples there wasn't a lot of concurrency on the wire.
I did some experiments with increasing the read ahead size (which causes more than one async read to be issued by cifs.ko but presumably does still result in some 'dead time') which seemed to help perf of some sequential read examples (e.g. grep or cp) to some servers but I didn't try enough variety of server targets to feel confident about that change especially if netfs is coming
e.g. a change I experimented with was:
sb->s_bdi->ra_pages = cifs_sb->ctx->rsize / PAGE_SIZE
to
sb->s_bdi->ra_pages = 2 * cifs_sb->ctx->rsize / PAGE_SIZEand it did seem to help a little.
I would expect that 8x1MB (ie trying to keep eight 1MB reads in process should keep the network mostly busy and not lead to too much dead time on server, client
or network) and is 'good enough' in many read ahead use cases (at least for non-RDMA, and non-multichannel on a slower network) to keep the pipe file, and I would expect the performance to be similar to the equivalent using 2MB read (e.g. 4x2MB) and perhaps better than 2x4MB. Below 1MB i/o size on the wire I would expect to see degradation due to packet processing and task switching
overhead. Would definitely be worth doing more experimentation here.
Signature · 3 lines
Thanks, Steve
Quoted 16 lines · Steve French
Jeff,
What are the performance differences you are seeing (positive or negative) with ceph and netfs, especially with simple examples like file copy or grep of large files?It could be good if netfs simplifies the problem experienced by network filesystems on Linux with readahead on large sequential reads
- where we don't get as much parallelism due to only having one readahead request at a time (thus in many cases there is 'dead time' on either the network or the file server while waiting for the next
readpages request to be issued). This can be a significant
performance problem for current readpages when network latency is long (or e.g. in cases when network encryption is enabled, and hardware offload not available so time consuming on the server or client to encrypt the packet).
Quoted 5 lines
Do you see netfs much faster than currentreadpages for ceph?
Have you been able to get much benefit from throttling readahead with ceph from the current netfs approach for clamping i/o?
I haven't seen big performance differences at all with this set. It's pretty much a wash, and it doesn't seem to change how the I/Os are ultimately driven on the wire. For instance, the clamp_length op basically just mirrors what ceph does today -- it ensures that the length of the I/O can't go past the end of the current object.
The main benefits are that we get a large swath of readpage, readpages amd write_begin code out of ceph altogether. All of the netfs's need to gather and vet pages for I/O, etc. Most of that doesn't have anything to do with the filesystem itself. By offloading that into the netfs lib, most of that is taken care of for us and we don't need to bother with doing that ourselves.
Signature · 1 line
Jeff Layton <[email protected]>
David Howells
maintainer[PATCH 34/33] netfs: Use in_interrupt() not in_softirq()
In reply to David HowellsThe in_softirq() in netfs_rreq_terminated() works fine for the cache being on a normal disk, as the completion handlers may get called in softirq context, but for an NVMe drive, the completion handler may get called in IRQ context.
Fix to use in_interrupt() instead of in_softirq() throughout the read helpers, particularly when deciding whether to punt code that might sleep off to a worker thread.
The symptom involves warnings like the following appearing and the kernel hanging:
WARNING: CPU: 0 PID: 0 at kernel/softirq.c:175 __local_bh_enable_ip+0x35/0x50 ... RIP: 0010:__local_bh_enable_ip+0x35/0x50 ... Call Trace: <IRQ> rxrpc_kernel_begin_call+0x7d/0x1b0 [rxrpc] ? afs_rx_new_call+0x40/0x40 [kafs] ? afs_alloc_call+0x28/0x120 [kafs] afs_make_call+0x120/0x510 [kafs] ? afs_rx_new_call+0x40/0x40 [kafs] ? afs_alloc_flat_call+0xba/0x100 [kafs] ? __kmalloc+0x167/0x2f0 ? afs_alloc_flat_call+0x9b/0x100 [kafs] afs_wait_for_operation+0x2d/0x200 [kafs] afs_do_sync_operation+0x16/0x20 [kafs] afs_req_issue_op+0x8c/0xb0 [kafs] netfs_rreq_assess+0x125/0x7d0 [netfs] ? cachefiles_end_operation+0x40/0x40 [cachefiles] netfs_subreq_terminated+0x117/0x220 [netfs] cachefiles_read_complete+0x21/0x60 [cachefiles] iomap_dio_bio_end_io+0xdd/0x110 blk_update_request+0x20a/0x380 blk_mq_end_request+0x1c/0x120 nvme_process_cq+0x159/0x1f0 [nvme] nvme_irq+0x10/0x20 [nvme] __handle_irq_event_percpu+0x37/0x150 handle_irq_event+0x49/0xb0 handle_edge_irq+0x7c/0x200 asm_call_irq_on_stack+0xf/0x20 </IRQ> common_interrupt+0xad/0x120 asm_common_interrupt+0x1e/0x40 ...
--- read_helper.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
fs/netfs/read_helper.c +4 -4
@@ -96,7 +96,7 @@ static void netfs_free_read_request(struct work_struct *work)static void netfs_put_read_request (struct netfs_read_request *rreq) {if (refcount_dec_and_test (&rreq->usage)) { -if (in_softirq ()) { +if (in_interrupt ()) { rreq->work.func = netfs_free_read_request;if (!queue_work (system_unbound_wq, &rreq->work))BUG ();
@@ -353,7 +353,7 @@ static void netfs_rreq_write_to_cache_work(struct work_struct *work)static void netfs_rreq_write_to_cache (struct netfs_read_request *rreq) { -if (in_softirq ()) { +if (in_interrupt ()) { rreq->work.func = netfs_rreq_write_to_cache_work;if (!queue_work (system_unbound_wq, &rreq->work))BUG ();
@@ -479,7 +479,7 @@ static bool netfs_rreq_perform_resubmissions(struct netfs_read_request *rreq) {struct netfs_read_subrequest *subreq; -WARN_ON (in_softirq ()); +WARN_ON (in_interrupt ());trace_netfs_rreq (rreq, netfs_rreq_trace_resubmit);
@@ -577,7 +577,7 @@ static void netfs_rreq_work(struct work_struct *work)static void netfs_rreq_terminated (struct netfs_read_request *rreq) {if (test_bit (NETFS_RREQ_INCOMPLETE_IO , &rreq->flags) && -in_softirq ()) { +in_interrupt ()) {if (!queue_work (system_unbound_wq, &rreq->work))BUG (); }else {
Re: [PATCH 34/33] netfs: Use in_interrupt() not in_softirq()
Quoted 8 lines · David Howells
The
in_softirq()innetfs_rreq_terminated()works fine for the cache being on a normal disk, as the completion handlers may get called in softirq context, but for an NVMe drive, the completion handler may get called in IRQ context.Fix to use
in_interrupt()instead ofin_softirq()throughout the read helpers, particularly when deciding whether to punt code that might sleep off to a worker thread.
We must not use either check, as they all are unreliable especially for PREEMPT-RT.
Re: [PATCH 34/33] netfs: Use in_interrupt() not in_softirq()
Quoted 6 lines · Christoph Hellwig
Quoted 5 lines · David Howells
The
in_softirq()innetfs_rreq_terminated()works fine for the cache being on a normal disk, as the completion handlers may get called in softirq context, but for an NVMe drive, the completion handler may get called in IRQ context.
Quoted 6 lines
Quoted 3 lines
Fix to use
in_interrupt()instead ofin_softirq()throughout the read helpers, particularly when deciding whether to punt code that might sleep off to a worker thread.We must not use either check, as they all are unreliable especially for PREEMPT-RT.
Yes, please. I try to cleanup the users one by one
https://lore.kernel.org/r/[email protected]/ https://lore.kernel.org/amd-gfx/[email protected]/
Sebastian
David Howells
maintainerRe: [PATCH 34/33] netfs: Use in_interrupt() not in_softirq()
In reply to Christoph HellwigQuoted 6 lines · Christoph Hellwig
Quoted 5 lines · David Howells
The
in_softirq()innetfs_rreq_terminated()works fine for the cache being on a normal disk, as the completion handlers may get called in softirq context, but for an NVMe drive, the completion handler may get called in IRQ context.
Quoted 6 lines
Quoted 3 lines
Fix to use
in_interrupt()instead ofin_softirq()throughout the read helpers, particularly when deciding whether to punt code that might sleep off to a worker thread.We must not use either check, as they all are unreliable especially for PREEMPT-RT.
Is there a better way to do it? The intent is to process the assessment phase in the calling thread's context if possible rather than bumping over to a worker thread. For synchronous I/O, for example, that's done in the caller's thread. Maybe that's the answer - if it's known to be asynchronous, I have to punt, but otherwise don't have to.
David
Re: [PATCH 34/33] netfs: Use in_interrupt() not in_softirq()
Quoted 5 lines · David Howells
Is there a better way to do it? The intent is to process the assessment phase in the calling thread's context if possible rather than bumping over to a worker thread. For synchronous I/O, for example, that's done in the caller's thread. Maybe that's the answer - if it's known to be asynchronous, I have to punt, but otherwise don't have to.
Yes, i think you want an explicit flag instead.
David Howells
maintainer[PATCH 34/33] netfs: Pass flag rather than use in_softirq()
Quoted 8 lines · Christoph Hellwig
Quoted 5 lines · David Howells
Is there a better way to do it? The intent is to process the assessment phase in the calling thread's context if possible rather than bumping over to a worker thread. For synchronous I/O, for example, that's done in the caller's thread. Maybe that's the answer - if it's known to be asynchronous, I have to punt, but otherwise don't have to.
Yes, i think you want an explicit flag instead.
How about the attached instead?
David
---
commit 29b3e9eed616db01f15c7998c062b4e501ea6582
Author: David Howells <[email protected]> Date: Mon Feb 15 21:56:43 2021 +0000
netfs: Pass flag rather than use in_softirq()
The in_softirq() in netfs_rreq_terminated() works fine for the cache being
on a normal disk, as the completion handlers may get called in softirq
context, but for an NVMe drive, the completion handler may get called in
IRQ context.
Fix to pass a flag to netfs_subreq_terminated() to indicate whether we
think the function isn't being called from a context in which we can do
allocations, waits and I/O submissions (such as softirq or interrupt
context). If this flag is set, netfs lib has to punt to a worker thread to
handle anything like that.
The symptom involves warnings like the following appearing and the kernel
hanging:
WARNING: CPU: 0 PID: 0 at kernel/softirq.c:175 __local_bh_enable_ip+0x35/0x50
...
RIP: 0010:__local_bh_enable_ip+0x35/0x50
...
Call Trace:
<IRQ>
rxrpc_kernel_begin_call+0x7d/0x1b0 [rxrpc]
? afs_rx_new_call+0x40/0x40 [kafs]
? afs_alloc_call+0x28/0x120 [kafs]
afs_make_call+0x120/0x510 [kafs]
? afs_rx_new_call+0x40/0x40 [kafs]
? afs_alloc_flat_call+0xba/0x100 [kafs]
? __kmalloc+0x167/0x2f0
? afs_alloc_flat_call+0x9b/0x100 [kafs]
afs_wait_for_operation+0x2d/0x200 [kafs]
afs_do_sync_operation+0x16/0x20 [kafs]
afs_req_issue_op+0x8c/0xb0 [kafs]
netfs_rreq_assess+0x125/0x7d0 [netfs]
? cachefiles_end_operation+0x40/0x40 [cachefiles]
netfs_subreq_terminated+0x117/0x220 [netfs]
cachefiles_read_complete+0x21/0x60 [cachefiles]
iomap_dio_bio_end_io+0xdd/0x110
blk_update_request+0x20a/0x380
blk_mq_end_request+0x1c/0x120
nvme_process_cq+0x159/0x1f0 [nvme]
nvme_irq+0x10/0x20 [nvme]
__handle_irq_event_percpu+0x37/0x150
handle_irq_event+0x49/0xb0
handle_edge_irq+0x7c/0x200
asm_call_irq_on_stack+0xf/0x20
</IRQ>
common_interrupt+0xad/0x120
asm_common_interrupt+0x1e/0x40
...
Reported-by: Marc Dionne <[email protected]>
Signed-off-by: David Howells <[email protected]>
cc: Matthew Wilcox <[email protected]>
cc: [email protected]
cc: [email protected]
cc: [email protected]
cc: [email protected]
cc: [email protected]
cc: [email protected]
cc: [email protected]
cc: [email protected]fs/afs/file.c +3 -3
@@ -223,7 +223,7 @@ static void afs_fetch_data_notify(struct afs_operation *op)if (subreq) {__set_bit (NETFS_SREQ_CLEAR_TAIL , &subreq->flags); -netfs_subreq_terminated (subreq, error ?: req->actual_len); +netfs_subreq_terminated (subreq, error ?: req->actual_len, false); req->subreq =NULL ; }else if (req->done) { req->done (req);
@@ -289,7 +289,7 @@ static void afs_req_issue_op(struct netfs_read_subrequest *subreq) fsreq =afs_alloc_read (GFP_NOFS );if (!fsreq) -return netfs_subreq_terminated (subreq, -ENOMEM ); +return netfs_subreq_terminated (subreq, -ENOMEM , false); fsreq->subreq = subreq; fsreq->pos = subreq->start + subreq->transferred;
@@ -304,7 +304,7 @@ static void afs_req_issue_op(struct netfs_read_subrequest *subreq) ret =afs_fetch_data (fsreq->vnode, fsreq);if (ret <0 ) -return netfs_subreq_terminated (subreq, ret); +return netfs_subreq_terminated (subreq, ret, false); }static int afs_symlink_readpage (struct page *page)
fs/cachefiles/rdwr2.c +11 -7
@@ -23,6 +23,7 @@ struct cachefiles_kiocb { };netfs_io_terminated_t term_func;void *term_func_priv; +bool was_async; };static inline void cachefiles_put_kiocb (struct cachefiles_kiocb *ki)
@@ -43,10 +44,9 @@ static void cachefiles_read_complete(struct kiocb *iocb, long ret, long ret2)_enter ("%ld,%ld" , ret, ret2);if (ki->term_func) { -if (ret <0 ) - ki->term_func (ki->term_func_priv, ret); -else - ki->term_func (ki->term_func_priv, ki->skipped + ret); +if (ret >=0 ) + ret += ki->skipped; + ki->term_func (ki->term_func_priv, ret, ki->was_async); }cachefiles_put_kiocb (ki);
@@ -114,6 +114,7 @@ static int cachefiles_read(struct netfs_cache_resources *cres, ki->skipped = skipped; ki->term_func = term_func; ki->term_func_priv = term_func_priv; + ki->was_async = true;if (ki->term_func) ki->iocb.ki_complete = cachefiles_read_complete;
@@ -141,6 +142,7 @@ static int cachefiles_read(struct netfs_cache_resources *cres, ret = -EINTR ; fallthrough;default : + ki->was_async = false;cachefiles_read_complete (&ki->iocb, ret,0 );if (ret >0 ) ret =0 ;
@@ -156,7 +158,7 @@ static int cachefiles_read(struct netfs_cache_resources *cres,kfree (ki); presubmission_error:if (term_func) -term_func (term_func_priv, ret <0 ? ret : skipped); +term_func (term_func_priv, ret <0 ? ret : skipped, false);return ret; }
@@ -175,7 +177,7 @@ static void cachefiles_write_complete(struct kiocb *iocb, long ret, long ret2)__sb_end_write (inode->i_sb,SB_FREEZE_WRITE );if (ki->term_func) - ki->term_func (ki->term_func_priv, ret); + ki->term_func (ki->term_func_priv, ret, ki->was_async);cachefiles_put_kiocb (ki); }
@@ -214,6 +216,7 @@ static int cachefiles_write(struct netfs_cache_resources *cres, ki->len = len; ki->term_func = term_func; ki->term_func_priv = term_func_priv; + ki->was_async = true;if (ki->term_func) ki->iocb.ki_complete = cachefiles_write_complete;
@@ -250,6 +253,7 @@ static int cachefiles_write(struct netfs_cache_resources *cres, ret = -EINTR ;/* Fall through */ default : + ki->was_async = false;cachefiles_write_complete (&ki->iocb, ret,0 );if (ret >0 ) ret =0 ;
@@ -265,7 +269,7 @@ static int cachefiles_write(struct netfs_cache_resources *cres,kfree (ki); presubmission_error:if (term_func) -term_func (term_func_priv, -ENOMEM ); +term_func (term_func_priv, -ENOMEM , false);return -ENOMEM ; }
fs/ceph/addr.c +2 -2
@@ -221,7 +221,7 @@ static void finish_netfs_read(struct ceph_osd_request *req)if (err >=0 && err < subreq->len)__set_bit (NETFS_SREQ_CLEAR_TAIL , &subreq->flags); -netfs_subreq_terminated (subreq, err); +netfs_subreq_terminated (subreq, err, true); num_pages =calc_pages_for (osd_data->alignment, osd_data->length);ceph_put_page_vector (osd_data->pages, num_pages, false);
@@ -276,7 +276,7 @@ static void ceph_netfs_issue_op(struct netfs_read_subrequest *subreq) out:ceph_osdc_put_request (req);if (err) -netfs_subreq_terminated (subreq, err); +netfs_subreq_terminated (subreq, err, false);dout ("%s: result %d\n" , __func__, err); }
fs/netfs/read_helper.c +59 -47
324 lines not on this page · raw message
include/linux/netfs.h +3 -2
@@ -60,7 +60,8 @@ enum netfs_read_source {NETFS_INVALID_READ , } __mode(byte); -typedef void (*netfs_io_terminated_t )(void *priv,ssize_t transferred_or_error); +typedef void (*netfs_io_terminated_t )(void *priv,ssize_t transferred_or_error, +bool was_async);/* * Resources required to do operations on a cache.
@@ -189,7 +190,7 @@ extern int netfs_write_begin(struct file *, struct address_space *, const struct netfs_read_request_ops *, void *); -extern void netfs_subreq_terminated (struct netfs_read_subrequest *,ssize_t ); +extern void netfs_subreq_terminated (struct netfs_read_subrequest *,ssize_t ,bool );extern void netfs_stats_show (struct seq_file *);#endif /* _LINUX_NETFS_H */
Re: [PATCH 34/33] netfs: Pass flag rather than use in_softirq()
Quoted 594 lines · David Howells
Quoted 8 lines · Christoph Hellwig
Quoted 5 lines · David Howells
Is there a better way to do it? The intent is to process the assessment phase in the calling thread's context if possible rather than bumping over to a worker thread. For synchronous I/O, for example, that's done in the caller's thread. Maybe that's the answer - if it's known to be asynchronous, I have to punt, but otherwise don't have to.
Yes, i think you want an explicit flag instead.
How about the attached instead?
David
---
commit29b3e9eed616db01f15c7998c062b4e501ea6582Author: David Howells <[email protected]> Date: Mon Feb 15 21:56:43 2021 +0000netfs: Pass flag rather than use in_softirq() The in_softirq() in netfs_rreq_terminated() works fine for the cache being on a normal disk, as the completion handlers may get called in softirq context, but for an NVMe drive, the completion handler may get called in IRQ context. Fix to pass a flag to netfs_subreq_terminated() to indicate whether we think the function isn't being called from a context in which we can do allocations, waits and I/O submissions (such as softirq or interrupt context). If this flag is set, netfs lib has to punt to a worker thread to handle anything like that. The symptom involves warnings like the following appearing and the kernel hanging: WARNING: CPU: 0 PID: 0 at kernel/softirq.c:175 __local_bh_enable_ip+0x35/0x50 ... RIP: 0010:__local_bh_enable_ip+0x35/0x50 ... Call Trace: <IRQ> rxrpc_kernel_begin_call+0x7d/0x1b0 [rxrpc] ? afs_rx_new_call+0x40/0x40 [kafs] ? afs_alloc_call+0x28/0x120 [kafs] afs_make_call+0x120/0x510 [kafs] ? afs_rx_new_call+0x40/0x40 [kafs] ? afs_alloc_flat_call+0xba/0x100 [kafs] ? __kmalloc+0x167/0x2f0 ? afs_alloc_flat_call+0x9b/0x100 [kafs] afs_wait_for_operation+0x2d/0x200 [kafs] afs_do_sync_operation+0x16/0x20 [kafs] afs_req_issue_op+0x8c/0xb0 [kafs] netfs_rreq_assess+0x125/0x7d0 [netfs] ? cachefiles_end_operation+0x40/0x40 [cachefiles] netfs_subreq_terminated+0x117/0x220 [netfs] cachefiles_read_complete+0x21/0x60 [cachefiles] iomap_dio_bio_end_io+0xdd/0x110 blk_update_request+0x20a/0x380 blk_mq_end_request+0x1c/0x120 nvme_process_cq+0x159/0x1f0 [nvme] nvme_irq+0x10/0x20 [nvme] __handle_irq_event_percpu+0x37/0x150 handle_irq_event+0x49/0xb0 handle_edge_irq+0x7c/0x200 asm_call_irq_on_stack+0xf/0x20 </IRQ> common_interrupt+0xad/0x120 asm_common_interrupt+0x1e/0x40 ... Reported-by: Marc Dionne <[email protected]> Signed-off-by: David Howells <[email protected]> cc: Matthew Wilcox <[email protected]> cc: [email protected] cc: [email protected] cc: [email protected] cc: [email protected] cc: [email protected] cc: [email protected] cc: [email protected] cc: [email protected]fs/afs/file.c +3
-3@@ -223,7 +223,7 @@ static void afs_fetch_data_notify(struct afs_operation *op)if (subreq) {__set_bit (NETFS_SREQ_CLEAR_TAIL , &subreq->flags); -netfs_subreq_terminated (subreq, error ?: req->actual_len); +netfs_subreq_terminated (subreq, error ?: req->actual_len, false); req->subreq =NULL ; }else if (req->done) { req->done (req);@@ -289,7 +289,7 @@ static void afs_req_issue_op(struct netfs_read_subrequest *subreq) fsreq =afs_alloc_read (GFP_NOFS );if (!fsreq) -return netfs_subreq_terminated (subreq, -ENOMEM ); +return netfs_subreq_terminated (subreq, -ENOMEM , false); fsreq->subreq = subreq; fsreq->pos = subreq->start + subreq->transferred;@@ -304,7 +304,7 @@ static void afs_req_issue_op(struct netfs_read_subrequest *subreq) ret =afs_fetch_data (fsreq->vnode, fsreq);if (ret <0 ) -return netfs_subreq_terminated (subreq, ret); +return netfs_subreq_terminated (subreq, ret, false); }static int afs_symlink_readpage (struct page *page)fs/cachefiles/rdwr2.c +11
-7@@ -23,6 +23,7 @@ struct cachefiles_kiocb { };netfs_io_terminated_t term_func;void *term_func_priv; +bool was_async; };static inline void cachefiles_put_kiocb (struct cachefiles_kiocb *ki)@@ -43,10 +44,9 @@ static void cachefiles_read_complete(struct kiocb *iocb, long ret, long ret2)_enter ("%ld,%ld" , ret, ret2);if (ki->term_func) { -if (ret <0 ) - ki->term_func (ki->term_func_priv, ret); -else - ki->term_func (ki->term_func_priv, ki->skipped + ret); +if (ret >=0 ) + ret += ki->skipped; + ki->term_func (ki->term_func_priv, ret, ki->was_async); }cachefiles_put_kiocb (ki);@@ -114,6 +114,7 @@ static int cachefiles_read(struct netfs_cache_resources *cres, ki->skipped = skipped; ki->term_func = term_func; ki->term_func_priv = term_func_priv; + ki->was_async = true;if (ki->term_func) ki->iocb.ki_complete = cachefiles_read_complete;@@ -141,6 +142,7 @@ static int cachefiles_read(struct netfs_cache_resources *cres, ret = -EINTR ; fallthrough;default : + ki->was_async = false;cachefiles_read_complete (&ki->iocb, ret,0 );if (ret >0 ) ret =0 ;@@ -156,7 +158,7 @@ static int cachefiles_read(struct netfs_cache_resources *cres,kfree (ki); presubmission_error:if (term_func) -term_func (term_func_priv, ret <0 ? ret : skipped); +term_func (term_func_priv, ret <0 ? ret : skipped, false);return ret; }@@ -175,7 +177,7 @@ static void cachefiles_write_complete(struct kiocb *iocb, long ret, long ret2)__sb_end_write (inode->i_sb,SB_FREEZE_WRITE );if (ki->term_func) - ki->term_func (ki->term_func_priv, ret); + ki->term_func (ki->term_func_priv, ret, ki->was_async);cachefiles_put_kiocb (ki); }@@ -214,6 +216,7 @@ static int cachefiles_write(struct netfs_cache_resources *cres, ki->len = len; ki->term_func = term_func; ki->term_func_priv = term_func_priv; + ki->was_async = true;if (ki->term_func) ki->iocb.ki_complete = cachefiles_write_complete;@@ -250,6 +253,7 @@ static int cachefiles_write(struct netfs_cache_resources *cres, ret = -EINTR ;/* Fall through */ default : + ki->was_async = false;cachefiles_write_complete (&ki->iocb, ret,0 );if (ret >0 ) ret =0 ;@@ -265,7 +269,7 @@ static int cachefiles_write(struct netfs_cache_resources *cres,kfree (ki); presubmission_error:if (term_func) -term_func (term_func_priv, -ENOMEM ); +term_func (term_func_priv, -ENOMEM , false);return -ENOMEM ; }fs/ceph/addr.c +2
-2@@ -221,7 +221,7 @@ static void finish_netfs_read(struct ceph_osd_request *req)if (err >=0 && err < subreq->len)__set_bit (NETFS_SREQ_CLEAR_TAIL , &subreq->flags); -netfs_subreq_terminated (subreq, err); +netfs_subreq_terminated (subreq, err, true); num_pages =calc_pages_for (osd_data->alignment, osd_data->length);ceph_put_page_vector (osd_data->pages, num_pages, false);@@ -276,7 +276,7 @@ static void ceph_netfs_issue_op(struct netfs_read_subrequest *subreq) out:ceph_osdc_put_request (req);if (err) -netfs_subreq_terminated (subreq, err); +netfs_subreq_terminated (subreq, err, false);dout ("%s: result %d\n" , __func__, err); }fs/netfs/read_helper.c +59
-47@@ -29,12 +29,13 @@ module_param_named(debug, netfs_debug, uint, S_IWUSR | S_IRUGO);MODULE_PARM_DESC (netfs_debug,"Netfs support debugging mask" );static void netfs_rreq_work (struct work_struct *); -static void __netfs_put_subrequest (struct netfs_read_subrequest *); +static void __netfs_put_subrequest (struct netfs_read_subrequest *,bool ); -static void netfs_put_subrequest (struct netfs_read_subrequest *subreq) +static void netfs_put_subrequest (struct netfs_read_subrequest *subreq, +bool was_async) {if (refcount_dec_and_test (&subreq->usage)) -__netfs_put_subrequest (subreq); +__netfs_put_subrequest (subreq, was_async); } static struct netfs_read_request *netfs_alloc_read_request(@@ -67,7 +68,8 @@ static void netfs_get_read_request(struct netfs_read_request *rreq)refcount_inc (&rreq->usage); } -static void netfs_rreq_clear_subreqs (struct netfs_read_request *rreq) +static void netfs_rreq_clear_subreqs (struct netfs_read_request *rreq, +bool was_async) {struct netfs_read_subrequest *subreq;@@ -75,7 +77,7 @@ static void netfs_rreq_clear_subreqs(struct netfs_read_request *rreq) subreq =list_first_entry (&rreq->subrequests, struct netfs_read_subrequest, rreq_link);list_del (&subreq->rreq_link); -netfs_put_subrequest (subreq); +netfs_put_subrequest (subreq, was_async); } }@@ -83,7 +85,7 @@ static void netfs_free_read_request(struct work_struct *work) {struct netfs_read_request *rreq = container_of(work, struct netfs_read_request, work); -netfs_rreq_clear_subreqs (rreq); +netfs_rreq_clear_subreqs (rreq, false);if (rreq->netfs_priv) rreq->netfs_ops->cleanup (rreq->mapping, rreq->netfs_priv);trace_netfs_rreq (rreq, netfs_rreq_trace_free);@@ -93,10 +95,10 @@ static void netfs_free_read_request(struct work_struct *work)netfs_stat_d (&netfs_n_rh_rreq); } -static void netfs_put_read_request (struct netfs_read_request *rreq) +static void netfs_put_read_request (struct netfs_read_request *rreq,bool was_async) {if (refcount_dec_and_test (&rreq->usage)) { -if (in_softirq ()) { +if (was_async) { rreq->work.func = netfs_free_read_request;if (!queue_work (system_unbound_wq, &rreq->work))BUG ();@@ -131,12 +133,15 @@ static void netfs_get_read_subrequest(struct netfs_read_subrequest *subreq)refcount_inc (&subreq->usage); } -static void __netfs_put_subrequest (struct netfs_read_subrequest *subreq) +static void __netfs_put_subrequest (struct netfs_read_subrequest *subreq, +bool was_async) { +struct netfs_read_request *rreq = subreq->rreq; +trace_netfs_sreq (subreq, netfs_sreq_trace_free); -netfs_put_read_request (subreq->rreq);kfree (subreq);netfs_stat_d (&netfs_n_rh_sreq); +netfs_put_read_request (rreq, was_async); }/* @@ -152,11 +157,12 @@ static void netfs_clear_unread(struct netfs_read_subrequest *subreq)iov_iter_zero (iov_iter_count (&iter), &iter); } -static void netfs_cache_read_terminated (void *priv,ssize_t transferred_or_error) +static void netfs_cache_read_terminated (void *priv,ssize_t transferred_or_error, +bool was_async) {struct netfs_read_subrequest *subreq = priv; -netfs_subreq_terminated (subreq, transferred_or_error); +netfs_subreq_terminated (subreq, transferred_or_error, was_async); }/* @@ -186,7 +192,7 @@ static void netfs_fill_with_zeroes(struct netfs_read_request *rreq, {netfs_stat (&netfs_n_rh_zero);__set_bit (NETFS_SREQ_CLEAR_TAIL , &subreq->flags); -netfs_subreq_terminated (subreq,0 ); +netfs_subreq_terminated (subreq,0 , false); }/* @@ -215,11 +221,11 @@ static void netfs_read_from_server(struct netfs_read_request *rreq,/* * Release those waiting. */ -static void netfs_rreq_completed (struct netfs_read_request *rreq) +static void netfs_rreq_completed (struct netfs_read_request *rreq,bool was_async) {trace_netfs_rreq (rreq, netfs_rreq_trace_done); -netfs_rreq_clear_subreqs (rreq); -netfs_put_read_request (rreq); +netfs_rreq_clear_subreqs (rreq, was_async); +netfs_put_read_request (rreq, was_async); }/* @@ -228,7 +234,8 @@ static void netfs_rreq_completed(struct netfs_read_request *rreq)* * May be called in softirq mode and we inherit a ref from the caller. */ -static void netfs_rreq_unmark_after_write (struct netfs_read_request *rreq) +static void netfs_rreq_unmark_after_write (struct netfs_read_request *rreq, +bool was_async) {struct netfs_read_subrequest *subreq;struct pagevec pvec;@@ -258,10 +265,11 @@ static void netfs_rreq_unmark_after_write(struct netfs_read_request *rreq) }rcu_read_unlock (); -netfs_rreq_completed (rreq); +netfs_rreq_completed (rreq, was_async); } -static void netfs_rreq_copy_terminated (void *priv,ssize_t transferred_or_error) +static void netfs_rreq_copy_terminated (void *priv,ssize_t transferred_or_error, +bool was_async) {struct netfs_read_subrequest *subreq = priv;struct netfs_read_request *rreq = subreq->rreq;@@ -278,9 +286,9 @@ static void netfs_rreq_copy_terminated(void *priv, ssize_t transferred_or_error)/* If we decrement nr_wr_ops to 0, the ref belongs to us. */ if (atomic_dec_and_test (&rreq->nr_wr_ops)) -netfs_rreq_unmark_after_write (rreq); +netfs_rreq_unmark_after_write (rreq, was_async); -netfs_put_subrequest (subreq); +netfs_put_subrequest (subreq, was_async); }/* @@ -304,7 +312,7 @@ static void netfs_rreq_do_write_to_cache(struct netfs_read_request *rreq)list_for_each_entry_safe (subreq, p, &rreq->subrequests, rreq_link) {if (!test_bit (NETFS_SREQ_WRITE_TO_CACHE , &subreq->flags)) {list_del_init (&subreq->rreq_link); -netfs_put_subrequest (subreq); +netfs_put_subrequest (subreq, false); } }@@ -324,7 +332,7 @@ static void netfs_rreq_do_write_to_cache(struct netfs_read_request *rreq) subreq->len += next->len; subreq->len =round_up (subreq->len,PAGE_SIZE );list_del_init (&next->rreq_link); -netfs_put_subrequest (next); +netfs_put_subrequest (next, false); } iov_iter_xarray(&iter, WRITE, &rreq->mapping->i_pages,@@ -340,7 +348,7 @@ static void netfs_rreq_do_write_to_cache(struct netfs_read_request *rreq)/* If we decrement nr_wr_ops to 0, the usage ref belongs to us. */ if (atomic_dec_and_test (&rreq->nr_wr_ops)) -netfs_rreq_unmark_after_write (rreq); +netfs_rreq_unmark_after_write (rreq, false); }static void netfs_rreq_write_to_cache_work (struct work_struct *work)@@ -351,9 +359,10 @@ static void netfs_rreq_write_to_cache_work(struct work_struct *work)netfs_rreq_do_write_to_cache (rreq); } -static void netfs_rreq_write_to_cache (struct netfs_read_request *rreq) +static void netfs_rreq_write_to_cache (struct netfs_read_request *rreq, +bool was_async) { -if (in_softirq ()) { +if (was_async) { rreq->work.func = netfs_rreq_write_to_cache_work;if (!queue_work (system_unbound_wq, &rreq->work))BUG ();@@ -479,7 +488,7 @@ static bool netfs_rreq_perform_resubmissions(struct netfs_read_request *rreq) {struct netfs_read_subrequest *subreq; -WARN_ON (in_softirq ()); +WARN_ON (in_interrupt ());trace_netfs_rreq (rreq, netfs_rreq_trace_resubmit);@@ -538,7 +547,7 @@ static void netfs_rreq_is_still_valid(struct netfs_read_request *rreq)* 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_read_request *rreq) +static void netfs_rreq_assess (struct netfs_read_request *rreq,bool was_async) {trace_netfs_rreq (rreq, netfs_rreq_trace_assess);@@ -558,30 +567,31 @@ static void netfs_rreq_assess(struct netfs_read_request *rreq)wake_up_bit (&rreq->flags,NETFS_RREQ_IN_PROGRESS );if (test_bit (NETFS_RREQ_WRITE_TO_CACHE , &rreq->flags)) -return netfs_rreq_write_to_cache (rreq); +return netfs_rreq_write_to_cache (rreq, was_async); -netfs_rreq_completed (rreq); +netfs_rreq_completed (rreq, was_async); }static void netfs_rreq_work (struct work_struct *work) {struct netfs_read_request *rreq = container_of(work, struct netfs_read_request, work); -netfs_rreq_assess (rreq); +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_read_request *rreq) +static void netfs_rreq_terminated (struct netfs_read_request *rreq, +bool was_async) {if (test_bit (NETFS_RREQ_INCOMPLETE_IO , &rreq->flags) && -in_softirq ()) { + was_async) {if (!queue_work (system_unbound_wq, &rreq->work))BUG (); }else { -netfs_rreq_assess (rreq); +netfs_rreq_assess (rreq, was_async); } }@@ -589,6 +599,7 @@ static void netfs_rreq_terminated(struct netfs_read_request *rreq)* 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. @@ -599,11 +610,12 @@ static void netfs_rreq_terminated(struct netfs_read_request *rreq)* error code. The helper will look after reissuing I/O operations as * appropriate and writing downloaded data to the cache. * -* This may be called from a softirq handler, so we want to avoid taking the -* spinlock if we can. +* 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_read_subrequest *subreq, -ssize_t transferred_or_error) +ssize_t transferred_or_error, +bool was_async) {struct netfs_read_request *rreq = subreq->rreq;int u;@@ -647,11 +659,11 @@ void netfs_subreq_terminated(struct netfs_read_subrequest *subreq,/* If we decrement nr_rd_ops to 0, the ref belongs to us. */ u =atomic_dec_return (&rreq->nr_rd_ops);if (u ==0 ) -netfs_rreq_terminated (rreq); +netfs_rreq_terminated (rreq, was_async);else if (u ==1 )wake_up_var (&rreq->nr_rd_ops); -netfs_put_subrequest (subreq); +netfs_put_subrequest (subreq, was_async);return ; incomplete:@@ -796,7 +808,7 @@ static bool netfs_rreq_submit_slice(struct netfs_read_request *rreq, subreq_failed: rreq->error = subreq->error; -netfs_put_subrequest (subreq); +netfs_put_subrequest (subreq, false);return false; }@@ -901,7 +913,7 @@ void netfs_readahead(struct readahead_control *ractl, }while (rreq->submitted < rreq->len);if (rreq->submitted ==0 ) { -netfs_put_read_request (rreq); +netfs_put_read_request (rreq, false);return ; }@@ -913,11 +925,11 @@ void netfs_readahead(struct readahead_control *ractl,/* If we decrement nr_rd_ops to 0, the ref belongs to us. */ if (atomic_dec_and_test (&rreq->nr_rd_ops)) -netfs_rreq_assess (rreq); +netfs_rreq_assess (rreq, false);return ; cleanup_free: -netfs_put_read_request (rreq); +netfs_put_read_request (rreq, false);return ; cleanup:if (netfs_priv)@@ -991,14 +1003,14 @@ int netfs_readpage(struct file *file,*/ do {wait_var_event (&rreq->nr_rd_ops,atomic_read (&rreq->nr_rd_ops) ==1 ); -netfs_rreq_assess (rreq); +netfs_rreq_assess (rreq, false); }while (test_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags)); ret = rreq->error;if (ret ==0 && rreq->submitted < rreq->len) ret = -EIO ; out: -netfs_put_read_request (rreq); +netfs_put_read_request (rreq, false);return ret; }EXPORT_SYMBOL (netfs_readpage);@@ -1136,7 +1148,7 @@ int netfs_write_begin(struct file *file, struct address_space *mapping,*/ for (;;) {wait_var_event (&rreq->nr_rd_ops,atomic_read (&rreq->nr_rd_ops) ==1 ); -netfs_rreq_assess (rreq); +netfs_rreq_assess (rreq, false);if (!test_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags))break ;cond_resched ();@@ -1145,7 +1157,7 @@ int netfs_write_begin(struct file *file, struct address_space *mapping, ret = rreq->error;if (ret ==0 && rreq->submitted < rreq->len) ret = -EIO ; -netfs_put_read_request (rreq); +netfs_put_read_request (rreq, false);if (ret <0 ) goto error;include/linux/netfs.h +2
-1@@ -60,7 +60,8 @@ enum netfs_read_source {NETFS_INVALID_READ , } __mode(byte); -typedef void (*netfs_io_terminated_t )(void *priv,ssize_t transferred_or_error); +typedef void (*netfs_io_terminated_t )(void *priv,ssize_t transferred_or_error, +bool was_async);/* * Resources required to do operations on a cache.
include/linux/netfs.h extern int netfs_write_begin(struct file *, struct address_space *, · line 196
Quoted 8 lines
include/linux/netfs.h +1
-1@@ -189,7 +190,7 @@ extern int netfs_write_begin(struct file *, struct address_space *, const struct netfs_read_request_ops *, void *); -extern void netfs_subreq_terminated (struct netfs_read_subrequest *,ssize_t ); +extern void netfs_subreq_terminated (struct netfs_read_subrequest *,ssize_t ,bool );extern void netfs_stats_show (struct seq_file *);#endif /* _LINUX_NETFS_H */
Looks good in testing.
Marc Dionne
Tested-byRe: [PATCH 34/33] netfs: Pass flag rather than use in_softirq()
In reply to David HowellsQuoted 594 lines · David Howells
Quoted 8 lines · Christoph Hellwig
Quoted 5 lines · David Howells
Is there a better way to do it? The intent is to process the assessment phase in the calling thread's context if possible rather than bumping over to a worker thread. For synchronous I/O, for example, that's done in the caller's thread. Maybe that's the answer - if it's known to be asynchronous, I have to punt, but otherwise don't have to.
Yes, i think you want an explicit flag instead.
How about the attached instead?
David
---
commit29b3e9eed616db01f15c7998c062b4e501ea6582Author: David Howells <[email protected]> Date: Mon Feb 15 21:56:43 2021 +0000netfs: Pass flag rather than use in_softirq() The in_softirq() in netfs_rreq_terminated() works fine for the cache being on a normal disk, as the completion handlers may get called in softirq context, but for an NVMe drive, the completion handler may get called in IRQ context. Fix to pass a flag to netfs_subreq_terminated() to indicate whether we think the function isn't being called from a context in which we can do allocations, waits and I/O submissions (such as softirq or interrupt context). If this flag is set, netfs lib has to punt to a worker thread to handle anything like that. The symptom involves warnings like the following appearing and the kernel hanging: WARNING: CPU: 0 PID: 0 at kernel/softirq.c:175 __local_bh_enable_ip+0x35/0x50 ... RIP: 0010:__local_bh_enable_ip+0x35/0x50 ... Call Trace: <IRQ> rxrpc_kernel_begin_call+0x7d/0x1b0 [rxrpc] ? afs_rx_new_call+0x40/0x40 [kafs] ? afs_alloc_call+0x28/0x120 [kafs] afs_make_call+0x120/0x510 [kafs] ? afs_rx_new_call+0x40/0x40 [kafs] ? afs_alloc_flat_call+0xba/0x100 [kafs] ? __kmalloc+0x167/0x2f0 ? afs_alloc_flat_call+0x9b/0x100 [kafs] afs_wait_for_operation+0x2d/0x200 [kafs] afs_do_sync_operation+0x16/0x20 [kafs] afs_req_issue_op+0x8c/0xb0 [kafs] netfs_rreq_assess+0x125/0x7d0 [netfs] ? cachefiles_end_operation+0x40/0x40 [cachefiles] netfs_subreq_terminated+0x117/0x220 [netfs] cachefiles_read_complete+0x21/0x60 [cachefiles] iomap_dio_bio_end_io+0xdd/0x110 blk_update_request+0x20a/0x380 blk_mq_end_request+0x1c/0x120 nvme_process_cq+0x159/0x1f0 [nvme] nvme_irq+0x10/0x20 [nvme] __handle_irq_event_percpu+0x37/0x150 handle_irq_event+0x49/0xb0 handle_edge_irq+0x7c/0x200 asm_call_irq_on_stack+0xf/0x20 </IRQ> common_interrupt+0xad/0x120 asm_common_interrupt+0x1e/0x40 ... Reported-by: Marc Dionne <[email protected]> Signed-off-by: David Howells <[email protected]> cc: Matthew Wilcox <[email protected]> cc: [email protected] cc: [email protected] cc: [email protected] cc: [email protected] cc: [email protected] cc: [email protected] cc: [email protected] cc: [email protected]fs/afs/file.c +3
-3@@ -223,7 +223,7 @@ static void afs_fetch_data_notify(struct afs_operation *op)if (subreq) {__set_bit (NETFS_SREQ_CLEAR_TAIL , &subreq->flags); -netfs_subreq_terminated (subreq, error ?: req->actual_len); +netfs_subreq_terminated (subreq, error ?: req->actual_len, false); req->subreq =NULL ; }else if (req->done) { req->done (req);@@ -289,7 +289,7 @@ static void afs_req_issue_op(struct netfs_read_subrequest *subreq) fsreq =afs_alloc_read (GFP_NOFS );if (!fsreq) -return netfs_subreq_terminated (subreq, -ENOMEM ); +return netfs_subreq_terminated (subreq, -ENOMEM , false); fsreq->subreq = subreq; fsreq->pos = subreq->start + subreq->transferred;@@ -304,7 +304,7 @@ static void afs_req_issue_op(struct netfs_read_subrequest *subreq) ret =afs_fetch_data (fsreq->vnode, fsreq);if (ret <0 ) -return netfs_subreq_terminated (subreq, ret); +return netfs_subreq_terminated (subreq, ret, false); }static int afs_symlink_readpage (struct page *page)fs/cachefiles/rdwr2.c +11
-7@@ -23,6 +23,7 @@ struct cachefiles_kiocb { };netfs_io_terminated_t term_func;void *term_func_priv; +bool was_async; };static inline void cachefiles_put_kiocb (struct cachefiles_kiocb *ki)@@ -43,10 +44,9 @@ static void cachefiles_read_complete(struct kiocb *iocb, long ret, long ret2)_enter ("%ld,%ld" , ret, ret2);if (ki->term_func) { -if (ret <0 ) - ki->term_func (ki->term_func_priv, ret); -else - ki->term_func (ki->term_func_priv, ki->skipped + ret); +if (ret >=0 ) + ret += ki->skipped; + ki->term_func (ki->term_func_priv, ret, ki->was_async); }cachefiles_put_kiocb (ki);@@ -114,6 +114,7 @@ static int cachefiles_read(struct netfs_cache_resources *cres, ki->skipped = skipped; ki->term_func = term_func; ki->term_func_priv = term_func_priv; + ki->was_async = true;if (ki->term_func) ki->iocb.ki_complete = cachefiles_read_complete;@@ -141,6 +142,7 @@ static int cachefiles_read(struct netfs_cache_resources *cres, ret = -EINTR ; fallthrough;default : + ki->was_async = false;cachefiles_read_complete (&ki->iocb, ret,0 );if (ret >0 ) ret =0 ;@@ -156,7 +158,7 @@ static int cachefiles_read(struct netfs_cache_resources *cres,kfree (ki); presubmission_error:if (term_func) -term_func (term_func_priv, ret <0 ? ret : skipped); +term_func (term_func_priv, ret <0 ? ret : skipped, false);return ret; }@@ -175,7 +177,7 @@ static void cachefiles_write_complete(struct kiocb *iocb, long ret, long ret2)__sb_end_write (inode->i_sb,SB_FREEZE_WRITE );if (ki->term_func) - ki->term_func (ki->term_func_priv, ret); + ki->term_func (ki->term_func_priv, ret, ki->was_async);cachefiles_put_kiocb (ki); }@@ -214,6 +216,7 @@ static int cachefiles_write(struct netfs_cache_resources *cres, ki->len = len; ki->term_func = term_func; ki->term_func_priv = term_func_priv; + ki->was_async = true;if (ki->term_func) ki->iocb.ki_complete = cachefiles_write_complete;@@ -250,6 +253,7 @@ static int cachefiles_write(struct netfs_cache_resources *cres, ret = -EINTR ;/* Fall through */ default : + ki->was_async = false;cachefiles_write_complete (&ki->iocb, ret,0 );if (ret >0 ) ret =0 ;@@ -265,7 +269,7 @@ static int cachefiles_write(struct netfs_cache_resources *cres,kfree (ki); presubmission_error:if (term_func) -term_func (term_func_priv, -ENOMEM ); +term_func (term_func_priv, -ENOMEM , false);return -ENOMEM ; }fs/ceph/addr.c +2
-2@@ -221,7 +221,7 @@ static void finish_netfs_read(struct ceph_osd_request *req)if (err >=0 && err < subreq->len)__set_bit (NETFS_SREQ_CLEAR_TAIL , &subreq->flags); -netfs_subreq_terminated (subreq, err); +netfs_subreq_terminated (subreq, err, true); num_pages =calc_pages_for (osd_data->alignment, osd_data->length);ceph_put_page_vector (osd_data->pages, num_pages, false);@@ -276,7 +276,7 @@ static void ceph_netfs_issue_op(struct netfs_read_subrequest *subreq) out:ceph_osdc_put_request (req);if (err) -netfs_subreq_terminated (subreq, err); +netfs_subreq_terminated (subreq, err, false);dout ("%s: result %d\n" , __func__, err); }fs/netfs/read_helper.c +59
-47@@ -29,12 +29,13 @@ module_param_named(debug, netfs_debug, uint, S_IWUSR | S_IRUGO);MODULE_PARM_DESC (netfs_debug,"Netfs support debugging mask" );static void netfs_rreq_work (struct work_struct *); -static void __netfs_put_subrequest (struct netfs_read_subrequest *); +static void __netfs_put_subrequest (struct netfs_read_subrequest *,bool ); -static void netfs_put_subrequest (struct netfs_read_subrequest *subreq) +static void netfs_put_subrequest (struct netfs_read_subrequest *subreq, +bool was_async) {if (refcount_dec_and_test (&subreq->usage)) -__netfs_put_subrequest (subreq); +__netfs_put_subrequest (subreq, was_async); } static struct netfs_read_request *netfs_alloc_read_request(@@ -67,7 +68,8 @@ static void netfs_get_read_request(struct netfs_read_request *rreq)refcount_inc (&rreq->usage); } -static void netfs_rreq_clear_subreqs (struct netfs_read_request *rreq) +static void netfs_rreq_clear_subreqs (struct netfs_read_request *rreq, +bool was_async) {struct netfs_read_subrequest *subreq;@@ -75,7 +77,7 @@ static void netfs_rreq_clear_subreqs(struct netfs_read_request *rreq) subreq =list_first_entry (&rreq->subrequests, struct netfs_read_subrequest, rreq_link);list_del (&subreq->rreq_link); -netfs_put_subrequest (subreq); +netfs_put_subrequest (subreq, was_async); } }@@ -83,7 +85,7 @@ static void netfs_free_read_request(struct work_struct *work) {struct netfs_read_request *rreq = container_of(work, struct netfs_read_request, work); -netfs_rreq_clear_subreqs (rreq); +netfs_rreq_clear_subreqs (rreq, false);if (rreq->netfs_priv) rreq->netfs_ops->cleanup (rreq->mapping, rreq->netfs_priv);trace_netfs_rreq (rreq, netfs_rreq_trace_free);@@ -93,10 +95,10 @@ static void netfs_free_read_request(struct work_struct *work)netfs_stat_d (&netfs_n_rh_rreq); } -static void netfs_put_read_request (struct netfs_read_request *rreq) +static void netfs_put_read_request (struct netfs_read_request *rreq,bool was_async) {if (refcount_dec_and_test (&rreq->usage)) { -if (in_softirq ()) { +if (was_async) { rreq->work.func = netfs_free_read_request;if (!queue_work (system_unbound_wq, &rreq->work))BUG ();@@ -131,12 +133,15 @@ static void netfs_get_read_subrequest(struct netfs_read_subrequest *subreq)refcount_inc (&subreq->usage); } -static void __netfs_put_subrequest (struct netfs_read_subrequest *subreq) +static void __netfs_put_subrequest (struct netfs_read_subrequest *subreq, +bool was_async) { +struct netfs_read_request *rreq = subreq->rreq; +trace_netfs_sreq (subreq, netfs_sreq_trace_free); -netfs_put_read_request (subreq->rreq);kfree (subreq);netfs_stat_d (&netfs_n_rh_sreq); +netfs_put_read_request (rreq, was_async); }/* @@ -152,11 +157,12 @@ static void netfs_clear_unread(struct netfs_read_subrequest *subreq)iov_iter_zero (iov_iter_count (&iter), &iter); } -static void netfs_cache_read_terminated (void *priv,ssize_t transferred_or_error) +static void netfs_cache_read_terminated (void *priv,ssize_t transferred_or_error, +bool was_async) {struct netfs_read_subrequest *subreq = priv; -netfs_subreq_terminated (subreq, transferred_or_error); +netfs_subreq_terminated (subreq, transferred_or_error, was_async); }/* @@ -186,7 +192,7 @@ static void netfs_fill_with_zeroes(struct netfs_read_request *rreq, {netfs_stat (&netfs_n_rh_zero);__set_bit (NETFS_SREQ_CLEAR_TAIL , &subreq->flags); -netfs_subreq_terminated (subreq,0 ); +netfs_subreq_terminated (subreq,0 , false); }/* @@ -215,11 +221,11 @@ static void netfs_read_from_server(struct netfs_read_request *rreq,/* * Release those waiting. */ -static void netfs_rreq_completed (struct netfs_read_request *rreq) +static void netfs_rreq_completed (struct netfs_read_request *rreq,bool was_async) {trace_netfs_rreq (rreq, netfs_rreq_trace_done); -netfs_rreq_clear_subreqs (rreq); -netfs_put_read_request (rreq); +netfs_rreq_clear_subreqs (rreq, was_async); +netfs_put_read_request (rreq, was_async); }/* @@ -228,7 +234,8 @@ static void netfs_rreq_completed(struct netfs_read_request *rreq)* * May be called in softirq mode and we inherit a ref from the caller. */ -static void netfs_rreq_unmark_after_write (struct netfs_read_request *rreq) +static void netfs_rreq_unmark_after_write (struct netfs_read_request *rreq, +bool was_async) {struct netfs_read_subrequest *subreq;struct pagevec pvec;@@ -258,10 +265,11 @@ static void netfs_rreq_unmark_after_write(struct netfs_read_request *rreq) }rcu_read_unlock (); -netfs_rreq_completed (rreq); +netfs_rreq_completed (rreq, was_async); } -static void netfs_rreq_copy_terminated (void *priv,ssize_t transferred_or_error) +static void netfs_rreq_copy_terminated (void *priv,ssize_t transferred_or_error, +bool was_async) {struct netfs_read_subrequest *subreq = priv;struct netfs_read_request *rreq = subreq->rreq;@@ -278,9 +286,9 @@ static void netfs_rreq_copy_terminated(void *priv, ssize_t transferred_or_error)/* If we decrement nr_wr_ops to 0, the ref belongs to us. */ if (atomic_dec_and_test (&rreq->nr_wr_ops)) -netfs_rreq_unmark_after_write (rreq); +netfs_rreq_unmark_after_write (rreq, was_async); -netfs_put_subrequest (subreq); +netfs_put_subrequest (subreq, was_async); }/* @@ -304,7 +312,7 @@ static void netfs_rreq_do_write_to_cache(struct netfs_read_request *rreq)list_for_each_entry_safe (subreq, p, &rreq->subrequests, rreq_link) {if (!test_bit (NETFS_SREQ_WRITE_TO_CACHE , &subreq->flags)) {list_del_init (&subreq->rreq_link); -netfs_put_subrequest (subreq); +netfs_put_subrequest (subreq, false); } }@@ -324,7 +332,7 @@ static void netfs_rreq_do_write_to_cache(struct netfs_read_request *rreq) subreq->len += next->len; subreq->len =round_up (subreq->len,PAGE_SIZE );list_del_init (&next->rreq_link); -netfs_put_subrequest (next); +netfs_put_subrequest (next, false); } iov_iter_xarray(&iter, WRITE, &rreq->mapping->i_pages,@@ -340,7 +348,7 @@ static void netfs_rreq_do_write_to_cache(struct netfs_read_request *rreq)/* If we decrement nr_wr_ops to 0, the usage ref belongs to us. */ if (atomic_dec_and_test (&rreq->nr_wr_ops)) -netfs_rreq_unmark_after_write (rreq); +netfs_rreq_unmark_after_write (rreq, false); }static void netfs_rreq_write_to_cache_work (struct work_struct *work)@@ -351,9 +359,10 @@ static void netfs_rreq_write_to_cache_work(struct work_struct *work)netfs_rreq_do_write_to_cache (rreq); } -static void netfs_rreq_write_to_cache (struct netfs_read_request *rreq) +static void netfs_rreq_write_to_cache (struct netfs_read_request *rreq, +bool was_async) { -if (in_softirq ()) { +if (was_async) { rreq->work.func = netfs_rreq_write_to_cache_work;if (!queue_work (system_unbound_wq, &rreq->work))BUG ();@@ -479,7 +488,7 @@ static bool netfs_rreq_perform_resubmissions(struct netfs_read_request *rreq) {struct netfs_read_subrequest *subreq; -WARN_ON (in_softirq ()); +WARN_ON (in_interrupt ());trace_netfs_rreq (rreq, netfs_rreq_trace_resubmit);@@ -538,7 +547,7 @@ static void netfs_rreq_is_still_valid(struct netfs_read_request *rreq)* 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_read_request *rreq) +static void netfs_rreq_assess (struct netfs_read_request *rreq,bool was_async) {trace_netfs_rreq (rreq, netfs_rreq_trace_assess);@@ -558,30 +567,31 @@ static void netfs_rreq_assess(struct netfs_read_request *rreq)wake_up_bit (&rreq->flags,NETFS_RREQ_IN_PROGRESS );if (test_bit (NETFS_RREQ_WRITE_TO_CACHE , &rreq->flags)) -return netfs_rreq_write_to_cache (rreq); +return netfs_rreq_write_to_cache (rreq, was_async); -netfs_rreq_completed (rreq); +netfs_rreq_completed (rreq, was_async); }static void netfs_rreq_work (struct work_struct *work) {struct netfs_read_request *rreq = container_of(work, struct netfs_read_request, work); -netfs_rreq_assess (rreq); +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_read_request *rreq) +static void netfs_rreq_terminated (struct netfs_read_request *rreq, +bool was_async) {if (test_bit (NETFS_RREQ_INCOMPLETE_IO , &rreq->flags) && -in_softirq ()) { + was_async) {if (!queue_work (system_unbound_wq, &rreq->work))BUG (); }else { -netfs_rreq_assess (rreq); +netfs_rreq_assess (rreq, was_async); } }@@ -589,6 +599,7 @@ static void netfs_rreq_terminated(struct netfs_read_request *rreq)* 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. @@ -599,11 +610,12 @@ static void netfs_rreq_terminated(struct netfs_read_request *rreq)* error code. The helper will look after reissuing I/O operations as * appropriate and writing downloaded data to the cache. * -* This may be called from a softirq handler, so we want to avoid taking the -* spinlock if we can. +* 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_read_subrequest *subreq, -ssize_t transferred_or_error) +ssize_t transferred_or_error, +bool was_async) {struct netfs_read_request *rreq = subreq->rreq;int u;@@ -647,11 +659,11 @@ void netfs_subreq_terminated(struct netfs_read_subrequest *subreq,/* If we decrement nr_rd_ops to 0, the ref belongs to us. */ u =atomic_dec_return (&rreq->nr_rd_ops);if (u ==0 ) -netfs_rreq_terminated (rreq); +netfs_rreq_terminated (rreq, was_async);else if (u ==1 )wake_up_var (&rreq->nr_rd_ops); -netfs_put_subrequest (subreq); +netfs_put_subrequest (subreq, was_async);return ; incomplete:@@ -796,7 +808,7 @@ static bool netfs_rreq_submit_slice(struct netfs_read_request *rreq, subreq_failed: rreq->error = subreq->error; -netfs_put_subrequest (subreq); +netfs_put_subrequest (subreq, false);return false; }@@ -901,7 +913,7 @@ void netfs_readahead(struct readahead_control *ractl, }while (rreq->submitted < rreq->len);if (rreq->submitted ==0 ) { -netfs_put_read_request (rreq); +netfs_put_read_request (rreq, false);return ; }@@ -913,11 +925,11 @@ void netfs_readahead(struct readahead_control *ractl,/* If we decrement nr_rd_ops to 0, the ref belongs to us. */ if (atomic_dec_and_test (&rreq->nr_rd_ops)) -netfs_rreq_assess (rreq); +netfs_rreq_assess (rreq, false);return ; cleanup_free: -netfs_put_read_request (rreq); +netfs_put_read_request (rreq, false);return ; cleanup:if (netfs_priv)@@ -991,14 +1003,14 @@ int netfs_readpage(struct file *file,*/ do {wait_var_event (&rreq->nr_rd_ops,atomic_read (&rreq->nr_rd_ops) ==1 ); -netfs_rreq_assess (rreq); +netfs_rreq_assess (rreq, false); }while (test_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags)); ret = rreq->error;if (ret ==0 && rreq->submitted < rreq->len) ret = -EIO ; out: -netfs_put_read_request (rreq); +netfs_put_read_request (rreq, false);return ret; }EXPORT_SYMBOL (netfs_readpage);@@ -1136,7 +1148,7 @@ int netfs_write_begin(struct file *file, struct address_space *mapping,*/ for (;;) {wait_var_event (&rreq->nr_rd_ops,atomic_read (&rreq->nr_rd_ops) ==1 ); -netfs_rreq_assess (rreq); +netfs_rreq_assess (rreq, false);if (!test_bit (NETFS_RREQ_IN_PROGRESS , &rreq->flags))break ;cond_resched ();@@ -1145,7 +1157,7 @@ int netfs_write_begin(struct file *file, struct address_space *mapping, ret = rreq->error;if (ret ==0 && rreq->submitted < rreq->len) ret = -EIO ; -netfs_put_read_request (rreq); +netfs_put_read_request (rreq, false);if (ret <0 ) goto error;include/linux/netfs.h +2
-1@@ -60,7 +60,8 @@ enum netfs_read_source {NETFS_INVALID_READ , } __mode(byte); -typedef void (*netfs_io_terminated_t )(void *priv,ssize_t transferred_or_error); +typedef void (*netfs_io_terminated_t )(void *priv,ssize_t transferred_or_error, +bool was_async);/* * Resources required to do operations on a cache.
include/linux/netfs.h extern int netfs_write_begin(struct file *, struct address_space *, · line 196
Quoted 8 lines
include/linux/netfs.h +1
-1@@ -189,7 +190,7 @@ extern int netfs_write_begin(struct file *, struct address_space *, const struct netfs_read_request_ops *, void *); -extern void netfs_subreq_terminated (struct netfs_read_subrequest *,ssize_t ); +extern void netfs_subreq_terminated (struct netfs_read_subrequest *,ssize_t ,bool );extern void netfs_stats_show (struct seq_file *);#endif /* _LINUX_NETFS_H */
Looks good in testing.
Re: [PATCH 34/33] netfs: Pass flag rather than use in_softirq()
In reply to David HowellsQuoted 1 line · David Howells
How about the attached instead?
Thank you for that flag.
Quoted 1 line
David
Sebastian