nfs41: allow async version layoutreturn

[linux-2.6-block.git] / fs / nfs / nfs4proc.c

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index e7f8d5ff2581a98269a262998beb43ccaca23e3c..2397c0f080d30d5c2b6003fb9f98370722afce0c 100644 (file)
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -495,12 +495,11 @@ static void nfs4_set_sequence_privileged(struct nfs4_sequence_args *args)
        args->sa_privileged = 1;
 }
 
-static int nfs40_setup_sequence(const struct nfs_server *server,
-                               struct nfs4_sequence_args *args,
-                               struct nfs4_sequence_res *res,
-                               struct rpc_task *task)
+int nfs40_setup_sequence(struct nfs4_slot_table *tbl,
+                        struct nfs4_sequence_args *args,
+                        struct nfs4_sequence_res *res,
+                        struct rpc_task *task)
 {
-       struct nfs4_slot_table *tbl = server->nfs_client->cl_slot_tbl;
        struct nfs4_slot *slot;
 
        /* slot already allocated? */
@@ -535,6 +534,7 @@ out_sleep:
        spin_unlock(&tbl->slot_tbl_lock);
        return -EAGAIN;
 }
+EXPORT_SYMBOL_GPL(nfs40_setup_sequence);
 
 static int nfs40_sequence_done(struct rpc_task *task,
                               struct nfs4_sequence_res *res)
@@ -694,8 +694,7 @@ out_retry:
 }
 EXPORT_SYMBOL_GPL(nfs41_sequence_done);
 
