Merge branch 'multipath' (ecf78286) · Commits · 戴 / test

fs/nfs/nfs4proc.c

+58 −3

Original line number	Original line	Diff line number	Diff line
	@@ -6782,13 +6782,26 @@ nfs41_same_server_scope(struct nfs41_server_scope *a,
	return false;		return false;
	}		}

			static void
			nfs4_bind_one_conn_to_session_done(struct rpc_task task, void calldata)
			{
			}

			static const struct rpc_call_ops nfs4_bind_one_conn_to_session_ops = {
			.rpc_call_done = &nfs4_bind_one_conn_to_session_done,
			};

	/*		/*
	* nfs4_proc_bind_conn_to_session()		* nfs4_proc_bind_one_conn_to_session()
	*		*
	* The 4.1 client currently uses the same TCP connection for the		* The 4.1 client currently uses the same TCP connection for the
	* fore and backchannel.		* fore and backchannel.
	*/		*/
	int nfs4_proc_bind_conn_to_session(struct nfs_client clp, struct rpc_cred cred)		static
			int nfs4_proc_bind_one_conn_to_session(struct rpc_clnt *clnt,
			struct rpc_xprt *xprt,
			struct nfs_client *clp,
			struct rpc_cred *cred)
	{		{
	int status;		int status;
	struct nfs41_bind_conn_to_session_args args = {		struct nfs41_bind_conn_to_session_args args = {
	@@ -6803,6 +6816,14 @@ int nfs4_proc_bind_conn_to_session(struct nfs_client clp, struct rpc_cred cred
	.rpc_resp = &res,		.rpc_resp = &res,
	.rpc_cred = cred,		.rpc_cred = cred,
	};		};
			struct rpc_task_setup task_setup_data = {
			.rpc_client = clnt,
			.rpc_xprt = xprt,
			.callback_ops = &nfs4_bind_one_conn_to_session_ops,
			.rpc_message = &msg,
			.flags = RPC_TASK_TIMEOUT,
			};
			struct rpc_task *task;

	dprintk("--> %s\n", __func__);		dprintk("--> %s\n", __func__);

	@@ -6810,7 +6831,16 @@ int nfs4_proc_bind_conn_to_session(struct nfs_client clp, struct rpc_cred cred
	if (!(clp->cl_session->flags & SESSION4_BACK_CHAN))		if (!(clp->cl_session->flags & SESSION4_BACK_CHAN))
	args.dir = NFS4_CDFC4_FORE;		args.dir = NFS4_CDFC4_FORE;

	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);		/* Do not set the backchannel flag unless this is clnt->cl_xprt */
			if (xprt != rcu_access_pointer(clnt->cl_xprt))
			args.dir = NFS4_CDFC4_FORE;

			task = rpc_run_task(&task_setup_data);
			if (!IS_ERR(task)) {
			status = task->tk_status;
			rpc_put_task(task);
			} else
			status = PTR_ERR(task);
	trace_nfs4_bind_conn_to_session(clp, status);		trace_nfs4_bind_conn_to_session(clp, status);
	if (status == 0) {		if (status == 0) {
	if (memcmp(res.sessionid.data,		if (memcmp(res.sessionid.data,
	@@ -6837,6 +6867,31 @@ out:
	return status;		return status;
	}		}

			struct rpc_bind_conn_calldata {
			struct nfs_client *clp;
			struct rpc_cred *cred;
			};

			static int
			nfs4_proc_bind_conn_to_session_callback(struct rpc_clnt *clnt,
			struct rpc_xprt *xprt,
			void *calldata)
			{
			struct rpc_bind_conn_calldata *p = calldata;

			return nfs4_proc_bind_one_conn_to_session(clnt, xprt, p->clp, p->cred);
			}

			int nfs4_proc_bind_conn_to_session(struct nfs_client clp, struct rpc_cred cred)
			{
			struct rpc_bind_conn_calldata data = {
			.clp = clp,
			.cred = cred,
			};
			return rpc_clnt_iterate_for_each_xprt(clp->cl_rpcclient,
			nfs4_proc_bind_conn_to_session_callback, &data);
			}

	/*		/*
	* Minimum set of SP4_MACH_CRED operations from RFC 5661 in the enforce map		* Minimum set of SP4_MACH_CRED operations from RFC 5661 in the enforce map
	* and operations we'd like to see to enable certain features in the allow map		* and operations we'd like to see to enable certain features in the allow map

fs/nfs/pnfs_nfs.c

+13 −3

Original line number	Original line	Diff line number	Diff line
	@@ -606,12 +606,22 @@ static int _nfs4_pnfs_v3_ds_connect(struct nfs_server *mds_srv,
	dprintk("%s: DS %s: trying address %s\n",		dprintk("%s: DS %s: trying address %s\n",
	__func__, ds->ds_remotestr, da->da_remotestr);		__func__, ds->ds_remotestr, da->da_remotestr);

			if (!IS_ERR(clp)) {
			struct xprt_create xprt_args = {
			.ident = XPRT_TRANSPORT_TCP,
			.net = clp->cl_net,
			.dstaddr = (struct sockaddr *)&da->da_addr,
			.addrlen = da->da_addrlen,
			.servername = clp->cl_hostname,
			};
			/* Add this address as an alias */
			rpc_clnt_add_xprt(clp->cl_rpcclient, &xprt_args,
			rpc_clnt_test_and_add_xprt, NULL);
			} else
	clp = get_v3_ds_connect(mds_srv->nfs_client,		clp = get_v3_ds_connect(mds_srv->nfs_client,
	(struct sockaddr *)&da->da_addr,		(struct sockaddr *)&da->da_addr,
	da->da_addrlen, IPPROTO_TCP,		da->da_addrlen, IPPROTO_TCP,
	timeo, retrans, au_flavor);		timeo, retrans, au_flavor);
	if (!IS_ERR(clp))
	break;
	}		}

	if (IS_ERR(clp)) {		if (IS_ERR(clp)) {

include/linux/sunrpc/clnt.h

+17 −1

Original line number	Original line	Diff line number	Diff line
	@@ -25,6 +25,7 @@
	#include <asm/signal.h>		#include <asm/signal.h>
	#include <linux/path.h>		#include <linux/path.h>
	#include <net/ipv6.h>		#include <net/ipv6.h>
			#include <linux/sunrpc/xprtmultipath.h>

	struct rpc_inode;		struct rpc_inode;

	@@ -67,6 +68,7 @@ struct rpc_clnt {
	#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)		#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
	struct dentry cl_debugfs; / debugfs directory */		struct dentry cl_debugfs; / debugfs directory */
	#endif		#endif
			struct rpc_xprt_iter cl_xpi;
	};		};

	/*		/*
	@@ -139,7 +141,6 @@ struct rpc_clnt rpc_create_xprt(struct rpc_create_args args,
	struct rpc_xprt *xprt);		struct rpc_xprt *xprt);
	struct rpc_clnt rpc_bind_new_program(struct rpc_clnt ,		struct rpc_clnt rpc_bind_new_program(struct rpc_clnt ,
	const struct rpc_program *, u32);		const struct rpc_program *, u32);
	void rpc_task_reset_client(struct rpc_task task, struct rpc_clnt clnt);
	struct rpc_clnt rpc_clone_client(struct rpc_clnt );		struct rpc_clnt rpc_clone_client(struct rpc_clnt );
	struct rpc_clnt rpc_clone_client_set_auth(struct rpc_clnt ,		struct rpc_clnt rpc_clone_client_set_auth(struct rpc_clnt ,
	rpc_authflavor_t);		rpc_authflavor_t);
	@@ -181,6 +182,21 @@ size_t rpc_peeraddr(struct rpc_clnt , struct sockaddr , size_t);
	const char rpc_peeraddr2str(struct rpc_clnt , enum rpc_display_format_t);		const char rpc_peeraddr2str(struct rpc_clnt , enum rpc_display_format_t);
	int rpc_localaddr(struct rpc_clnt , struct sockaddr , size_t);		int rpc_localaddr(struct rpc_clnt , struct sockaddr , size_t);

			int rpc_clnt_iterate_for_each_xprt(struct rpc_clnt *clnt,
			int (fn)(struct rpc_clnt , struct rpc_xprt , void ),
			void *data);

			int rpc_clnt_test_and_add_xprt(struct rpc_clnt *clnt,
			struct rpc_xprt_switch *xps,
			struct rpc_xprt *xprt,
			void *dummy);
			int rpc_clnt_add_xprt(struct rpc_clnt , struct xprt_create ,
			int (setup)(struct rpc_clnt ,
			struct rpc_xprt_switch *,
			struct rpc_xprt *,
			void *),
			void *data);

	const char rpc_proc_name(const struct rpc_task task);		const char rpc_proc_name(const struct rpc_task task);
	#endif /* __KERNEL__ */		#endif /* __KERNEL__ */
	#endif /* _LINUX_SUNRPC_CLNT_H */		#endif /* _LINUX_SUNRPC_CLNT_H */

include/linux/sunrpc/sched.h

+18 −14

Original line number	Original line	Diff line number	Diff line
	@@ -42,40 +42,43 @@ struct rpc_wait {
	*/		*/
	struct rpc_task {		struct rpc_task {
	atomic_t tk_count; /* Reference count */		atomic_t tk_count; /* Reference count */
			int tk_status; /* result of last operation */
	struct list_head tk_task; /* global list of tasks */		struct list_head tk_task; /* global list of tasks */
	struct rpc_clnt * tk_client; /* RPC client */
	struct rpc_rqst * tk_rqstp; /* RPC request */

	/*
	* RPC call state
	*/
	struct rpc_message tk_msg; /* RPC call info */

	/*		/*
	* callback to be executed after waking up		* callback to be executed after waking up
	* action next procedure for async tasks		* action next procedure for async tasks
	* tk_ops caller callbacks
	*/		*/
	void (tk_callback)(struct rpc_task );		void (tk_callback)(struct rpc_task );
	void (tk_action)(struct rpc_task );		void (tk_action)(struct rpc_task );
	const struct rpc_call_ops *tk_ops;
	void * tk_calldata;

	unsigned long tk_timeout; /* timeout for rpc_sleep() */		unsigned long tk_timeout; /* timeout for rpc_sleep() */
	unsigned long tk_runstate; /* Task run status */		unsigned long tk_runstate; /* Task run status */
	struct workqueue_struct tk_workqueue; / Normally rpciod, but could
	* be any workqueue
	*/
	struct rpc_wait_queue tk_waitqueue; / RPC wait queue we're on */		struct rpc_wait_queue tk_waitqueue; / RPC wait queue we're on */
	union {		union {
	struct work_struct tk_work; /* Async task work queue */		struct work_struct tk_work; /* Async task work queue */
	struct rpc_wait tk_wait; /* RPC wait */		struct rpc_wait tk_wait; /* RPC wait */
	} u;		} u;

			/*
			* RPC call state
			*/
			struct rpc_message tk_msg; /* RPC call info */
			void * tk_calldata; /* Caller private data */
			const struct rpc_call_ops tk_ops; / Caller callbacks */

			struct rpc_clnt * tk_client; /* RPC client */
			struct rpc_xprt * tk_xprt; /* Transport */

			struct rpc_rqst * tk_rqstp; /* RPC request */

			struct workqueue_struct tk_workqueue; / Normally rpciod, but could
			* be any workqueue
			*/
	ktime_t tk_start; /* RPC task init timestamp */		ktime_t tk_start; /* RPC task init timestamp */

	pid_t tk_owner; /* Process id for batching tasks */		pid_t tk_owner; /* Process id for batching tasks */
	int tk_status; /* result of last operation */
	unsigned short tk_flags; /* misc flags */		unsigned short tk_flags; /* misc flags */
	unsigned short tk_timeouts; /* maj timeouts */		unsigned short tk_timeouts; /* maj timeouts */

	@@ -100,6 +103,7 @@ struct rpc_call_ops {
	struct rpc_task_setup {		struct rpc_task_setup {
	struct rpc_task *task;		struct rpc_task *task;
	struct rpc_clnt *rpc_client;		struct rpc_clnt *rpc_client;
			struct rpc_xprt *rpc_xprt;
	const struct rpc_message *rpc_message;		const struct rpc_message *rpc_message;
	const struct rpc_call_ops *callback_ops;		const struct rpc_call_ops *callback_ops;
	void *callback_data;		void *callback_data;

include/linux/sunrpc/xprt.h

+9 −13

Original line number	Original line	Diff line number	Diff line
	@@ -13,6 +13,7 @@
	#include <linux/socket.h>		#include <linux/socket.h>
	#include <linux/in.h>		#include <linux/in.h>
	#include <linux/ktime.h>		#include <linux/ktime.h>
			#include <linux/kref.h>
	#include <linux/sunrpc/sched.h>		#include <linux/sunrpc/sched.h>
	#include <linux/sunrpc/xdr.h>		#include <linux/sunrpc/xdr.h>
	#include <linux/sunrpc/msg_prot.h>		#include <linux/sunrpc/msg_prot.h>
	@@ -166,7 +167,7 @@ enum xprt_transports {
	};		};

	struct rpc_xprt {		struct rpc_xprt {
	atomic_t count; /* Reference count */		struct kref kref; /* Reference count */
	struct rpc_xprt_ops * ops; /* transport methods */		struct rpc_xprt_ops * ops; /* transport methods */

	const struct rpc_timeout timeout; / timeout parms */		const struct rpc_timeout timeout; / timeout parms */
	@@ -196,6 +197,11 @@ struct rpc_xprt {
	transport */		transport */
	unsigned int bind_index; /* bind function index */		unsigned int bind_index; /* bind function index */

			/*
			* Multipath
			*/
			struct list_head xprt_switch;

	/*		/*
	* Connection of transports		* Connection of transports
	*/		*/
	@@ -256,6 +262,7 @@ struct rpc_xprt {
	struct dentry debugfs; / debugfs directory */		struct dentry debugfs; / debugfs directory */
	atomic_t inject_disconnect;		atomic_t inject_disconnect;
	#endif		#endif
			struct rcu_head rcu;
	};		};

	#if defined(CONFIG_SUNRPC_BACKCHANNEL)		#if defined(CONFIG_SUNRPC_BACKCHANNEL)
	@@ -318,24 +325,13 @@ int xprt_adjust_timeout(struct rpc_rqst *req);
	void xprt_release_xprt(struct rpc_xprt xprt, struct rpc_task task);		void xprt_release_xprt(struct rpc_xprt xprt, struct rpc_task task);
	void xprt_release_xprt_cong(struct rpc_xprt xprt, struct rpc_task task);		void xprt_release_xprt_cong(struct rpc_xprt xprt, struct rpc_task task);
	void xprt_release(struct rpc_task *task);		void xprt_release(struct rpc_task *task);
			struct rpc_xprt * xprt_get(struct rpc_xprt *xprt);
	void xprt_put(struct rpc_xprt *xprt);		void xprt_put(struct rpc_xprt *xprt);
	struct rpc_xprt * xprt_alloc(struct net *net, size_t size,		struct rpc_xprt * xprt_alloc(struct net *net, size_t size,
	unsigned int num_prealloc,		unsigned int num_prealloc,
	unsigned int max_req);		unsigned int max_req);
	void xprt_free(struct rpc_xprt *);		void xprt_free(struct rpc_xprt *);

	/**
	* xprt_get - return a reference to an RPC transport.
	* @xprt: pointer to the transport
	*
	*/
	static inline struct rpc_xprt xprt_get(struct rpc_xprt xprt)
	{
	if (atomic_inc_not_zero(&xprt->count))
	return xprt;
	return NULL;
	}

	static inline __be32 xprt_skip_transport_header(struct rpc_xprt xprt, __be32 *p)		static inline __be32 xprt_skip_transport_header(struct rpc_xprt xprt, __be32 *p)
	{		{
	return p + xprt->tsh_size;		return p + xprt->tsh_size;

Admin message