NFS refactor nfs_find_client and reference client across callback processing (c36fca52) · Commits · 戴 / test

fs/nfs/callback.c

+18 −3

Original line number	Diff line number	Diff line
		@@ -16,9 +16,7 @@
		#include <linux/freezer.h>
		#include <linux/kthread.h>
		#include <linux/sunrpc/svcauth_gss.h>
		#if defined(CONFIG_NFS_V4_1)
		#include <linux/sunrpc/bc_xprt.h>
		#endif

		#include <net/inet_sock.h>

		@@ -384,6 +382,23 @@ static int check_gss_callback_principal(struct nfs_client *clp,
		return SVC_OK;
		}

		/* pg_authenticate method helper */
		static struct nfs_client nfs_cb_find_client(struct svc_rqst rqstp)
		{
		struct nfs4_sessionid *sessionid = bc_xprt_sid(rqstp);
		int is_cb_compound = rqstp->rq_proc == CB_COMPOUND ? 1 : 0;

		dprintk("--> %s rq_proc %d\n", __func__, rqstp->rq_proc);
		if (svc_is_backchannel(rqstp))
		/* Sessionid (usually) set after CB_NULL ping */
		return nfs4_find_client_sessionid(svc_addr(rqstp), sessionid,
		is_cb_compound);
		else
		/* No callback identifier in pg_authenticate */
		return nfs4_find_client_no_ident(svc_addr(rqstp));
		}

		/* pg_authenticate method for nfsv4 callback threads. */
		static int nfs_callback_authenticate(struct svc_rqst *rqstp)
		{
		struct nfs_client *clp;
		@@ -391,7 +406,7 @@ static int nfs_callback_authenticate(struct svc_rqst *rqstp)
		int ret = SVC_OK;

		/* Don't talk to strangers */
		clp = nfs_find_client(svc_addr(rqstp), 4);
		clp = nfs_cb_find_client(rqstp);
		if (clp == NULL)
		return SVC_DROP;

fs/nfs/callback.h

+21 −7

Original line number	Diff line number	Diff line
		@@ -34,10 +34,17 @@ enum nfs4_callback_opnum {
		OP_CB_ILLEGAL = 10044,
		};

		struct cb_process_state {
		__be32 drc_status;
		struct nfs_client *clp;
		struct nfs4_sessionid svc_sid; / v4.1 callback service sessionid */
		};

		struct cb_compound_hdr_arg {
		unsigned int taglen;
		const char *tag;
		unsigned int minorversion;
		unsigned int cb_ident; /* v4.0 callback identifier */
		unsigned nops;
		};

		@@ -103,8 +110,9 @@ struct cb_sequenceres {
		uint32_t csr_target_highestslotid;
		};

		extern unsigned nfs4_callback_sequence(struct cb_sequenceargs *args,
		struct cb_sequenceres *res);
		extern __be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
		struct cb_sequenceres *res,
		struct cb_process_state *cps);

		extern int nfs41_validate_delegation_stateid(struct nfs_delegation *delegation,
		const nfs4_stateid *stateid);
		@@ -118,19 +126,25 @@ struct cb_recallanyargs {
		uint32_t craa_type_mask;
		};

		extern unsigned nfs4_callback_recallany(struct cb_recallanyargs args, void dummy);
		extern __be32 nfs4_callback_recallany(struct cb_recallanyargs *args,
		void *dummy,
		struct cb_process_state *cps);

		struct cb_recallslotargs {
		struct sockaddr *crsa_addr;
		uint32_t crsa_target_max_slots;
		};
		extern unsigned nfs4_callback_recallslot(struct cb_recallslotargs *args,
		void *dummy);
		extern __be32 nfs4_callback_recallslot(struct cb_recallslotargs *args,
		void *dummy,
		struct cb_process_state *cps);

		#endif /* CONFIG_NFS_V4_1 */

		extern __be32 nfs4_callback_getattr(struct cb_getattrargs args, struct cb_getattrres res);
		extern __be32 nfs4_callback_recall(struct cb_recallargs args, void dummy);
		extern __be32 nfs4_callback_getattr(struct cb_getattrargs *args,
		struct cb_getattrres *res,
		struct cb_process_state *cps);
		extern __be32 nfs4_callback_recall(struct cb_recallargs args, void dummy,
		struct cb_process_state *cps);

		#ifdef CONFIG_NFS_V4
		extern int nfs_callback_up(u32 minorversion, struct rpc_xprt *xprt);

