xprt.h

  1/* SPDX-License-Identifier: GPL-2.0 */
  2/*
  3 *  linux/include/linux/sunrpc/xprt.h
  4 *
  5 *  Declarations for the RPC transport interface.
  6 *
  7 *  Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
  8 */
  9
 10#ifndef _LINUX_SUNRPC_XPRT_H
 11#define _LINUX_SUNRPC_XPRT_H
 12
 13#include <linux/uio.h>
 14#include <linux/socket.h>
 15#include <linux/in.h>
 16#include <linux/ktime.h>
 17#include <linux/kref.h>
 18#include <linux/sunrpc/sched.h>
 19#include <linux/sunrpc/xdr.h>
 20#include <linux/sunrpc/msg_prot.h>
 21
 22#define RPC_MIN_SLOT_TABLE	(2U)
 23#define RPC_DEF_SLOT_TABLE	(16U)
 24#define RPC_MAX_SLOT_TABLE_LIMIT	(65536U)
 25#define RPC_MAX_SLOT_TABLE	RPC_MAX_SLOT_TABLE_LIMIT
 26
 27#define RPC_CWNDSHIFT		(8U)
 28#define RPC_CWNDSCALE		(1U << RPC_CWNDSHIFT)
 29#define RPC_INITCWND		RPC_CWNDSCALE
 30#define RPC_MAXCWND(xprt)	((xprt)->max_reqs << RPC_CWNDSHIFT)
 31#define RPCXPRT_CONGESTED(xprt) ((xprt)->cong >= (xprt)->cwnd)
 32
 33#define RPC_GSS_SEQNO_ARRAY_SIZE 3U
 34
 35enum rpc_display_format_t {
 36	RPC_DISPLAY_ADDR = 0,
 37	RPC_DISPLAY_PORT,
 38	RPC_DISPLAY_PROTO,
 39	RPC_DISPLAY_HEX_ADDR,
 40	RPC_DISPLAY_HEX_PORT,
 41	RPC_DISPLAY_NETID,
 42	RPC_DISPLAY_MAX,
 43};
 44
 45struct rpc_task;
 46struct rpc_xprt;
 47struct xprt_class;
 48struct seq_file;
 49struct svc_serv;
 50struct net;
 51#include <linux/lwq.h>
 52
 53/*
 54 * This describes a complete RPC request
 55 */
 56struct rpc_rqst {
 57	/*
 58	 * This is the user-visible part
 59	 */
 60	struct rpc_xprt *	rq_xprt;		/* RPC client */
 61	struct xdr_buf		rq_snd_buf;		/* send buffer */
 62	struct xdr_buf		rq_rcv_buf;		/* recv buffer */
 63
 64	/*
 65	 * This is the private part
 66	 */
 67	struct rpc_task *	rq_task;	/* RPC task data */
 68	struct rpc_cred *	rq_cred;	/* Bound cred */
 69	__be32			rq_xid;		/* request XID */
 70	int			rq_cong;	/* has incremented xprt->cong */
 71	u32			rq_seqnos[RPC_GSS_SEQNO_ARRAY_SIZE];	/* past gss req seq nos. */
 72	unsigned int		rq_seqno_count;	/* number of entries in rq_seqnos */
 73	int			rq_enc_pages_num;
 74	struct page		**rq_enc_pages;	/* scratch pages for use by
 75						   gss privacy code */
 76	void (*rq_release_snd_buf)(struct rpc_rqst *); /* release rq_enc_pages */
 77
 78	union {
 79		struct list_head	rq_list;	/* Slot allocation list */
 80		struct rb_node		rq_recv;	/* Receive queue */
 81	};
 82
 83	struct list_head	rq_xmit;	/* Send queue */
 84	struct list_head	rq_xmit2;	/* Send queue */
 85
 86	void			*rq_buffer;	/* Call XDR encode buffer */
 87	size_t			rq_callsize;
 88	void			*rq_rbuffer;	/* Reply XDR decode buffer */
 89	size_t			rq_rcvsize;
 90	size_t			rq_xmit_bytes_sent;	/* total bytes sent */
 91	size_t			rq_reply_bytes_recvd;	/* total reply bytes */
 92							/* received */
 93
 94	struct xdr_buf		rq_private_buf;		/* The receive buffer
 95							 * used in the softirq.
 96							 */
 97	unsigned long		rq_majortimeo;	/* major timeout alarm */
 98	unsigned long		rq_minortimeo;	/* minor timeout alarm */
 99	unsigned long		rq_timeout;	/* Current timeout value */
100	ktime_t			rq_rtt;		/* round-trip time */
101	unsigned int		rq_retries;	/* # of retries */
102	unsigned int		rq_connect_cookie;
103						/* A cookie used to track the
104						   state of the transport
105						   connection */
106	atomic_t		rq_pin;
107	
108	/*
109	 * Partial send handling
110	 */
111	u32			rq_bytes_sent;	/* Bytes we have sent */
112
113	ktime_t			rq_xtime;	/* transmit time stamp */
114	int			rq_ntrans;
115
116#if defined(CONFIG_SUNRPC_BACKCHANNEL)
117	struct lwq_node		rq_bc_list;	/* Callback service list */
118	unsigned long		rq_bc_pa_state;	/* Backchannel prealloc state */
119	struct list_head	rq_bc_pa_list;	/* Backchannel prealloc list */
120#endif /* CONFIG_SUNRPC_BACKCHANEL */
121};
122#define rq_svec			rq_snd_buf.head
123#define rq_slen			rq_snd_buf.len
124
125static inline int xprt_rqst_add_seqno(struct rpc_rqst *req, u32 seqno)
126{
127	if (likely(req->rq_seqno_count < RPC_GSS_SEQNO_ARRAY_SIZE))
128		req->rq_seqno_count++;
129
130	/* Shift array to make room for the newest element at the beginning */
131	memmove(&req->rq_seqnos[1], &req->rq_seqnos[0],
132		(RPC_GSS_SEQNO_ARRAY_SIZE - 1) * sizeof(req->rq_seqnos[0]));
133	req->rq_seqnos[0] = seqno;
134	return 0;
135}
136
137/* RPC transport layer security policies */
138enum xprtsec_policies {
139	RPC_XPRTSEC_NONE = 0,
140	RPC_XPRTSEC_TLS_ANON,
141	RPC_XPRTSEC_TLS_X509,
142};
143
144struct xprtsec_parms {
145	enum xprtsec_policies	policy;
146
147	/* authentication material */
148	key_serial_t		cert_serial;
149	key_serial_t		privkey_serial;
150};
151
152struct rpc_xprt_ops {
153	void		(*set_buffer_size)(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize);
154	int		(*reserve_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
155	void		(*release_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
156	void		(*alloc_slot)(struct rpc_xprt *xprt, struct rpc_task *task);
157	void		(*free_slot)(struct rpc_xprt *xprt,
158				     struct rpc_rqst *req);
159	void		(*rpcbind)(struct rpc_task *task);
160	void		(*set_port)(struct rpc_xprt *xprt, unsigned short port);
161	void		(*connect)(struct rpc_xprt *xprt, struct rpc_task *task);
162	int		(*get_srcaddr)(struct rpc_xprt *xprt, char *buf,
163				       size_t buflen);
164	unsigned short	(*get_srcport)(struct rpc_xprt *xprt);
165	int		(*buf_alloc)(struct rpc_task *task);
166	void		(*buf_free)(struct rpc_task *task);
167	int		(*prepare_request)(struct rpc_rqst *req,
168					   struct xdr_buf *buf);
169	int		(*send_request)(struct rpc_rqst *req);
170	void		(*abort_send_request)(struct rpc_rqst *req);
171	void		(*wait_for_reply_request)(struct rpc_task *task);
172	void		(*timer)(struct rpc_xprt *xprt, struct rpc_task *task);
173	void		(*release_request)(struct rpc_task *task);
174	void		(*close)(struct rpc_xprt *xprt);
175	void		(*destroy)(struct rpc_xprt *xprt);
176	void		(*set_connect_timeout)(struct rpc_xprt *xprt,
177					unsigned long connect_timeout,
178					unsigned long reconnect_timeout);
179	void		(*print_stats)(struct rpc_xprt *xprt, struct seq_file *seq);
180	int		(*enable_swap)(struct rpc_xprt *xprt);
181	void		(*disable_swap)(struct rpc_xprt *xprt);
182	void		(*inject_disconnect)(struct rpc_xprt *xprt);
183	int		(*bc_setup)(struct rpc_xprt *xprt,
184				    unsigned int min_reqs);
185	size_t		(*bc_maxpayload)(struct rpc_xprt *xprt);
186	unsigned int	(*bc_num_slots)(struct rpc_xprt *xprt);
187	void		(*bc_free_rqst)(struct rpc_rqst *rqst);
188	void		(*bc_destroy)(struct rpc_xprt *xprt,
189				      unsigned int max_reqs);
190};
191
192/*
193 * RPC transport identifiers
194 *
195 * To preserve compatibility with the historical use of raw IP protocol
196 * id's for transport selection, UDP and TCP identifiers are specified
197 * with the previous values. No such restriction exists for new transports,
198 * except that they may not collide with these values (17 and 6,
199 * respectively).
200 */
201#define XPRT_TRANSPORT_BC       (1 << 31)
202enum xprt_transports {
203	XPRT_TRANSPORT_UDP	= IPPROTO_UDP,
204	XPRT_TRANSPORT_TCP	= IPPROTO_TCP,
205	XPRT_TRANSPORT_BC_TCP	= IPPROTO_TCP | XPRT_TRANSPORT_BC,
206	XPRT_TRANSPORT_RDMA	= 256,
207	XPRT_TRANSPORT_BC_RDMA	= XPRT_TRANSPORT_RDMA | XPRT_TRANSPORT_BC,
208	XPRT_TRANSPORT_LOCAL	= 257,
209	XPRT_TRANSPORT_TCP_TLS	= 258,
210};
211
212struct rpc_sysfs_xprt;
213struct rpc_xprt {
214	struct kref		kref;		/* Reference count */
215	const struct rpc_xprt_ops *ops;		/* transport methods */
216	unsigned int		id;		/* transport id */
217
218	const struct rpc_timeout *timeout;	/* timeout parms */
219	struct sockaddr_storage	addr;		/* server address */
220	size_t			addrlen;	/* size of server address */
221	int			prot;		/* IP protocol */
222
223	unsigned long		cong;		/* current congestion */
224	unsigned long		cwnd;		/* congestion window */
225
226	size_t			max_payload;	/* largest RPC payload size,
227						   in bytes */
228
229	struct rpc_wait_queue	binding;	/* requests waiting on rpcbind */
230	struct rpc_wait_queue	sending;	/* requests waiting to send */
231	struct rpc_wait_queue	pending;	/* requests in flight */
232	struct rpc_wait_queue	backlog;	/* waiting for slot */
233	struct list_head	free;		/* free slots */
234	unsigned int		max_reqs;	/* max number of slots */
235	unsigned int		min_reqs;	/* min number of slots */
236	unsigned int		num_reqs;	/* total slots */
237	unsigned long		state;		/* transport state */
238	unsigned char		resvport   : 1,	/* use a reserved port */
239				reuseport  : 1; /* reuse port on reconnect */
240	atomic_t		swapper;	/* we're swapping over this
241						   transport */
242	unsigned int		bind_index;	/* bind function index */
243
244	/*
245	 * Multipath
246	 */
247	struct list_head	xprt_switch;
248
249	/*
250	 * Connection of transports
251	 */
252	unsigned long		bind_timeout,
253				reestablish_timeout;
254	struct xprtsec_parms	xprtsec;
255	unsigned int		connect_cookie;	/* A cookie that gets bumped
256						   every time the transport
257						   is reconnected */
258
259	/*
260	 * Disconnection of idle transports
261	 */
262	struct work_struct	task_cleanup;
263	struct timer_list	timer;
264	unsigned long		last_used,
265				idle_timeout,
266				connect_timeout,
267				max_reconnect_timeout;
268
269	/*
270	 * Send stuff
271	 */
272	atomic_long_t		queuelen;
273	spinlock_t		transport_lock;	/* lock transport info */
274	spinlock_t		reserve_lock;	/* lock slot table */
275	spinlock_t		queue_lock;	/* send/receive queue lock */
276	u32			xid;		/* Next XID value to use */
277	struct rpc_task *	snd_task;	/* Task blocked in send */
278
279	struct list_head	xmit_queue;	/* Send queue */
280	atomic_long_t		xmit_queuelen;
281
282	struct svc_xprt		*bc_xprt;	/* NFSv4.1 backchannel */
283#if defined(CONFIG_SUNRPC_BACKCHANNEL)
284	struct svc_serv		*bc_serv;       /* The RPC service which will */
285						/* process the callback */
286	unsigned int		bc_alloc_max;
287	unsigned int		bc_alloc_count;	/* Total number of preallocs */
288	atomic_t		bc_slot_count;	/* Number of allocated slots */
289	spinlock_t		bc_pa_lock;	/* Protects the preallocated
290						 * items */
291	struct list_head	bc_pa_list;	/* List of preallocated
292						 * backchannel rpc_rqst's */
293#endif /* CONFIG_SUNRPC_BACKCHANNEL */
294
295	struct rb_root		recv_queue;	/* Receive queue */
296
297	struct {
298		unsigned long		bind_count,	/* total number of binds */
299					connect_count,	/* total number of connects */
300					connect_start,	/* connect start timestamp */
301					connect_time,	/* jiffies waiting for connect */
302					sends,		/* how many complete requests */
303					recvs,		/* how many complete requests */
304					bad_xids,	/* lookup_rqst didn't find XID */
305					max_slots;	/* max rpc_slots used */
306
307		unsigned long long	req_u,		/* average requests on the wire */
308					bklog_u,	/* backlog queue utilization */
309					sending_u,	/* send q utilization */
310					pending_u;	/* pend q utilization */
311	} stat;
312
313	struct net		*xprt_net;
314	netns_tracker		ns_tracker;
315	const char		*servername;
316	const char		*address_strings[RPC_DISPLAY_MAX];
317#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
318	struct dentry		*debugfs;		/* debugfs directory */
319#endif
320	struct rcu_head		rcu;
321	const struct xprt_class	*xprt_class;
322	struct rpc_sysfs_xprt	*xprt_sysfs;
323	bool			main; /*mark if this is the 1st transport */
324};
325
326#if defined(CONFIG_SUNRPC_BACKCHANNEL)
327/*
328 * Backchannel flags
329 */
330#define	RPC_BC_PA_IN_USE	0x0001		/* Preallocated backchannel */
331						/* buffer in use */
332#endif /* CONFIG_SUNRPC_BACKCHANNEL */
333
334#if defined(CONFIG_SUNRPC_BACKCHANNEL)
335static inline int bc_prealloc(struct rpc_rqst *req)
336{
337	return test_bit(RPC_BC_PA_IN_USE, &req->rq_bc_pa_state);
338}
339#else
340static inline int bc_prealloc(struct rpc_rqst *req)
341{
342	return 0;
343}
344#endif /* CONFIG_SUNRPC_BACKCHANNEL */
345
346#define XPRT_CREATE_INFINITE_SLOTS	(1U)
347#define XPRT_CREATE_NO_IDLE_TIMEOUT	(1U << 1)
348
349struct xprt_create {
350	int			ident;		/* XPRT_TRANSPORT identifier */
351	struct net *		net;
352	struct sockaddr *	srcaddr;	/* optional local address */
353	struct sockaddr *	dstaddr;	/* remote peer address */
354	size_t			addrlen;
355	const char		*servername;
356	struct svc_xprt		*bc_xprt;	/* NFSv4.1 backchannel */
357	struct rpc_xprt_switch	*bc_xps;
358	unsigned int		flags;
359	struct xprtsec_parms	xprtsec;
360	unsigned long		connect_timeout;
361	unsigned long		reconnect_timeout;
362};
363
364struct xprt_class {
365	struct list_head	list;
366	int			ident;		/* XPRT_TRANSPORT identifier */
367	struct rpc_xprt *	(*setup)(struct xprt_create *);
368	struct module		*owner;
369	char			name[32];
370	const char *		netid[];
371};
372
373/*
374 * Generic internal transport functions
375 */
376struct rpc_xprt		*xprt_create_transport(struct xprt_create *args);
377void			xprt_connect(struct rpc_task *task);
378unsigned long		xprt_reconnect_delay(const struct rpc_xprt *xprt);
379void			xprt_reconnect_backoff(struct rpc_xprt *xprt,
380					       unsigned long init_to);
381void			xprt_reserve(struct rpc_task *task);
382void			xprt_retry_reserve(struct rpc_task *task);
383int			xprt_reserve_xprt(struct rpc_xprt *xprt, struct rpc_task *task);
384int			xprt_reserve_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task);
385void			xprt_alloc_slot(struct rpc_xprt *xprt, struct rpc_task *task);
386void			xprt_free_slot(struct rpc_xprt *xprt,
387				       struct rpc_rqst *req);
388bool			xprt_prepare_transmit(struct rpc_task *task);
389void			xprt_request_enqueue_transmit(struct rpc_task *task);
390int			xprt_request_enqueue_receive(struct rpc_task *task);
391void			xprt_request_wait_receive(struct rpc_task *task);
392void			xprt_request_dequeue_xprt(struct rpc_task *task);
393bool			xprt_request_need_retransmit(struct rpc_task *task);
394void			xprt_transmit(struct rpc_task *task);
395void			xprt_end_transmit(struct rpc_task *task);
396int			xprt_adjust_timeout(struct rpc_rqst *req);
397void			xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task);
398void			xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task);
399void			xprt_release(struct rpc_task *task);
400struct rpc_xprt *	xprt_get(struct rpc_xprt *xprt);
401void			xprt_put(struct rpc_xprt *xprt);
402struct rpc_xprt *	xprt_alloc(struct net *net, size_t size,
403				unsigned int num_prealloc,
404				unsigned int max_req);
405void			xprt_free(struct rpc_xprt *);
406void			xprt_add_backlog(struct rpc_xprt *xprt, struct rpc_task *task);
407bool			xprt_wake_up_backlog(struct rpc_xprt *xprt, struct rpc_rqst *req);
408void			xprt_cleanup_ids(void);
409
410static inline int
411xprt_enable_swap(struct rpc_xprt *xprt)
412{
413	return xprt->ops->enable_swap(xprt);
414}
415
416static inline void
417xprt_disable_swap(struct rpc_xprt *xprt)
418{
419	xprt->ops->disable_swap(xprt);
420}
421
422/*
423 * Transport switch helper functions
424 */
425int			xprt_register_transport(struct xprt_class *type);
426int			xprt_unregister_transport(struct xprt_class *type);
427int			xprt_find_transport_ident(const char *);
428void			xprt_wait_for_reply_request_def(struct rpc_task *task);
429void			xprt_wait_for_reply_request_rtt(struct rpc_task *task);
430void			xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status);
431void			xprt_wait_for_buffer_space(struct rpc_xprt *xprt);
432bool			xprt_write_space(struct rpc_xprt *xprt);
433void			xprt_adjust_cwnd(struct rpc_xprt *xprt, struct rpc_task *task, int result);
434struct rpc_rqst *	xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid);
435void			xprt_update_rtt(struct rpc_task *task);
436void			xprt_complete_rqst(struct rpc_task *task, int copied);
437void			xprt_pin_rqst(struct rpc_rqst *req);
438void			xprt_unpin_rqst(struct rpc_rqst *req);
439void			xprt_release_rqst_cong(struct rpc_task *task);
440bool			xprt_request_get_cong(struct rpc_xprt *xprt, struct rpc_rqst *req);
441void			xprt_disconnect_done(struct rpc_xprt *xprt);
442void			xprt_force_disconnect(struct rpc_xprt *xprt);
443void			xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie);
444
445bool			xprt_lock_connect(struct rpc_xprt *, struct rpc_task *, void *);
446void			xprt_unlock_connect(struct rpc_xprt *, void *);
447void			xprt_release_write(struct rpc_xprt *, struct rpc_task *);
448
449/*
450 * Reserved bit positions in xprt->state
451 */
452#define XPRT_LOCKED		(0)
453#define XPRT_CONNECTED		(1)
454#define XPRT_CONNECTING		(2)
455#define XPRT_CLOSE_WAIT		(3)
456#define XPRT_BOUND		(4)
457#define XPRT_BINDING		(5)
458#define XPRT_CLOSING		(6)
459#define XPRT_OFFLINE		(7)
460#define XPRT_REMOVE		(8)
461#define XPRT_CONGESTED		(9)
462#define XPRT_CWND_WAIT		(10)
463#define XPRT_WRITE_SPACE	(11)
464#define XPRT_SND_IS_COOKIE	(12)
465
466static inline void xprt_set_connected(struct rpc_xprt *xprt)
467{
468	set_bit(XPRT_CONNECTED, &xprt->state);
469}
470
471static inline void xprt_clear_connected(struct rpc_xprt *xprt)
472{
473	clear_bit(XPRT_CONNECTED, &xprt->state);
474}
475
476static inline int xprt_connected(struct rpc_xprt *xprt)
477{
478	return test_bit(XPRT_CONNECTED, &xprt->state);
479}
480
481static inline int xprt_test_and_set_connected(struct rpc_xprt *xprt)
482{
483	return test_and_set_bit(XPRT_CONNECTED, &xprt->state);
484}
485
486static inline int xprt_test_and_clear_connected(struct rpc_xprt *xprt)
487{
488	return test_and_clear_bit(XPRT_CONNECTED, &xprt->state);
489}
490
491static inline void xprt_clear_connecting(struct rpc_xprt *xprt)
492{
493	smp_mb__before_atomic();
494	clear_bit(XPRT_CONNECTING, &xprt->state);
495	smp_mb__after_atomic();
496}
497
498static inline int xprt_connecting(struct rpc_xprt *xprt)
499{
500	return test_bit(XPRT_CONNECTING, &xprt->state);
501}
502
503static inline int xprt_test_and_set_connecting(struct rpc_xprt *xprt)
504{
505	return test_and_set_bit(XPRT_CONNECTING, &xprt->state);
506}
507
508static inline void xprt_set_bound(struct rpc_xprt *xprt)
509{
510	test_and_set_bit(XPRT_BOUND, &xprt->state);
511}
512
513static inline int xprt_bound(struct rpc_xprt *xprt)
514{
515	return test_bit(XPRT_BOUND, &xprt->state);
516}
517
518static inline void xprt_clear_bound(struct rpc_xprt *xprt)
519{
520	clear_bit(XPRT_BOUND, &xprt->state);
521}
522
523static inline void xprt_clear_binding(struct rpc_xprt *xprt)
524{
525	smp_mb__before_atomic();
526	clear_bit(XPRT_BINDING, &xprt->state);
527	smp_mb__after_atomic();
528}
529
530static inline int xprt_test_and_set_binding(struct rpc_xprt *xprt)
531{
532	return test_and_set_bit(XPRT_BINDING, &xprt->state);
533}
534
535void xprt_set_offline_locked(struct rpc_xprt *xprt, struct rpc_xprt_switch *xps);
536void xprt_set_online_locked(struct rpc_xprt *xprt, struct rpc_xprt_switch *xps);
537void xprt_delete_locked(struct rpc_xprt *xprt, struct rpc_xprt_switch *xps);
538#endif /* _LINUX_SUNRPC_XPRT_H */