1/*
2 * linux/include/linux/sunrpc/svc.h
3 *
4 * RPC server declarations.
5 *
6 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
7 */
8
9
10#ifndef SUNRPC_SVC_H
11#define SUNRPC_SVC_H
12
13#include <linux/in.h>
14#include <linux/in6.h>
15#include <linux/sunrpc/types.h>
16#include <linux/sunrpc/xdr.h>
17#include <linux/sunrpc/auth.h>
18#include <linux/sunrpc/svcauth.h>
19#include <linux/wait.h>
20#include <linux/mm.h>
21
22/*
23 * This is the RPC server thread function prototype
24 */
25typedef int		(*svc_thread_fn)(void *);
26
27/* statistics for svc_pool structures */
28struct svc_pool_stats {
29	unsigned long	packets;
30	unsigned long	sockets_queued;
31	unsigned long	threads_woken;
32	unsigned long	threads_timedout;
33};
34
35/*
36 *
37 * RPC service thread pool.
38 *
39 * Pool of threads and temporary sockets.  Generally there is only
40 * a single one of these per RPC service, but on NUMA machines those
41 * services that can benefit from it (i.e. nfs but not lockd) will
42 * have one pool per NUMA node.  This optimisation reduces cross-
43 * node traffic on multi-node NUMA NFS servers.
44 */
45struct svc_pool {
46	unsigned int		sp_id;	    	/* pool id; also node id on NUMA */
47	spinlock_t		sp_lock;	/* protects all fields */
48	struct list_head	sp_threads;	/* idle server threads */
49	struct list_head	sp_sockets;	/* pending sockets */
50	unsigned int		sp_nrthreads;	/* # of threads in pool */
51	struct list_head	sp_all_threads;	/* all server threads */
52	struct svc_pool_stats	sp_stats;	/* statistics on pool operation */
53	int			sp_task_pending;/* has pending task */
54} ____cacheline_aligned_in_smp;
55
56/*
57 * RPC service.
58 *
59 * An RPC service is a ``daemon,'' possibly multithreaded, which
60 * receives and processes incoming RPC messages.
61 * It has one or more transport sockets associated with it, and maintains
62 * a list of idle threads waiting for input.
63 *
64 * We currently do not support more than one RPC program per daemon.
65 */
66struct svc_serv {
67	struct svc_program *	sv_program;	/* RPC program */
68	struct svc_stat *	sv_stats;	/* RPC statistics */
69	spinlock_t		sv_lock;
70	unsigned int		sv_nrthreads;	/* # of server threads */
71	unsigned int		sv_maxconn;	/* max connections allowed or
72						 * '0' causing max to be based
73						 * on number of threads. */
74
75	unsigned int		sv_max_payload;	/* datagram payload size */
76	unsigned int		sv_max_mesg;	/* max_payload + 1 page for overheads */
77	unsigned int		sv_xdrsize;	/* XDR buffer size */
78	struct list_head	sv_permsocks;	/* all permanent sockets */
79	struct list_head	sv_tempsocks;	/* all temporary sockets */
80	int			sv_tmpcnt;	/* count of temporary sockets */
81	struct timer_list	sv_temptimer;	/* timer for aging temporary sockets */
82
83	char *			sv_name;	/* service name */
84
85	unsigned int		sv_nrpools;	/* number of thread pools */
86	struct svc_pool *	sv_pools;	/* array of thread pools */
87
88	void			(*sv_shutdown)(struct svc_serv *serv,
89					       struct net *net);
90						/* Callback to use when last thread
91						 * exits.
92						 */
93
94	struct module *		sv_module;	/* optional module to count when
95						 * adding threads */
96	svc_thread_fn		sv_function;	/* main function for threads */
97#if defined(CONFIG_SUNRPC_BACKCHANNEL)
98	struct list_head	sv_cb_list;	/* queue for callback requests
99						 * that arrive over the same
100						 * connection */
101	spinlock_t		sv_cb_lock;	/* protects the svc_cb_list */
102	wait_queue_head_t	sv_cb_waitq;	/* sleep here if there are no
103						 * entries in the svc_cb_list */
104	struct svc_xprt		*sv_bc_xprt;	/* callback on fore channel */
105#endif /* CONFIG_SUNRPC_BACKCHANNEL */
106};
107
108/*
109 * We use sv_nrthreads as a reference count.  svc_destroy() drops
110 * this refcount, so we need to bump it up around operations that
111 * change the number of threads.  Horrible, but there it is.
112 * Should be called with the BKL held.
113 */
114static inline void svc_get(struct svc_serv *serv)
115{
116	serv->sv_nrthreads++;
117}
118
119/*
120 * Maximum payload size supported by a kernel RPC server.
121 * This is use to determine the max number of pages nfsd is
122 * willing to return in a single READ operation.
123 *
124 * These happen to all be powers of 2, which is not strictly
125 * necessary but helps enforce the real limitation, which is
126 * that they should be multiples of PAGE_CACHE_SIZE.
127 *
128 * For UDP transports, a block plus NFS,RPC, and UDP headers
129 * has to fit into the IP datagram limit of 64K.  The largest
130 * feasible number for all known page sizes is probably 48K,
131 * but we choose 32K here.  This is the same as the historical
132 * Linux limit; someone who cares more about NFS/UDP performance
133 * can test a larger number.
134 *
135 * For TCP transports we have more freedom.  A size of 1MB is
136 * chosen to match the client limit.  Other OSes are known to
137 * have larger limits, but those numbers are probably beyond
138 * the point of diminishing returns.
139 */
140#define RPCSVC_MAXPAYLOAD	(1*1024*1024u)
141#define RPCSVC_MAXPAYLOAD_TCP	RPCSVC_MAXPAYLOAD
142#define RPCSVC_MAXPAYLOAD_UDP	(32*1024u)
143
144extern u32 svc_max_payload(const struct svc_rqst *rqstp);
145
146/*
147 * RPC Requsts and replies are stored in one or more pages.
148 * We maintain an array of pages for each server thread.
149 * Requests are copied into these pages as they arrive.  Remaining
150 * pages are available to write the reply into.
151 *
152 * Pages are sent using ->sendpage so each server thread needs to
153 * allocate more to replace those used in sending.  To help keep track
154 * of these pages we have a receive list where all pages initialy live,
155 * and a send list where pages are moved to when there are to be part
156 * of a reply.
157 *
158 * We use xdr_buf for holding responses as it fits well with NFS
159 * read responses (that have a header, and some data pages, and possibly
160 * a tail) and means we can share some client side routines.
161 *
162 * The xdr_buf.head kvec always points to the first page in the rq_*pages
163 * list.  The xdr_buf.pages pointer points to the second page on that
164 * list.  xdr_buf.tail points to the end of the first page.
165 * This assumes that the non-page part of an rpc reply will fit
166 * in a page - NFSd ensures this.  lockd also has no trouble.
167 *
168 * Each request/reply pair can have at most one "payload", plus two pages,
169 * one for the request, and one for the reply.
170 * We using ->sendfile to return read data, we might need one extra page
171 * if the request is not page-aligned.  So add another '1'.
172 */
173#define RPCSVC_MAXPAGES		((RPCSVC_MAXPAYLOAD+PAGE_SIZE-1)/PAGE_SIZE \
174				+ 2 + 1)
175
176static inline u32 svc_getnl(struct kvec *iov)
177{
178	__be32 val, *vp;
179	vp = iov->iov_base;
180	val = *vp++;
181	iov->iov_base = (void*)vp;
182	iov->iov_len -= sizeof(__be32);
183	return ntohl(val);
184}
185
186static inline void svc_putnl(struct kvec *iov, u32 val)
187{
188	__be32 *vp = iov->iov_base + iov->iov_len;
189	*vp = htonl(val);
190	iov->iov_len += sizeof(__be32);
191}
192
193static inline __be32 svc_getu32(struct kvec *iov)
194{
195	__be32 val, *vp;
196	vp = iov->iov_base;
197	val = *vp++;
198	iov->iov_base = (void*)vp;
199	iov->iov_len -= sizeof(__be32);
200	return val;
201}
202
203static inline void svc_ungetu32(struct kvec *iov)
204{
205	__be32 *vp = (__be32 *)iov->iov_base;
206	iov->iov_base = (void *)(vp - 1);
207	iov->iov_len += sizeof(*vp);
208}
209
210static inline void svc_putu32(struct kvec *iov, __be32 val)
211{
212	__be32 *vp = iov->iov_base + iov->iov_len;
213	*vp = val;
214	iov->iov_len += sizeof(__be32);
215}
216
217/*
218 * The context of a single thread, including the request currently being
219 * processed.
220 */
221struct svc_rqst {
222	struct list_head	rq_list;	/* idle list */
223	struct list_head	rq_all;		/* all threads list */
224	struct svc_xprt *	rq_xprt;	/* transport ptr */
225
226	struct sockaddr_storage	rq_addr;	/* peer address */
227	size_t			rq_addrlen;
228	struct sockaddr_storage	rq_daddr;	/* dest addr of request
229						 *  - reply from here */
230	size_t			rq_daddrlen;
231
232	struct svc_serv *	rq_server;	/* RPC service definition */
233	struct svc_pool *	rq_pool;	/* thread pool */
234	struct svc_procedure *	rq_procinfo;	/* procedure info */
235	struct auth_ops *	rq_authop;	/* authentication flavour */
236	struct svc_cred		rq_cred;	/* auth info */
237	void *			rq_xprt_ctxt;	/* transport specific context ptr */
238	struct svc_deferred_req*rq_deferred;	/* deferred request we are replaying */
239	bool			rq_usedeferral;	/* use deferral */
240
241	size_t			rq_xprt_hlen;	/* xprt header len */
242	struct xdr_buf		rq_arg;
243	struct xdr_buf		rq_res;
244	struct page *		rq_pages[RPCSVC_MAXPAGES];
245	struct page *		*rq_respages;	/* points into rq_pages */
246	struct page *		*rq_next_page; /* next reply page to use */
247	struct page *		*rq_page_end;  /* one past the last page */
248
249	struct kvec		rq_vec[RPCSVC_MAXPAGES]; /* generally useful.. */
250
251	__be32			rq_xid;		/* transmission id */
252	u32			rq_prog;	/* program number */
253	u32			rq_vers;	/* program version */
254	u32			rq_proc;	/* procedure number */
255	u32			rq_prot;	/* IP protocol */
256	unsigned short
257				rq_secure  : 1;	/* secure port */
258	unsigned short		rq_local   : 1;	/* local request */
259
260	void *			rq_argp;	/* decoded arguments */
261	void *			rq_resp;	/* xdr'd results */
262	void *			rq_auth_data;	/* flavor-specific data */
263	int			rq_auth_slack;	/* extra space xdr code
264						 * should leave in head
265						 * for krb5i, krb5p.
266						 */
267	int			rq_reserved;	/* space on socket outq
268						 * reserved for this request
269						 */
270
271	struct cache_req	rq_chandle;	/* handle passed to caches for
272						 * request delaying
273						 */
274	bool			rq_dropme;
275	/* Catering to nfsd */
276	struct auth_domain *	rq_client;	/* RPC peer info */
277	struct auth_domain *	rq_gssclient;	/* "gss/"-style peer info */
278	int			rq_cachetype;
279	struct svc_cacherep *	rq_cacherep;	/* cache info */
280	bool			rq_splice_ok;   /* turned off in gss privacy
281						 * to prevent encrypting page
282						 * cache pages */
283	struct task_struct	*rq_task;	/* service thread */
284};
285
286#define SVC_NET(svc_rqst)	(svc_rqst->rq_xprt->xpt_net)
287
288/*
289 * Rigorous type checking on sockaddr type conversions
290 */
291static inline struct sockaddr_in *svc_addr_in(const struct svc_rqst *rqst)
292{
293	return (struct sockaddr_in *) &rqst->rq_addr;
294}
295
296static inline struct sockaddr_in6 *svc_addr_in6(const struct svc_rqst *rqst)
297{
298	return (struct sockaddr_in6 *) &rqst->rq_addr;
299}
300
301static inline struct sockaddr *svc_addr(const struct svc_rqst *rqst)
302{
303	return (struct sockaddr *) &rqst->rq_addr;
304}
305
306static inline struct sockaddr_in *svc_daddr_in(const struct svc_rqst *rqst)
307{
308	return (struct sockaddr_in *) &rqst->rq_daddr;
309}
310
311static inline struct sockaddr_in6 *svc_daddr_in6(const struct svc_rqst *rqst)
312{
313	return (struct sockaddr_in6 *) &rqst->rq_daddr;
314}
315
316static inline struct sockaddr *svc_daddr(const struct svc_rqst *rqst)
317{
318	return (struct sockaddr *) &rqst->rq_daddr;
319}
320
321/*
322 * Check buffer bounds after decoding arguments
323 */
324static inline int
325xdr_argsize_check(struct svc_rqst *rqstp, __be32 *p)
326{
327	char *cp = (char *)p;
328	struct kvec *vec = &rqstp->rq_arg.head[0];
329	return cp >= (char*)vec->iov_base
330		&& cp <= (char*)vec->iov_base + vec->iov_len;
331}
332
333static inline int
334xdr_ressize_check(struct svc_rqst *rqstp, __be32 *p)
335{
336	struct kvec *vec = &rqstp->rq_res.head[0];
337	char *cp = (char*)p;
338
339	vec->iov_len = cp - (char*)vec->iov_base;
340
341	return vec->iov_len <= PAGE_SIZE;
342}
343
344static inline void svc_free_res_pages(struct svc_rqst *rqstp)
345{
346	while (rqstp->rq_next_page != rqstp->rq_respages) {
347		struct page **pp = --rqstp->rq_next_page;
348		if (*pp) {
349			put_page(*pp);
350			*pp = NULL;
351		}
352	}
353}
354
355struct svc_deferred_req {
356	u32			prot;	/* protocol (UDP or TCP) */
357	struct svc_xprt		*xprt;
358	struct sockaddr_storage	addr;	/* where reply must go */
359	size_t			addrlen;
360	struct sockaddr_storage	daddr;	/* where reply must come from */
361	size_t			daddrlen;
362	struct cache_deferred_req handle;
363	size_t			xprt_hlen;
364	int			argslen;
365	__be32			args[0];
366};
367
368/*
369 * List of RPC programs on the same transport endpoint
370 */
371struct svc_program {
372	struct svc_program *	pg_next;	/* other programs (same xprt) */
373	u32			pg_prog;	/* program number */
374	unsigned int		pg_lovers;	/* lowest version */
375	unsigned int		pg_hivers;	/* highest version */
376	unsigned int		pg_nvers;	/* number of versions */
377	struct svc_version **	pg_vers;	/* version array */
378	char *			pg_name;	/* service name */
379	char *			pg_class;	/* class name: services sharing authentication */
380	struct svc_stat *	pg_stats;	/* rpc statistics */
381	int			(*pg_authenticate)(struct svc_rqst *);
382};
383
384/*
385 * RPC program version
386 */
387struct svc_version {
388	u32			vs_vers;	/* version number */
389	u32			vs_nproc;	/* number of procedures */
390	struct svc_procedure *	vs_proc;	/* per-procedure info */
391	u32			vs_xdrsize;	/* xdrsize needed for this version */
392
393	unsigned int		vs_hidden : 1,	/* Don't register with portmapper.
394						 * Only used for nfsacl so far. */
395				vs_rpcb_optnl:1;/* Don't care the result of register.
396						 * Only used for nfsv4. */
397
398	/* Override dispatch function (e.g. when caching replies).
399	 * A return value of 0 means drop the request.
400	 * vs_dispatch == NULL means use default dispatcher.
401	 */
402	int			(*vs_dispatch)(struct svc_rqst *, __be32 *);
403};
404
405/*
406 * RPC procedure info
407 */
408typedef __be32	(*svc_procfunc)(struct svc_rqst *, void *argp, void *resp);
409struct svc_procedure {
410	svc_procfunc		pc_func;	/* process the request */
411	kxdrproc_t		pc_decode;	/* XDR decode args */
412	kxdrproc_t		pc_encode;	/* XDR encode result */
413	kxdrproc_t		pc_release;	/* XDR free result */
414	unsigned int		pc_argsize;	/* argument struct size */
415	unsigned int		pc_ressize;	/* result struct size */
416	unsigned int		pc_count;	/* call count */
417	unsigned int		pc_cachetype;	/* cache info (NFS) */
418	unsigned int		pc_xdrressize;	/* maximum size of XDR reply */
419};
420
421/*
422 * Function prototypes.
423 */
424int svc_rpcb_setup(struct svc_serv *serv, struct net *net);
425void svc_rpcb_cleanup(struct svc_serv *serv, struct net *net);
426int svc_bind(struct svc_serv *serv, struct net *net);
427struct svc_serv *svc_create(struct svc_program *, unsigned int,
428			    void (*shutdown)(struct svc_serv *, struct net *net));
429struct svc_rqst *svc_prepare_thread(struct svc_serv *serv,
430					struct svc_pool *pool, int node);
431void		   svc_exit_thread(struct svc_rqst *);
432struct svc_serv *  svc_create_pooled(struct svc_program *, unsigned int,
433			void (*shutdown)(struct svc_serv *, struct net *net),
434			svc_thread_fn, struct module *);
435int		   svc_set_num_threads(struct svc_serv *, struct svc_pool *, int);
436int		   svc_pool_stats_open(struct svc_serv *serv, struct file *file);
437void		   svc_destroy(struct svc_serv *);
438void		   svc_shutdown_net(struct svc_serv *, struct net *);
439int		   svc_process(struct svc_rqst *);
440int		   bc_svc_process(struct svc_serv *, struct rpc_rqst *,
441			struct svc_rqst *);
442int		   svc_register(const struct svc_serv *, struct net *, const int,
443				const unsigned short, const unsigned short);
444
445void		   svc_wake_up(struct svc_serv *);
446void		   svc_reserve(struct svc_rqst *rqstp, int space);
447struct svc_pool *  svc_pool_for_cpu(struct svc_serv *serv, int cpu);
448char *		   svc_print_addr(struct svc_rqst *, char *, size_t);
449
450#define	RPC_MAX_ADDRBUFLEN	(63U)
451
452/*
453 * When we want to reduce the size of the reserved space in the response
454 * buffer, we need to take into account the size of any checksum data that
455 * may be at the end of the packet. This is difficult to determine exactly
456 * for all cases without actually generating the checksum, so we just use a
457 * static value.
458 */
459static inline void svc_reserve_auth(struct svc_rqst *rqstp, int space)
460{
461	svc_reserve(rqstp, space + rqstp->rq_auth_slack);
462}
463
464#endif /* SUNRPC_SVC_H */
465