svc.h 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390
  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. #ifndef SUNRPC_SVC_H
  9. #define SUNRPC_SVC_H
  10. #include <linux/in.h>
  11. #include <linux/sunrpc/types.h>
  12. #include <linux/sunrpc/xdr.h>
  13. #include <linux/sunrpc/svcauth.h>
  14. #include <linux/wait.h>
  15. #include <linux/mm.h>
  16. /*
  17. * This is the RPC server thread function prototype
  18. */
  19. typedef void (*svc_thread_fn)(struct svc_rqst *);
  20. /*
  21. *
  22. * RPC service thread pool.
  23. *
  24. * Pool of threads and temporary sockets. Generally there is only
  25. * a single one of these per RPC service, but on NUMA machines those
  26. * services that can benefit from it (i.e. nfs but not lockd) will
  27. * have one pool per NUMA node. This optimisation reduces cross-
  28. * node traffic on multi-node NUMA NFS servers.
  29. */
  30. struct svc_pool {
  31. unsigned int sp_id; /* pool id; also node id on NUMA */
  32. spinlock_t sp_lock; /* protects all fields */
  33. struct list_head sp_threads; /* idle server threads */
  34. struct list_head sp_sockets; /* pending sockets */
  35. unsigned int sp_nrthreads; /* # of threads in pool */
  36. struct list_head sp_all_threads; /* all server threads */
  37. } ____cacheline_aligned_in_smp;
  38. /*
  39. * RPC service.
  40. *
  41. * An RPC service is a ``daemon,'' possibly multithreaded, which
  42. * receives and processes incoming RPC messages.
  43. * It has one or more transport sockets associated with it, and maintains
  44. * a list of idle threads waiting for input.
  45. *
  46. * We currently do not support more than one RPC program per daemon.
  47. */
  48. struct svc_serv {
  49. struct svc_program * sv_program; /* RPC program */
  50. struct svc_stat * sv_stats; /* RPC statistics */
  51. spinlock_t sv_lock;
  52. unsigned int sv_nrthreads; /* # of server threads */
  53. unsigned int sv_bufsz; /* datagram buffer size */
  54. unsigned int sv_xdrsize; /* XDR buffer size */
  55. struct list_head sv_permsocks; /* all permanent sockets */
  56. struct list_head sv_tempsocks; /* all temporary sockets */
  57. int sv_tmpcnt; /* count of temporary sockets */
  58. struct timer_list sv_temptimer; /* timer for aging temporary sockets */
  59. char * sv_name; /* service name */
  60. unsigned int sv_nrpools; /* number of thread pools */
  61. struct svc_pool * sv_pools; /* array of thread pools */
  62. void (*sv_shutdown)(struct svc_serv *serv);
  63. /* Callback to use when last thread
  64. * exits.
  65. */
  66. struct module * sv_module; /* optional module to count when
  67. * adding threads */
  68. svc_thread_fn sv_function; /* main function for threads */
  69. int sv_kill_signal; /* signal to kill threads */
  70. };
  71. /*
  72. * We use sv_nrthreads as a reference count. svc_destroy() drops
  73. * this refcount, so we need to bump it up around operations that
  74. * change the number of threads. Horrible, but there it is.
  75. * Should be called with the BKL held.
  76. */
  77. static inline void svc_get(struct svc_serv *serv)
  78. {
  79. serv->sv_nrthreads++;
  80. }
  81. /*
  82. * Maximum payload size supported by a kernel RPC server.
  83. * This is use to determine the max number of pages nfsd is
  84. * willing to return in a single READ operation.
  85. */
  86. #define RPCSVC_MAXPAYLOAD (64*1024u)
  87. /*
  88. * RPC Requsts and replies are stored in one or more pages.
  89. * We maintain an array of pages for each server thread.
  90. * Requests are copied into these pages as they arrive. Remaining
  91. * pages are available to write the reply into.
  92. *
  93. * Pages are sent using ->sendpage so each server thread needs to
  94. * allocate more to replace those used in sending. To help keep track
  95. * of these pages we have a receive list where all pages initialy live,
  96. * and a send list where pages are moved to when there are to be part
  97. * of a reply.
  98. *
  99. * We use xdr_buf for holding responses as it fits well with NFS
  100. * read responses (that have a header, and some data pages, and possibly
  101. * a tail) and means we can share some client side routines.
  102. *
  103. * The xdr_buf.head kvec always points to the first page in the rq_*pages
  104. * list. The xdr_buf.pages pointer points to the second page on that
  105. * list. xdr_buf.tail points to the end of the first page.
  106. * This assumes that the non-page part of an rpc reply will fit
  107. * in a page - NFSd ensures this. lockd also has no trouble.
  108. *
  109. * Each request/reply pair can have at most one "payload", plus two pages,
  110. * one for the request, and one for the reply.
  111. */
  112. #define RPCSVC_MAXPAGES ((RPCSVC_MAXPAYLOAD+PAGE_SIZE-1)/PAGE_SIZE + 2)
  113. static inline u32 svc_getnl(struct kvec *iov)
  114. {
  115. __be32 val, *vp;
  116. vp = iov->iov_base;
  117. val = *vp++;
  118. iov->iov_base = (void*)vp;
  119. iov->iov_len -= sizeof(__be32);
  120. return ntohl(val);
  121. }
  122. static inline void svc_putnl(struct kvec *iov, u32 val)
  123. {
  124. __be32 *vp = iov->iov_base + iov->iov_len;
  125. *vp = htonl(val);
  126. iov->iov_len += sizeof(__be32);
  127. }
  128. static inline __be32 svc_getu32(struct kvec *iov)
  129. {
  130. __be32 val, *vp;
  131. vp = iov->iov_base;
  132. val = *vp++;
  133. iov->iov_base = (void*)vp;
  134. iov->iov_len -= sizeof(__be32);
  135. return val;
  136. }
  137. static inline void svc_ungetu32(struct kvec *iov)
  138. {
  139. __be32 *vp = (__be32 *)iov->iov_base;
  140. iov->iov_base = (void *)(vp - 1);
  141. iov->iov_len += sizeof(*vp);
  142. }
  143. static inline void svc_putu32(struct kvec *iov, __be32 val)
  144. {
  145. __be32 *vp = iov->iov_base + iov->iov_len;
  146. *vp = val;
  147. iov->iov_len += sizeof(__be32);
  148. }
  149. /*
  150. * The context of a single thread, including the request currently being
  151. * processed.
  152. * NOTE: First two items must be prev/next.
  153. */
  154. struct svc_rqst {
  155. struct list_head rq_list; /* idle list */
  156. struct list_head rq_all; /* all threads list */
  157. struct svc_sock * rq_sock; /* socket */
  158. struct sockaddr_in rq_addr; /* peer address */
  159. int rq_addrlen;
  160. struct svc_serv * rq_server; /* RPC service definition */
  161. struct svc_pool * rq_pool; /* thread pool */
  162. struct svc_procedure * rq_procinfo; /* procedure info */
  163. struct auth_ops * rq_authop; /* authentication flavour */
  164. struct svc_cred rq_cred; /* auth info */
  165. struct sk_buff * rq_skbuff; /* fast recv inet buffer */
  166. struct svc_deferred_req*rq_deferred; /* deferred request we are replaying */
  167. struct xdr_buf rq_arg;
  168. struct xdr_buf rq_res;
  169. struct page * rq_argpages[RPCSVC_MAXPAGES];
  170. struct page * rq_respages[RPCSVC_MAXPAGES];
  171. int rq_restailpage;
  172. short rq_argused; /* pages used for argument */
  173. short rq_arghi; /* pages available in argument page list */
  174. short rq_resused; /* pages used for result */
  175. __be32 rq_xid; /* transmission id */
  176. u32 rq_prog; /* program number */
  177. u32 rq_vers; /* program version */
  178. u32 rq_proc; /* procedure number */
  179. u32 rq_prot; /* IP protocol */
  180. unsigned short
  181. rq_secure : 1; /* secure port */
  182. __be32 rq_daddr; /* dest addr of request - reply from here */
  183. void * rq_argp; /* decoded arguments */
  184. void * rq_resp; /* xdr'd results */
  185. void * rq_auth_data; /* flavor-specific data */
  186. int rq_reserved; /* space on socket outq
  187. * reserved for this request
  188. */
  189. struct cache_req rq_chandle; /* handle passed to caches for
  190. * request delaying
  191. */
  192. /* Catering to nfsd */
  193. struct auth_domain * rq_client; /* RPC peer info */
  194. struct svc_cacherep * rq_cacherep; /* cache info */
  195. struct knfsd_fh * rq_reffh; /* Referrence filehandle, used to
  196. * determine what device number
  197. * to report (real or virtual)
  198. */
  199. int rq_sendfile_ok; /* turned off in gss privacy
  200. * to prevent encrypting page
  201. * cache pages */
  202. wait_queue_head_t rq_wait; /* synchronization */
  203. struct task_struct *rq_task; /* service thread */
  204. };
  205. /*
  206. * Check buffer bounds after decoding arguments
  207. */
  208. static inline int
  209. xdr_argsize_check(struct svc_rqst *rqstp, __be32 *p)
  210. {
  211. char *cp = (char *)p;
  212. struct kvec *vec = &rqstp->rq_arg.head[0];
  213. return cp >= (char*)vec->iov_base
  214. && cp <= (char*)vec->iov_base + vec->iov_len;
  215. }
  216. static inline int
  217. xdr_ressize_check(struct svc_rqst *rqstp, __be32 *p)
  218. {
  219. struct kvec *vec = &rqstp->rq_res.head[0];
  220. char *cp = (char*)p;
  221. vec->iov_len = cp - (char*)vec->iov_base;
  222. return vec->iov_len <= PAGE_SIZE;
  223. }
  224. static inline struct page *
  225. svc_take_res_page(struct svc_rqst *rqstp)
  226. {
  227. if (rqstp->rq_arghi <= rqstp->rq_argused)
  228. return NULL;
  229. rqstp->rq_arghi--;
  230. rqstp->rq_respages[rqstp->rq_resused] =
  231. rqstp->rq_argpages[rqstp->rq_arghi];
  232. return rqstp->rq_respages[rqstp->rq_resused++];
  233. }
  234. static inline void svc_take_page(struct svc_rqst *rqstp)
  235. {
  236. if (rqstp->rq_arghi <= rqstp->rq_argused) {
  237. WARN_ON(1);
  238. return;
  239. }
  240. rqstp->rq_arghi--;
  241. rqstp->rq_respages[rqstp->rq_resused] =
  242. rqstp->rq_argpages[rqstp->rq_arghi];
  243. rqstp->rq_resused++;
  244. }
  245. static inline void svc_pushback_allpages(struct svc_rqst *rqstp)
  246. {
  247. while (rqstp->rq_resused) {
  248. if (rqstp->rq_respages[--rqstp->rq_resused] == NULL)
  249. continue;
  250. rqstp->rq_argpages[rqstp->rq_arghi++] =
  251. rqstp->rq_respages[rqstp->rq_resused];
  252. rqstp->rq_respages[rqstp->rq_resused] = NULL;
  253. }
  254. }
  255. static inline void svc_pushback_unused_pages(struct svc_rqst *rqstp)
  256. {
  257. while (rqstp->rq_resused &&
  258. rqstp->rq_res.pages != &rqstp->rq_respages[rqstp->rq_resused]) {
  259. if (rqstp->rq_respages[--rqstp->rq_resused] != NULL) {
  260. rqstp->rq_argpages[rqstp->rq_arghi++] =
  261. rqstp->rq_respages[rqstp->rq_resused];
  262. rqstp->rq_respages[rqstp->rq_resused] = NULL;
  263. }
  264. }
  265. }
  266. static inline void svc_free_allpages(struct svc_rqst *rqstp)
  267. {
  268. while (rqstp->rq_resused) {
  269. if (rqstp->rq_respages[--rqstp->rq_resused] == NULL)
  270. continue;
  271. put_page(rqstp->rq_respages[rqstp->rq_resused]);
  272. rqstp->rq_respages[rqstp->rq_resused] = NULL;
  273. }
  274. }
  275. struct svc_deferred_req {
  276. u32 prot; /* protocol (UDP or TCP) */
  277. struct sockaddr_in addr;
  278. struct svc_sock *svsk; /* where reply must go */
  279. __be32 daddr; /* where reply must come from */
  280. struct cache_deferred_req handle;
  281. int argslen;
  282. __be32 args[0];
  283. };
  284. /*
  285. * List of RPC programs on the same transport endpoint
  286. */
  287. struct svc_program {
  288. struct svc_program * pg_next; /* other programs (same xprt) */
  289. u32 pg_prog; /* program number */
  290. unsigned int pg_lovers; /* lowest version */
  291. unsigned int pg_hivers; /* lowest version */
  292. unsigned int pg_nvers; /* number of versions */
  293. struct svc_version ** pg_vers; /* version array */
  294. char * pg_name; /* service name */
  295. char * pg_class; /* class name: services sharing authentication */
  296. struct svc_stat * pg_stats; /* rpc statistics */
  297. int (*pg_authenticate)(struct svc_rqst *);
  298. };
  299. /*
  300. * RPC program version
  301. */
  302. struct svc_version {
  303. u32 vs_vers; /* version number */
  304. u32 vs_nproc; /* number of procedures */
  305. struct svc_procedure * vs_proc; /* per-procedure info */
  306. u32 vs_xdrsize; /* xdrsize needed for this version */
  307. /* Override dispatch function (e.g. when caching replies).
  308. * A return value of 0 means drop the request.
  309. * vs_dispatch == NULL means use default dispatcher.
  310. */
  311. int (*vs_dispatch)(struct svc_rqst *, __be32 *);
  312. };
  313. /*
  314. * RPC procedure info
  315. */
  316. typedef int (*svc_procfunc)(struct svc_rqst *, void *argp, void *resp);
  317. struct svc_procedure {
  318. svc_procfunc pc_func; /* process the request */
  319. kxdrproc_t pc_decode; /* XDR decode args */
  320. kxdrproc_t pc_encode; /* XDR encode result */
  321. kxdrproc_t pc_release; /* XDR free result */
  322. unsigned int pc_argsize; /* argument struct size */
  323. unsigned int pc_ressize; /* result struct size */
  324. unsigned int pc_count; /* call count */
  325. unsigned int pc_cachetype; /* cache info (NFS) */
  326. unsigned int pc_xdrressize; /* maximum size of XDR reply */
  327. };
  328. /*
  329. * Function prototypes.
  330. */
  331. struct svc_serv * svc_create(struct svc_program *, unsigned int,
  332. void (*shutdown)(struct svc_serv*));
  333. int svc_create_thread(svc_thread_fn, struct svc_serv *);
  334. void svc_exit_thread(struct svc_rqst *);
  335. struct svc_serv * svc_create_pooled(struct svc_program *, unsigned int,
  336. void (*shutdown)(struct svc_serv*),
  337. svc_thread_fn, int sig, struct module *);
  338. int svc_set_num_threads(struct svc_serv *, struct svc_pool *, int);
  339. void svc_destroy(struct svc_serv *);
  340. int svc_process(struct svc_rqst *);
  341. int svc_register(struct svc_serv *, int, unsigned short);
  342. void svc_wake_up(struct svc_serv *);
  343. void svc_reserve(struct svc_rqst *rqstp, int space);
  344. #endif /* SUNRPC_SVC_H */