ceph: conversion to new netfs/fscache APIs
cover ceph: conversion to new netfs/fscache APIs
This patchset converts ceph to the new netfs/fscache APIs, and depends on the fscache overhaul that David Howells recently posted. It also adds support for writing to the cache. Due to the fact that we're leveraging the new netfs_* helpers, this is substantial reduction in code as well.
I've tested this pretty extensively using xfstests and kernel builds, both with and without the cache enabled. It all seems to do the right thing now.
Jeff Layton (5):
ceph: conversion to new fscache API
ceph: convert readpage to fscache read helper
ceph: plug write_begin into read helper
ceph: convert ceph_readpages to ceph_readahead
ceph: add fscache writeback support
fs/ceph/Kconfig | 3 +- fs/ceph/addr.c | 627 ++++++++++++++++++++++-------------------------- fs/ceph/cache.c | 295 +++++++---------------- fs/ceph/cache.h | 106 +++----- fs/ceph/caps.c | 12 +- fs/ceph/file.c | 14 +- fs/ceph/inode.c | 24 +- fs/ceph/super.c | 1 + fs/ceph/super.h | 1 - 9 files changed, 450 insertions(+), 633 deletions(-)
Signature · 1 line
2.28.0
PATCH 1/5 ceph: conversion to new fscache API
Now that the fscache API has been reworked and simplified, start changing ceph over to use it. Drop functions that are no longer needed and rework some of the others to conform to the new API.
Change how cookies are managed as well. With the old API, we would only instantiate a cookie when the file was open for reads. Change it to instantiate the cookie when the inode is instantiated and call use/unuse when the file is opened/closed. This will allow us to plumb in write support in subsequent patches.
For now, just rip most of the code out of the read+write codepaths, as subsequent patches will rework that code to use new helper functions.
--- fs/ceph/addr.c | 55 ++++----- fs/ceph/cache.c | 295 ++++++++++++++---------------------------------- fs/ceph/cache.h | 106 +++++++---------- fs/ceph/caps.c | 12 +- fs/ceph/file.c | 14 ++- fs/ceph/inode.c | 24 +++- fs/ceph/super.c | 1 + fs/ceph/super.h | 1 - 8 files changed, 177 insertions(+), 331 deletions(-)
fs/ceph/addr.c +19 -36
@@ -127,7 +127,7 @@ static int ceph_set_page_dirty(struct page *page) page->private = (unsigned long )snapc;SetPagePrivate (page); - ret =__set_page_dirty_nobuffers (page); + ret =ceph_fscache_set_page_dirty (page);WARN_ON (!PageLocked (page));WARN_ON (!page->mapping);
@@ -155,31 +155,34 @@ 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 ; +if (PagePrivate (page)) { +dout ("%p invalidatepage %p idx %lu full dirty page\n" , + inode, page, page->index); -dout ("%p invalidatepage %p idx %lu full dirty page\n" , - inode, page, page->index); +ceph_put_wrbuffer_cap_refs (ci,1 , snapc); +ceph_put_snap_context (snapc); + page->private =0 ; +ClearPagePrivate (page); + } -ceph_put_wrbuffer_cap_refs (ci,1 , snapc); -ceph_put_snap_context (snapc); - page->private =0 ; -ClearPagePrivate (page); +ceph_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 " ); -/* Can we release the page from the cache? */ -if (!ceph_release_fscache_page (page, g)) +if (PagePrivate (page))return 0 ; -return !PagePrivate (page); +if (PageFsCache (page)) { +if (!(gfp_flags & __GFP_DIRECT_RECLAIM) || !(gfp_flags & __GFP_FS)) +return 0 ; +ceph_wait_on_page_fscache (page); + } +return 1 ; }/* read a single page, without unlocking it. */
@@ -213,10 +216,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 +240,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 +251,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 +290,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 +301,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 +401,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);
@@ -441,7 +433,6 @@ static int start_read(struct inode *inode, struct ceph_rw_context *rw_ctx, out_pages:for (i =0 ; i < nr_pages; ++i) { -ceph_fscache_readpage_cancel (inode, pages[i]);unlock_page (pages[i]); }ceph_put_page_vector (pages, nr_pages, false);
@@ -471,12 +462,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 +472,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 +86 -209
356 lines not on this page · raw message
fs/ceph/cache.h +40 -66
170 lines not on this page · raw message
fs/ceph/caps.c +2 -10
@@ -1999,7 +1999,7 @@ void ceph_check_caps(struct ceph_inode_info *ci, int flags, !(ci->i_wb_ref || ci->i_wrbuffer_ref) && /* no dirty pages... */ inode->i_data.nrpages && /* have cached pages */ (revoking & (CEPH_CAP_FILE_CACHE| - CEPH_CAP_FILE_LAZYIO)) && /* or revoking cache */ + CEPH_CAP_FILE_LAZYIO)) && /* revoking Fc */ !tried_invalidate) {dout ("check_caps trying to invalidate on %p\n" , inode);if (try_nonblocking_invalidate (inode) <0 ) {
@@ -2387,6 +2387,7 @@ int ceph_write_inode(struct inode *inode, struct writeback_control *wbc)int wait = (wbc->sync_mode ==WB_SYNC_ALL && !wbc->for_sync);dout ("write_inode %p wait=%d\n" , inode, wait); +ceph_fscache_unpin_writeback (inode, wbc);if (wait) { dirty =try_flush_caps (inode, &flush_tid);if (dirty)
@@ -2729,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 ; }
@@ -2982,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 ; }
fs/ceph/file.c +11 -3
@@ -12,6 +12,7 @@#include <linux/falloc.h> #include <linux/iversion.h> #include <linux/ktime.h> +#include <linux/fscache.h> #include "super.h" #include "mds_client.h"
@@ -249,8 +250,7 @@ static int ceph_init_file(struct inode *inode, struct file *file, int fmode)switch (inode->i_mode &S_IFMT ) {case S_IFREG : -ceph_fscache_register_inode_cookie (inode); -ceph_fscache_file_set_cookie (inode, file); +ceph_fscache_use_cookie (inode, file->f_mode &FMODE_WRITE ); fallthrough;case S_IFDIR : ret = ceph_init_file_info(inode, file, fmode,
@@ -800,6 +800,7 @@ int ceph_release(struct inode *inode, struct file *file)dout ("release inode %p regular file %p\n" , inode, file);WARN_ON (!list_empty (&fi->rw_contexts)); +ceph_fscache_unuse_cookie (inode, file->f_mode &FMODE_WRITE );ceph_put_fmode (ci, fi->fmode,1 );kmem_cache_free (ceph_file_cachep, fi);
@@ -1194,7 +1195,11 @@ ceph_direct_read_write(struct kiocb *iocb, struct iov_iter *iter, snapc, snapc ? snapc->seq : 0);if (write) { -int ret2 =invalidate_inode_pages2_range (inode->i_mapping, +int ret2; + +ceph_fscache_invalidate (inode,FSCACHE_INVAL_DIO_WRITE ); + + ret2 =invalidate_inode_pages2_range (inode->i_mapping, pos >>PAGE_SHIFT , (pos + count -1 ) >>PAGE_SHIFT );if (ret2 <0 )
@@ -1405,6 +1410,7 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,if (ret <0 )return ret; +ceph_fscache_invalidate (inode,0 ); ret =invalidate_inode_pages2_range (inode->i_mapping, pos >>PAGE_SHIFT , (pos + count -1 ) >>PAGE_SHIFT );
@@ -2087,6 +2093,7 @@ static long ceph_fallocate(struct file *file, int mode,if (ret <0 ) goto unlock; +ceph_fscache_invalidate (inode,0 );ceph_zero_pagecache_range (inode, offset, length); ret =ceph_zero_objects (inode, offset, length);
@@ -2354,6 +2361,7 @@ static ssize_t __ceph_copy_file_range(struct file *src_file, loff_t src_off, goto out_caps;/* Drop dst file cached pages */ +ceph_fscache_invalidate (dst_inode,0 ); ret =invalidate_inode_pages2_range (dst_inode->i_mapping, dst_off >>PAGE_SHIFT , (dst_off + len) >>PAGE_SHIFT );
fs/ceph/inode.c +18 -6
@@ -550,6 +550,8 @@ void ceph_evict_inode(struct inode *inode)percpu_counter_dec (&mdsc->metric.total_inodes);truncate_inode_pages_final (&inode->i_data); +if (inode->i_state &I_PINNING_FSCACHE_WB ) +ceph_fscache_unuse_cookie (inode, true);clear_inode (inode);ceph_fscache_unregister_inode_cookie (ci);
@@ -616,16 +618,25 @@ int ceph_fill_file_size(struct inode *inode, int issued, {struct ceph_inode_info *ci =ceph_inode (inode);int queue_trunc =0 ; +loff_t oldsize =i_size_read (inode);if (ceph_seq_cmp (truncate_seq, ci->i_truncate_seq) >0 || - (truncate_seq == ci->i_truncate_seq && size > inode->i_size)) { -dout ("size %lld -> %llu\n" , inode->i_size, size); + (truncate_seq == ci->i_truncate_seq && size > oldsize)) { +dout ("size %lld -> %llu\n" , oldsize, size);if (size >0 &&S_ISDIR (inode->i_mode)) {pr_err ("fill_file_size non-zero size for directory\n" ); size =0 ; }i_size_write (inode, size); inode->i_blocks =calc_inode_blocks (size); +/* +* If we're truncating up, then we should be able to just update +* the existing cookie. Otherwise, we need to invalidate. +*/ +if (size > oldsize) +ceph_fscache_update (inode); +else +ceph_fscache_invalidate (inode,0 ); ci->i_reported_size = size;if (truncate_seq != ci->i_truncate_seq) { dout("truncate_seq %u -> %u\n",
@@ -658,10 +669,6 @@ int ceph_fill_file_size(struct inode *inode, int issued, truncate_size); ci->i_truncate_size = truncate_size; } - -if (queue_trunc) -ceph_fscache_invalidate (inode); -return queue_trunc; }
@@ -930,6 +937,7 @@ int ceph_fill_inode(struct inode *inode, struct page *locked_page, inode->i_op = &ceph_file_iops;break ;case S_IFREG : +ceph_fscache_register_inode_cookie (inode); inode->i_op = &ceph_file_iops; inode->i_fop = &ceph_file_fops;break ;
@@ -1790,11 +1798,13 @@ bool ceph_inode_set_size(struct inode *inode, loff_t size)spin_lock (&ci->i_ceph_lock);dout ("set_size %p %llu -> %llu\n" , inode, inode->i_size, size);i_size_write (inode, size); +ceph_fscache_update (inode); inode->i_blocks =calc_inode_blocks (size); ret =__ceph_should_report_size (ci);spin_unlock (&ci->i_ceph_lock); +return ret; }
@@ -1870,6 +1880,7 @@ void ceph_queue_vmtruncate(struct inode *inode)set_bit (CEPH_I_WORK_VMTRUNCATE , &ci->i_work_mask);ihold (inode); +ceph_fscache_invalidate (inode,0 );if (queue_inode_work (inode)) {dout ("ceph_queue_vmtruncate %p\n" , inode); }else {
@@ -2139,6 +2150,7 @@ int __ceph_setattr(struct inode *inode, struct iattr *attr)if ((issued &CEPH_CAP_FILE_EXCL ) && attr->ia_size > inode->i_size) {i_size_write (inode, attr->ia_size); +ceph_fscache_resize (inode); inode->i_blocks =calc_inode_blocks (attr->ia_size); ci->i_reported_size = attr->ia_size; dirtied |=CEPH_CAP_FILE_EXCL ;
fs/ceph/super.c +1 -0
@@ -45,6 +45,7 @@ static void ceph_put_super(struct super_block *s)dout ("put_super\n" );ceph_mdsc_close_sessions (fsc->mdsc); +ceph_fscache_put_super (s); }static int ceph_statfs (struct dentry *dentry,struct kstatfs *buf)
fs/ceph/super.h +0 -1
@@ -427,7 +427,6 @@ struct ceph_inode_info {#ifdef CONFIG_CEPH_FSCACHE struct fscache_cookie *fscache; -u32 i_fscache_gen;#endif errseq_t i_meta_err;
Signature · 1 line
2.28.0
PATCH 2/5 ceph: convert readpage to fscache read helper
In reply to Jeff LaytonHave the ceph KConfig select NETFS_SUPPORT. Add a new netfs ops structure that and convert ceph_readpage to use the new netfs_readpage helper.
--- fs/ceph/Kconfig | 1 + fs/ceph/addr.c | 167 +++++++++++++++++++++++++++++++++++++++++++++--- 2 files changed, 158 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 +157 -10
185 lines not on this page · raw message
Signature · 1 line
2.28.0
PATCH 3/5 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
@@ -342,76 +342,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. */
@@ -1432,6 +1362,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.
@@ -1442,75 +1406,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 ) +ceph_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.28.0
PATCH 4/5 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 | 230 ++++++++----------------------------------------- 1 file changed, 34 insertions(+), 196 deletions(-)
fs/ceph/addr.c +34 -196
@@ -342,215 +342,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) -{ -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) +static void ceph_readahead_cleanup (struct address_space *mapping,void *priv) { -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 ; +int got = (int )(uintptr_t )priv; -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); - -/* 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
@@ -1503,7 +1341,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.28.0
PATCH 5/5 ceph: add fscache writeback support
In reply to Jeff LaytonWhen updating the backing store from the pagecache (a'la writepage or writepages), write to the cache first. This allows us to keep caching files even when they are open for write.
With this change we we can now re-enable CEPH_FSCACHE in Kconfig.
--- fs/ceph/Kconfig | 2 +- fs/ceph/addr.c | 64 +++++++++++++++++++++++++++++++++++++++++++------ 2 files changed, 58 insertions(+), 8 deletions(-)
fs/ceph/Kconfig +1 -1
@@ -21,7 +21,7 @@ config CEPH_FS if CEPH_FS config CEPH_FSCACHE bool "Enable Ceph client caching support" - depends on CEPH_FS=m && FSCACHE_OLD || CEPH_FS=y && FSCACHE_OLD=y + depends on CEPH_FS=m && FSCACHE || CEPH_FS=y && FSCACHE=y help Choose Y here to enable persistent, read-only local caching support for Ceph clients using FS-Cache
fs/ceph/addr.c +57 -7
122 lines not on this page · raw message
Signature · 1 line
2.28.0