ceph: convert buffered read codepaths to new netfs API
Subsystems (2)
cover ceph: convert buffered read codepaths to new netfs API
This patchset coverts ceph to use the new netfs API that David Howells has proposed [1]. It's a substantial reduction in code in the ceph layer itself, but the main impetus is to allow the VM, filesystem and fscache to better work together to optimize readahead on network filesystems.
I think the resulting code is also easier to understand, and should be more maintainable as a lot of the pagecache handling is now done at the netfs layer.
This has been lightly tested with xfstests. With fscache disabled, I saw no regressions. With fscache enabled, I still hit some bugs down in the fscache layer itself, but those seem to be present without this set as well. This doesn't seem to make any of that worse.
[1]: https://lore.kernel.org/ceph-devel/[email protected]/T/#t
Jeff Layton (6):
ceph: disable old fscache readpage handling
ceph: rework PageFsCache handling
ceph: fix invalidation
ceph: convert readpage to fscache read helper
ceph: plug write_begin into read helper
ceph: convert ceph_readpages to ceph_readahead
fs/ceph/Kconfig | 1 + fs/ceph/addr.c | 536 +++++++++++++++++++----------------------------- fs/ceph/cache.c | 123 ----------- fs/ceph/cache.h | 101 +++------ fs/ceph/caps.c | 10 +- fs/ceph/inode.c | 1 + 6 files changed, 236 insertions(+), 536 deletions(-)
Signature · 1 line
2.29.2
RFC PATCH 1/6 ceph: disable old fscache readpage handling
With the new netfs read helper functions, we won't need a lot of this infrastructure as it handles a the pagecache 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 | 123 ------------------------------------------------ fs/ceph/cache.h | 91 +---------------------------------- fs/ceph/caps.c | 9 ---- 4 files changed, 3 insertions(+), 251 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 -123
132 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 ; }
Signature · 1 line
2.29.2
RFC PATCH 2/6 ceph: rework PageFsCache handling
In reply to Jeff LaytonWith 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.
--- fs/ceph/addr.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
fs/ceph/addr.c +7 -1
@@ -166,13 +166,19 @@ static void ceph_invalidatepage(struct page *page, unsigned int offset,ceph_put_snap_context (snapc); page->private =0 ;ClearPagePrivate (page); +wait_on_page_fscache (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); }
Signature · 1 line
2.29.2
RFC PATCH 3/6 ceph: fix invalidation
In reply to Jeff LaytonEnsure that we invalidate the fscache whenever we go to 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
@@ -1863,6 +1863,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); }
Signature · 1 line
2.29.2
RFC PATCH 4/6 ceph: convert readpage to fscache read helper
In reply to Jeff LaytonHave 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 */
Signature · 1 line
2.29.2
RFC PATCH 5/6 ceph: plug write_begin into read helper
In reply to Jeff LaytonConvert 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
@@ -321,76 +321,6 @@ static int ceph_readpage(struct file *filp, struct page *page)return netfs_readpage (filp, 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. */
@@ -1410,6 +1340,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.
@@ -1420,75 +1384,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;
Signature · 1 line
2.29.2
RFC PATCH 6/6 ceph: convert ceph_readpages to ceph_readahead
In reply to Jeff LaytonConvert 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
@@ -321,214 +321,53 @@ static int ceph_readpage(struct file *filp, struct page *page)return netfs_readpage (filp, 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
@@ -1481,7 +1320,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,
Signature · 1 line
2.29.2