NFS: Cleanup of NFS write code in preparation for asynchronous o_direct

This patch inverts the callback hierarchy for NFS write calls.

Instead of having the NFSv2/v3/v4-specific code set up the RPC callback
ops, we allow the original caller to do so. This allows for more
flexibility w.r.t. how to set up and tear down the nfs_write_data
structure while still allowing the NFSv3/v4 code to perform error
handling.

The greater flexibility is needed by the asynchronous O_DIRECT code, which
wants to be able to hold on to the original nfs_write_data structures after
the WRITE RPC call has completed in order to be able to replay them if the
COMMIT call determines that the server has rebooted.

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>

4 files changed, 101 insertions, 135 deletions

diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index 740f8b1ab04d..c4f7de8830e9 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -849,29 +849,17 @@ nfs3_proc_read_setup(struct nfs_read_data *data)
         rpc_call_setup(task, &msg, 0);
 }
 
-static void nfs3_write_done(struct rpc_task *task, void *calldata)
+static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data)
 {
-        struct nfs_write_data *data = calldata;
-
         if (nfs3_async_handle_jukebox(task, data->inode))
-                return;
+                return -EAGAIN;
         if (task->tk_status >= 0)
                 nfs_post_op_update_inode(data->inode, data->res.fattr);
-        nfs_writeback_done(task, calldata);
+        return 0;
 }
 
-static const struct rpc_call_ops nfs3_write_ops = {
-        .rpc_call_done = nfs3_write_done,
-        .rpc_release = nfs_writedata_release,
-};
-
-static void
-nfs3_proc_write_setup(struct nfs_write_data *data, int how)
+static void nfs3_proc_write_setup(struct nfs_write_data *data, int how)
 {
-        struct rpc_task         *task = &data->task;
-        struct inode            *inode = data->inode;
-        int                     stable;
-        int                     flags;
         struct rpc_message      msg = {
                 .rpc_proc       = &nfs3_procedures[NFS3PROC_WRITE],
                 .rpc_argp       = &data->args,
@@ -879,45 +867,28 @@ nfs3_proc_write_setup(struct nfs_write_data *data, int how)
                 .rpc_cred       = data->cred,
         };
 
+        data->args.stable = NFS_UNSTABLE;
         if (how & FLUSH_STABLE) {
-                if (!NFS_I(inode)->ncommit)
-                        stable = NFS_FILE_SYNC;
-                else
-                        stable = NFS_DATA_SYNC;
-        } else
-                stable = NFS_UNSTABLE;
-        data->args.stable = stable;
-
-        /* Set the initial flags for the task.  */
-        flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
+                data->args.stable = NFS_FILE_SYNC;
+                if (NFS_I(data->inode)->ncommit)
+                        data->args.stable = NFS_DATA_SYNC;
+        }
 
         /* Finalize the task. */
-        rpc_init_task(task, NFS_CLIENT(inode), flags, &nfs3_write_ops, data);
-        rpc_call_setup(task, &msg, 0);
+        rpc_call_setup(&data->task, &msg, 0);
 }
 
-static void nfs3_commit_done(struct rpc_task *task, void *calldata)
+static int nfs3_commit_done(struct rpc_task *task, struct nfs_write_data *data)
 {
-        struct nfs_write_data *data = calldata;
-
         if (nfs3_async_handle_jukebox(task, data->inode))
-                return;
+                return -EAGAIN;
         if (task->tk_status >= 0)
                 nfs_post_op_update_inode(data->inode, data->res.fattr);
-        nfs_commit_done(task, calldata);
+        return 0;
 }
 
-static const struct rpc_call_ops nfs3_commit_ops = {
-        .rpc_call_done = nfs3_commit_done,
-        .rpc_release = nfs_commit_release,
-};
-
-static void
-nfs3_proc_commit_setup(struct nfs_write_data *data, int how)
+static void nfs3_proc_commit_setup(struct nfs_write_data *data, int how)
 {
-        struct rpc_task         *task = &data->task;
-        struct inode            *inode = data->inode;
-        int                     flags;
         struct rpc_message      msg = {
                 .rpc_proc       = &nfs3_procedures[NFS3PROC_COMMIT],
                 .rpc_argp       = &data->args,
@@ -925,12 +896,7 @@ nfs3_proc_commit_setup(struct nfs_write_data *data, int how)
                 .rpc_cred       = data->cred,
         };
 
-        /* Set the initial flags for the task.  */
-        flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
-
-        /* Finalize the task. */
-        rpc_init_task(task, NFS_CLIENT(inode), flags, &nfs3_commit_ops, data);
-        rpc_call_setup(task, &msg, 0);
+        rpc_call_setup(&data->task, &msg, 0);
 }
 
 static int