fs/nfs/callback_proc.c

+65 −102

Original line number	Diff line number	Diff line
		@@ -17,25 +17,27 @@
		#define NFSDBG_FACILITY NFSDBG_CALLBACK
		#endif

		__be32 nfs4_callback_getattr(struct cb_getattrargs args, struct cb_getattrres res)
		__be32 nfs4_callback_getattr(struct cb_getattrargs *args,
		struct cb_getattrres *res,
		struct cb_process_state *cps)
		{
		struct nfs_client *clp;
		struct nfs_delegation *delegation;
		struct nfs_inode *nfsi;
		struct inode *inode;

		res->status = htonl(NFS4ERR_OP_NOT_IN_SESSION);
		if (!cps->clp) /* Always set for v4.0. Set in cb_sequence for v4.1 */
		goto out;

		res->bitmap[0] = res->bitmap[1] = 0;
		res->status = htonl(NFS4ERR_BADHANDLE);
		clp = nfs_find_client(args->addr, 4);
		if (clp == NULL)
		goto out;

		dprintk("NFS: GETATTR callback request from %s\n",
		rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));
		rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR));

		inode = nfs_delegation_find_inode(clp, &args->fh);
		inode = nfs_delegation_find_inode(cps->clp, &args->fh);
		if (inode == NULL)
		goto out_putclient;
		goto out;
		nfsi = NFS_I(inode);
		rcu_read_lock();
		delegation = rcu_dereference(nfsi->delegation);
		@@ -55,32 +57,28 @@ __be32 nfs4_callback_getattr(struct cb_getattrargs args, struct cb_getattrres
		out_iput:
		rcu_read_unlock();
		iput(inode);
		out_putclient:
		nfs_put_client(clp);
		out:
		dprintk("%s: exit with status = %d\n", __func__, ntohl(res->status));
		return res->status;
		}

		__be32 nfs4_callback_recall(struct cb_recallargs args, void dummy)
		__be32 nfs4_callback_recall(struct cb_recallargs args, void dummy,
		struct cb_process_state *cps)
		{
		struct nfs_client *clp;
		struct inode *inode;
		__be32 res;

		res = htonl(NFS4ERR_BADHANDLE);
		clp = nfs_find_client(args->addr, 4);
		if (clp == NULL)
		res = htonl(NFS4ERR_OP_NOT_IN_SESSION);
		if (!cps->clp) /* Always set for v4.0. Set in cb_sequence for v4.1 */
		goto out;

		dprintk("NFS: RECALL callback request from %s\n",
		rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));

		do {
		struct nfs_client *prev = clp;
		rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR));

		inode = nfs_delegation_find_inode(clp, &args->fh);
		if (inode != NULL) {
		res = htonl(NFS4ERR_BADHANDLE);
		inode = nfs_delegation_find_inode(cps->clp, &args->fh);
		if (inode == NULL)
		goto out;
		/* Set up a helper thread to actually return the delegation */
		switch (nfs_async_inode_return_delegation(inode, &args->stateid)) {
		case 0:
		@@ -94,10 +92,6 @@ __be32 nfs4_callback_recall(struct cb_recallargs args, void dummy)
		res = htonl(NFS4ERR_RESOURCE);
		}
		iput(inode);
		}
		clp = nfs_find_client_next(prev);
		nfs_put_client(prev);
		} while (clp != NULL);
		out:
		dprintk("%s: exit with status = %d\n", __func__, ntohl(res));
		return res;
		@@ -184,42 +178,6 @@ validate_seqid(struct nfs4_slot_table tbl, struct cb_sequenceargs args)
		return htonl(NFS4ERR_SEQ_MISORDERED);
		}

		/*
		* Returns a pointer to a held 'struct nfs_client' that matches the server's
		* address, major version number, and session ID. It is the caller's
		* responsibility to release the returned reference.
		*
		* Returns NULL if there are no connections with sessions, or if no session
		* matches the one of interest.
		*/
		static struct nfs_client *find_client_with_session(
		const struct sockaddr *addr, u32 nfsversion,
		struct nfs4_sessionid *sessionid)
		{
		struct nfs_client *clp;

		clp = nfs_find_client(addr, 4);
		if (clp == NULL)
		return NULL;

		do {
		struct nfs_client *prev = clp;

		if (clp->cl_session != NULL) {
		if (memcmp(clp->cl_session->sess_id.data,
		sessionid->data,
		NFS4_MAX_SESSIONID_LEN) == 0) {
		/* Returns a held reference to clp */
		return clp;
		}
		}
		clp = nfs_find_client_next(prev);
		nfs_put_client(prev);
		} while (clp != NULL);

		return NULL;
		}

		/*
		* For each referring call triple, check the session's slot table for
		* a match. If the slot is in use and the sequence numbers match, the
		@@ -276,20 +234,28 @@ out:
		}

		__be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
		struct cb_sequenceres *res)
		struct cb_sequenceres *res,
		struct cb_process_state *cps)
		{
		struct nfs_client *clp;
		int i;
		__be32 status;

		cps->clp = NULL;

		status = htonl(NFS4ERR_BADSESSION);
		clp = find_client_with_session(args->csa_addr, 4, &args->csa_sessionid);
		/* Incoming session must match the callback session */
		if (memcmp(&args->csa_sessionid, cps->svc_sid, NFS4_MAX_SESSIONID_LEN))
		goto out;

		clp = nfs4_find_client_sessionid(args->csa_addr,
		&args->csa_sessionid, 1);
		if (clp == NULL)
		goto out;

		status = validate_seqid(&clp->cl_session->bc_slot_table, args);
		if (status)
		goto out_putclient;
		goto out;

		/*
		* Check for pending referring calls. If a match is found, a
		@@ -298,7 +264,7 @@ __be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
		*/
		if (referring_call_exists(clp, args->csa_nrclists, args->csa_rclists)) {
		status = htonl(NFS4ERR_DELAY);
		goto out_putclient;
		goto out;
		}

		memcpy(&res->csr_sessionid, &args->csa_sessionid,
		@@ -307,36 +273,36 @@ __be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
		res->csr_slotid = args->csa_slotid;
		res->csr_highestslotid = NFS41_BC_MAX_CALLBACKS - 1;
		res->csr_target_highestslotid = NFS41_BC_MAX_CALLBACKS - 1;
		cps->clp = clp; /* put in nfs4_callback_compound */

		out_putclient:
		nfs_put_client(clp);
		out:
		for (i = 0; i < args->csa_nrclists; i++)
		kfree(args->csa_rclists[i].rcl_refcalls);
		kfree(args->csa_rclists);

		if (status == htonl(NFS4ERR_RETRY_UNCACHED_REP))
		res->csr_status = 0;
		else
		if (status == htonl(NFS4ERR_RETRY_UNCACHED_REP)) {
		cps->drc_status = status;
		status = 0;
		} else
		res->csr_status = status;

		dprintk("%s: exit with status = %d res->csr_status %d\n", __func__,
		ntohl(status), ntohl(res->csr_status));
		return status;
		}

		__be32 nfs4_callback_recallany(struct cb_recallanyargs args, void dummy)
		__be32 nfs4_callback_recallany(struct cb_recallanyargs args, void dummy,
		struct cb_process_state *cps)
		{
		struct nfs_client *clp;
		__be32 status;
		fmode_t flags = 0;

		status = htonl(NFS4ERR_OP_NOT_IN_SESSION);
		clp = nfs_find_client(args->craa_addr, 4);
		if (clp == NULL)
		if (!cps->clp) /* set in cb_sequence */
		goto out;

		dprintk("NFS: RECALL_ANY callback request from %s\n",
		rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));
		rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR));

		if (test_bit(RCA4_TYPE_MASK_RDATA_DLG, (const unsigned long *)
		&args->craa_type_mask))
		@@ -346,7 +312,7 @@ __be32 nfs4_callback_recallany(struct cb_recallanyargs args, void dummy)
		flags \|= FMODE_WRITE;

		if (flags)
		nfs_expire_all_delegation_types(clp, flags);
		nfs_expire_all_delegation_types(cps->clp, flags);
		status = htonl(NFS4_OK);
		out:
		dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
		@@ -354,36 +320,33 @@ out:
		}

		/* Reduce the fore channel's max_slots to the target value */
		__be32 nfs4_callback_recallslot(struct cb_recallslotargs args, void dummy)
		__be32 nfs4_callback_recallslot(struct cb_recallslotargs args, void dummy,
		struct cb_process_state *cps)
		{
		struct nfs_client *clp;
		struct nfs4_slot_table *fc_tbl;
		__be32 status;

		status = htonl(NFS4ERR_OP_NOT_IN_SESSION);
		clp = nfs_find_client(args->crsa_addr, 4);
		if (clp == NULL)
		if (!cps->clp) /* set in cb_sequence */
		goto out;

		dprintk("NFS: CB_RECALL_SLOT request from %s target max slots %d\n",
		rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR),
		rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR),
		args->crsa_target_max_slots);

		fc_tbl = &clp->cl_session->fc_slot_table;
		fc_tbl = &cps->clp->cl_session->fc_slot_table;

		status = htonl(NFS4ERR_BAD_HIGH_SLOT);
		if (args->crsa_target_max_slots > fc_tbl->max_slots \|\|
		args->crsa_target_max_slots < 1)
		goto out_putclient;
		goto out;

		status = htonl(NFS4_OK);
		if (args->crsa_target_max_slots == fc_tbl->max_slots)
		goto out_putclient;
		goto out;

		fc_tbl->target_max_slots = args->crsa_target_max_slots;
		nfs41_handle_recall_slot(clp);
		out_putclient:
		nfs_put_client(clp); /* balance nfs_find_client */
		nfs41_handle_recall_slot(cps->clp);
		out:
		dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
		return status;

