nfsd4: fix minor memory leak

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

diff --git a/fs/nfsd/nfs4callback.c b/fs/nfsd/nfs4callback.c
index d37707d..4bc22c7 100644 (file)
--- a/fs/nfsd/nfs4callback.c
+++ b/fs/nfsd/nfs4callback.c
@@ -1,6 +1,4 @@
 /*
- *  linux/fs/nfsd/nfs4callback.c
- *
  *  Copyright (c) 2001 The Regents of the University of Michigan.
  *  All rights reserved.
  *
@@ -33,21 +31,9 @@
  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <linux/module.h>
-#include <linux/list.h>
-#include <linux/inet.h>
-#include <linux/errno.h>
-#include <linux/delay.h>
-#include <linux/sched.h>
-#include <linux/kthread.h>
-#include <linux/sunrpc/xdr.h>
-#include <linux/sunrpc/svc.h>
 #include <linux/sunrpc/clnt.h>
-#include <linux/sunrpc/svcsock.h>
-#include <linux/nfsd/nfsd.h>
-#include <linux/nfsd/state.h>
-#include <linux/sunrpc/sched.h>
-#include <linux/nfs4.h>
+#include "nfsd.h"
+#include "state.h"
 
 #define NFSDDBG_FACILITY                NFSDDBG_PROC
 
@@ -288,15 +274,19 @@ 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_delegation *args)
+nfs4_xdr_enc_cb_recall(struct rpc_rqst *req, __be32 *p,
+               struct nfs4_rpc_args *rpc_args)
 {
        struct xdr_stream xdr;
+       struct nfs4_delegation *args = rpc_args->args_op;
        struct nfs4_cb_compound_hdr hdr = {
                .ident = args->dl_ident,
+               .minorversion = rpc_args->args_seq.cbs_minorversion,
        };
 
        xdr_init_encode(&xdr, &req->rq_snd_buf, p);
        encode_cb_compound_hdr(&xdr, &hdr);
+       encode_cb_sequence(&xdr, &rpc_args->args_seq, &hdr);
        encode_cb_recall(&xdr, args, &hdr);
        encode_cb_nops(&hdr);
        return 0;
@@ -396,7 +386,8 @@ nfs4_xdr_dec_cb_null(struct rpc_rqst *req, __be32 *p)
 }
 
 static int
-nfs4_xdr_dec_cb_recall(struct rpc_rqst *rqstp, __be32 *p)
+nfs4_xdr_dec_cb_recall(struct rpc_rqst *rqstp, __be32 *p,
+               struct nfsd4_cb_sequence *seq)
 {
        struct xdr_stream xdr;
        struct nfs4_cb_compound_hdr hdr;
@@ -406,6 +397,11 @@ nfs4_xdr_dec_cb_recall(struct rpc_rqst *rqstp, __be32 *p)
        status = decode_cb_compound_hdr(&xdr, &hdr);
        if (status)
                goto out;
+       if (seq) {
+               status = decode_cb_sequence(&xdr, seq, rqstp);
+               if (status)
+                       goto out;
+       }
        status = decode_cb_op_hdr(&xdr, OP_CB_RECALL);
 out:
        return status;
@@ -473,7 +469,7 @@ int setup_callback_client(struct nfs4_client *clp)
                .to_retries     = 0,
        };
        struct rpc_create_args args = {
-               .protocol       = IPPROTO_TCP,
+               .protocol       = XPRT_TRANSPORT_TCP,
                .address        = (struct sockaddr *) &cb->cb_addr,
                .addrsize       = cb->cb_addrlen,
                .timeout        = &timeparms,
@@ -488,7 +484,10 @@ int setup_callback_client(struct nfs4_client *clp)
 
        if (!clp->cl_principal && (clp->cl_flavor >= RPC_AUTH_GSS_KRB5))
                return -EINVAL;
-
+       if (cb->cb_minorversion) {
+               args.bc_xprt = clp->cl_cb_xprt;
+               args.protocol = XPRT_TRANSPORT_BC_TCP;
+       }
        /* Create RPC client */
        client = rpc_create(&args);
        if (IS_ERR(client)) {
@@ -526,6 +525,8 @@ static struct rpc_cred *callback_cred;
 
 int set_callback_cred(void)
 {
+       if (callback_cred)
+               return 0;
        callback_cred = rpc_lookup_machine_cred();
        if (!callback_cred)
                return -ENOMEM;
@@ -543,7 +544,8 @@ void do_probe_callback(struct nfs4_client *clp)
        };
        int status;
 
-       status = rpc_call_async(cb->cb_client, &msg, RPC_TASK_SOFT,
+       status = rpc_call_async(cb->cb_client, &msg,
+                               RPC_TASK_SOFT | RPC_TASK_SOFTCONN,
                                &nfsd4_cb_probe_ops, (void *)clp);
        if (status) {
                warn_no_callback_path(clp, status);
@@ -634,11 +636,34 @@ static void nfsd4_cb_prepare(struct rpc_task *task, void *calldata)
        rpc_call_start(task);
 }
 
+static void nfsd4_cb_done(struct rpc_task *task, void *calldata)
+{
+       struct nfs4_delegation *dp = calldata;
+       struct nfs4_client *clp = dp->dl_client;
+
+       dprintk("%s: minorversion=%d\n", __func__,
+               clp->cl_cb_conn.cb_minorversion);
+
+       if (clp->cl_cb_conn.cb_minorversion) {
+               /* No need for lock, access serialized in nfsd4_cb_prepare */
+               ++clp->cl_cb_seq_nr;
+               clear_bit(0, &clp->cl_cb_slot_busy);
+               rpc_wake_up_next(&clp->cl_cb_waitq);
+               dprintk("%s: freed slot, new seqid=%d\n", __func__,
+                       clp->cl_cb_seq_nr);
+
+               /* We're done looking into the sequence information */
+               task->tk_msg.rpc_resp = NULL;
+       }
+}
+
 static void nfsd4_cb_recall_done(struct rpc_task *task, void *calldata)
 {
        struct nfs4_delegation *dp = calldata;
        struct nfs4_client *clp = dp->dl_client;
 
+       nfsd4_cb_done(task, calldata);
+
        switch (task->tk_status) {
        case -EIO:
                /* Network partition? */
@@ -651,16 +676,19 @@ static void nfsd4_cb_recall_done(struct rpc_task *task, void *calldata)
                break;
        default:
                /* success, or error we can't handle */
-               return;
+               goto done;
        }
        if (dp->dl_retries--) {
                rpc_delay(task, 2*HZ);
                task->tk_status = 0;
                rpc_restart_call(task);
+               return;
        } else {
                atomic_set(&clp->cl_cb_conn.cb_set, 0);
                warn_no_callback_path(clp, task->tk_status);
        }
+done:
+       kfree(task->tk_msg.rpc_argp);
 }
 
 static void nfsd4_cb_recall_release(void *calldata)
@@ -686,17 +714,24 @@ nfsd4_cb_recall(struct nfs4_delegation *dp)
 {
        struct nfs4_client *clp = dp->dl_client;
        struct rpc_clnt *clnt = clp->cl_cb_conn.cb_client;
+       struct nfs4_rpc_args *args;
        struct rpc_message msg = {
                .rpc_proc = &nfs4_cb_procedures[NFSPROC4_CLNT_CB_RECALL],
-               .rpc_argp = dp,
                .rpc_cred = callback_cred
        };
-       int status;
+       int status = -ENOMEM;
 
+       args = kzalloc(sizeof(*args), GFP_KERNEL);
+       if (!args)
+               goto out;
+       args->args_op = dp;
+       msg.rpc_argp = args;
        dp->dl_retries = 1;
        status = rpc_call_async(clnt, &msg, RPC_TASK_SOFT,
                                &nfsd4_cb_recall_ops, dp);
+out:
        if (status) {
+               kfree(args);
                put_nfs4_client(clp);
                nfs4_put_delegation(dp);
        }