Commit | Line | Data |
---|---|---|
b2441318 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
1da177e4 LT |
2 | /* |
3 | * linux/include/linux/sunrpc/svc.h | |
4 | * | |
5 | * RPC server declarations. | |
6 | * | |
7 | * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de> | |
8 | */ | |
9 | ||
10 | ||
11 | #ifndef SUNRPC_SVC_H | |
12 | #define SUNRPC_SVC_H | |
13 | ||
14 | #include <linux/in.h> | |
73df0dba | 15 | #include <linux/in6.h> |
1da177e4 LT |
16 | #include <linux/sunrpc/types.h> |
17 | #include <linux/sunrpc/xdr.h> | |
7adae489 | 18 | #include <linux/sunrpc/auth.h> |
1da177e4 LT |
19 | #include <linux/sunrpc/svcauth.h> |
20 | #include <linux/wait.h> | |
21 | #include <linux/mm.h> | |
22 | ||
03cf6c9f GB |
23 | /* statistics for svc_pool structures */ |
24 | struct svc_pool_stats { | |
403c7b44 | 25 | atomic_long_t packets; |
03cf6c9f | 26 | unsigned long sockets_queued; |
403c7b44 JL |
27 | atomic_long_t threads_woken; |
28 | atomic_long_t threads_timedout; | |
03cf6c9f GB |
29 | }; |
30 | ||
3262c816 GB |
31 | /* |
32 | * | |
33 | * RPC service thread pool. | |
34 | * | |
35 | * Pool of threads and temporary sockets. Generally there is only | |
36 | * a single one of these per RPC service, but on NUMA machines those | |
37 | * services that can benefit from it (i.e. nfs but not lockd) will | |
38 | * have one pool per NUMA node. This optimisation reduces cross- | |
39 | * node traffic on multi-node NUMA NFS servers. | |
40 | */ | |
41 | struct svc_pool { | |
42 | unsigned int sp_id; /* pool id; also node id on NUMA */ | |
43 | spinlock_t sp_lock; /* protects all fields */ | |
3262c816 GB |
44 | struct list_head sp_sockets; /* pending sockets */ |
45 | unsigned int sp_nrthreads; /* # of threads in pool */ | |
a7455442 | 46 | struct list_head sp_all_threads; /* all server threads */ |
03cf6c9f | 47 | struct svc_pool_stats sp_stats; /* statistics on pool operation */ |
4d5db3f5 JL |
48 | #define SP_TASK_PENDING (0) /* still work to do even if no |
49 | * xprt is queued. */ | |
22700f3c | 50 | #define SP_CONGESTED (1) |
4d5db3f5 | 51 | unsigned long sp_flags; |
3262c816 GB |
52 | } ____cacheline_aligned_in_smp; |
53 | ||
ea126e74 JL |
54 | struct svc_serv; |
55 | ||
56 | struct svc_serv_ops { | |
57 | /* Callback to use when last thread exits. */ | |
c369014f | 58 | void (*svo_shutdown)(struct svc_serv *, struct net *); |
758f62ff JL |
59 | |
60 | /* function for service threads to run */ | |
c369014f | 61 | int (*svo_function)(void *); |
758f62ff | 62 | |
b9e13cdf JL |
63 | /* queue up a transport for servicing */ |
64 | void (*svo_enqueue_xprt)(struct svc_xprt *); | |
65 | ||
598e2359 JL |
66 | /* set up thread (or whatever) execution context */ |
67 | int (*svo_setup)(struct svc_serv *, struct svc_pool *, int); | |
68 | ||
758f62ff JL |
69 | /* optional module to count when adding threads (pooled svcs only) */ |
70 | struct module *svo_module; | |
ea126e74 JL |
71 | }; |
72 | ||
1da177e4 LT |
73 | /* |
74 | * RPC service. | |
75 | * | |
76 | * An RPC service is a ``daemon,'' possibly multithreaded, which | |
77 | * receives and processes incoming RPC messages. | |
78 | * It has one or more transport sockets associated with it, and maintains | |
79 | * a list of idle threads waiting for input. | |
80 | * | |
81 | * We currently do not support more than one RPC program per daemon. | |
82 | */ | |
83 | struct svc_serv { | |
1da177e4 LT |
84 | struct svc_program * sv_program; /* RPC program */ |
85 | struct svc_stat * sv_stats; /* RPC statistics */ | |
86 | spinlock_t sv_lock; | |
87 | unsigned int sv_nrthreads; /* # of server threads */ | |
c9233eb7 JL |
88 | unsigned int sv_maxconn; /* max connections allowed or |
89 | * '0' causing max to be based | |
90 | * on number of threads. */ | |
91 | ||
c6b0a9f8 N |
92 | unsigned int sv_max_payload; /* datagram payload size */ |
93 | unsigned int sv_max_mesg; /* max_payload + 1 page for overheads */ | |
1da177e4 | 94 | unsigned int sv_xdrsize; /* XDR buffer size */ |
1da177e4 LT |
95 | struct list_head sv_permsocks; /* all permanent sockets */ |
96 | struct list_head sv_tempsocks; /* all temporary sockets */ | |
97 | int sv_tmpcnt; /* count of temporary sockets */ | |
36bdfc8b | 98 | struct timer_list sv_temptimer; /* timer for aging temporary sockets */ |
1da177e4 LT |
99 | |
100 | char * sv_name; /* service name */ | |
bc591ccf | 101 | |
3262c816 GB |
102 | unsigned int sv_nrpools; /* number of thread pools */ |
103 | struct svc_pool * sv_pools; /* array of thread pools */ | |
afea5657 | 104 | const struct svc_serv_ops *sv_ops; /* server operations */ |
9e00abc3 | 105 | #if defined(CONFIG_SUNRPC_BACKCHANNEL) |
56632b5b RL |
106 | struct list_head sv_cb_list; /* queue for callback requests |
107 | * that arrive over the same | |
108 | * connection */ | |
109 | spinlock_t sv_cb_lock; /* protects the svc_cb_list */ | |
110 | wait_queue_head_t sv_cb_waitq; /* sleep here if there are no | |
111 | * entries in the svc_cb_list */ | |
a289ce53 | 112 | bool sv_bc_enabled; /* service uses backchannel */ |
9e00abc3 | 113 | #endif /* CONFIG_SUNRPC_BACKCHANNEL */ |
1da177e4 LT |
114 | }; |
115 | ||
9a24ab57 GB |
116 | /* |
117 | * We use sv_nrthreads as a reference count. svc_destroy() drops | |
118 | * this refcount, so we need to bump it up around operations that | |
119 | * change the number of threads. Horrible, but there it is. | |
3c519914 | 120 | * Should be called with the "service mutex" held. |
9a24ab57 GB |
121 | */ |
122 | static inline void svc_get(struct svc_serv *serv) | |
123 | { | |
124 | serv->sv_nrthreads++; | |
125 | } | |
126 | ||
1da177e4 LT |
127 | /* |
128 | * Maximum payload size supported by a kernel RPC server. | |
129 | * This is use to determine the max number of pages nfsd is | |
130 | * willing to return in a single READ operation. | |
7adae489 GB |
131 | * |
132 | * These happen to all be powers of 2, which is not strictly | |
133 | * necessary but helps enforce the real limitation, which is | |
ea1754a0 | 134 | * that they should be multiples of PAGE_SIZE. |
7adae489 GB |
135 | * |
136 | * For UDP transports, a block plus NFS,RPC, and UDP headers | |
137 | * has to fit into the IP datagram limit of 64K. The largest | |
138 | * feasible number for all known page sizes is probably 48K, | |
139 | * but we choose 32K here. This is the same as the historical | |
140 | * Linux limit; someone who cares more about NFS/UDP performance | |
141 | * can test a larger number. | |
142 | * | |
143 | * For TCP transports we have more freedom. A size of 1MB is | |
144 | * chosen to match the client limit. Other OSes are known to | |
145 | * have larger limits, but those numbers are probably beyond | |
146 | * the point of diminishing returns. | |
1da177e4 | 147 | */ |
7adae489 GB |
148 | #define RPCSVC_MAXPAYLOAD (1*1024*1024u) |
149 | #define RPCSVC_MAXPAYLOAD_TCP RPCSVC_MAXPAYLOAD | |
150 | #define RPCSVC_MAXPAYLOAD_UDP (32*1024u) | |
151 | ||
152 | extern u32 svc_max_payload(const struct svc_rqst *rqstp); | |
1da177e4 LT |
153 | |
154 | /* | |
155 | * RPC Requsts and replies are stored in one or more pages. | |
156 | * We maintain an array of pages for each server thread. | |
157 | * Requests are copied into these pages as they arrive. Remaining | |
158 | * pages are available to write the reply into. | |
159 | * | |
160 | * Pages are sent using ->sendpage so each server thread needs to | |
161 | * allocate more to replace those used in sending. To help keep track | |
162 | * of these pages we have a receive list where all pages initialy live, | |
163 | * and a send list where pages are moved to when there are to be part | |
164 | * of a reply. | |
165 | * | |
166 | * We use xdr_buf for holding responses as it fits well with NFS | |
167 | * read responses (that have a header, and some data pages, and possibly | |
168 | * a tail) and means we can share some client side routines. | |
169 | * | |
170 | * The xdr_buf.head kvec always points to the first page in the rq_*pages | |
171 | * list. The xdr_buf.pages pointer points to the second page on that | |
172 | * list. xdr_buf.tail points to the end of the first page. | |
173 | * This assumes that the non-page part of an rpc reply will fit | |
174 | * in a page - NFSd ensures this. lockd also has no trouble. | |
175 | * | |
176 | * Each request/reply pair can have at most one "payload", plus two pages, | |
177 | * one for the request, and one for the reply. | |
250f3915 N |
178 | * We using ->sendfile to return read data, we might need one extra page |
179 | * if the request is not page-aligned. So add another '1'. | |
1da177e4 | 180 | */ |
250f3915 N |
181 | #define RPCSVC_MAXPAGES ((RPCSVC_MAXPAYLOAD+PAGE_SIZE-1)/PAGE_SIZE \ |
182 | + 2 + 1) | |
1da177e4 | 183 | |
76994313 | 184 | static inline u32 svc_getnl(struct kvec *iov) |
1da177e4 | 185 | { |
76994313 | 186 | __be32 val, *vp; |
1da177e4 LT |
187 | vp = iov->iov_base; |
188 | val = *vp++; | |
189 | iov->iov_base = (void*)vp; | |
76994313 AD |
190 | iov->iov_len -= sizeof(__be32); |
191 | return ntohl(val); | |
192 | } | |
193 | ||
194 | static inline void svc_putnl(struct kvec *iov, u32 val) | |
195 | { | |
196 | __be32 *vp = iov->iov_base + iov->iov_len; | |
197 | *vp = htonl(val); | |
198 | iov->iov_len += sizeof(__be32); | |
199 | } | |
200 | ||
201 | static inline __be32 svc_getu32(struct kvec *iov) | |
202 | { | |
203 | __be32 val, *vp; | |
204 | vp = iov->iov_base; | |
205 | val = *vp++; | |
206 | iov->iov_base = (void*)vp; | |
207 | iov->iov_len -= sizeof(__be32); | |
1da177e4 LT |
208 | return val; |
209 | } | |
210 | ||
211 | static inline void svc_ungetu32(struct kvec *iov) | |
212 | { | |
76994313 | 213 | __be32 *vp = (__be32 *)iov->iov_base; |
1da177e4 LT |
214 | iov->iov_base = (void *)(vp - 1); |
215 | iov->iov_len += sizeof(*vp); | |
216 | } | |
217 | ||
76994313 | 218 | static inline void svc_putu32(struct kvec *iov, __be32 val) |
1da177e4 | 219 | { |
76994313 | 220 | __be32 *vp = iov->iov_base + iov->iov_len; |
1da177e4 | 221 | *vp = val; |
76994313 | 222 | iov->iov_len += sizeof(__be32); |
1da177e4 LT |
223 | } |
224 | ||
1da177e4 LT |
225 | /* |
226 | * The context of a single thread, including the request currently being | |
227 | * processed. | |
1da177e4 LT |
228 | */ |
229 | struct svc_rqst { | |
a7455442 | 230 | struct list_head rq_all; /* all threads list */ |
81244386 | 231 | struct rcu_head rq_rcu_head; /* for RCU deferred kfree */ |
57b1d3ba | 232 | struct svc_xprt * rq_xprt; /* transport ptr */ |
849a1cf1 | 233 | |
27459f09 CL |
234 | struct sockaddr_storage rq_addr; /* peer address */ |
235 | size_t rq_addrlen; | |
849a1cf1 MJ |
236 | struct sockaddr_storage rq_daddr; /* dest addr of request |
237 | * - reply from here */ | |
238 | size_t rq_daddrlen; | |
1da177e4 LT |
239 | |
240 | struct svc_serv * rq_server; /* RPC service definition */ | |
3262c816 | 241 | struct svc_pool * rq_pool; /* thread pool */ |
860bda29 | 242 | const struct svc_procedure *rq_procinfo;/* procedure info */ |
1da177e4 LT |
243 | struct auth_ops * rq_authop; /* authentication flavour */ |
244 | struct svc_cred rq_cred; /* auth info */ | |
5148bf4e | 245 | void * rq_xprt_ctxt; /* transport specific context ptr */ |
1da177e4 LT |
246 | struct svc_deferred_req*rq_deferred; /* deferred request we are replaying */ |
247 | ||
260c1d12 | 248 | size_t rq_xprt_hlen; /* xprt header len */ |
1da177e4 | 249 | struct xdr_buf rq_arg; |
5191955d CL |
250 | struct xdr_stream rq_arg_stream; |
251 | struct page *rq_scratch_page; | |
1da177e4 | 252 | struct xdr_buf rq_res; |
8c6ae498 | 253 | struct page *rq_pages[RPCSVC_MAXPAGES + 1]; |
44524359 | 254 | struct page * *rq_respages; /* points into rq_pages */ |
afc59400 | 255 | struct page * *rq_next_page; /* next reply page to use */ |
2825a7f9 | 256 | struct page * *rq_page_end; /* one past the last page */ |
1da177e4 | 257 | |
3cc03b16 | 258 | struct kvec rq_vec[RPCSVC_MAXPAGES]; /* generally useful.. */ |
ca07eda3 | 259 | struct bio_vec rq_bvec[RPCSVC_MAXPAGES]; |
3cc03b16 | 260 | |
d8ed029d | 261 | __be32 rq_xid; /* transmission id */ |
1da177e4 LT |
262 | u32 rq_prog; /* program number */ |
263 | u32 rq_vers; /* program version */ | |
264 | u32 rq_proc; /* procedure number */ | |
265 | u32 rq_prot; /* IP protocol */ | |
62978b3c | 266 | int rq_cachetype; /* catering to nfsd */ |
4d152e2c | 267 | #define RQ_SECURE (0) /* secure port */ |
7501cc2b | 268 | #define RQ_LOCAL (1) /* local request */ |
30660e04 | 269 | #define RQ_USEDEFERRAL (2) /* use deferral */ |
78b65eb3 | 270 | #define RQ_DROPME (3) /* drop current reply */ |
779fb0f3 JL |
271 | #define RQ_SPLICE_OK (4) /* turned off in gss privacy |
272 | * to prevent encrypting page | |
273 | * cache pages */ | |
81244386 | 274 | #define RQ_VICTIM (5) /* about to be shut down */ |
b1691bc0 | 275 | #define RQ_BUSY (6) /* request is busy */ |
ff3ac5c3 | 276 | #define RQ_DATA (7) /* request has data */ |
83dd59a0 | 277 | #define RQ_AUTHERR (8) /* Request status is auth error */ |
4d152e2c | 278 | unsigned long rq_flags; /* flags field */ |
55f5088c | 279 | ktime_t rq_qtime; /* enqueue time */ |
1da177e4 | 280 | |
1da177e4 LT |
281 | void * rq_argp; /* decoded arguments */ |
282 | void * rq_resp; /* xdr'd results */ | |
283 | void * rq_auth_data; /* flavor-specific data */ | |
a5cddc88 BF |
284 | int rq_auth_slack; /* extra space xdr code |
285 | * should leave in head | |
286 | * for krb5i, krb5p. | |
287 | */ | |
1da177e4 LT |
288 | int rq_reserved; /* space on socket outq |
289 | * reserved for this request | |
290 | */ | |
aaba72cd | 291 | ktime_t rq_stime; /* start time */ |
1da177e4 LT |
292 | |
293 | struct cache_req rq_chandle; /* handle passed to caches for | |
294 | * request delaying | |
295 | */ | |
296 | /* Catering to nfsd */ | |
297 | struct auth_domain * rq_client; /* RPC peer info */ | |
3ab4d8b1 | 298 | struct auth_domain * rq_gssclient; /* "gss/"-style peer info */ |
1da177e4 | 299 | struct svc_cacherep * rq_cacherep; /* cache info */ |
a7455442 | 300 | struct task_struct *rq_task; /* service thread */ |
b1691bc0 | 301 | spinlock_t rq_lock; /* per-request lock */ |
d4b09acf VA |
302 | struct net *rq_bc_net; /* pointer to backchannel's |
303 | * net namespace | |
304 | */ | |
28df3d15 | 305 | void ** rq_lease_breaker; /* The v4 client breaking a lease */ |
1da177e4 LT |
306 | }; |
307 | ||
d4b09acf | 308 | #define SVC_NET(rqst) (rqst->rq_xprt ? rqst->rq_xprt->xpt_net : rqst->rq_bc_net) |
9695c705 | 309 | |
27459f09 CL |
310 | /* |
311 | * Rigorous type checking on sockaddr type conversions | |
312 | */ | |
5344b12d | 313 | static inline struct sockaddr_in *svc_addr_in(const struct svc_rqst *rqst) |
27459f09 CL |
314 | { |
315 | return (struct sockaddr_in *) &rqst->rq_addr; | |
316 | } | |
317 | ||
5344b12d | 318 | static inline struct sockaddr_in6 *svc_addr_in6(const struct svc_rqst *rqst) |
95756482 CL |
319 | { |
320 | return (struct sockaddr_in6 *) &rqst->rq_addr; | |
321 | } | |
322 | ||
5344b12d | 323 | static inline struct sockaddr *svc_addr(const struct svc_rqst *rqst) |
27459f09 CL |
324 | { |
325 | return (struct sockaddr *) &rqst->rq_addr; | |
326 | } | |
327 | ||
849a1cf1 MJ |
328 | static inline struct sockaddr_in *svc_daddr_in(const struct svc_rqst *rqst) |
329 | { | |
330 | return (struct sockaddr_in *) &rqst->rq_daddr; | |
331 | } | |
332 | ||
333 | static inline struct sockaddr_in6 *svc_daddr_in6(const struct svc_rqst *rqst) | |
334 | { | |
335 | return (struct sockaddr_in6 *) &rqst->rq_daddr; | |
336 | } | |
337 | ||
338 | static inline struct sockaddr *svc_daddr(const struct svc_rqst *rqst) | |
339 | { | |
340 | return (struct sockaddr *) &rqst->rq_daddr; | |
341 | } | |
342 | ||
1da177e4 LT |
343 | /* |
344 | * Check buffer bounds after decoding arguments | |
345 | */ | |
346 | static inline int | |
d8ed029d | 347 | xdr_argsize_check(struct svc_rqst *rqstp, __be32 *p) |
1da177e4 LT |
348 | { |
349 | char *cp = (char *)p; | |
350 | struct kvec *vec = &rqstp->rq_arg.head[0]; | |
9512a16b BF |
351 | return cp >= (char*)vec->iov_base |
352 | && cp <= (char*)vec->iov_base + vec->iov_len; | |
1da177e4 LT |
353 | } |
354 | ||
355 | static inline int | |
d8ed029d | 356 | xdr_ressize_check(struct svc_rqst *rqstp, __be32 *p) |
1da177e4 LT |
357 | { |
358 | struct kvec *vec = &rqstp->rq_res.head[0]; | |
359 | char *cp = (char*)p; | |
360 | ||
361 | vec->iov_len = cp - (char*)vec->iov_base; | |
362 | ||
363 | return vec->iov_len <= PAGE_SIZE; | |
364 | } | |
365 | ||
44524359 | 366 | static inline void svc_free_res_pages(struct svc_rqst *rqstp) |
a257cdd0 | 367 | { |
afc59400 BF |
368 | while (rqstp->rq_next_page != rqstp->rq_respages) { |
369 | struct page **pp = --rqstp->rq_next_page; | |
44524359 N |
370 | if (*pp) { |
371 | put_page(*pp); | |
372 | *pp = NULL; | |
1da177e4 LT |
373 | } |
374 | } | |
375 | } | |
376 | ||
1da177e4 LT |
377 | struct svc_deferred_req { |
378 | u32 prot; /* protocol (UDP or TCP) */ | |
8c7b0172 | 379 | struct svc_xprt *xprt; |
24422222 CL |
380 | struct sockaddr_storage addr; /* where reply must go */ |
381 | size_t addrlen; | |
849a1cf1 MJ |
382 | struct sockaddr_storage daddr; /* where reply must come from */ |
383 | size_t daddrlen; | |
1da177e4 | 384 | struct cache_deferred_req handle; |
260c1d12 | 385 | size_t xprt_hlen; |
1da177e4 | 386 | int argslen; |
469aef23 | 387 | __be32 args[]; |
1da177e4 LT |
388 | }; |
389 | ||
8e5b6773 TM |
390 | struct svc_process_info { |
391 | union { | |
392 | int (*dispatch)(struct svc_rqst *, __be32 *); | |
393 | struct { | |
394 | unsigned int lovers; | |
395 | unsigned int hivers; | |
396 | } mismatch; | |
397 | }; | |
398 | }; | |
399 | ||
1da177e4 | 400 | /* |
9ba02638 | 401 | * List of RPC programs on the same transport endpoint |
1da177e4 LT |
402 | */ |
403 | struct svc_program { | |
9ba02638 | 404 | struct svc_program * pg_next; /* other programs (same xprt) */ |
1da177e4 LT |
405 | u32 pg_prog; /* program number */ |
406 | unsigned int pg_lovers; /* lowest version */ | |
28303ca3 | 407 | unsigned int pg_hivers; /* highest version */ |
1da177e4 | 408 | unsigned int pg_nvers; /* number of versions */ |
e9679189 | 409 | const struct svc_version **pg_vers; /* version array */ |
1da177e4 LT |
410 | char * pg_name; /* service name */ |
411 | char * pg_class; /* class name: services sharing authentication */ | |
412 | struct svc_stat * pg_stats; /* rpc statistics */ | |
413 | int (*pg_authenticate)(struct svc_rqst *); | |
8e5b6773 TM |
414 | __be32 (*pg_init_request)(struct svc_rqst *, |
415 | const struct svc_program *, | |
416 | struct svc_process_info *); | |
642ee6b2 TM |
417 | int (*pg_rpcbind_set)(struct net *net, |
418 | const struct svc_program *, | |
419 | u32 version, int family, | |
420 | unsigned short proto, | |
421 | unsigned short port); | |
1da177e4 LT |
422 | }; |
423 | ||
424 | /* | |
425 | * RPC program version | |
426 | */ | |
427 | struct svc_version { | |
428 | u32 vs_vers; /* version number */ | |
429 | u32 vs_nproc; /* number of procedures */ | |
860bda29 | 430 | const struct svc_procedure *vs_proc; /* per-procedure info */ |
7fd38af9 | 431 | unsigned int *vs_count; /* call counts */ |
1da177e4 LT |
432 | u32 vs_xdrsize; /* xdrsize needed for this version */ |
433 | ||
05a45a2d JL |
434 | /* Don't register with rpcbind */ |
435 | bool vs_hidden; | |
436 | ||
437 | /* Don't care if the rpcbind registration fails */ | |
438 | bool vs_rpcb_optnl; | |
bc5fea42 | 439 | |
5283b03e JL |
440 | /* Need xprt with congestion control */ |
441 | bool vs_need_cong_ctrl; | |
442 | ||
1da177e4 LT |
443 | /* Override dispatch function (e.g. when caching replies). |
444 | * A return value of 0 means drop the request. | |
445 | * vs_dispatch == NULL means use default dispatcher. | |
446 | */ | |
d8ed029d | 447 | int (*vs_dispatch)(struct svc_rqst *, __be32 *); |
1da177e4 LT |
448 | }; |
449 | ||
450 | /* | |
451 | * RPC procedure info | |
452 | */ | |
1da177e4 | 453 | struct svc_procedure { |
a6beb732 CH |
454 | /* process the request: */ |
455 | __be32 (*pc_func)(struct svc_rqst *); | |
026fec7e CH |
456 | /* XDR decode args: */ |
457 | int (*pc_decode)(struct svc_rqst *, __be32 *data); | |
63f8de37 CH |
458 | /* XDR encode result: */ |
459 | int (*pc_encode)(struct svc_rqst *, __be32 *data); | |
8537488b CH |
460 | /* XDR free result: */ |
461 | void (*pc_release)(struct svc_rqst *); | |
1da177e4 LT |
462 | unsigned int pc_argsize; /* argument struct size */ |
463 | unsigned int pc_ressize; /* result struct size */ | |
1da177e4 LT |
464 | unsigned int pc_cachetype; /* cache info (NFS) */ |
465 | unsigned int pc_xdrressize; /* maximum size of XDR reply */ | |
466 | }; | |
467 | ||
d70bc0c6 JL |
468 | /* |
469 | * Mode for mapping cpus to pools. | |
470 | */ | |
471 | enum { | |
472 | SVC_POOL_AUTO = -1, /* choose one of the others */ | |
473 | SVC_POOL_GLOBAL, /* no mapping, just a single global pool | |
474 | * (legacy & UP mode) */ | |
475 | SVC_POOL_PERCPU, /* one pool per cpu */ | |
476 | SVC_POOL_PERNODE /* one pool per numa node */ | |
477 | }; | |
478 | ||
479 | struct svc_pool_map { | |
480 | int count; /* How many svc_servs use us */ | |
481 | int mode; /* Note: int not enum to avoid | |
482 | * warnings about "enumeration value | |
483 | * not handled in switch" */ | |
484 | unsigned int npools; | |
485 | unsigned int *pool_to; /* maps pool id to cpu or node */ | |
486 | unsigned int *to_pool; /* maps cpu or node to pool id */ | |
487 | }; | |
488 | ||
489 | extern struct svc_pool_map svc_pool_map; | |
490 | ||
1da177e4 LT |
491 | /* |
492 | * Function prototypes. | |
493 | */ | |
bb2224df | 494 | int svc_rpcb_setup(struct svc_serv *serv, struct net *net); |
5ecebb7c | 495 | void svc_rpcb_cleanup(struct svc_serv *serv, struct net *net); |
9793f7c8 | 496 | int svc_bind(struct svc_serv *serv, struct net *net); |
49a9072f | 497 | struct svc_serv *svc_create(struct svc_program *, unsigned int, |
afea5657 | 498 | const struct svc_serv_ops *); |
1b6dc1df JL |
499 | struct svc_rqst *svc_rqst_alloc(struct svc_serv *serv, |
500 | struct svc_pool *pool, int node); | |
0113ab34 | 501 | struct svc_rqst *svc_prepare_thread(struct svc_serv *serv, |
11fd165c | 502 | struct svc_pool *pool, int node); |
1b6dc1df | 503 | void svc_rqst_free(struct svc_rqst *); |
1da177e4 | 504 | void svc_exit_thread(struct svc_rqst *); |
d70bc0c6 JL |
505 | unsigned int svc_pool_map_get(void); |
506 | void svc_pool_map_put(void); | |
a7455442 | 507 | struct svc_serv * svc_create_pooled(struct svc_program *, unsigned int, |
afea5657 | 508 | const struct svc_serv_ops *); |
a7455442 | 509 | int svc_set_num_threads(struct svc_serv *, struct svc_pool *, int); |
ed6473dd | 510 | int svc_set_num_threads_sync(struct svc_serv *, struct svc_pool *, int); |
03cf6c9f | 511 | int svc_pool_stats_open(struct svc_serv *serv, struct file *file); |
1da177e4 | 512 | void svc_destroy(struct svc_serv *); |
bb2224df | 513 | void svc_shutdown_net(struct svc_serv *, struct net *); |
6fb2b47f | 514 | int svc_process(struct svc_rqst *); |
4d6bbb62 RL |
515 | int bc_svc_process(struct svc_serv *, struct rpc_rqst *, |
516 | struct svc_rqst *); | |
5247fab5 | 517 | int svc_register(const struct svc_serv *, struct net *, const int, |
4b62e58c | 518 | const unsigned short, const unsigned short); |
a26cfad6 | 519 | |
1da177e4 LT |
520 | void svc_wake_up(struct svc_serv *); |
521 | void svc_reserve(struct svc_rqst *rqstp, int space); | |
bfd24160 | 522 | struct svc_pool * svc_pool_for_cpu(struct svc_serv *serv, int cpu); |
ad06e4bd | 523 | char * svc_print_addr(struct svc_rqst *, char *, size_t); |
03493bca CL |
524 | int svc_encode_result_payload(struct svc_rqst *rqstp, |
525 | unsigned int offset, | |
526 | unsigned int length); | |
8154ef27 | 527 | unsigned int svc_fill_write_vector(struct svc_rqst *rqstp, |
3fd9557a | 528 | struct page **pages, |
8154ef27 | 529 | struct kvec *first, size_t total); |
38a70315 | 530 | char *svc_fill_symlink_pathname(struct svc_rqst *rqstp, |
11b4d66e CL |
531 | struct kvec *first, void *p, |
532 | size_t total); | |
83dd59a0 | 533 | __be32 svc_return_autherr(struct svc_rqst *rqstp, __be32 auth_err); |
8e5b6773 TM |
534 | __be32 svc_generic_init_request(struct svc_rqst *rqstp, |
535 | const struct svc_program *progp, | |
536 | struct svc_process_info *procinfo); | |
642ee6b2 TM |
537 | int svc_generic_rpcbind_set(struct net *net, |
538 | const struct svc_program *progp, | |
539 | u32 version, int family, | |
540 | unsigned short proto, | |
541 | unsigned short port); | |
542 | int svc_rpcbind_set_version(struct net *net, | |
543 | const struct svc_program *progp, | |
544 | u32 version, int family, | |
545 | unsigned short proto, | |
546 | unsigned short port); | |
ad06e4bd CL |
547 | |
548 | #define RPC_MAX_ADDRBUFLEN (63U) | |
1da177e4 | 549 | |
cd123012 JL |
550 | /* |
551 | * When we want to reduce the size of the reserved space in the response | |
552 | * buffer, we need to take into account the size of any checksum data that | |
553 | * may be at the end of the packet. This is difficult to determine exactly | |
554 | * for all cases without actually generating the checksum, so we just use a | |
555 | * static value. | |
556 | */ | |
fbb7878c | 557 | static inline void svc_reserve_auth(struct svc_rqst *rqstp, int space) |
cd123012 | 558 | { |
a5cddc88 | 559 | svc_reserve(rqstp, space + rqstp->rq_auth_slack); |
cd123012 JL |
560 | } |
561 | ||
5191955d CL |
562 | /** |
563 | * svcxdr_init_decode - Prepare an xdr_stream for svc Call decoding | |
564 | * @rqstp: controlling server RPC transaction context | |
565 | * | |
566 | */ | |
567 | static inline void svcxdr_init_decode(struct svc_rqst *rqstp) | |
568 | { | |
569 | struct xdr_stream *xdr = &rqstp->rq_arg_stream; | |
570 | struct kvec *argv = rqstp->rq_arg.head; | |
571 | ||
572 | xdr_init_decode(xdr, &rqstp->rq_arg, argv->iov_base, NULL); | |
573 | xdr_set_scratch_page(xdr, rqstp->rq_scratch_page); | |
574 | } | |
575 | ||
1da177e4 | 576 | #endif /* SUNRPC_SVC_H */ |