6 files changed, 103 insertions, 143 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,
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index b71da4d4b137..782e59765696 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -407,13 +407,6 @@ extern int  nfs_writepage(struct page *page, struct writeback_control *wbc);
 extern int  nfs_writepages(struct address_space *, struct writeback_control *);
 extern int  nfs_flush_incompatible(struct file *file, struct page *page);
 extern int  nfs_updatepage(struct file *, struct page *, unsigned int, unsigned int);
-extern void nfs_writeback_done(struct rpc_task *task, void *data);
-extern void nfs_writedata_release(void *data);
-
-#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
-extern void nfs_commit_done(struct rpc_task *, void *data);
-extern void nfs_commit_release(void *data);
-#endif
 
 /*
  * Try to write back everything synchronously (but check the
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 6d6f69ec5675..277750cc70c0 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -714,7 +714,6 @@ struct nfs_write_data {
 #ifdef CONFIG_NFS_V4
         unsigned long           timestamp;      /* For lease renewal */
 #endif
-        void (*complete) (struct nfs_write_data *, int);
         struct page             *page_array[NFS_PAGEVEC_SIZE + 1];
 };
 
@@ -770,7 +769,9 @@ struct nfs_rpc_ops {
         u32 *   (*decode_dirent)(u32 *, struct nfs_entry *, int plus);
         void    (*read_setup)   (struct nfs_read_data *);
         void    (*write_setup)  (struct nfs_write_data *, int how);
+        int     (*write_done)  (struct rpc_task *, struct nfs_write_data *);
         void    (*commit_setup) (struct nfs_write_data *, int how);
+        int     (*commit_done) (struct rpc_task *, struct nfs_write_data *);
         int     (*file_open)   (struct inode *, struct file *);
         int     (*file_release) (struct inode *, struct file *);
         int     (*lock)(struct file *, int, struct file_lock *);