@@ -970,7 +936,9 @@ struct nfs_rpc_ops	nfs_v3_clientops = {
         .decode_dirent  = nfs3_decode_dirent,
         .read_setup     = nfs3_proc_read_setup,
         .write_setup    = nfs3_proc_write_setup,
+        .write_done     = nfs3_write_done,
         .commit_setup   = nfs3_proc_commit_setup,
+        .commit_done    = nfs3_commit_done,
         .file_open      = nfs_open,
         .file_release   = nfs_release,
         .lock           = nfs3_proc_lock,
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index f1ff4fa6cce5..ef4dc315ecc2 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -2388,32 +2388,23 @@ nfs4_proc_read_setup(struct nfs_read_data *data)
         rpc_call_setup(task, &msg, 0);
 }
 
-static void nfs4_write_done(struct rpc_task *task, void *calldata)
+static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data)
 {
-        struct nfs_write_data *data = calldata;
         struct inode *inode = data->inode;
         
         if (nfs4_async_handle_error(task, NFS_SERVER(inode)) == -EAGAIN) {
                 rpc_restart_call(task);
-                return;
+                return -EAGAIN;
         }
         if (task->tk_status >= 0) {
                 renew_lease(NFS_SERVER(inode), data->timestamp);
                 nfs_post_op_update_inode(inode, data->res.fattr);
         }
-        /* Call back common NFS writeback processing */
-        nfs_writeback_done(task, calldata);
+        return 0;
 }
 
-static const struct rpc_call_ops nfs4_write_ops = {
-        .rpc_call_done = nfs4_write_done,
-        .rpc_release = nfs_writedata_release,
-};
-
-static void
-nfs4_proc_write_setup(struct nfs_write_data *data, int how)
+static void nfs4_proc_write_setup(struct nfs_write_data *data, int how)
 {
-        struct rpc_task *task = &data->task;
         struct rpc_message msg = {
                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE],
                 .rpc_argp = &data->args,
@@ -2423,7 +2414,6 @@ nfs4_proc_write_setup(struct nfs_write_data *data, int how)
         struct inode *inode = data->inode;
         struct nfs_server *server = NFS_SERVER(inode);
         int stable;
-        int flags;
         
         if (how & FLUSH_STABLE) {
                 if (!NFS_I(inode)->ncommit)
@@ -2438,57 +2428,37 @@ nfs4_proc_write_setup(struct nfs_write_data *data, int how)
 
         data->timestamp   = jiffies;
 
-        /* Set the initial flags for the task.  */
-        flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
-
         /* Finalize the task. */
-        rpc_init_task(task, NFS_CLIENT(inode), flags, &nfs4_write_ops, data);
-        rpc_call_setup(task, &msg, 0);
+        rpc_call_setup(&data->task, &msg, 0);
 }
 
-static void nfs4_commit_done(struct rpc_task *task, void *calldata)
+static int nfs4_commit_done(struct rpc_task *task, struct nfs_write_data *data)
 {
-        struct nfs_write_data *data = calldata;
         struct inode *inode = data->inode;
         
         if (nfs4_async_handle_error(task, NFS_SERVER(inode)) == -EAGAIN) {
                 rpc_restart_call(task);
-                return;
+                return -EAGAIN;
         }
         if (task->tk_status >= 0)
                 nfs_post_op_update_inode(inode, data->res.fattr);
-        /* Call back common NFS writeback processing */
-        nfs_commit_done(task, calldata);
+        return 0;
 }
 
-static const struct rpc_call_ops nfs4_commit_ops = {
-        .rpc_call_done = nfs4_commit_done,
-        .rpc_release = nfs_commit_release,
-};
-
-static void
-nfs4_proc_commit_setup(struct nfs_write_data *data, int how)
+static void nfs4_proc_commit_setup(struct nfs_write_data *data, int how)
 {
-        struct rpc_task *task = &data->task;
         struct rpc_message msg = {
                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT],
                 .rpc_argp = &data->args,
                 .rpc_resp = &data->res,
                 .rpc_cred = data->cred,
         };      
-        struct inode *inode = data->inode;
-        struct nfs_server *server = NFS_SERVER(inode);
-        int flags;
+        struct nfs_server *server = NFS_SERVER(data->inode);
         
         data->args.bitmask = server->attr_bitmask;
         data->res.server = server;
 
-        /* Set the initial flags for the task.  */
-        flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
-
-        /* Finalize the task. */
-        rpc_init_task(task, NFS_CLIENT(inode), flags, &nfs4_commit_ops, data);
-        rpc_call_setup(task, &msg, 0);  
+        rpc_call_setup(&data->task, &msg, 0);
 }
 
 /*
@@ -3648,7 +3618,9 @@ struct nfs_rpc_ops	nfs_v4_clientops = {
         .decode_dirent  = nfs4_decode_dirent,
         .read_setup     = nfs4_proc_read_setup,
         .write_setup    = nfs4_proc_write_setup,
+        .write_done     = nfs4_write_done,
         .commit_setup   = nfs4_proc_commit_setup,
+        .commit_done    = nfs4_commit_done,
         .file_open      = nfs_open,
         .file_release   = nfs_release,
         .lock           = nfs4_proc_lock,
diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
index 2b051ab8bea8..608aa5932a1d 100644
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
@@ -654,26 +654,15 @@ nfs_proc_read_setup(struct nfs_read_data *data)
         rpc_call_setup(task, &msg, 0);
 }
 
-static void nfs_write_done(struct rpc_task *task, void *calldata)
+static int nfs_write_done(struct rpc_task *task, struct nfs_write_data *data)
 {
-        struct nfs_write_data *data = calldata;
-
         if (task->tk_status >= 0)
                 nfs_post_op_update_inode(data->inode, data->res.fattr);
-        nfs_writeback_done(task, calldata);
+        return 0;
 }
 
-static const struct rpc_call_ops nfs_write_ops = {
-        .rpc_call_done = nfs_write_done,
-        .rpc_release = nfs_writedata_release,
-};
-
-static void
-nfs_proc_write_setup(struct nfs_write_data *data, int how)
+static void nfs_proc_write_setup(struct nfs_write_data *data, int how)
 {
-        struct rpc_task         *task = &data->task;
-        struct inode            *inode = data->inode;
-        int                     flags;
         struct rpc_message      msg = {
                 .rpc_proc       = &nfs_procedures[NFSPROC_WRITE],
                 .rpc_argp       = &data->args,
@@ -684,12 +673,8 @@ nfs_proc_write_setup(struct nfs_write_data *data, int how)
         /* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
         data->args.stable = NFS_FILE_SYNC;
 
-        /* Set the initial flags for the task.  */
-        flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
-
         /* Finalize the task. */
