blob: 64c97552964a42f523b5c3dcba8a149f5edd4b3e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Chuck Lever73df0db2007-02-12 00:53:35 -080014#include <linux/in6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/sunrpc/types.h>
16#include <linux/sunrpc/xdr.h>
Greg Banks7adae482006-10-04 02:15:47 -070017#include <linux/sunrpc/auth.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/sunrpc/svcauth.h>
19#include <linux/wait.h>
20#include <linux/mm.h>
21
Greg Banksa7455442006-10-02 02:17:59 -070022/*
23 * This is the RPC server thread function prototype
24 */
25typedef void (*svc_thread_fn)(struct svc_rqst *);
Greg Banks3262c812006-10-02 02:17:58 -070026
27/*
28 *
29 * RPC service thread pool.
30 *
31 * Pool of threads and temporary sockets. Generally there is only
32 * a single one of these per RPC service, but on NUMA machines those
33 * services that can benefit from it (i.e. nfs but not lockd) will
34 * have one pool per NUMA node. This optimisation reduces cross-
35 * node traffic on multi-node NUMA NFS servers.
36 */
37struct svc_pool {
38 unsigned int sp_id; /* pool id; also node id on NUMA */
39 spinlock_t sp_lock; /* protects all fields */
40 struct list_head sp_threads; /* idle server threads */
41 struct list_head sp_sockets; /* pending sockets */
42 unsigned int sp_nrthreads; /* # of threads in pool */
Greg Banksa7455442006-10-02 02:17:59 -070043 struct list_head sp_all_threads; /* all server threads */
Greg Banks3262c812006-10-02 02:17:58 -070044} ____cacheline_aligned_in_smp;
45
Linus Torvalds1da177e2005-04-16 15:20:36 -070046/*
47 * RPC service.
48 *
49 * An RPC service is a ``daemon,'' possibly multithreaded, which
50 * receives and processes incoming RPC messages.
51 * It has one or more transport sockets associated with it, and maintains
52 * a list of idle threads waiting for input.
53 *
54 * We currently do not support more than one RPC program per daemon.
55 */
56struct svc_serv {
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 struct svc_program * sv_program; /* RPC program */
58 struct svc_stat * sv_stats; /* RPC statistics */
59 spinlock_t sv_lock;
60 unsigned int sv_nrthreads; /* # of server threads */
NeilBrownc6b0a9f2006-10-06 00:44:05 -070061 unsigned int sv_max_payload; /* datagram payload size */
62 unsigned int sv_max_mesg; /* max_payload + 1 page for overheads */
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 unsigned int sv_xdrsize; /* XDR buffer size */
64
65 struct list_head sv_permsocks; /* all permanent sockets */
66 struct list_head sv_tempsocks; /* all temporary sockets */
67 int sv_tmpcnt; /* count of temporary sockets */
Greg Banks36bdfc82006-10-02 02:17:54 -070068 struct timer_list sv_temptimer; /* timer for aging temporary sockets */
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
70 char * sv_name; /* service name */
NeilBrownbc591cc2006-10-02 02:17:44 -070071
Greg Banks3262c812006-10-02 02:17:58 -070072 unsigned int sv_nrpools; /* number of thread pools */
73 struct svc_pool * sv_pools; /* array of thread pools */
74
NeilBrownbc591cc2006-10-02 02:17:44 -070075 void (*sv_shutdown)(struct svc_serv *serv);
76 /* Callback to use when last thread
77 * exits.
78 */
Greg Banksa7455442006-10-02 02:17:59 -070079
80 struct module * sv_module; /* optional module to count when
81 * adding threads */
82 svc_thread_fn sv_function; /* main function for threads */
83 int sv_kill_signal; /* signal to kill threads */
Linus Torvalds1da177e2005-04-16 15:20:36 -070084};
85
86/*
Greg Banks9a24ab52006-10-02 02:17:58 -070087 * We use sv_nrthreads as a reference count. svc_destroy() drops
88 * this refcount, so we need to bump it up around operations that
89 * change the number of threads. Horrible, but there it is.
90 * Should be called with the BKL held.
91 */
92static inline void svc_get(struct svc_serv *serv)
93{
94 serv->sv_nrthreads++;
95}
96
97/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 * Maximum payload size supported by a kernel RPC server.
99 * This is use to determine the max number of pages nfsd is
100 * willing to return in a single READ operation.
Greg Banks7adae482006-10-04 02:15:47 -0700101 *
102 * These happen to all be powers of 2, which is not strictly
103 * necessary but helps enforce the real limitation, which is
104 * that they should be multiples of PAGE_CACHE_SIZE.
105 *
106 * For UDP transports, a block plus NFS,RPC, and UDP headers
107 * has to fit into the IP datagram limit of 64K. The largest
108 * feasible number for all known page sizes is probably 48K,
109 * but we choose 32K here. This is the same as the historical
110 * Linux limit; someone who cares more about NFS/UDP performance
111 * can test a larger number.
112 *
113 * For TCP transports we have more freedom. A size of 1MB is
114 * chosen to match the client limit. Other OSes are known to
115 * have larger limits, but those numbers are probably beyond
116 * the point of diminishing returns.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 */
Greg Banks7adae482006-10-04 02:15:47 -0700118#define RPCSVC_MAXPAYLOAD (1*1024*1024u)
119#define RPCSVC_MAXPAYLOAD_TCP RPCSVC_MAXPAYLOAD
120#define RPCSVC_MAXPAYLOAD_UDP (32*1024u)
121
122extern u32 svc_max_payload(const struct svc_rqst *rqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
124/*
125 * RPC Requsts and replies are stored in one or more pages.
126 * We maintain an array of pages for each server thread.
127 * Requests are copied into these pages as they arrive. Remaining
128 * pages are available to write the reply into.
129 *
130 * Pages are sent using ->sendpage so each server thread needs to
131 * allocate more to replace those used in sending. To help keep track
132 * of these pages we have a receive list where all pages initialy live,
133 * and a send list where pages are moved to when there are to be part
134 * of a reply.
135 *
136 * We use xdr_buf for holding responses as it fits well with NFS
137 * read responses (that have a header, and some data pages, and possibly
138 * a tail) and means we can share some client side routines.
139 *
140 * The xdr_buf.head kvec always points to the first page in the rq_*pages
141 * list. The xdr_buf.pages pointer points to the second page on that
142 * list. xdr_buf.tail points to the end of the first page.
143 * This assumes that the non-page part of an rpc reply will fit
144 * in a page - NFSd ensures this. lockd also has no trouble.
145 *
146 * Each request/reply pair can have at most one "payload", plus two pages,
147 * one for the request, and one for the reply.
NeilBrown250f3912007-01-26 00:56:59 -0800148 * We using ->sendfile to return read data, we might need one extra page
149 * if the request is not page-aligned. So add another '1'.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 */
NeilBrown250f3912007-01-26 00:56:59 -0800151#define RPCSVC_MAXPAGES ((RPCSVC_MAXPAYLOAD+PAGE_SIZE-1)/PAGE_SIZE \
152 + 2 + 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
Alexey Dobriyan76994312006-09-26 22:28:46 -0700154static inline u32 svc_getnl(struct kvec *iov)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155{
Alexey Dobriyan76994312006-09-26 22:28:46 -0700156 __be32 val, *vp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 vp = iov->iov_base;
158 val = *vp++;
159 iov->iov_base = (void*)vp;
Alexey Dobriyan76994312006-09-26 22:28:46 -0700160 iov->iov_len -= sizeof(__be32);
161 return ntohl(val);
162}
163
164static inline void svc_putnl(struct kvec *iov, u32 val)
165{
166 __be32 *vp = iov->iov_base + iov->iov_len;
167 *vp = htonl(val);
168 iov->iov_len += sizeof(__be32);
169}
170
171static inline __be32 svc_getu32(struct kvec *iov)
172{
173 __be32 val, *vp;
174 vp = iov->iov_base;
175 val = *vp++;
176 iov->iov_base = (void*)vp;
177 iov->iov_len -= sizeof(__be32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 return val;
179}
180
181static inline void svc_ungetu32(struct kvec *iov)
182{
Alexey Dobriyan76994312006-09-26 22:28:46 -0700183 __be32 *vp = (__be32 *)iov->iov_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 iov->iov_base = (void *)(vp - 1);
185 iov->iov_len += sizeof(*vp);
186}
187
Alexey Dobriyan76994312006-09-26 22:28:46 -0700188static inline void svc_putu32(struct kvec *iov, __be32 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189{
Alexey Dobriyan76994312006-09-26 22:28:46 -0700190 __be32 *vp = iov->iov_base + iov->iov_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 *vp = val;
Alexey Dobriyan76994312006-09-26 22:28:46 -0700192 iov->iov_len += sizeof(__be32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193}
194
Chuck Lever73df0db2007-02-12 00:53:35 -0800195union svc_addr_u {
196 struct in_addr addr;
Chuck Lever73df0db2007-02-12 00:53:35 -0800197 struct in6_addr addr6;
Chuck Lever73df0db2007-02-12 00:53:35 -0800198};
199
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200/*
201 * The context of a single thread, including the request currently being
202 * processed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 */
204struct svc_rqst {
205 struct list_head rq_list; /* idle list */
Greg Banksa7455442006-10-02 02:17:59 -0700206 struct list_head rq_all; /* all threads list */
Tom Tucker57b1d3b2007-12-30 21:08:22 -0600207 struct svc_xprt * rq_xprt; /* transport ptr */
Chuck Lever27459f02007-02-12 00:53:34 -0800208 struct sockaddr_storage rq_addr; /* peer address */
209 size_t rq_addrlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
211 struct svc_serv * rq_server; /* RPC service definition */
Greg Banks3262c812006-10-02 02:17:58 -0700212 struct svc_pool * rq_pool; /* thread pool */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 struct svc_procedure * rq_procinfo; /* procedure info */
214 struct auth_ops * rq_authop; /* authentication flavour */
Andy Adamsonc4170582007-07-17 04:04:42 -0700215 u32 rq_flavor; /* pseudoflavor */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 struct svc_cred rq_cred; /* auth info */
Tom Tucker5148bf42007-12-30 21:07:25 -0600217 void * rq_xprt_ctxt; /* transport specific context ptr */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 struct svc_deferred_req*rq_deferred; /* deferred request we are replaying */
219
Tom Tucker260c1d12007-12-30 21:08:29 -0600220 size_t rq_xprt_hlen; /* xprt header len */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 struct xdr_buf rq_arg;
222 struct xdr_buf rq_res;
NeilBrown44524352006-10-04 02:15:46 -0700223 struct page * rq_pages[RPCSVC_MAXPAGES];
224 struct page * *rq_respages; /* points into rq_pages */
225 int rq_resused; /* number of pages used for result */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
NeilBrown3cc03b12006-10-04 02:15:47 -0700227 struct kvec rq_vec[RPCSVC_MAXPAGES]; /* generally useful.. */
228
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700229 __be32 rq_xid; /* transmission id */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 u32 rq_prog; /* program number */
231 u32 rq_vers; /* program version */
232 u32 rq_proc; /* procedure number */
233 u32 rq_prot; /* IP protocol */
234 unsigned short
235 rq_secure : 1; /* secure port */
236
Chuck Lever73df0db2007-02-12 00:53:35 -0800237 union svc_addr_u rq_daddr; /* dest addr of request
238 * - reply from here */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239
240 void * rq_argp; /* decoded arguments */
241 void * rq_resp; /* xdr'd results */
242 void * rq_auth_data; /* flavor-specific data */
243
244 int rq_reserved; /* space on socket outq
245 * reserved for this request
246 */
247
248 struct cache_req rq_chandle; /* handle passed to caches for
249 * request delaying
250 */
251 /* Catering to nfsd */
252 struct auth_domain * rq_client; /* RPC peer info */
J. Bruce Fields3ab4d8b2007-07-17 04:04:46 -0700253 struct auth_domain * rq_gssclient; /* "gss/"-style peer info */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 struct svc_cacherep * rq_cacherep; /* cache info */
255 struct knfsd_fh * rq_reffh; /* Referrence filehandle, used to
256 * determine what device number
257 * to report (real or virtual)
258 */
Jens Axboecf8208d2007-06-12 21:22:14 +0200259 int rq_splice_ok; /* turned off in gss privacy
J. Bruce Fields5c04c462006-06-30 01:56:19 -0700260 * to prevent encrypting page
261 * cache pages */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 wait_queue_head_t rq_wait; /* synchronization */
Greg Banksa7455442006-10-02 02:17:59 -0700263 struct task_struct *rq_task; /* service thread */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264};
265
266/*
Chuck Lever27459f02007-02-12 00:53:34 -0800267 * Rigorous type checking on sockaddr type conversions
268 */
269static inline struct sockaddr_in *svc_addr_in(struct svc_rqst *rqst)
270{
271 return (struct sockaddr_in *) &rqst->rq_addr;
272}
273
Chuck Lever95756482007-02-12 00:53:38 -0800274static inline struct sockaddr_in6 *svc_addr_in6(struct svc_rqst *rqst)
275{
276 return (struct sockaddr_in6 *) &rqst->rq_addr;
277}
278
Chuck Lever27459f02007-02-12 00:53:34 -0800279static inline struct sockaddr *svc_addr(struct svc_rqst *rqst)
280{
281 return (struct sockaddr *) &rqst->rq_addr;
282}
283
284/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 * Check buffer bounds after decoding arguments
286 */
287static inline int
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700288xdr_argsize_check(struct svc_rqst *rqstp, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289{
290 char *cp = (char *)p;
291 struct kvec *vec = &rqstp->rq_arg.head[0];
NeilBrown0ba75362005-11-07 01:00:26 -0800292 return cp >= (char*)vec->iov_base
293 && cp <= (char*)vec->iov_base + vec->iov_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294}
295
296static inline int
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700297xdr_ressize_check(struct svc_rqst *rqstp, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298{
299 struct kvec *vec = &rqstp->rq_res.head[0];
300 char *cp = (char*)p;
301
302 vec->iov_len = cp - (char*)vec->iov_base;
303
304 return vec->iov_len <= PAGE_SIZE;
305}
306
NeilBrown44524352006-10-04 02:15:46 -0700307static inline void svc_free_res_pages(struct svc_rqst *rqstp)
Andreas Gruenbachera257cdd2005-06-22 17:16:26 +0000308{
NeilBrown44524352006-10-04 02:15:46 -0700309 while (rqstp->rq_resused) {
310 struct page **pp = (rqstp->rq_respages +
311 --rqstp->rq_resused);
312 if (*pp) {
313 put_page(*pp);
314 *pp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 }
316 }
317}
318
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319struct svc_deferred_req {
320 u32 prot; /* protocol (UDP or TCP) */
Tom Tucker8c7b0172007-12-30 21:08:10 -0600321 struct svc_xprt *xprt;
Chuck Lever24422222007-02-12 00:53:33 -0800322 struct sockaddr_storage addr; /* where reply must go */
323 size_t addrlen;
Chuck Lever73df0db2007-02-12 00:53:35 -0800324 union svc_addr_u daddr; /* where reply must come from */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 struct cache_deferred_req handle;
Tom Tucker260c1d12007-12-30 21:08:29 -0600326 size_t xprt_hlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 int argslen;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700328 __be32 args[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329};
330
331/*
Andreas Gruenbacher9ba02632005-06-22 17:16:24 +0000332 * List of RPC programs on the same transport endpoint
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 */
334struct svc_program {
Andreas Gruenbacher9ba02632005-06-22 17:16:24 +0000335 struct svc_program * pg_next; /* other programs (same xprt) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 u32 pg_prog; /* program number */
337 unsigned int pg_lovers; /* lowest version */
338 unsigned int pg_hivers; /* lowest version */
339 unsigned int pg_nvers; /* number of versions */
340 struct svc_version ** pg_vers; /* version array */
341 char * pg_name; /* service name */
342 char * pg_class; /* class name: services sharing authentication */
343 struct svc_stat * pg_stats; /* rpc statistics */
344 int (*pg_authenticate)(struct svc_rqst *);
345};
346
347/*
348 * RPC program version
349 */
350struct svc_version {
351 u32 vs_vers; /* version number */
352 u32 vs_nproc; /* number of procedures */
353 struct svc_procedure * vs_proc; /* per-procedure info */
354 u32 vs_xdrsize; /* xdrsize needed for this version */
355
Olaf Kirchbc5fea42006-10-04 02:16:05 -0700356 unsigned int vs_hidden : 1; /* Don't register with portmapper.
357 * Only used for nfsacl so far. */
358
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 /* Override dispatch function (e.g. when caching replies).
360 * A return value of 0 means drop the request.
361 * vs_dispatch == NULL means use default dispatcher.
362 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700363 int (*vs_dispatch)(struct svc_rqst *, __be32 *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364};
365
366/*
367 * RPC procedure info
368 */
Al Viro7111c662006-10-19 23:28:45 -0700369typedef __be32 (*svc_procfunc)(struct svc_rqst *, void *argp, void *resp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370struct svc_procedure {
371 svc_procfunc pc_func; /* process the request */
372 kxdrproc_t pc_decode; /* XDR decode args */
373 kxdrproc_t pc_encode; /* XDR encode result */
374 kxdrproc_t pc_release; /* XDR free result */
375 unsigned int pc_argsize; /* argument struct size */
376 unsigned int pc_ressize; /* result struct size */
377 unsigned int pc_count; /* call count */
378 unsigned int pc_cachetype; /* cache info (NFS) */
379 unsigned int pc_xdrressize; /* maximum size of XDR reply */
380};
381
382/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 * Function prototypes.
384 */
NeilBrownbc591cc2006-10-02 02:17:44 -0700385struct svc_serv * svc_create(struct svc_program *, unsigned int,
386 void (*shutdown)(struct svc_serv*));
Jeff Layton0113ab32008-01-29 10:30:54 -0500387struct svc_rqst *svc_prepare_thread(struct svc_serv *serv,
388 struct svc_pool *pool);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389int svc_create_thread(svc_thread_fn, struct svc_serv *);
390void svc_exit_thread(struct svc_rqst *);
Greg Banksa7455442006-10-02 02:17:59 -0700391struct svc_serv * svc_create_pooled(struct svc_program *, unsigned int,
392 void (*shutdown)(struct svc_serv*),
393 svc_thread_fn, int sig, struct module *);
394int svc_set_num_threads(struct svc_serv *, struct svc_pool *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395void svc_destroy(struct svc_serv *);
NeilBrown6fb2b472006-10-02 02:17:50 -0700396int svc_process(struct svc_rqst *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397int svc_register(struct svc_serv *, int, unsigned short);
398void svc_wake_up(struct svc_serv *);
399void svc_reserve(struct svc_rqst *rqstp, int space);
Greg Banksbfd24162006-10-02 02:18:01 -0700400struct svc_pool * svc_pool_for_cpu(struct svc_serv *serv, int cpu);
Chuck Leverad06e4b2007-02-12 00:53:32 -0800401char * svc_print_addr(struct svc_rqst *, char *, size_t);
402
403#define RPC_MAX_ADDRBUFLEN (63U)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
Jeff Laytoncd123012007-05-09 02:34:50 -0700405/*
406 * When we want to reduce the size of the reserved space in the response
407 * buffer, we need to take into account the size of any checksum data that
408 * may be at the end of the packet. This is difficult to determine exactly
409 * for all cases without actually generating the checksum, so we just use a
410 * static value.
411 */
J. Bruce Fieldsfbb78782008-02-07 23:10:21 -0500412static inline void svc_reserve_auth(struct svc_rqst *rqstp, int space)
Jeff Laytoncd123012007-05-09 02:34:50 -0700413{
J. Bruce Fieldsfbb78782008-02-07 23:10:21 -0500414 int added_space = 0;
Jeff Laytoncd123012007-05-09 02:34:50 -0700415
J. Bruce Fieldsfbb78782008-02-07 23:10:21 -0500416 if (rqstp->rq_authop->flavour)
417 added_space = RPC_MAX_AUTH_SIZE;
418 svc_reserve(rqstp, space + added_space);
Jeff Laytoncd123012007-05-09 02:34:50 -0700419}
420
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421#endif /* SUNRPC_SVC_H */