-static int nfs4_sequence_done(struct rpc_task *task,
-                              struct nfs4_sequence_res *res)
+int nfs4_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
 {
        if (res->sr_slot == NULL)
                return 1;
@@ -703,6 +702,7 @@ static int nfs4_sequence_done(struct rpc_task *task,
                return nfs40_sequence_done(task, res);
        return nfs41_sequence_done(task, res);
 }
+EXPORT_SYMBOL_GPL(nfs4_sequence_done);
 
 int nfs41_setup_sequence(struct nfs4_session *session,
                                struct nfs4_sequence_args *args,
@@ -777,7 +777,8 @@ static int nfs4_setup_sequence(const struct nfs_server *server,
        int ret = 0;
 
        if (!session)
-               return nfs40_setup_sequence(server, args, res, task);
+               return nfs40_setup_sequence(server->nfs_client->cl_slot_tbl,
+                                           args, res, task);
 
        dprintk("--> %s clp %p session %p sr_slot %u\n",
                __func__, session->clp, session, res->sr_slot ?
@@ -818,14 +819,16 @@ static int nfs4_setup_sequence(const struct nfs_server *server,
                               struct nfs4_sequence_res *res,
                               struct rpc_task *task)
 {
-       return nfs40_setup_sequence(server, args, res, task);
+       return nfs40_setup_sequence(server->nfs_client->cl_slot_tbl,
+                                   args, res, task);
 }
 
-static int nfs4_sequence_done(struct rpc_task *task,
-                              struct nfs4_sequence_res *res)
+int nfs4_sequence_done(struct rpc_task *task,
+                      struct nfs4_sequence_res *res)
 {
        return nfs40_sequence_done(task, res);
 }
+EXPORT_SYMBOL_GPL(nfs4_sequence_done);
 
 #endif /* !CONFIG_NFS_V4_1 */
 
@@ -1117,8 +1120,6 @@ static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode)
                return 0;
        if ((delegation->type & fmode) != fmode)
                return 0;
-       if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags))
-               return 0;
        if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
                return 0;
        nfs_mark_delegation_referenced(delegation);
@@ -1681,8 +1682,8 @@ static void nfs4_open_confirm_prepare(struct rpc_task *task, void *calldata)
 {
        struct nfs4_opendata *data = calldata;
 
-       nfs40_setup_sequence(data->o_arg.server, &data->c_arg.seq_args,
-                               &data->c_res.seq_res, task);
+       nfs40_setup_sequence(data->o_arg.server->nfs_client->cl_slot_tbl,
+                            &data->c_arg.seq_args, &data->c_res.seq_res, task);
 }
 
 static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
@@ -4917,11 +4918,14 @@ static void nfs4_init_boot_verifier(const struct nfs_client *clp,
 }
 
 static unsigned int
-nfs4_init_nonuniform_client_string(const struct nfs_client *clp,
+nfs4_init_nonuniform_client_string(struct nfs_client *clp,
                                   char *buf, size_t len)
 {
        unsigned int result;
 
+       if (clp->cl_owner_id != NULL)
+               return strlcpy(buf, clp->cl_owner_id, len);
+
        rcu_read_lock();
        result = scnprintf(buf, len, "Linux NFSv4.0 %s/%s %s",
                                clp->cl_ipaddr,
@@ -4930,24 +4934,32 @@ nfs4_init_nonuniform_client_string(const struct nfs_client *clp,
                                rpc_peeraddr2str(clp->cl_rpcclient,
                                                        RPC_DISPLAY_PROTO));
        rcu_read_unlock();
+       clp->cl_owner_id = kstrdup(buf, GFP_KERNEL);
        return result;
 }
 
 static unsigned int
-nfs4_init_uniform_client_string(const struct nfs_client *clp,
+nfs4_init_uniform_client_string(struct nfs_client *clp,
                                char *buf, size_t len)
 {
        const char *nodename = clp->cl_rpcclient->cl_nodename;
+       unsigned int result;
+
+       if (clp->cl_owner_id != NULL)
+               return strlcpy(buf, clp->cl_owner_id, len);
 
        if (nfs4_client_id_uniquifier[0] != '\0')
-               return scnprintf(buf, len, "Linux NFSv%u.%u %s/%s",
+               result = scnprintf(buf, len, "Linux NFSv%u.%u %s/%s",
                                clp->rpc_ops->version,
                                clp->cl_minorversion,
                                nfs4_client_id_uniquifier,
                                nodename);
-       return scnprintf(buf, len, "Linux NFSv%u.%u %s",
+       else
+               result = scnprintf(buf, len, "Linux NFSv%u.%u %s",
                                clp->rpc_ops->version, clp->cl_minorversion,
                                nodename);
+       clp->cl_owner_id = kstrdup(buf, GFP_KERNEL);
+       return result;
 }
 
 /*
@@ -5965,8 +5977,8 @@ static void nfs4_release_lockowner_prepare(struct rpc_task *task, void *calldata
 {
        struct nfs_release_lockowner_data *data = calldata;
        struct nfs_server *server = data->server;
-       nfs40_setup_sequence(server, &data->args.seq_args,
-                               &data->res.seq_res, task);
+       nfs40_setup_sequence(server->nfs_client->cl_slot_tbl,
+                            &data->args.seq_args, &data->res.seq_res, task);
        data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
        data->timestamp = jiffies;
 }
@@ -7528,6 +7540,7 @@ nfs4_layoutget_prepare(struct rpc_task *task, void *calldata)
                return;
        if (pnfs_choose_layoutget_stateid(&lgp->args.stateid,
                                          NFS_I(lgp->args.inode)->layout,
+                                         &lgp->args.range,
                                          lgp->args.ctx->state)) {
                rpc_exit(task, NFS4_OK);
        }
@@ -7783,6 +7796,7 @@ static void nfs4_layoutreturn_release(void *calldata)
        spin_lock(&lo->plh_inode->i_lock);
        if (lrp->res.lrs_present)
                pnfs_set_layout_stateid(lo, &lrp->res.stateid, true);
+       clear_bit(NFS_LAYOUT_RETURN, &lo->plh_flags);
        lo->plh_block_lgets--;
        spin_unlock(&lo->plh_inode->i_lock);
        pnfs_put_layout_hdr(lrp->args.layout);
@@ -7796,7 +7810,7 @@ static const struct rpc_call_ops nfs4_layoutreturn_call_ops = {
        .rpc_release = nfs4_layoutreturn_release,
 };
 
-int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp)
+int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, bool sync)
 {
        struct rpc_task *task;
        struct rpc_message msg = {
@@ -7810,16 +7824,23 @@ int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp)
                .rpc_message = &msg,
                .callback_ops = &nfs4_layoutreturn_call_ops,
                .callback_data = lrp,
+               .flags = RPC_TASK_ASYNC,
        };
-       int status;
+       int status = 0;
 
        dprintk("--> %s\n", __func__);
        nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1);
        task = rpc_run_task(&task_setup_data);
        if (IS_ERR(task))
                return PTR_ERR(task);
+       if (sync == false)
+               goto out;
+       status = nfs4_wait_for_completion_rpc_task(task);
+       if (status != 0)
+               goto out;
        status = task->tk_status;
        trace_nfs4_layoutreturn(lrp->args.inode, status);
+out:
        dprintk("<-- %s status=%d\n", __func__, status);
        rpc_put_task(task);
        return status;