NFS: Add nfs_pageio_complete_read() and remove nfs_readpage_async()

Add nfs_pageio_complete_read() and call this from both nfs_readpage()
and nfs_readpages(), since the submission and accounting is the same
for both functions.

Signed-off-by: Dave Wysochanski <dwysocha@redhat.com>
Signed-off-by: Anna Schumaker <Anna.Schumaker@Netapp.com>

diff --git a/fs/nfs/fscache.c b/fs/nfs/fscache.c
index a60df88..c4c021c 100644 (file)
--- a/fs/nfs/fscache.c
+++ b/fs/nfs/fscache.c
@@ -390,10 +390,6 @@ static void nfs_readpage_from_fscache_complete(struct page *page,
        if (!error) {
                SetPageUptodate(page);
                unlock_page(page);
-       } else {
-               error = nfs_readpage_async(context, page->mapping->host, page);
-               if (error)
-                       unlock_page(page);
        }
 }
 

diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index 0ed79e6..d2b6dce 100644 (file)
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -74,6 +74,24 @@ void nfs_pageio_init_read(struct nfs_pageio_descriptor *pgio,
 }
 EXPORT_SYMBOL_GPL(nfs_pageio_init_read);
 
+static void nfs_pageio_complete_read(struct nfs_pageio_descriptor *pgio,
+                                    struct inode *inode)
+{
+       struct nfs_pgio_mirror *pgm;
+       unsigned long npages;
+
+       nfs_pageio_complete(pgio);
+
+       /* It doesn't make sense to do mirrored reads! */
+       WARN_ON_ONCE(pgio->pg_mirror_count != 1);
+
+       pgm = &pgio->pg_mirrors[0];
+       NFS_I(inode)->read_io += pgm->pg_bytes_written;
+       npages = (pgm->pg_bytes_written + PAGE_SIZE - 1) >> PAGE_SHIFT;
+       nfs_add_stats(inode, NFSIOS_READPAGES, npages);
+}
+
+
 void nfs_pageio_reset_read_mds(struct nfs_pageio_descriptor *pgio)
 {
        struct nfs_pgio_mirror *mirror;
@@ -119,36 +137,6 @@ struct nfs_readdesc {
        struct nfs_open_context *ctx;
 };
 
-static int readpage_async_filler(void *data, struct page *page);
-
-int nfs_readpage_async(void *data, struct inode *inode,
-                      struct page *page)
-{
-       struct nfs_readdesc *desc = data;
-       struct nfs_pgio_mirror *pgm;
-       int error;
-
-       nfs_pageio_init_read(&desc->pgio, inode, false,
-                            &nfs_async_read_completion_ops);
-
-       error = readpage_async_filler(desc, page);
-       if (error)
-               goto out;
-
-       nfs_pageio_complete(&desc->pgio);
-
-       /* It doesn't make sense to do mirrored reads! */
-       WARN_ON_ONCE(desc->pgio.pg_mirror_count != 1);
-
-       pgm = &desc->pgio.pg_mirrors[0];
-       NFS_I(inode)->read_io += pgm->pg_bytes_written;
-
-       return desc->pgio.pg_error < 0 ? desc->pgio.pg_error : 0;
-
-out:
-       return error;
-}
-
 static void nfs_page_group_set_uptodate(struct nfs_page *req)
 {
        if (nfs_page_group_sync_on_bit(req, PG_UPTODATE))
@@ -170,8 +158,7 @@ static void nfs_read_completion(struct nfs_pgio_header *hdr)
 
                if (test_bit(NFS_IOHDR_EOF, &hdr->flags)) {
                        /* note: regions of the page not covered by a
-                        * request are zeroed in nfs_readpage_async /
-                        * readpage_async_filler */
+                        * request are zeroed in readpage_async_filler */
                        if (bytes > hdr->good_bytes) {
                                /* nothing in this request was good, so zero
                                 * the full extent of the request */
@@ -303,6 +290,38 @@ static void nfs_readpage_result(struct rpc_task *task,
                nfs_readpage_retry(task, hdr);
 }
 
+static int
+readpage_async_filler(void *data, struct page *page)
+{
+       struct nfs_readdesc *desc = data;
+       struct nfs_page *new;
+       unsigned int len;
+       int error;
+
+       len = nfs_page_length(page);
+       if (len == 0)
+               return nfs_return_empty_page(page);
+
+       new = nfs_create_request(desc->ctx, page, 0, len);
+       if (IS_ERR(new))
+               goto out_error;
+
+       if (len < PAGE_SIZE)
+               zero_user_segment(page, len, PAGE_SIZE);
+       if (!nfs_pageio_add_request(&desc->pgio, new)) {
+               nfs_list_remove_request(new);
+               error = desc->pgio.pg_error;
+               nfs_readpage_release(new, error);
+               goto out;
+       }
+       return 0;
+out_error:
+       error = PTR_ERR(new);
+       unlock_page(page);
+out:
+       return error;
+}
+
 /*
  * Read a page over NFS.
  * We read the page synchronously in the following case:
@@ -351,13 +370,20 @@ int nfs_readpage(struct file *file, struct page *page)
        }
 
        xchg(&desc.ctx->error, 0);
-       ret = nfs_readpage_async(&desc, inode, page);
+       nfs_pageio_init_read(&desc.pgio, inode, false,
+                            &nfs_async_read_completion_ops);
+
+       ret = readpage_async_filler(&desc, page);
+
+       if (!ret)
+               nfs_pageio_complete_read(&desc.pgio, inode);
+
+       ret = desc.pgio.pg_error < 0 ? desc.pgio.pg_error : 0;
        if (!ret) {
                ret = wait_on_page_locked_killable(page);
                if (!PageUptodate(page) && !ret)
                        ret = xchg(&desc.ctx->error, 0);
        }
-       nfs_add_stats(inode, NFSIOS_READPAGES, 1);
 out:
        put_nfs_open_context(desc.ctx);
        return ret;
@@ -366,45 +392,11 @@ out_unlock:
        return ret;
 }
 
-static int
-readpage_async_filler(void *data, struct page *page)
-{
-       struct nfs_readdesc *desc = (struct nfs_readdesc *)data;
-       struct nfs_page *new;
-       unsigned int len;
-       int error;
-
-       len = nfs_page_length(page);
-       if (len == 0)
-               return nfs_return_empty_page(page);
-
-       new = nfs_create_request(desc->ctx, page, 0, len);
-       if (IS_ERR(new))
-               goto out_error;
-
-       if (len < PAGE_SIZE)
-               zero_user_segment(page, len, PAGE_SIZE);
-       if (!nfs_pageio_add_request(&desc->pgio, new)) {
-               nfs_list_remove_request(new);
-               error = desc->pgio.pg_error;
-               nfs_readpage_release(new, error);
-               goto out;
-       }
-       return 0;
-out_error:
-       error = PTR_ERR(new);
-       unlock_page(page);
-out:
-       return error;
-}
-
 int nfs_readpages(struct file *file, struct address_space *mapping,
                struct list_head *pages, unsigned nr_pages)
 {
-       struct nfs_pgio_mirror *pgm;
        struct nfs_readdesc desc;
        struct inode *inode = mapping->host;
-       unsigned long npages;
        int ret;
 
        dprintk("NFS: nfs_readpages (%s/%Lu %d)\n",
@@ -437,16 +429,9 @@ int nfs_readpages(struct file *file, struct address_space *mapping,
                             &nfs_async_read_completion_ops);
 
        ret = read_cache_pages(mapping, pages, readpage_async_filler, &desc);
-       nfs_pageio_complete(&desc.pgio);
 
-       /* It doesn't make sense to do mirrored reads! */
-       WARN_ON_ONCE(desc.pgio.pg_mirror_count != 1);
+       nfs_pageio_complete_read(&desc.pgio, inode);
 
-       pgm = &desc.pgio.pg_mirrors[0];
-       NFS_I(inode)->read_io += pgm->pg_bytes_written;
-       npages = (pgm->pg_bytes_written + PAGE_SIZE - 1) >>
-                PAGE_SHIFT;
-       nfs_add_stats(inode, NFSIOS_READPAGES, npages);
 read_complete:
        put_nfs_open_context(desc.ctx);
 out:

diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index cb0248a..3cfcf21 100644 (file)
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -570,7 +570,6 @@ nfs_have_writebacks(struct inode *inode)
 extern int  nfs_readpage(struct file *, struct page *);
 extern int  nfs_readpages(struct file *, struct address_space *,
                struct list_head *, unsigned);
-extern int  nfs_readpage_async(void *, struct inode *, struct page *);
 
 /*
  * inline functions