-        rpc_init_task(task, NFS_CLIENT(inode), flags, &nfs_write_ops, data);
-        rpc_call_setup(task, &msg, 0);
+        rpc_call_setup(&data->task, &msg, 0);
 }
 
 static void
@@ -736,6 +721,7 @@ struct nfs_rpc_ops	nfs_v2_clientops = {
         .decode_dirent  = nfs_decode_dirent,
         .read_setup     = nfs_proc_read_setup,
         .write_setup    = nfs_proc_write_setup,
+        .write_done     = nfs_write_done,
         .commit_setup   = nfs_proc_commit_setup,
         .file_open      = nfs_open,
         .file_release   = nfs_release,
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index e7c8361cf201..5912274ff1a1 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -77,12 +77,14 @@ static struct nfs_page * nfs_update_request(struct nfs_open_context*,
                                             struct inode *,
                                             struct page *,
                                             unsigned int, unsigned int);
-static void nfs_writeback_done_partial(struct nfs_write_data *, int);
-static void nfs_writeback_done_full(struct nfs_write_data *, int);
+static int nfs_writeback_done(struct rpc_task *, struct nfs_write_data *);
 static int nfs_wait_on_write_congestion(struct address_space *, int);
 static int nfs_wait_on_requests(struct inode *, unsigned long, unsigned int);
 static int nfs_flush_inode(struct inode *inode, unsigned long idx_start,
                            unsigned int npages, int how);
+static const struct rpc_call_ops nfs_write_partial_ops;
+static const struct rpc_call_ops nfs_write_full_ops;
+static const struct rpc_call_ops nfs_commit_ops;
 
 static kmem_cache_t *nfs_wdata_cachep;
 mempool_t *nfs_wdata_mempool;
@@ -872,10 +874,12 @@ static inline int flush_task_priority(int how)
  */
 static void nfs_write_rpcsetup(struct nfs_page *req,
                 struct nfs_write_data *data,
+                const struct rpc_call_ops *call_ops,
                 unsigned int count, unsigned int offset,
                 int how)
 {
         struct inode            *inode;
+        int flags;
 
         /* Set up the RPC argument and reply structs
          * NB: take care not to mess about with data->commit et al. */
@@ -896,6 +900,9 @@ static void nfs_write_rpcsetup(struct nfs_page *req,
         data->res.verf    = &data->verf;
         nfs_fattr_init(&data->fattr);
 
+        /* Set up the initial task struct.  */
+        flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
+        rpc_init_task(&data->task, NFS_CLIENT(inode), flags, call_ops, data);
         NFS_PROTO(inode)->write_setup(data, how);
 
         data->task.tk_priority = flush_task_priority(how);
@@ -959,14 +966,15 @@ static int nfs_flush_multi(struct list_head *head, struct inode *inode, int how)
                 list_del_init(&data->pages);
 
                 data->pagevec[0] = page;
-                data->complete = nfs_writeback_done_partial;
 
                 if (nbytes > wsize) {
-                        nfs_write_rpcsetup(req, data, wsize, offset, how);
+                        nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,
+                                        wsize, offset, how);
                         offset += wsize;
                         nbytes -= wsize;
                 } else {
-                        nfs_write_rpcsetup(req, data, nbytes, offset, how);
+                        nfs_write_rpcsetup(req, data, &nfs_write_partial_ops,
+                                        nbytes, offset, how);
                         nbytes = 0;
                 }
                 nfs_execute_write(data);
@@ -1020,9 +1028,8 @@ static int nfs_flush_one(struct list_head *head, struct inode *inode, int how)
         }
         req = nfs_list_entry(data->pages.next);
 
-        data->complete = nfs_writeback_done_full;
         /* Set up the argument struct */
-        nfs_write_rpcsetup(req, data, count, 0, how);
+        nfs_write_rpcsetup(req, data, &nfs_write_full_ops, count, 0, how);
 
         nfs_execute_write(data);
         return 0;
@@ -1066,8 +1073,9 @@ nfs_flush_list(struct list_head *head, int wpages, int how)
 /*
  * Handle a write reply that flushed part of a page.
  */
-static void nfs_writeback_done_partial(struct nfs_write_data *data, int status)
+static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata)
 {
+        struct nfs_write_data   *data = calldata;
         struct nfs_page         *req = data->req;
         struct page             *page = req->wb_page;
 
@@ -1077,11 +1085,14 @@ static void nfs_writeback_done_partial(struct nfs_write_data *data, int status)
                 req->wb_bytes,
                 (long long)req_offset(req));
 
