svc.h 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596
  1. /* SPDX-License-Identifier: GPL-2.0 */
  2. /*
  3. * linux/include/linux/sunrpc/svc.h
  4. *
  5. * RPC server declarations.
  6. *
  7. * Copyright (C) 1995, 1996 Olaf Kirch <[email protected]>
  8. */
  9. #ifndef SUNRPC_SVC_H
  10. #define SUNRPC_SVC_H
  11. #include <linux/in.h>
  12. #include <linux/in6.h>
  13. #include <linux/sunrpc/types.h>
  14. #include <linux/sunrpc/xdr.h>
  15. #include <linux/sunrpc/auth.h>
  16. #include <linux/sunrpc/svcauth.h>
  17. #include <linux/wait.h>
  18. #include <linux/mm.h>
  19. #include <linux/pagevec.h>
  20. /* statistics for svc_pool structures */
  21. struct svc_pool_stats {
  22. atomic_long_t packets;
  23. unsigned long sockets_queued;
  24. atomic_long_t threads_woken;
  25. atomic_long_t threads_timedout;
  26. };
  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. */
  37. struct 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_sockets; /* pending sockets */
  41. unsigned int sp_nrthreads; /* # of threads in pool */
  42. struct list_head sp_all_threads; /* all server threads */
  43. struct svc_pool_stats sp_stats; /* statistics on pool operation */
  44. #define SP_TASK_PENDING (0) /* still work to do even if no
  45. * xprt is queued. */
  46. #define SP_CONGESTED (1)
  47. unsigned long sp_flags;
  48. } ____cacheline_aligned_in_smp;
  49. /*
  50. * RPC service.
  51. *
  52. * An RPC service is a ``daemon,'' possibly multithreaded, which
  53. * receives and processes incoming RPC messages.
  54. * It has one or more transport sockets associated with it, and maintains
  55. * a list of idle threads waiting for input.
  56. *
  57. * We currently do not support more than one RPC program per daemon.
  58. */
  59. struct svc_serv {
  60. struct svc_program * sv_program; /* RPC program */
  61. struct svc_stat * sv_stats; /* RPC statistics */
  62. spinlock_t sv_lock;
  63. struct kref sv_refcnt;
  64. unsigned int sv_nrthreads; /* # of server threads */
  65. unsigned int sv_maxconn; /* max connections allowed or
  66. * '0' causing max to be based
  67. * on number of threads. */
  68. unsigned int sv_max_payload; /* datagram payload size */
  69. unsigned int sv_max_mesg; /* max_payload + 1 page for overheads */
  70. unsigned int sv_xdrsize; /* XDR buffer size */
  71. struct list_head sv_permsocks; /* all permanent sockets */
  72. struct list_head sv_tempsocks; /* all temporary sockets */
  73. int sv_tmpcnt; /* count of temporary sockets */
  74. struct timer_list sv_temptimer; /* timer for aging temporary sockets */
  75. char * sv_name; /* service name */
  76. unsigned int sv_nrpools; /* number of thread pools */
  77. struct svc_pool * sv_pools; /* array of thread pools */
  78. int (*sv_threadfn)(void *data);
  79. #if defined(CONFIG_SUNRPC_BACKCHANNEL)
  80. struct list_head sv_cb_list; /* queue for callback requests
  81. * that arrive over the same
  82. * connection */
  83. spinlock_t sv_cb_lock; /* protects the svc_cb_list */
  84. wait_queue_head_t sv_cb_waitq; /* sleep here if there are no
  85. * entries in the svc_cb_list */
  86. bool sv_bc_enabled; /* service uses backchannel */
  87. #endif /* CONFIG_SUNRPC_BACKCHANNEL */
  88. };
  89. /**
  90. * svc_get() - increment reference count on a SUNRPC serv
  91. * @serv: the svc_serv to have count incremented
  92. *
  93. * Returns: the svc_serv that was passed in.
  94. */
  95. static inline struct svc_serv *svc_get(struct svc_serv *serv)
  96. {
  97. kref_get(&serv->sv_refcnt);
  98. return serv;
  99. }
  100. void svc_destroy(struct kref *);
  101. /**
  102. * svc_put - decrement reference count on a SUNRPC serv
  103. * @serv: the svc_serv to have count decremented
  104. *
  105. * When the reference count reaches zero, svc_destroy()
  106. * is called to clean up and free the serv.
  107. */
  108. static inline void svc_put(struct svc_serv *serv)
  109. {
  110. kref_put(&serv->sv_refcnt, svc_destroy);
  111. }
  112. /**
  113. * svc_put_not_last - decrement non-final reference count on SUNRPC serv
  114. * @serv: the svc_serv to have count decremented
  115. *
  116. * Returns: %true is refcount was decremented.
  117. *
  118. * If the refcount is 1, it is not decremented and instead failure is reported.
  119. */
  120. static inline bool svc_put_not_last(struct svc_serv *serv)
  121. {
  122. return refcount_dec_not_one(&serv->sv_refcnt.refcount);
  123. }
  124. /*
  125. * Maximum payload size supported by a kernel RPC server.
  126. * This is use to determine the max number of pages nfsd is
  127. * willing to return in a single READ operation.
  128. *
  129. * These happen to all be powers of 2, which is not strictly
  130. * necessary but helps enforce the real limitation, which is
  131. * that they should be multiples of PAGE_SIZE.
  132. *
  133. * For UDP transports, a block plus NFS,RPC, and UDP headers
  134. * has to fit into the IP datagram limit of 64K. The largest
  135. * feasible number for all known page sizes is probably 48K,
  136. * but we choose 32K here. This is the same as the historical
  137. * Linux limit; someone who cares more about NFS/UDP performance
  138. * can test a larger number.
  139. *
  140. * For TCP transports we have more freedom. A size of 1MB is
  141. * chosen to match the client limit. Other OSes are known to
  142. * have larger limits, but those numbers are probably beyond
  143. * the point of diminishing returns.
  144. */
  145. #define RPCSVC_MAXPAYLOAD (1*1024*1024u)
  146. #define RPCSVC_MAXPAYLOAD_TCP RPCSVC_MAXPAYLOAD
  147. #define RPCSVC_MAXPAYLOAD_UDP (32*1024u)
  148. extern u32 svc_max_payload(const struct svc_rqst *rqstp);
  149. /*
  150. * RPC Requsts and replies are stored in one or more pages.
  151. * We maintain an array of pages for each server thread.
  152. * Requests are copied into these pages as they arrive. Remaining
  153. * pages are available to write the reply into.
  154. *
  155. * Pages are sent using ->sendpage so each server thread needs to
  156. * allocate more to replace those used in sending. To help keep track
  157. * of these pages we have a receive list where all pages initialy live,
  158. * and a send list where pages are moved to when there are to be part
  159. * of a reply.
  160. *
  161. * We use xdr_buf for holding responses as it fits well with NFS
  162. * read responses (that have a header, and some data pages, and possibly
  163. * a tail) and means we can share some client side routines.
  164. *
  165. * The xdr_buf.head kvec always points to the first page in the rq_*pages
  166. * list. The xdr_buf.pages pointer points to the second page on that
  167. * list. xdr_buf.tail points to the end of the first page.
  168. * This assumes that the non-page part of an rpc reply will fit
  169. * in a page - NFSd ensures this. lockd also has no trouble.
  170. *
  171. * Each request/reply pair can have at most one "payload", plus two pages,
  172. * one for the request, and one for the reply.
  173. * We using ->sendfile to return read data, we might need one extra page
  174. * if the request is not page-aligned. So add another '1'.
  175. */
  176. #define RPCSVC_MAXPAGES ((RPCSVC_MAXPAYLOAD+PAGE_SIZE-1)/PAGE_SIZE \
  177. + 2 + 1)
  178. static inline u32 svc_getnl(struct kvec *iov)
  179. {
  180. __be32 val, *vp;
  181. vp = iov->iov_base;
  182. val = *vp++;
  183. iov->iov_base = (void*)vp;
  184. iov->iov_len -= sizeof(__be32);
  185. return ntohl(val);
  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. static 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. static inline void svc_ungetu32(struct kvec *iov)
  203. {
  204. __be32 *vp = (__be32 *)iov->iov_base;
  205. iov->iov_base = (void *)(vp - 1);
  206. iov->iov_len += sizeof(*vp);
  207. }
  208. static inline void svc_putu32(struct kvec *iov, __be32 val)
  209. {
  210. __be32 *vp = iov->iov_base + iov->iov_len;
  211. *vp = val;
  212. iov->iov_len += sizeof(__be32);
  213. }
  214. /*
  215. * The context of a single thread, including the request currently being
  216. * processed.
  217. */
  218. struct svc_rqst {
  219. struct list_head rq_all; /* all threads list */
  220. struct rcu_head rq_rcu_head; /* for RCU deferred kfree */
  221. struct svc_xprt * rq_xprt; /* transport ptr */
  222. struct sockaddr_storage rq_addr; /* peer address */
  223. size_t rq_addrlen;
  224. struct sockaddr_storage rq_daddr; /* dest addr of request
  225. * - reply from here */
  226. size_t rq_daddrlen;
  227. struct svc_serv * rq_server; /* RPC service definition */
  228. struct svc_pool * rq_pool; /* thread pool */
  229. const struct svc_procedure *rq_procinfo;/* procedure info */
  230. struct auth_ops * rq_authop; /* authentication flavour */
  231. struct svc_cred rq_cred; /* auth info */
  232. void * rq_xprt_ctxt; /* transport specific context ptr */
  233. struct svc_deferred_req*rq_deferred; /* deferred request we are replaying */
  234. struct xdr_buf rq_arg;
  235. struct xdr_stream rq_arg_stream;
  236. struct xdr_stream rq_res_stream;
  237. struct page *rq_scratch_page;
  238. struct xdr_buf rq_res;
  239. struct page *rq_pages[RPCSVC_MAXPAGES + 1];
  240. struct page * *rq_respages; /* points into rq_pages */
  241. struct page * *rq_next_page; /* next reply page to use */
  242. struct page * *rq_page_end; /* one past the last page */
  243. struct pagevec rq_pvec;
  244. struct kvec rq_vec[RPCSVC_MAXPAGES]; /* generally useful.. */
  245. struct bio_vec rq_bvec[RPCSVC_MAXPAGES];
  246. __be32 rq_xid; /* transmission id */
  247. u32 rq_prog; /* program number */
  248. u32 rq_vers; /* program version */
  249. u32 rq_proc; /* procedure number */
  250. u32 rq_prot; /* IP protocol */
  251. int rq_cachetype; /* catering to nfsd */
  252. #define RQ_SECURE (0) /* secure port */
  253. #define RQ_LOCAL (1) /* local request */
  254. #define RQ_USEDEFERRAL (2) /* use deferral */
  255. #define RQ_DROPME (3) /* drop current reply */
  256. #define RQ_SPLICE_OK (4) /* turned off in gss privacy
  257. * to prevent encrypting page
  258. * cache pages */
  259. #define RQ_VICTIM (5) /* about to be shut down */
  260. #define RQ_BUSY (6) /* request is busy */
  261. #define RQ_DATA (7) /* request has data */
  262. unsigned long rq_flags; /* flags field */
  263. ktime_t rq_qtime; /* enqueue time */
  264. void * rq_argp; /* decoded arguments */
  265. void * rq_resp; /* xdr'd results */
  266. void * rq_auth_data; /* flavor-specific data */
  267. __be32 rq_auth_stat; /* authentication status */
  268. int rq_auth_slack; /* extra space xdr code
  269. * should leave in head
  270. * for krb5i, krb5p.
  271. */
  272. int rq_reserved; /* space on socket outq
  273. * reserved for this request
  274. */
  275. ktime_t rq_stime; /* start time */
  276. struct cache_req rq_chandle; /* handle passed to caches for
  277. * request delaying
  278. */
  279. /* Catering to nfsd */
  280. struct auth_domain * rq_client; /* RPC peer info */
  281. struct auth_domain * rq_gssclient; /* "gss/"-style peer info */
  282. struct svc_cacherep * rq_cacherep; /* cache info */
  283. struct task_struct *rq_task; /* service thread */
  284. spinlock_t rq_lock; /* per-request lock */
  285. struct net *rq_bc_net; /* pointer to backchannel's
  286. * net namespace
  287. */
  288. void ** rq_lease_breaker; /* The v4 client breaking a lease */
  289. };
  290. #define SVC_NET(rqst) (rqst->rq_xprt ? rqst->rq_xprt->xpt_net : rqst->rq_bc_net)
  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. static inline struct sockaddr_in6 *svc_addr_in6(const struct svc_rqst *rqst)
  299. {
  300. return (struct sockaddr_in6 *) &rqst->rq_addr;
  301. }
  302. static inline struct sockaddr *svc_addr(const struct svc_rqst *rqst)
  303. {
  304. return (struct sockaddr *) &rqst->rq_addr;
  305. }
  306. static inline struct sockaddr_in *svc_daddr_in(const struct svc_rqst *rqst)
  307. {
  308. return (struct sockaddr_in *) &rqst->rq_daddr;
  309. }
  310. static inline struct sockaddr_in6 *svc_daddr_in6(const struct svc_rqst *rqst)
  311. {
  312. return (struct sockaddr_in6 *) &rqst->rq_daddr;
  313. }
  314. static inline struct sockaddr *svc_daddr(const struct svc_rqst *rqst)
  315. {
  316. return (struct sockaddr *) &rqst->rq_daddr;
  317. }
  318. /*
  319. * Check buffer bounds after decoding arguments
  320. */
  321. static inline int
  322. xdr_argsize_check(struct svc_rqst *rqstp, __be32 *p)
  323. {
  324. char *cp = (char *)p;
  325. struct kvec *vec = &rqstp->rq_arg.head[0];
  326. return cp >= (char*)vec->iov_base
  327. && cp <= (char*)vec->iov_base + vec->iov_len;
  328. }
  329. static inline int
  330. xdr_ressize_check(struct svc_rqst *rqstp, __be32 *p)
  331. {
  332. struct kvec *vec = &rqstp->rq_res.head[0];
  333. char *cp = (char*)p;
  334. vec->iov_len = cp - (char*)vec->iov_base;
  335. return vec->iov_len <= PAGE_SIZE;
  336. }
  337. static inline void svc_free_res_pages(struct svc_rqst *rqstp)
  338. {
  339. while (rqstp->rq_next_page != rqstp->rq_respages) {
  340. struct page **pp = --rqstp->rq_next_page;
  341. if (*pp) {
  342. put_page(*pp);
  343. *pp = NULL;
  344. }
  345. }
  346. }
  347. struct svc_deferred_req {
  348. u32 prot; /* protocol (UDP or TCP) */
  349. struct svc_xprt *xprt;
  350. struct sockaddr_storage addr; /* where reply must go */
  351. size_t addrlen;
  352. struct sockaddr_storage daddr; /* where reply must come from */
  353. size_t daddrlen;
  354. void *xprt_ctxt;
  355. struct cache_deferred_req handle;
  356. int argslen;
  357. __be32 args[];
  358. };
  359. struct svc_process_info {
  360. union {
  361. int (*dispatch)(struct svc_rqst *, __be32 *);
  362. struct {
  363. unsigned int lovers;
  364. unsigned int hivers;
  365. } mismatch;
  366. };
  367. };
  368. /*
  369. * List of RPC programs on the same transport endpoint
  370. */
  371. struct 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. const 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. __be32 (*pg_init_request)(struct svc_rqst *,
  383. const struct svc_program *,
  384. struct svc_process_info *);
  385. int (*pg_rpcbind_set)(struct net *net,
  386. const struct svc_program *,
  387. u32 version, int family,
  388. unsigned short proto,
  389. unsigned short port);
  390. };
  391. /*
  392. * RPC program version
  393. */
  394. struct svc_version {
  395. u32 vs_vers; /* version number */
  396. u32 vs_nproc; /* number of procedures */
  397. const struct svc_procedure *vs_proc; /* per-procedure info */
  398. unsigned int *vs_count; /* call counts */
  399. u32 vs_xdrsize; /* xdrsize needed for this version */
  400. /* Don't register with rpcbind */
  401. bool vs_hidden;
  402. /* Don't care if the rpcbind registration fails */
  403. bool vs_rpcb_optnl;
  404. /* Need xprt with congestion control */
  405. bool vs_need_cong_ctrl;
  406. /* Dispatch function */
  407. int (*vs_dispatch)(struct svc_rqst *, __be32 *);
  408. };
  409. /*
  410. * RPC procedure info
  411. */
  412. struct svc_procedure {
  413. /* process the request: */
  414. __be32 (*pc_func)(struct svc_rqst *);
  415. /* XDR decode args: */
  416. bool (*pc_decode)(struct svc_rqst *rqstp,
  417. struct xdr_stream *xdr);
  418. /* XDR encode result: */
  419. bool (*pc_encode)(struct svc_rqst *rqstp,
  420. struct xdr_stream *xdr);
  421. /* XDR free result: */
  422. void (*pc_release)(struct svc_rqst *);
  423. unsigned int pc_argsize; /* argument struct size */
  424. unsigned int pc_argzero; /* how much of argument to clear */
  425. unsigned int pc_ressize; /* result struct size */
  426. unsigned int pc_cachetype; /* cache info (NFS) */
  427. unsigned int pc_xdrressize; /* maximum size of XDR reply */
  428. const char * pc_name; /* for display */
  429. };
  430. /*
  431. * Function prototypes.
  432. */
  433. int svc_rpcb_setup(struct svc_serv *serv, struct net *net);
  434. void svc_rpcb_cleanup(struct svc_serv *serv, struct net *net);
  435. int svc_bind(struct svc_serv *serv, struct net *net);
  436. struct svc_serv *svc_create(struct svc_program *, unsigned int,
  437. int (*threadfn)(void *data));
  438. struct svc_rqst *svc_rqst_alloc(struct svc_serv *serv,
  439. struct svc_pool *pool, int node);
  440. void svc_rqst_replace_page(struct svc_rqst *rqstp,
  441. struct page *page);
  442. void svc_rqst_free(struct svc_rqst *);
  443. void svc_exit_thread(struct svc_rqst *);
  444. struct svc_serv * svc_create_pooled(struct svc_program *, unsigned int,
  445. int (*threadfn)(void *data));
  446. int svc_set_num_threads(struct svc_serv *, struct svc_pool *, int);
  447. int svc_pool_stats_open(struct svc_serv *serv, struct file *file);
  448. int svc_process(struct svc_rqst *);
  449. int bc_svc_process(struct svc_serv *, struct rpc_rqst *,
  450. struct svc_rqst *);
  451. int svc_register(const struct svc_serv *, struct net *, const int,
  452. const unsigned short, const unsigned short);
  453. void svc_wake_up(struct svc_serv *);
  454. void svc_reserve(struct svc_rqst *rqstp, int space);
  455. struct svc_pool *svc_pool_for_cpu(struct svc_serv *serv);
  456. char * svc_print_addr(struct svc_rqst *, char *, size_t);
  457. const char * svc_proc_name(const struct svc_rqst *rqstp);
  458. int svc_encode_result_payload(struct svc_rqst *rqstp,
  459. unsigned int offset,
  460. unsigned int length);
  461. unsigned int svc_fill_write_vector(struct svc_rqst *rqstp,
  462. struct xdr_buf *payload);
  463. char *svc_fill_symlink_pathname(struct svc_rqst *rqstp,
  464. struct kvec *first, void *p,
  465. size_t total);
  466. __be32 svc_generic_init_request(struct svc_rqst *rqstp,
  467. const struct svc_program *progp,
  468. struct svc_process_info *procinfo);
  469. int svc_generic_rpcbind_set(struct net *net,
  470. const struct svc_program *progp,
  471. u32 version, int family,
  472. unsigned short proto,
  473. unsigned short port);
  474. int svc_rpcbind_set_version(struct net *net,
  475. const struct svc_program *progp,
  476. u32 version, int family,
  477. unsigned short proto,
  478. unsigned short port);
  479. #define RPC_MAX_ADDRBUFLEN (63U)
  480. /*
  481. * When we want to reduce the size of the reserved space in the response
  482. * buffer, we need to take into account the size of any checksum data that
  483. * may be at the end of the packet. This is difficult to determine exactly
  484. * for all cases without actually generating the checksum, so we just use a
  485. * static value.
  486. */
  487. static inline void svc_reserve_auth(struct svc_rqst *rqstp, int space)
  488. {
  489. svc_reserve(rqstp, space + rqstp->rq_auth_slack);
  490. }
  491. /**
  492. * svcxdr_init_decode - Prepare an xdr_stream for Call decoding
  493. * @rqstp: controlling server RPC transaction context
  494. *
  495. * This function currently assumes the RPC header in rq_arg has
  496. * already been decoded. Upon return, xdr->p points to the
  497. * location of the upper layer header.
  498. */
  499. static inline void svcxdr_init_decode(struct svc_rqst *rqstp)
  500. {
  501. struct xdr_stream *xdr = &rqstp->rq_arg_stream;
  502. struct xdr_buf *buf = &rqstp->rq_arg;
  503. struct kvec *argv = buf->head;
  504. /*
  505. * svc_getnl() and friends do not keep the xdr_buf's ::len
  506. * field up to date. Refresh that field before initializing
  507. * the argument decoding stream.
  508. */
  509. buf->len = buf->head->iov_len + buf->page_len + buf->tail->iov_len;
  510. xdr_init_decode(xdr, buf, argv->iov_base, NULL);
  511. xdr_set_scratch_page(xdr, rqstp->rq_scratch_page);
  512. }
  513. /**
  514. * svcxdr_init_encode - Prepare an xdr_stream for svc Reply encoding
  515. * @rqstp: controlling server RPC transaction context
  516. *
  517. */
  518. static inline void svcxdr_init_encode(struct svc_rqst *rqstp)
  519. {
  520. struct xdr_stream *xdr = &rqstp->rq_res_stream;
  521. struct xdr_buf *buf = &rqstp->rq_res;
  522. struct kvec *resv = buf->head;
  523. xdr_reset_scratch_buffer(xdr);
  524. xdr->buf = buf;
  525. xdr->iov = resv;
  526. xdr->p = resv->iov_base + resv->iov_len;
  527. xdr->end = resv->iov_base + PAGE_SIZE - rqstp->rq_auth_slack;
  528. buf->len = resv->iov_len;
  529. xdr->page_ptr = buf->pages - 1;
  530. buf->buflen = PAGE_SIZE * (rqstp->rq_page_end - buf->pages);
  531. buf->buflen -= rqstp->rq_auth_slack;
  532. xdr->rqst = NULL;
  533. }
  534. #endif /* SUNRPC_SVC_H */