FS-Cache: Miscellaneous fixes
Subsystems (4)
David Howells
maintainercover FS-Cache: Miscellaneous fixes
Attached are a number of fixes for bugs in FS-Cache and CacheFiles:
(1) Fix refcounting of parent of netfs index during registration.
(2) Only set primary index cookie of netfs if registration successful.
(3) Check block size of backing filesystem is suitable in CacheFiles.
(4) Fix off-by-one error in checking store limit when writing a page to cache.
These can also be found here:
http://git.kernel.org/cgit/linux/kernel/git/dhowells/linux-fs.git/log/?h=fscache-fixes
tagged with:
fscache-fixes-20151104
David
---
David Howells (1):
FS-Cache: Handle a write to the page immediately beyond the EOF marker
Kinglong Mee (2):
FS-Cache: Increase reference of parent after registering, netfs success
FS-Cache: Don't override netfs's primary_index if registering failed
NeilBrown (1):
cachefiles: perform test on s_blocksize when opening cache file.
fs/cachefiles/namei.c | 2 + fs/cachefiles/rdwr.c | 73 +++++++++++++++++++++++++------------------------ fs/fscache/netfs.c | 38 ++++++++++++-------------- fs/fscache/page.c | 2 + 4 files changed, 58 insertions(+), 57 deletions(-)
David Howells
maintainerPATCH 1/4 FS-Cache: Increase reference of parent after registering, netfs success
From: Kinglong Mee <[email protected]>
If netfs exist, fscache should not increase the reference of parent's usage and n_children, otherwise, never be decreased.
v2: thanks David's suggest,
move increasing reference of parent if success use kmem_cache_free() freeing primary_index directly
v3: don't move "netfs->primary_index->parent = &fscache_fsdef_index;"
---
fs/fscache/netfs.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-)
fs/fscache/netfs.c +4 -5
@@ -47,9 +47,6 @@ int __fscache_register_netfs(struct fscache_netfs *netfs) netfs->primary_index->netfs_data = netfs; netfs->primary_index->flags =1 <<FSCACHE_COOKIE_ENABLED ; -atomic_inc (&netfs->primary_index->parent->usage); -atomic_inc (&netfs->primary_index->parent->n_children); -spin_lock_init (&netfs->primary_index->lock);INIT_HLIST_HEAD (&netfs->primary_index->backing_objects);
@@ -62,6 +59,9 @@ int __fscache_register_netfs(struct fscache_netfs *netfs) goto already_registered; } +atomic_inc (&netfs->primary_index->parent->usage); +atomic_inc (&netfs->primary_index->parent->n_children); +list_add (&netfs->link, &fscache_netfs_list); ret =0 ;
@@ -71,8 +71,7 @@ already_registered:up_write (&fscache_addremove_sem);if (ret <0 ) { - netfs->primary_index->parent =NULL ; -__fscache_cookie_put (netfs->primary_index); +kmem_cache_free (fscache_cookie_jar, netfs->primary_index); netfs->primary_index =NULL ; }
David Howells
maintainerPATCH 2/4 FS-Cache: Don't override netfs's primary_index if registering failed
In reply to David HowellsFrom: Kinglong Mee <[email protected]>
Only override netfs->primary_index when registering success.
---
fs/fscache/netfs.c | 35 +++++++++++++++++------------------ 1 file changed, 17 insertions(+), 18 deletions(-)
fs/fscache/netfs.c +17 -18
@@ -22,6 +22,7 @@ static LIST_HEAD(fscache_netfs_list);int __fscache_register_netfs (struct fscache_netfs *netfs) {struct fscache_netfs *ptr; +struct fscache_cookie *cookie;int ret;_enter ("{%s}" , netfs->name);
@@ -29,26 +30,25 @@ int __fscache_register_netfs(struct fscache_netfs *netfs)INIT_LIST_HEAD (&netfs->link);/* allocate a cookie for the primary index */ - netfs->primary_index = -kmem_cache_zalloc (fscache_cookie_jar,GFP_KERNEL ); + cookie =kmem_cache_zalloc (fscache_cookie_jar,GFP_KERNEL ); -if (!netfs->primary_index) { +if (!cookie) {_leave (" = -ENOMEM" );return -ENOMEM ; }/* initialise the primary index cookie */ -atomic_set (&netfs->primary_index->usage,1 ); -atomic_set (&netfs->primary_index->n_children,0 ); -atomic_set (&netfs->primary_index->n_active,1 ); +atomic_set (&cookie->usage,1 ); +atomic_set (&cookie->n_children,0 ); +atomic_set (&cookie->n_active,1 ); - netfs->primary_index->def = &fscache_fsdef_netfs_def; - netfs->primary_index->parent = &fscache_fsdef_index; - netfs->primary_index->netfs_data = netfs; - netfs->primary_index->flags =1 <<FSCACHE_COOKIE_ENABLED ; + cookie->def = &fscache_fsdef_netfs_def; + cookie->parent = &fscache_fsdef_index; + cookie->netfs_data = netfs; + cookie->flags =1 <<FSCACHE_COOKIE_ENABLED ; -spin_lock_init (&netfs->primary_index->lock); -INIT_HLIST_HEAD (&netfs->primary_index->backing_objects); +spin_lock_init (&cookie->lock); +INIT_HLIST_HEAD (&cookie->backing_objects);/* check the netfs type is not already present */ down_write (&fscache_addremove_sem);
@@ -59,9 +59,10 @@ int __fscache_register_netfs(struct fscache_netfs *netfs) goto already_registered; } -atomic_inc (&netfs->primary_index->parent->usage); -atomic_inc (&netfs->primary_index->parent->n_children); +atomic_inc (&cookie->parent->usage); +atomic_inc (&cookie->parent->n_children); + netfs->primary_index = cookie;list_add (&netfs->link, &fscache_netfs_list); ret =0 ;
@@ -70,10 +71,8 @@ int __fscache_register_netfs(struct fscache_netfs *netfs) already_registered:up_write (&fscache_addremove_sem); -if (ret <0 ) { -kmem_cache_free (fscache_cookie_jar, netfs->primary_index); - netfs->primary_index =NULL ; - } +if (ret <0 ) +kmem_cache_free (fscache_cookie_jar, cookie);_leave (" = %d" , ret);return ret;
David Howells
maintainerPATCH 3/4 cachefiles: perform test on s_blocksize when opening cache file.
In reply to David HowellsFrom: NeilBrown <[email protected]>
cachefiles requires that s_blocksize in the cache is not greater than PAGE_SIZE, and performs the check every time a block is accessed.
Move the test to the place where the file is "opened", where other file-validity tests are performed.
---
fs/cachefiles/namei.c | 2 ++ fs/cachefiles/rdwr.c | 6 ------ 2 files changed, 2 insertions(+), 6 deletions(-)
fs/cachefiles/namei.c +2 -0
@@ -655,6 +655,8 @@ lookup_again: aops =d_backing_inode (object->dentry)->i_mapping->a_ops;if (!aops->bmap) goto check_error; +if (object->dentry->d_sb->s_blocksize >PAGE_SIZE ) + goto check_error; object->backer = object->dentry; }else {
fs/cachefiles/rdwr.c +0 -6
@@ -414,9 +414,6 @@ int cachefiles_read_or_alloc_page(struct fscache_retrieval *op,ASSERT (inode->i_mapping->a_ops->readpages);/* calculate the shift required to use bmap */ -if (inode->i_sb->s_blocksize >PAGE_SIZE ) - goto enobufs; - shift =PAGE_SHIFT - inode->i_sb->s_blocksize_bits; op->op.flags &=FSCACHE_OP_KEEP_FLAGS ;
@@ -711,9 +708,6 @@ int cachefiles_read_or_alloc_pages(struct fscache_retrieval *op,ASSERT (inode->i_mapping->a_ops->readpages);/* calculate the shift required to use bmap */ -if (inode->i_sb->s_blocksize >PAGE_SIZE ) - goto all_enobufs; - shift =PAGE_SHIFT - inode->i_sb->s_blocksize_bits;pagevec_init (&pagevec,0 );
David Howells
maintainerPATCH 4/4 FS-Cache: Handle a write to the page immediately beyond the EOF marker
In reply to David HowellsHandle a write being requested to the page immediately beyond the EOF marker on a cache object. Currently this gets an assertion failure in CacheFiles because the EOF marker is used there to encode information about a partial page at the EOF - which could lead to an unknown blank spot in the file if we extend the file over it.
The problem is actually in fscache where we check the index of the page being written against store_limit. store_limit is set to the number of pages that we're allowed to store by fscache_set_store_limit() - which means it's one more than the index of the last page we're allowed to store. The problem is that we permit writing to a page with an index _equal_ to the store limit - when we should reject that case.
Whilst we're at it, change the triggered assertion in CacheFiles to just return -ENOBUFS instead.
The assertion failure looks something like this:
CacheFiles: Assertion failed
1000 < 7b1 is false
------------[ cut here ]------------ kernel BUG at fs/cachefiles/rdwr.c:962! ... RIP: 0010:[<ffffffffa02c9e83>] [<ffffffffa02c9e83>] cachefiles_write_page+0x273/0x2d0 [cachefiles]
---
fs/cachefiles/rdwr.c | 67 ++++++++++++++++++++++++++++---------------------- fs/fscache/page.c | 2 + 2 files changed, 38 insertions(+), 31 deletions(-)
fs/cachefiles/rdwr.c +37 -30
@@ -899,6 +899,15 @@ int cachefiles_write_page(struct fscache_storage *op, struct page *page) cache =container_of (object->fscache.cache, struct cachefiles_cache, cache); + pos = (loff_t )page->index <<PAGE_SHIFT ; + +/* We mustn't write more data than we have, so we have to beware of a +* partial page at EOF. +*/ + eof = object->fscache.store_limit_l; +if (pos >= eof) + goto error; +/* write the page to the backing filesystem and let it store it in its * own time */ path.mnt = cache->mnt;
@@ -906,40 +915,38 @@ int cachefiles_write_page(struct fscache_storage *op, struct page *page) file =dentry_open (&path,O_RDWR |O_LARGEFILE , cache->cache_cred);if (IS_ERR (file)) { ret =PTR_ERR (file); - }else { - pos = (loff_t ) page->index <<PAGE_SHIFT ; - -/* we mustn't write more data than we have, so we have -* to beware of a partial page at EOF */ - eof = object->fscache.store_limit_l; - len =PAGE_SIZE ; -if (eof & ~PAGE_MASK ) { - ASSERTCMP(pos, <, eof); -if (eof - pos <PAGE_SIZE ) { -_debug ("cut short %llx to %llx" , - pos, eof); - len = eof - pos; - ASSERTCMP(pos + len, ==, eof); - } - } - - data =kmap (page); - ret =__kernel_write (file, data, len, &pos); -kunmap (page); -if (ret != len) - ret = -EIO ; -fput (file); + goto error_2; } -if (ret <0 ) { -if (ret == -EIO ) -cachefiles_io_error_obj ( - object,"Write page to backing file failed" ); - ret = -ENOBUFS ; + len =PAGE_SIZE ; +if (eof & ~PAGE_MASK ) { +if (eof - pos <PAGE_SIZE ) { +_debug ("cut short %llx to %llx" , + pos, eof); + len = eof - pos; + ASSERTCMP(pos + len, ==, eof); + } } -_leave (" = %d" , ret); -return ret; + data =kmap (page); + ret =__kernel_write (file, data, len, &pos); +kunmap (page); +fput (file); +if (ret != len) + goto error_eio; + +_leave (" = 0" ); +return 0 ; + +error_eio: + ret = -EIO ; +error_2: +if (ret == -EIO ) +cachefiles_io_error_obj (object, +"Write page to backing file failed" ); +error: +_leave (" = -ENOBUFS [%d]" , ret); +return -ENOBUFS ; }/*
fs/fscache/page.c +1 -1
@@ -816,7 +816,7 @@ static void fscache_write_op(struct fscache_operation *_op) goto superseded; page = results[0 ];_debug ("gang %d [%lx]" , n, page->index); -if (page->index > op->store_limit) { +if (page->index >= op->store_limit) {fscache_stat (&fscache_n_store_pages_over_limit); goto superseded; }