-        if (status < 0) {
+        if (nfs_writeback_done(task, data) != 0)
+                return;
+
+        if (task->tk_status < 0) {
                 ClearPageUptodate(page);
                 SetPageError(page);
-                req->wb_context->error = status;
-                dprintk(", error = %d\n", status);
+                req->wb_context->error = task->tk_status;
+                dprintk(", error = %d\n", task->tk_status);
         } else {
 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
                 if (data->verf.committed < NFS_FILE_SYNC) {
@@ -1102,6 +1113,11 @@ static void nfs_writeback_done_partial(struct nfs_write_data *data, int status)
                 nfs_writepage_release(req);
 }
 
+static const struct rpc_call_ops nfs_write_partial_ops = {
+        .rpc_call_done = nfs_writeback_done_partial,
+        .rpc_release = nfs_writedata_release,
+};
+
 /*
  * Handle a write reply that flushes a whole page.
  *
@@ -1109,11 +1125,15 @@ static void nfs_writeback_done_partial(struct nfs_write_data *data, int status)
  *        writebacks since the page->count is kept > 1 for as long
  *        as the page has a write request pending.
  */
-static void nfs_writeback_done_full(struct nfs_write_data *data, int status)
+static void nfs_writeback_done_full(struct rpc_task *task, void *calldata)
 {
+        struct nfs_write_data   *data = calldata;
         struct nfs_page         *req;
         struct page             *page;
 
+        if (nfs_writeback_done(task, data) != 0)
+                return;
+
         /* Update attributes as result of writeback. */
         while (!list_empty(&data->pages)) {
                 req = nfs_list_entry(data->pages.next);
@@ -1126,13 +1146,13 @@ static void nfs_writeback_done_full(struct nfs_write_data *data, int status)
                         req->wb_bytes,
                         (long long)req_offset(req));
 
-                if (status < 0) {
+                if (task->tk_status < 0) {
                         ClearPageUptodate(page);
                         SetPageError(page);
-                        req->wb_context->error = status;
+                        req->wb_context->error = task->tk_status;
                         end_page_writeback(page);
                         nfs_inode_remove_request(req);
-                        dprintk(", error = %d\n", status);
+                        dprintk(", error = %d\n", task->tk_status);
                         goto next;
                 }
                 end_page_writeback(page);
@@ -1154,18 +1174,28 @@ static void nfs_writeback_done_full(struct nfs_write_data *data, int status)
         }
 }
 
+static const struct rpc_call_ops nfs_write_full_ops = {
+        .rpc_call_done = nfs_writeback_done_full,
+        .rpc_release = nfs_writedata_release,
+};
+
+
 /*
  * This function is called when the WRITE call is complete.
  */
-void nfs_writeback_done(struct rpc_task *task, void *calldata)
+static int nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data)
 {
-        struct nfs_write_data   *data = calldata;
         struct nfs_writeargs    *argp = &data->args;
         struct nfs_writeres     *resp = &data->res;
+        int status;
 
         dprintk("NFS: %4d nfs_writeback_done (status %d)\n",
                 task->tk_pid, task->tk_status);
 
+        /* Call the NFS version-specific code */
+        status = NFS_PROTO(data->inode)->write_done(task, data);
+        if (status != 0)
+                return status;
         nfs_add_stats(data->inode, NFSIOS_SERVERWRITTENBYTES, resp->count);
 
 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
@@ -1210,7 +1240,7 @@ void nfs_writeback_done(struct rpc_task *task, void *calldata)
                                 argp->stable = NFS_FILE_SYNC;
                         }
                         rpc_restart_call(task);
-                        return;
+                        return -EAGAIN;
                 }
                 if (time_before(complain, jiffies)) {
                         printk(KERN_WARNING
@@ -1221,11 +1251,7 @@ void nfs_writeback_done(struct rpc_task *task, void *calldata)
                 /* Can't do anything about it except throw an error. */
                 task->tk_status = -EIO;
         }
-
-        /*
-         * Process the nfs_page list
-         */
-        data->complete(data, task->tk_status);
+        return 0;
 }
 
 
