Merge branch 'pnfs-submit' of git://git.open-osd.org/linux-open-osd

[cascardo/linux.git] / fs / nfs / nfs4proc.c

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index cf1b339..d2c4b59 100644 (file)
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -267,9 +267,11 @@ static int nfs4_handle_exception(struct nfs_server *server, int errorcode, struc
                                break;
                        nfs4_schedule_stateid_recovery(server, state);
                        goto wait_on_recovery;
+               case -NFS4ERR_EXPIRED:
+                       if (state != NULL)
+                               nfs4_schedule_stateid_recovery(server, state);
                case -NFS4ERR_STALE_STATEID:
                case -NFS4ERR_STALE_CLIENTID:
-               case -NFS4ERR_EXPIRED:
                        nfs4_schedule_lease_recovery(clp);
                        goto wait_on_recovery;
 #if defined(CONFIG_NFS_V4_1)
@@ -2361,6 +2363,9 @@ nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
        struct nfs4_state *state = NULL;
        int status;
 
+       if (pnfs_ld_layoutret_on_setattr(inode))
+               pnfs_return_layout(inode);
+
        nfs_fattr_init(fattr);
        
        /* Search for an existing open(O_WRITE) file */
@@ -3175,6 +3180,11 @@ static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
        return err;
 }
 
+void __nfs4_read_done_cb(struct nfs_read_data *data)
+{
+       nfs_invalidate_atime(data->inode);
+}
+
 static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_read_data *data)
 {
        struct nfs_server *server = NFS_SERVER(data->inode);
@@ -3184,7 +3194,7 @@ static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_read_data *data)
                return -EAGAIN;
        }
 
-       nfs_invalidate_atime(data->inode);
+       __nfs4_read_done_cb(data);
        if (task->tk_status > 0)
                renew_lease(server, data->timestamp);
        return 0;
@@ -3198,7 +3208,8 @@ static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data)
        if (!nfs4_sequence_done(task, &data->res.seq_res))
                return -EAGAIN;
 
-       return data->read_done_cb(task, data);
+       return data->read_done_cb ? data->read_done_cb(task, data) :
+                                   nfs4_read_done_cb(task, data);
 }
 
 static void nfs4_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
@@ -3243,7 +3254,8 @@ static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data)
 {
        if (!nfs4_sequence_done(task, &data->res.seq_res))
                return -EAGAIN;
-       return data->write_done_cb(task, data);
+       return data->write_done_cb ? data->write_done_cb(task, data) :
+               nfs4_write_done_cb(task, data);
 }
 
 /* Reset the the nfs_write_data to send the write to the MDS. */
@@ -3670,9 +3682,11 @@ nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server,
                                break;
                        nfs4_schedule_stateid_recovery(server, state);
                        goto wait_on_recovery;
+               case -NFS4ERR_EXPIRED:
+                       if (state != NULL)
+                               nfs4_schedule_stateid_recovery(server, state);
                case -NFS4ERR_STALE_STATEID:
                case -NFS4ERR_STALE_CLIENTID:
-               case -NFS4ERR_EXPIRED:
                        nfs4_schedule_lease_recovery(clp);
                        goto wait_on_recovery;
 #if defined(CONFIG_NFS_V4_1)
@@ -4543,6 +4557,7 @@ int nfs4_lock_delegation_recall(struct nfs4_state *state, struct file_lock *fl)
                        case -ESTALE:
                                goto out;
                        case -NFS4ERR_EXPIRED:
+                               nfs4_schedule_stateid_recovery(server, state);
                        case -NFS4ERR_STALE_CLIENTID:
                        case -NFS4ERR_STALE_STATEID:
                                nfs4_schedule_lease_recovery(server->nfs_client);
@@ -5666,6 +5681,88 @@ int nfs4_proc_layoutget(struct nfs4_layoutget *lgp)
        return status;
 }
 
+static void
+nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata)
+{
+       struct nfs4_layoutreturn *lrp = calldata;
+
+       dprintk("--> %s\n", __func__);
+       if (nfs41_setup_sequence(lrp->clp->cl_session, &lrp->args.seq_args,
+                               &lrp->res.seq_res, 0, task))
+               return;
+       rpc_call_start(task);
+}
+
+static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata)
+{
+       struct nfs4_layoutreturn *lrp = calldata;
+       struct nfs_server *server;
+
+       dprintk("--> %s\n", __func__);
+
+       if (!nfs4_sequence_done(task, &lrp->res.seq_res))
+               return;
+
+       server = NFS_SERVER(lrp->args.inode);
+       if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {
+               nfs_restart_rpc(task, lrp->clp);
+               return;
+       }
+       if (task->tk_status == 0) {
+               struct pnfs_layout_hdr *lo = NFS_I(lrp->args.inode)->layout;
+
+               if (lrp->res.lrs_present) {
+                       spin_lock(&lo->plh_inode->i_lock);
+                       pnfs_set_layout_stateid(lo, &lrp->res.stateid, true);
+                       spin_unlock(&lo->plh_inode->i_lock);
+               } else
+                       BUG_ON(!list_empty(&lo->plh_segs));
+       }
+       dprintk("<-- %s\n", __func__);
+}
+
+static void nfs4_layoutreturn_release(void *calldata)
+{
+       struct nfs4_layoutreturn *lrp = calldata;
+
+       dprintk("--> %s\n", __func__);
+       put_layout_hdr(NFS_I(lrp->args.inode)->layout);
+       kfree(calldata);
+       dprintk("<-- %s\n", __func__);
+}
+
+static const struct rpc_call_ops nfs4_layoutreturn_call_ops = {
+       .rpc_call_prepare = nfs4_layoutreturn_prepare,
+       .rpc_call_done = nfs4_layoutreturn_done,
+       .rpc_release = nfs4_layoutreturn_release,
+};
+
+int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp)
+{
+       struct rpc_task *task;
+       struct rpc_message msg = {
+               .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN],
+               .rpc_argp = &lrp->args,
+               .rpc_resp = &lrp->res,
+       };
+       struct rpc_task_setup task_setup_data = {
+               .rpc_client = lrp->clp->cl_rpcclient,
+               .rpc_message = &msg,
+               .callback_ops = &nfs4_layoutreturn_call_ops,
+               .callback_data = lrp,
+       };
+       int status;
+
+       dprintk("--> %s\n", __func__);
+       task = rpc_run_task(&task_setup_data);
+       if (IS_ERR(task))
+               return PTR_ERR(task);
+       status = task->tk_status;
+       dprintk("<-- %s status=%d\n", __func__, status);
+       rpc_put_task(task);
+       return status;
+}
+
 static int
 _nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
 {