fs/nfs/callback_xdr.c

+24 −15

Original line number	Diff line number	Diff line
		@@ -10,8 +10,10 @@
		#include <linux/nfs4.h>
		#include <linux/nfs_fs.h>
		#include <linux/slab.h>
		#include <linux/sunrpc/bc_xprt.h>
		#include "nfs4_fs.h"
		#include "callback.h"
		#include "internal.h"

		#define CB_OP_TAGLEN_MAXSZ (512)
		#define CB_OP_HDR_RES_MAXSZ (2 + CB_OP_TAGLEN_MAXSZ)
		@@ -33,7 +35,8 @@
		/* Internal error code */
		#define NFS4ERR_RESOURCE_HDR 11050

		typedef __be32 (callback_process_op_t)(void , void *);
		typedef __be32 (callback_process_op_t)(void , void *,
		struct cb_process_state *);
		typedef __be32 (callback_decode_arg_t)(struct svc_rqst , struct xdr_stream , void );
		typedef __be32 (callback_encode_res_t)(struct svc_rqst , struct xdr_stream , void );

		@@ -160,7 +163,7 @@ static __be32 decode_compound_hdr_arg(struct xdr_stream *xdr, struct cb_compound
		hdr->minorversion = ntohl(*p++);
		/* Check minor version is zero or one. */
		if (hdr->minorversion <= 1) {
		p++; /* skip callback_ident */
		hdr->cb_ident = ntohl(p++); / ignored by v4.1 */
		} else {
		printk(KERN_WARNING "%s: NFSv4 server callback with "
		"illegal minor version %u!\n",
		@@ -621,7 +624,8 @@ preprocess_nfs4_op(unsigned int op_nr, struct callback_op **op)
		static __be32 process_op(uint32_t minorversion, int nop,
		struct svc_rqst *rqstp,
		struct xdr_stream xdr_in, void argp,
		struct xdr_stream xdr_out, void resp, int* drc_status)
		struct xdr_stream xdr_out, void resp,
		struct cb_process_state *cps)
		{
		struct callback_op *op = &callback_ops[0];
		unsigned int op_nr;
		@@ -644,8 +648,8 @@ static __be32 process_op(uint32_t minorversion, int nop,
		if (status)
		goto encode_hdr;

		if (*drc_status) {
		status = *drc_status;
		if (cps->drc_status) {
		status = cps->drc_status;
		goto encode_hdr;
		}

		@@ -653,16 +657,10 @@ static __be32 process_op(uint32_t minorversion, int nop,
		if (maxlen > 0 && maxlen < PAGE_SIZE) {
		status = op->decode_args(rqstp, xdr_in, argp);
		if (likely(status == 0))
		status = op->process_op(argp, resp);
		status = op->process_op(argp, resp, cps);
		} else
		status = htonl(NFS4ERR_RESOURCE);

		/* Only set by OP_CB_SEQUENCE processing */
		if (status == htonl(NFS4ERR_RETRY_UNCACHED_REP)) {
		*drc_status = status;
		status = 0;
		}

		encode_hdr:
		res = encode_op_hdr(xdr_out, op_nr, status);
		if (unlikely(res))
		@@ -681,8 +679,11 @@ static __be32 nfs4_callback_compound(struct svc_rqst rqstp, void argp, void *r
		struct cb_compound_hdr_arg hdr_arg = { 0 };
		struct cb_compound_hdr_res hdr_res = { NULL };
		struct xdr_stream xdr_in, xdr_out;
		__be32 *p;
		__be32 status, drc_status = 0;
		__be32 *p, status;
		struct cb_process_state cps = {
		.drc_status = 0,
		.clp = NULL,
		};
		unsigned int nops = 0;

		dprintk("%s: start\n", __func__);
		@@ -696,6 +697,13 @@ static __be32 nfs4_callback_compound(struct svc_rqst rqstp, void argp, void *r
		if (status == __constant_htonl(NFS4ERR_RESOURCE))
		return rpc_garbage_args;

		if (hdr_arg.minorversion == 0) {
		cps.clp = nfs4_find_client_ident(hdr_arg.cb_ident);
		if (!cps.clp)
		return rpc_drop_reply;
		} else
		cps.svc_sid = bc_xprt_sid(rqstp);

		hdr_res.taglen = hdr_arg.taglen;
		hdr_res.tag = hdr_arg.tag;
		if (encode_compound_hdr_res(&xdr_out, &hdr_res) != 0)
		@@ -703,7 +711,7 @@ static __be32 nfs4_callback_compound(struct svc_rqst rqstp, void argp, void *r

		while (status == 0 && nops != hdr_arg.nops) {
		status = process_op(hdr_arg.minorversion, nops, rqstp,
		&xdr_in, argp, &xdr_out, resp, &drc_status);
		&xdr_in, argp, &xdr_out, resp, &cps);
		nops++;
		}

		@@ -716,6 +724,7 @@ static __be32 nfs4_callback_compound(struct svc_rqst rqstp, void argp, void *r

		*hdr_res.status = status;
		*hdr_res.nops = htonl(nops);
		nfs_put_client(cps.clp);
		dprintk("%s: done, status = %u\n", __func__, ntohl(status));
		return rpc_success;
		}

fs/nfs/client.c

+112 −59

Original line number	Diff line number	Diff line
		@@ -410,70 +410,28 @@ static int nfs_sockaddr_cmp(const struct sockaddr *sa1,
		return 0;
		}

		/*
		* Find a client by IP address and protocol version
		* - returns NULL if no such client
		*/
		struct nfs_client nfs_find_client(const struct sockaddr addr, u32 nfsversion)
		/* Common match routine for v4.0 and v4.1 callback services */
		bool
		nfs4_cb_match_client(const struct sockaddr addr, struct nfs_client clp,
		u32 minorversion)
		{
		struct nfs_client *clp;

		spin_lock(&nfs_client_lock);
		list_for_each_entry(clp, &nfs_client_list, cl_share_link) {
		struct sockaddr clap = (struct sockaddr )&clp->cl_addr;

		/* Don't match clients that failed to initialise properly */
		/* Don't match clients that failed to initialise */
		if (!(clp->cl_cons_state == NFS_CS_READY \|\|
		clp->cl_cons_state == NFS_CS_SESSION_INITING))
		continue;
		return false;

		/* Different NFS versions cannot share the same nfs_client */
		if (clp->rpc_ops->version != nfsversion)
		continue;
		/* Match the version and minorversion */
		if (clp->rpc_ops->version != 4 \|\|
		clp->cl_minorversion != minorversion)
		return false;

		/* Match only the IP address, not the port number */
		if (!nfs_sockaddr_match_ipaddr(addr, clap))
		continue;
		return false;

		atomic_inc(&clp->cl_count);
		spin_unlock(&nfs_client_lock);
		return clp;
		}
		spin_unlock(&nfs_client_lock);
		return NULL;
		}

		/*
		* Find a client by IP address and protocol version
		* - returns NULL if no such client
		*/
		struct nfs_client nfs_find_client_next(struct nfs_client clp)
		{
		struct sockaddr sap = (struct sockaddr )&clp->cl_addr;
		u32 nfsvers = clp->rpc_ops->version;

		spin_lock(&nfs_client_lock);
		list_for_each_entry_continue(clp, &nfs_client_list, cl_share_link) {
		struct sockaddr clap = (struct sockaddr )&clp->cl_addr;

		/* Don't match clients that failed to initialise properly */
		if (clp->cl_cons_state != NFS_CS_READY)
		continue;

		/* Different NFS versions cannot share the same nfs_client */
		if (clp->rpc_ops->version != nfsvers)
		continue;

		/* Match only the IP address, not the port number */
		if (!nfs_sockaddr_match_ipaddr(sap, clap))
		continue;

		atomic_inc(&clp->cl_count);
		spin_unlock(&nfs_client_lock);
		return clp;
		}
		spin_unlock(&nfs_client_lock);
		return NULL;
		return true;
		}

		/*
		@@ -1171,6 +1129,101 @@ error:
		}

		#ifdef CONFIG_NFS_V4
		/*
		* NFSv4.0 callback thread helper
		*
		* Find a client by IP address, protocol version, and minorversion
		*
		* Called from the pg_authenticate method. The callback identifier
		* is not used as it has not been decoded.
		*
		* Returns NULL if no such client
		*/
		struct nfs_client *
		nfs4_find_client_no_ident(const struct sockaddr *addr)
		{
		struct nfs_client *clp;

		spin_lock(&nfs_client_lock);
		list_for_each_entry(clp, &nfs_client_list, cl_share_link) {
		if (nfs4_cb_match_client(addr, clp, 0) == false)
		continue;
		atomic_inc(&clp->cl_count);
		spin_unlock(&nfs_client_lock);
		return clp;
		}
		spin_unlock(&nfs_client_lock);
		return NULL;
		}

		/*
		* NFSv4.0 callback thread helper
		*
		* Find a client by callback identifier
		*/
		struct nfs_client *
		nfs4_find_client_ident(int cb_ident)
		{
		struct nfs_client *clp;

		spin_lock(&nfs_client_lock);
		clp = idr_find(&cb_ident_idr, cb_ident);
		if (clp)
		atomic_inc(&clp->cl_count);
		spin_unlock(&nfs_client_lock);
		return clp;
		}

		#if defined(CONFIG_NFS_V4_1)
		/*
		* NFSv4.1 callback thread helper
		* For CB_COMPOUND calls, find a client by IP address, protocol version,
		* minorversion, and sessionID
		*
		* CREATE_SESSION triggers a CB_NULL ping from servers. The callback service
		* sessionid can only be set after the CREATE_SESSION return, so a CB_NULL
		* can arrive before the callback sessionid is set. For CB_NULL calls,
		* find a client by IP address protocol version, and minorversion.
		*
		* Returns NULL if no such client
		*/
		struct nfs_client *
		nfs4_find_client_sessionid(const struct sockaddr *addr,
		struct nfs4_sessionid *sid, int is_cb_compound)
		{
		struct nfs_client *clp;

		spin_lock(&nfs_client_lock);
		list_for_each_entry(clp, &nfs_client_list, cl_share_link) {
		if (nfs4_cb_match_client(addr, clp, 1) == false)
		continue;

		if (!nfs4_has_session(clp))
		continue;

		/* Match sessionid unless cb_null call*/
		if (is_cb_compound && (memcmp(clp->cl_session->sess_id.data,
		sid->data, NFS4_MAX_SESSIONID_LEN) != 0))
		continue;

		atomic_inc(&clp->cl_count);
		spin_unlock(&nfs_client_lock);
		return clp;
		}
		spin_unlock(&nfs_client_lock);
		return NULL;
		}

		#else /* CONFIG_NFS_V4_1 */

		struct nfs_client *
		nfs4_find_client_sessionid(const struct sockaddr *addr,
		struct nfs4_sessionid *sid, int is_cb_compound)
		{
		return NULL;
		}
		#endif /* CONFIG_NFS_V4_1 */

		/*
		* Initialize the NFS4 callback service
		*/

Admin message