@@ -1239,10 +1265,12 @@ void nfs_commit_release(void *wdata)
  * Set up the argument/result storage required for the RPC call.
  */
 static void nfs_commit_rpcsetup(struct list_head *head,
-                struct nfs_write_data *data, int how)
+                struct nfs_write_data *data,
+                int how)
 {
         struct nfs_page         *first;
         struct inode            *inode;
+        int flags;
 
         /* Set up the RPC argument and reply structs
          * NB: take care not to mess about with data->commit et al. */
@@ -1262,7 +1290,10 @@ static void nfs_commit_rpcsetup(struct list_head *head,
         data->res.fattr   = &data->fattr;
         data->res.verf    = &data->verf;
         nfs_fattr_init(&data->fattr);
-        
+
+        /* Set up the initial task struct.  */
+        flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
+        rpc_init_task(&data->task, NFS_CLIENT(inode), flags, &nfs_commit_ops, data);
         NFS_PROTO(inode)->commit_setup(data, how);
 
         data->task.tk_priority = flush_task_priority(how);
@@ -1303,7 +1334,7 @@ nfs_commit_list(struct inode *inode, struct list_head *head, int how)
 /*
  * COMMIT call returned
  */
-void nfs_commit_done(struct rpc_task *task, void *calldata)
+static void nfs_commit_done(struct rpc_task *task, void *calldata)
 {
         struct nfs_write_data   *data = calldata;
         struct nfs_page         *req;
@@ -1312,6 +1343,10 @@ void nfs_commit_done(struct rpc_task *task, void *calldata)
         dprintk("NFS: %4d nfs_commit_done (status %d)\n",
                                 task->tk_pid, task->tk_status);
 
+        /* Call the NFS version-specific code */
+        if (NFS_PROTO(data->inode)->commit_done(task, data) != 0)
+                return;
+
         while (!list_empty(&data->pages)) {
                 req = nfs_list_entry(data->pages.next);
                 nfs_list_remove_request(req);
@@ -1345,6 +1380,11 @@ void nfs_commit_done(struct rpc_task *task, void *calldata)
         }
         sub_page_state(nr_unstable,res);
 }
+
+static const struct rpc_call_ops nfs_commit_ops = {
+        .rpc_call_done = nfs_commit_done,
+        .rpc_release = nfs_commit_release,
+};
 #endif
 
 static int nfs_flush_inode(struct inode *inode, unsigned long idx_start,