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