nfsd4: remove unused dl_trunc

[safe/jmp/linux-2.6] / fs / nfsd / nfs4callback.c

diff --git a/fs/nfsd/nfs4callback.c b/fs/nfsd/nfs4callback.c
index cc10ed3..0420b5e 100644 (file)
--- a/fs/nfsd/nfs4callback.c
+++ b/fs/nfsd/nfs4callback.c
@@ -215,18 +215,18 @@ encode_cb_compound_hdr(struct xdr_stream *xdr, struct nfs4_cb_compound_hdr *hdr)
 }
 
 static int
-encode_cb_recall(struct xdr_stream *xdr, struct nfs4_cb_recall *cb_rec)
+encode_cb_recall(struct xdr_stream *xdr, struct nfs4_delegation *dp)
 {
        __be32 *p;
-       int len = cb_rec->cbr_fh.fh_size;
+       int len = dp->dl_fh.fh_size;
 
-       RESERVE_SPACE(12+sizeof(cb_rec->cbr_stateid) + len);
+       RESERVE_SPACE(12+sizeof(dp->dl_stateid) + len);
        WRITE32(OP_CB_RECALL);
-       WRITE32(cb_rec->cbr_stateid.si_generation);
-       WRITEMEM(&cb_rec->cbr_stateid.si_opaque, sizeof(stateid_opaque_t));
-       WRITE32(cb_rec->cbr_trunc);
+       WRITE32(dp->dl_stateid.si_generation);
+       WRITEMEM(&dp->dl_stateid.si_opaque, sizeof(stateid_opaque_t));
+       WRITE32(0); /* truncate optimization not implemented */
        WRITE32(len);
-       WRITEMEM(&cb_rec->cbr_fh.fh_base, len);
+       WRITEMEM(&dp->dl_fh.fh_base, len);
        return 0;
 }
 
@@ -241,11 +241,11 @@ nfs4_xdr_enc_cb_null(struct rpc_rqst *req, __be32 *p)
 }
 
 static int
-nfs4_xdr_enc_cb_recall(struct rpc_rqst *req, __be32 *p, struct nfs4_cb_recall *args)
+nfs4_xdr_enc_cb_recall(struct rpc_rqst *req, __be32 *p, struct nfs4_delegation *args)
 {
        struct xdr_stream xdr;
        struct nfs4_cb_compound_hdr hdr = {
-               .ident = args->cbr_ident,
+               .ident = args->dl_ident,
                .nops   = 1,
        };
 
@@ -369,7 +369,7 @@ static int max_cb_time(void)
 int setup_callback_client(struct nfs4_client *clp)
 {
        struct sockaddr_in      addr;
-       struct nfs4_callback    *cb = &clp->cl_callback;
+       struct nfs4_cb_conn *cb = &clp->cl_cb_conn;
        struct rpc_timeout      timeparms = {
                .to_initval     = max_cb_time(),
                .to_retries     = 0,
@@ -415,7 +415,22 @@ static void warn_no_callback_path(struct nfs4_client *clp, int reason)
                (int)clp->cl_name.len, clp->cl_name.data, reason);
 }
 
-static struct rpc_cred *lookup_cb_cred(struct nfs4_callback *cb)
+static void nfsd4_cb_probe_done(struct rpc_task *task, void *calldata)
+{
+       struct nfs4_client *clp = calldata;
+
+       if (task->tk_status)
+               warn_no_callback_path(clp, task->tk_status);
+       else
+               atomic_set(&clp->cl_cb_conn.cb_set, 1);
+       put_nfs4_client(clp);
+}
+
+static const struct rpc_call_ops nfsd4_cb_probe_ops = {
+       .rpc_call_done = nfsd4_cb_probe_done,
+};
+
+static struct rpc_cred *lookup_cb_cred(struct nfs4_cb_conn *cb)
 {
        struct auth_cred acred = {
                .machine_cred = 1
@@ -431,10 +446,9 @@ static struct rpc_cred *lookup_cb_cred(struct nfs4_callback *cb)
                                                        RPCAUTH_LOOKUP_NEW);
 }
 
-static int do_probe_callback(void *data)
+void do_probe_callback(struct nfs4_client *clp)
 {
-       struct nfs4_client *clp = data;
-       struct nfs4_callback    *cb = &clp->cl_callback;
+       struct nfs4_cb_conn *cb = &clp->cl_cb_conn;
        struct rpc_message msg = {
                .rpc_proc       = &nfs4_cb_procedures[NFSPROC4_CLNT_CB_NULL],
                .rpc_argp       = clp,
@@ -449,15 +463,13 @@ static int do_probe_callback(void *data)
        }
        cb->cb_cred = cred;
        msg.rpc_cred = cb->cb_cred;
-       status = rpc_call_sync(cb->cb_client, &msg, RPC_TASK_SOFT);
+       status = rpc_call_async(cb->cb_client, &msg, RPC_TASK_SOFT,
+                               &nfsd4_cb_probe_ops, (void *)clp);
 out:
-       if (status)
+       if (status) {
                warn_no_callback_path(clp, status);
-       else
-               atomic_set(&cb->cb_set, 1);
-
-       put_nfs4_client(clp);
-       return 0;
+               put_nfs4_client(clp);
+       }
 }
 
 /*
@@ -466,10 +478,9 @@ out:
 void
 nfsd4_probe_callback(struct nfs4_client *clp)
 {
-       struct task_struct *t;
        int status;
 
-       BUG_ON(atomic_read(&clp->cl_callback.cb_set));
+       BUG_ON(atomic_read(&clp->cl_cb_conn.cb_set));
 
        status = setup_callback_client(clp);
        if (status) {
@@ -480,12 +491,7 @@ nfsd4_probe_callback(struct nfs4_client *clp)
        /* the task holds a reference to the nfs4_client struct */
        atomic_inc(&clp->cl_count);
 
-       t = kthread_run(do_probe_callback, clp, "nfs4_cb_probe");
-
-       if (IS_ERR(t))
-               atomic_dec(&clp->cl_count);
-
-       return;
+       do_probe_callback(clp);
 }
 
 /*
@@ -495,25 +501,21 @@ void
 nfsd4_cb_recall(struct nfs4_delegation *dp)
 {
        struct nfs4_client *clp = dp->dl_client;
-       struct rpc_clnt *clnt = clp->cl_callback.cb_client;
-       struct nfs4_cb_recall *cbr = &dp->dl_recall;
+       struct rpc_clnt *clnt = clp->cl_cb_conn.cb_client;
        struct rpc_message msg = {
                .rpc_proc = &nfs4_cb_procedures[NFSPROC4_CLNT_CB_RECALL],
-               .rpc_argp = cbr,
-               .rpc_cred = clp->cl_callback.cb_cred
+               .rpc_argp = dp,
+               .rpc_cred = clp->cl_cb_conn.cb_cred
        };
        int retries = 1;
        int status = 0;
 
-       cbr->cbr_trunc = 0; /* XXX need to implement truncate optimization */
-       cbr->cbr_dp = dp;
-
        status = rpc_call_sync(clnt, &msg, RPC_TASK_SOFT);
        while (retries--) {
                switch (status) {
                        case -EIO:
                                /* Network partition? */
-                               atomic_set(&clp->cl_callback.cb_set, 0);
+                               atomic_set(&clp->cl_cb_conn.cb_set, 0);
                        case -EBADHANDLE:
                        case -NFS4ERR_BAD_STATEID:
                                /* Race: client probably got cb_recall