@@ -219,7 +219,9 @@ static void nfs_readdir_page_init_array(struct page *page, u64 last_cookie)
array->last_cookie = last_cookie;
array->cookies_are_ordered = 1;
kunmap_atomic(array);
- set_page_private(page, 0);
+ if (page->mapping)
+ set_page_private(page, nfs_save_change_attribute(page->mapping->host));
+ SetPageUptodate(page);
}
static int
@@ -256,6 +258,15 @@ void nfs_readdir_clear_array(struct page *page)
kfree(array->array[i].name);
nfs_readdir_array_init(array);
kunmap_atomic(array);
+ ClearPageUptodate(page);
+}
+
+static void
+nfs_readdir_recycle_page(struct page *page, u64 last_cookie)
+{
+ nfs_readdir_clear_array(page);
+ nfs_readdir_invalidatepage(page, 0, 0);
+ nfs_readdir_page_init_array(page, last_cookie);
}
static struct page *
@@ -372,18 +383,47 @@ int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page)
return ret;
}
+static bool
+nfs_readdir_page_valid(struct page *page, unsigned int entry_index, u64 index_cookie)
+{
+ bool ret = false;
+ struct nfs_cache_array *array;
+
+ if (page_private(page) != nfs_save_change_attribute(page->mapping->host))
+ goto out;
+
+ ret = true;
+ array = kmap_atomic(page);
+
+ if (array->size == 0 && array->last_cookie == index_cookie)
+ goto out_unmap;
+
+ if (array->size > entry_index &&
+ array->array[entry_index].cookie == index_cookie)
+ goto out_unmap;
+
+ ret = false;
+out_unmap:
+ kunmap_atomic(array);
+out:
+ return ret;
+}
+
static struct page *nfs_readdir_page_get_locked(struct address_space *mapping,
- pgoff_t index, u64 last_cookie)
+ struct nfs_dir_page_cursor *pgc)
{
struct page *page;
- page = grab_cache_page(mapping, index);
- if (page && !PageUptodate(page)) {
- nfs_readdir_page_init_array(page, last_cookie);
- if (invalidate_inode_pages2_range(mapping, index + 1, -1) < 0)
- nfs_zap_mapping(mapping->host, mapping);
- SetPageUptodate(page);
- }
+ page = grab_cache_page(mapping, pgc->page_index);
+
+ if (!page)
+ return page;
+
+ if (!PageUptodate(page))
+ nfs_readdir_page_init_array(page, pgc->index_cookie);
+
+ if (!nfs_readdir_page_valid(page, pgc->entry_index, pgc->index_cookie))
+ nfs_readdir_recycle_page(page, pgc->index_cookie);
return page;
}
@@ -429,8 +469,12 @@ static struct page *nfs_readdir_page_get_next(struct address_space *mapping,
pgoff_t index, u64 cookie)
{
struct page *page;
+ struct nfs_dir_page_cursor pgc = {
+ .page_index = index,
+ .index_cookie = cookie,
+ };
- page = nfs_readdir_page_get_locked(mapping, index, cookie);
+ page = nfs_readdir_page_get_locked(mapping, &pgc);
if (page) {
if (nfs_readdir_page_last_cookie(page) == cookie)
return page;
@@ -984,9 +1028,7 @@ nfs_readdir_page_unlock_and_put_cached(struct nfs_readdir_descriptor *desc)
static struct page *
nfs_readdir_page_get_cached(struct nfs_readdir_descriptor *desc)
{
- return nfs_readdir_page_get_locked(desc->file->f_mapping,
- desc->pgc.page_index,
- desc->pgc.index_cookie);
+ return nfs_readdir_page_get_locked(desc->file->f_mapping, &desc->pgc);
}
#define NFS_READDIR_PAGE_FILL_MISS_MAX 5
The current implementation of the readdir page cache requires that all pages contain entries ordered such that the cookie references lead to the first entry as represented by cookie 0. The invalidation of the cache truncates either the entire cache or every page beyond a known good page. A process that wants to emit directory entries near the end of a directory must first fill in any entries missing in the cache near the beginning of the directory in order that the entries decoded from READDIR XDR are appropriately page-aligned for any readers thay may come later (and for some error handling). However, if we're careful to check the alignment of directory entries on each page when the page is read, then it should be permissable to allow "disconnected" filling of the pagecache. Rather than requiring pagecache data to always be positionally aligned, we can instead validate that each page is properly aligned to the reading process' directory context. If it doesn't match our alignment, we'll refresh the entries in the page so that it does. This patch implements a check for validity for each page as it is obtained from the pagecache. A page is valid if it was filled within the client's current version of the directory and if the entries are aligned with the current reader's directory context. Invalid pages are re-filled by READDIR operations before being used to emit entries for the current reader. Signed-off-by: Benjamin Coddington <bcodding@redhat.com> --- fs/nfs/dir.c | 68 ++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 55 insertions(+), 13 deletions(-)