svcsock.c 42 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668
  1. /*
  2. * linux/net/sunrpc/svcsock.c
  3. *
  4. * These are the RPC server socket internals.
  5. *
  6. * The server scheduling algorithm does not always distribute the load
  7. * evenly when servicing a single client. May need to modify the
  8. * svc_xprt_enqueue procedure...
  9. *
  10. * TCP support is largely untested and may be a little slow. The problem
  11. * is that we currently do two separate recvfrom's, one for the 4-byte
  12. * record length, and the second for the actual record. This could possibly
  13. * be improved by always reading a minimum size of around 100 bytes and
  14. * tucking any superfluous bytes away in a temporary store. Still, that
  15. * leaves write requests out in the rain. An alternative may be to peek at
  16. * the first skb in the queue, and if it matches the next TCP sequence
  17. * number, to extract the record marker. Yuck.
  18. *
  19. * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
  20. */
  21. #include <linux/kernel.h>
  22. #include <linux/sched.h>
  23. #include <linux/module.h>
  24. #include <linux/errno.h>
  25. #include <linux/fcntl.h>
  26. #include <linux/net.h>
  27. #include <linux/in.h>
  28. #include <linux/inet.h>
  29. #include <linux/udp.h>
  30. #include <linux/tcp.h>
  31. #include <linux/unistd.h>
  32. #include <linux/slab.h>
  33. #include <linux/netdevice.h>
  34. #include <linux/skbuff.h>
  35. #include <linux/file.h>
  36. #include <linux/freezer.h>
  37. #include <net/sock.h>
  38. #include <net/checksum.h>
  39. #include <net/ip.h>
  40. #include <net/ipv6.h>
  41. #include <net/udp.h>
  42. #include <net/tcp.h>
  43. #include <net/tcp_states.h>
  44. #include <linux/uaccess.h>
  45. #include <asm/ioctls.h>
  46. #include <trace/events/skb.h>
  47. #include <linux/sunrpc/types.h>
  48. #include <linux/sunrpc/clnt.h>
  49. #include <linux/sunrpc/xdr.h>
  50. #include <linux/sunrpc/msg_prot.h>
  51. #include <linux/sunrpc/svcsock.h>
  52. #include <linux/sunrpc/stats.h>
  53. #include <linux/sunrpc/xprt.h>
  54. #include "sunrpc.h"
  55. #define RPCDBG_FACILITY RPCDBG_SVCXPRT
  56. static struct svc_sock *svc_setup_socket(struct svc_serv *, struct socket *,
  57. int flags);
  58. static int svc_udp_recvfrom(struct svc_rqst *);
  59. static int svc_udp_sendto(struct svc_rqst *);
  60. static void svc_sock_detach(struct svc_xprt *);
  61. static void svc_tcp_sock_detach(struct svc_xprt *);
  62. static void svc_sock_free(struct svc_xprt *);
  63. static struct svc_xprt *svc_create_socket(struct svc_serv *, int,
  64. struct net *, struct sockaddr *,
  65. int, int);
  66. #if defined(CONFIG_SUNRPC_BACKCHANNEL)
  67. static struct svc_xprt *svc_bc_create_socket(struct svc_serv *, int,
  68. struct net *, struct sockaddr *,
  69. int, int);
  70. static void svc_bc_sock_free(struct svc_xprt *xprt);
  71. #endif /* CONFIG_SUNRPC_BACKCHANNEL */
  72. #ifdef CONFIG_DEBUG_LOCK_ALLOC
  73. static struct lock_class_key svc_key[2];
  74. static struct lock_class_key svc_slock_key[2];
  75. static void svc_reclassify_socket(struct socket *sock)
  76. {
  77. struct sock *sk = sock->sk;
  78. if (WARN_ON_ONCE(!sock_allow_reclassification(sk)))
  79. return;
  80. switch (sk->sk_family) {
  81. case AF_INET:
  82. sock_lock_init_class_and_name(sk, "slock-AF_INET-NFSD",
  83. &svc_slock_key[0],
  84. "sk_xprt.xpt_lock-AF_INET-NFSD",
  85. &svc_key[0]);
  86. break;
  87. case AF_INET6:
  88. sock_lock_init_class_and_name(sk, "slock-AF_INET6-NFSD",
  89. &svc_slock_key[1],
  90. "sk_xprt.xpt_lock-AF_INET6-NFSD",
  91. &svc_key[1]);
  92. break;
  93. default:
  94. BUG();
  95. }
  96. }
  97. #else
  98. static void svc_reclassify_socket(struct socket *sock)
  99. {
  100. }
  101. #endif
  102. /*
  103. * Release an skbuff after use
  104. */
  105. static void svc_release_skb(struct svc_rqst *rqstp)
  106. {
  107. struct sk_buff *skb = rqstp->rq_xprt_ctxt;
  108. if (skb) {
  109. struct svc_sock *svsk =
  110. container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);
  111. rqstp->rq_xprt_ctxt = NULL;
  112. dprintk("svc: service %p, releasing skb %p\n", rqstp, skb);
  113. skb_free_datagram_locked(svsk->sk_sk, skb);
  114. }
  115. }
  116. static void svc_release_udp_skb(struct svc_rqst *rqstp)
  117. {
  118. struct sk_buff *skb = rqstp->rq_xprt_ctxt;
  119. if (skb) {
  120. rqstp->rq_xprt_ctxt = NULL;
  121. dprintk("svc: service %p, releasing skb %p\n", rqstp, skb);
  122. consume_skb(skb);
  123. }
  124. }
  125. union svc_pktinfo_u {
  126. struct in_pktinfo pkti;
  127. struct in6_pktinfo pkti6;
  128. };
  129. #define SVC_PKTINFO_SPACE \
  130. CMSG_SPACE(sizeof(union svc_pktinfo_u))
  131. static void svc_set_cmsg_data(struct svc_rqst *rqstp, struct cmsghdr *cmh)
  132. {
  133. struct svc_sock *svsk =
  134. container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);
  135. switch (svsk->sk_sk->sk_family) {
  136. case AF_INET: {
  137. struct in_pktinfo *pki = CMSG_DATA(cmh);
  138. cmh->cmsg_level = SOL_IP;
  139. cmh->cmsg_type = IP_PKTINFO;
  140. pki->ipi_ifindex = 0;
  141. pki->ipi_spec_dst.s_addr =
  142. svc_daddr_in(rqstp)->sin_addr.s_addr;
  143. cmh->cmsg_len = CMSG_LEN(sizeof(*pki));
  144. }
  145. break;
  146. case AF_INET6: {
  147. struct in6_pktinfo *pki = CMSG_DATA(cmh);
  148. struct sockaddr_in6 *daddr = svc_daddr_in6(rqstp);
  149. cmh->cmsg_level = SOL_IPV6;
  150. cmh->cmsg_type = IPV6_PKTINFO;
  151. pki->ipi6_ifindex = daddr->sin6_scope_id;
  152. pki->ipi6_addr = daddr->sin6_addr;
  153. cmh->cmsg_len = CMSG_LEN(sizeof(*pki));
  154. }
  155. break;
  156. }
  157. }
  158. /*
  159. * send routine intended to be shared by the fore- and back-channel
  160. */
  161. int svc_send_common(struct socket *sock, struct xdr_buf *xdr,
  162. struct page *headpage, unsigned long headoffset,
  163. struct page *tailpage, unsigned long tailoffset)
  164. {
  165. int result;
  166. int size;
  167. struct page **ppage = xdr->pages;
  168. size_t base = xdr->page_base;
  169. unsigned int pglen = xdr->page_len;
  170. unsigned int flags = MSG_MORE | MSG_SENDPAGE_NOTLAST;
  171. int slen;
  172. int len = 0;
  173. slen = xdr->len;
  174. /* send head */
  175. if (slen == xdr->head[0].iov_len)
  176. flags = 0;
  177. len = kernel_sendpage(sock, headpage, headoffset,
  178. xdr->head[0].iov_len, flags);
  179. if (len != xdr->head[0].iov_len)
  180. goto out;
  181. slen -= xdr->head[0].iov_len;
  182. if (slen == 0)
  183. goto out;
  184. /* send page data */
  185. size = PAGE_SIZE - base < pglen ? PAGE_SIZE - base : pglen;
  186. while (pglen > 0) {
  187. if (slen == size)
  188. flags = 0;
  189. result = kernel_sendpage(sock, *ppage, base, size, flags);
  190. if (result > 0)
  191. len += result;
  192. if (result != size)
  193. goto out;
  194. slen -= size;
  195. pglen -= size;
  196. size = PAGE_SIZE < pglen ? PAGE_SIZE : pglen;
  197. base = 0;
  198. ppage++;
  199. }
  200. /* send tail */
  201. if (xdr->tail[0].iov_len) {
  202. result = kernel_sendpage(sock, tailpage, tailoffset,
  203. xdr->tail[0].iov_len, 0);
  204. if (result > 0)
  205. len += result;
  206. }
  207. out:
  208. return len;
  209. }
  210. /*
  211. * Generic sendto routine
  212. */
  213. static int svc_sendto(struct svc_rqst *rqstp, struct xdr_buf *xdr)
  214. {
  215. struct svc_sock *svsk =
  216. container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);
  217. struct socket *sock = svsk->sk_sock;
  218. union {
  219. struct cmsghdr hdr;
  220. long all[SVC_PKTINFO_SPACE / sizeof(long)];
  221. } buffer;
  222. struct cmsghdr *cmh = &buffer.hdr;
  223. int len = 0;
  224. unsigned long tailoff;
  225. unsigned long headoff;
  226. RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
  227. if (rqstp->rq_prot == IPPROTO_UDP) {
  228. struct msghdr msg = {
  229. .msg_name = &rqstp->rq_addr,
  230. .msg_namelen = rqstp->rq_addrlen,
  231. .msg_control = cmh,
  232. .msg_controllen = sizeof(buffer),
  233. .msg_flags = MSG_MORE,
  234. };
  235. svc_set_cmsg_data(rqstp, cmh);
  236. if (sock_sendmsg(sock, &msg) < 0)
  237. goto out;
  238. }
  239. tailoff = ((unsigned long)xdr->tail[0].iov_base) & (PAGE_SIZE-1);
  240. headoff = 0;
  241. len = svc_send_common(sock, xdr, rqstp->rq_respages[0], headoff,
  242. rqstp->rq_respages[0], tailoff);
  243. out:
  244. dprintk("svc: socket %p sendto([%p %zu... ], %d) = %d (addr %s)\n",
  245. svsk, xdr->head[0].iov_base, xdr->head[0].iov_len,
  246. xdr->len, len, svc_print_addr(rqstp, buf, sizeof(buf)));
  247. return len;
  248. }
  249. /*
  250. * Report socket names for nfsdfs
  251. */
  252. static int svc_one_sock_name(struct svc_sock *svsk, char *buf, int remaining)
  253. {
  254. const struct sock *sk = svsk->sk_sk;
  255. const char *proto_name = sk->sk_protocol == IPPROTO_UDP ?
  256. "udp" : "tcp";
  257. int len;
  258. switch (sk->sk_family) {
  259. case PF_INET:
  260. len = snprintf(buf, remaining, "ipv4 %s %pI4 %d\n",
  261. proto_name,
  262. &inet_sk(sk)->inet_rcv_saddr,
  263. inet_sk(sk)->inet_num);
  264. break;
  265. #if IS_ENABLED(CONFIG_IPV6)
  266. case PF_INET6:
  267. len = snprintf(buf, remaining, "ipv6 %s %pI6 %d\n",
  268. proto_name,
  269. &sk->sk_v6_rcv_saddr,
  270. inet_sk(sk)->inet_num);
  271. break;
  272. #endif
  273. default:
  274. len = snprintf(buf, remaining, "*unknown-%d*\n",
  275. sk->sk_family);
  276. }
  277. if (len >= remaining) {
  278. *buf = '\0';
  279. return -ENAMETOOLONG;
  280. }
  281. return len;
  282. }
  283. /*
  284. * Generic recvfrom routine.
  285. */
  286. static int svc_recvfrom(struct svc_rqst *rqstp, struct kvec *iov, int nr,
  287. int buflen)
  288. {
  289. struct svc_sock *svsk =
  290. container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);
  291. struct msghdr msg = {
  292. .msg_flags = MSG_DONTWAIT,
  293. };
  294. int len;
  295. rqstp->rq_xprt_hlen = 0;
  296. clear_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
  297. iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, iov, nr, buflen);
  298. len = sock_recvmsg(svsk->sk_sock, &msg, msg.msg_flags);
  299. /* If we read a full record, then assume there may be more
  300. * data to read (stream based sockets only!)
  301. */
  302. if (len == buflen)
  303. set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
  304. dprintk("svc: socket %p recvfrom(%p, %zu) = %d\n",
  305. svsk, iov[0].iov_base, iov[0].iov_len, len);
  306. return len;
  307. }
  308. static int svc_partial_recvfrom(struct svc_rqst *rqstp,
  309. struct kvec *iov, int nr,
  310. int buflen, unsigned int base)
  311. {
  312. size_t save_iovlen;
  313. void *save_iovbase;
  314. unsigned int i;
  315. int ret;
  316. if (base == 0)
  317. return svc_recvfrom(rqstp, iov, nr, buflen);
  318. for (i = 0; i < nr; i++) {
  319. if (iov[i].iov_len > base)
  320. break;
  321. base -= iov[i].iov_len;
  322. }
  323. save_iovlen = iov[i].iov_len;
  324. save_iovbase = iov[i].iov_base;
  325. iov[i].iov_len -= base;
  326. iov[i].iov_base += base;
  327. ret = svc_recvfrom(rqstp, &iov[i], nr - i, buflen);
  328. iov[i].iov_len = save_iovlen;
  329. iov[i].iov_base = save_iovbase;
  330. return ret;
  331. }
  332. /*
  333. * Set socket snd and rcv buffer lengths
  334. */
  335. static void svc_sock_setbufsize(struct svc_sock *svsk, unsigned int nreqs)
  336. {
  337. unsigned int max_mesg = svsk->sk_xprt.xpt_server->sv_max_mesg;
  338. struct socket *sock = svsk->sk_sock;
  339. nreqs = min(nreqs, INT_MAX / 2 / max_mesg);
  340. lock_sock(sock->sk);
  341. sock->sk->sk_sndbuf = nreqs * max_mesg * 2;
  342. sock->sk->sk_rcvbuf = nreqs * max_mesg * 2;
  343. sock->sk->sk_write_space(sock->sk);
  344. release_sock(sock->sk);
  345. }
  346. static void svc_sock_secure_port(struct svc_rqst *rqstp)
  347. {
  348. if (svc_port_is_privileged(svc_addr(rqstp)))
  349. set_bit(RQ_SECURE, &rqstp->rq_flags);
  350. else
  351. clear_bit(RQ_SECURE, &rqstp->rq_flags);
  352. }
  353. /*
  354. * INET callback when data has been received on the socket.
  355. */
  356. static void svc_data_ready(struct sock *sk)
  357. {
  358. struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data;
  359. if (svsk) {
  360. dprintk("svc: socket %p(inet %p), busy=%d\n",
  361. svsk, sk,
  362. test_bit(XPT_BUSY, &svsk->sk_xprt.xpt_flags));
  363. /* Refer to svc_setup_socket() for details. */
  364. rmb();
  365. svsk->sk_odata(sk);
  366. if (!test_and_set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags))
  367. svc_xprt_enqueue(&svsk->sk_xprt);
  368. }
  369. }
  370. /*
  371. * INET callback when space is newly available on the socket.
  372. */
  373. static void svc_write_space(struct sock *sk)
  374. {
  375. struct svc_sock *svsk = (struct svc_sock *)(sk->sk_user_data);
  376. if (svsk) {
  377. dprintk("svc: socket %p(inet %p), write_space busy=%d\n",
  378. svsk, sk, test_bit(XPT_BUSY, &svsk->sk_xprt.xpt_flags));
  379. /* Refer to svc_setup_socket() for details. */
  380. rmb();
  381. svsk->sk_owspace(sk);
  382. svc_xprt_enqueue(&svsk->sk_xprt);
  383. }
  384. }
  385. static int svc_tcp_has_wspace(struct svc_xprt *xprt)
  386. {
  387. struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);
  388. if (test_bit(XPT_LISTENER, &xprt->xpt_flags))
  389. return 1;
  390. return !test_bit(SOCK_NOSPACE, &svsk->sk_sock->flags);
  391. }
  392. static void svc_tcp_kill_temp_xprt(struct svc_xprt *xprt)
  393. {
  394. struct svc_sock *svsk;
  395. struct socket *sock;
  396. struct linger no_linger = {
  397. .l_onoff = 1,
  398. .l_linger = 0,
  399. };
  400. svsk = container_of(xprt, struct svc_sock, sk_xprt);
  401. sock = svsk->sk_sock;
  402. kernel_setsockopt(sock, SOL_SOCKET, SO_LINGER,
  403. (char *)&no_linger, sizeof(no_linger));
  404. }
  405. /*
  406. * See net/ipv6/ip_sockglue.c : ip_cmsg_recv_pktinfo
  407. */
  408. static int svc_udp_get_dest_address4(struct svc_rqst *rqstp,
  409. struct cmsghdr *cmh)
  410. {
  411. struct in_pktinfo *pki = CMSG_DATA(cmh);
  412. struct sockaddr_in *daddr = svc_daddr_in(rqstp);
  413. if (cmh->cmsg_type != IP_PKTINFO)
  414. return 0;
  415. daddr->sin_family = AF_INET;
  416. daddr->sin_addr.s_addr = pki->ipi_spec_dst.s_addr;
  417. return 1;
  418. }
  419. /*
  420. * See net/ipv6/datagram.c : ip6_datagram_recv_ctl
  421. */
  422. static int svc_udp_get_dest_address6(struct svc_rqst *rqstp,
  423. struct cmsghdr *cmh)
  424. {
  425. struct in6_pktinfo *pki = CMSG_DATA(cmh);
  426. struct sockaddr_in6 *daddr = svc_daddr_in6(rqstp);
  427. if (cmh->cmsg_type != IPV6_PKTINFO)
  428. return 0;
  429. daddr->sin6_family = AF_INET6;
  430. daddr->sin6_addr = pki->ipi6_addr;
  431. daddr->sin6_scope_id = pki->ipi6_ifindex;
  432. return 1;
  433. }
  434. /*
  435. * Copy the UDP datagram's destination address to the rqstp structure.
  436. * The 'destination' address in this case is the address to which the
  437. * peer sent the datagram, i.e. our local address. For multihomed
  438. * hosts, this can change from msg to msg. Note that only the IP
  439. * address changes, the port number should remain the same.
  440. */
  441. static int svc_udp_get_dest_address(struct svc_rqst *rqstp,
  442. struct cmsghdr *cmh)
  443. {
  444. switch (cmh->cmsg_level) {
  445. case SOL_IP:
  446. return svc_udp_get_dest_address4(rqstp, cmh);
  447. case SOL_IPV6:
  448. return svc_udp_get_dest_address6(rqstp, cmh);
  449. }
  450. return 0;
  451. }
  452. /*
  453. * Receive a datagram from a UDP socket.
  454. */
  455. static int svc_udp_recvfrom(struct svc_rqst *rqstp)
  456. {
  457. struct svc_sock *svsk =
  458. container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);
  459. struct svc_serv *serv = svsk->sk_xprt.xpt_server;
  460. struct sk_buff *skb;
  461. union {
  462. struct cmsghdr hdr;
  463. long all[SVC_PKTINFO_SPACE / sizeof(long)];
  464. } buffer;
  465. struct cmsghdr *cmh = &buffer.hdr;
  466. struct msghdr msg = {
  467. .msg_name = svc_addr(rqstp),
  468. .msg_control = cmh,
  469. .msg_controllen = sizeof(buffer),
  470. .msg_flags = MSG_DONTWAIT,
  471. };
  472. size_t len;
  473. int err;
  474. if (test_and_clear_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags))
  475. /* udp sockets need large rcvbuf as all pending
  476. * requests are still in that buffer. sndbuf must
  477. * also be large enough that there is enough space
  478. * for one reply per thread. We count all threads
  479. * rather than threads in a particular pool, which
  480. * provides an upper bound on the number of threads
  481. * which will access the socket.
  482. */
  483. svc_sock_setbufsize(svsk, serv->sv_nrthreads + 3);
  484. clear_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
  485. skb = NULL;
  486. err = kernel_recvmsg(svsk->sk_sock, &msg, NULL,
  487. 0, 0, MSG_PEEK | MSG_DONTWAIT);
  488. if (err >= 0)
  489. skb = skb_recv_udp(svsk->sk_sk, 0, 1, &err);
  490. if (skb == NULL) {
  491. if (err != -EAGAIN) {
  492. /* possibly an icmp error */
  493. dprintk("svc: recvfrom returned error %d\n", -err);
  494. set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
  495. }
  496. return 0;
  497. }
  498. len = svc_addr_len(svc_addr(rqstp));
  499. rqstp->rq_addrlen = len;
  500. if (skb->tstamp == 0) {
  501. skb->tstamp = ktime_get_real();
  502. /* Don't enable netstamp, sunrpc doesn't
  503. need that much accuracy */
  504. }
  505. sock_write_timestamp(svsk->sk_sk, skb->tstamp);
  506. set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags); /* there may be more data... */
  507. len = skb->len;
  508. rqstp->rq_arg.len = len;
  509. rqstp->rq_prot = IPPROTO_UDP;
  510. if (!svc_udp_get_dest_address(rqstp, cmh)) {
  511. net_warn_ratelimited("svc: received unknown control message %d/%d; dropping RPC reply datagram\n",
  512. cmh->cmsg_level, cmh->cmsg_type);
  513. goto out_free;
  514. }
  515. rqstp->rq_daddrlen = svc_addr_len(svc_daddr(rqstp));
  516. if (skb_is_nonlinear(skb)) {
  517. /* we have to copy */
  518. local_bh_disable();
  519. if (csum_partial_copy_to_xdr(&rqstp->rq_arg, skb)) {
  520. local_bh_enable();
  521. /* checksum error */
  522. goto out_free;
  523. }
  524. local_bh_enable();
  525. consume_skb(skb);
  526. } else {
  527. /* we can use it in-place */
  528. rqstp->rq_arg.head[0].iov_base = skb->data;
  529. rqstp->rq_arg.head[0].iov_len = len;
  530. if (skb_checksum_complete(skb))
  531. goto out_free;
  532. rqstp->rq_xprt_ctxt = skb;
  533. }
  534. rqstp->rq_arg.page_base = 0;
  535. if (len <= rqstp->rq_arg.head[0].iov_len) {
  536. rqstp->rq_arg.head[0].iov_len = len;
  537. rqstp->rq_arg.page_len = 0;
  538. rqstp->rq_respages = rqstp->rq_pages+1;
  539. } else {
  540. rqstp->rq_arg.page_len = len - rqstp->rq_arg.head[0].iov_len;
  541. rqstp->rq_respages = rqstp->rq_pages + 1 +
  542. DIV_ROUND_UP(rqstp->rq_arg.page_len, PAGE_SIZE);
  543. }
  544. rqstp->rq_next_page = rqstp->rq_respages+1;
  545. if (serv->sv_stats)
  546. serv->sv_stats->netudpcnt++;
  547. return len;
  548. out_free:
  549. kfree_skb(skb);
  550. return 0;
  551. }
  552. static int
  553. svc_udp_sendto(struct svc_rqst *rqstp)
  554. {
  555. int error;
  556. svc_release_udp_skb(rqstp);
  557. error = svc_sendto(rqstp, &rqstp->rq_res);
  558. if (error == -ECONNREFUSED)
  559. /* ICMP error on earlier request. */
  560. error = svc_sendto(rqstp, &rqstp->rq_res);
  561. return error;
  562. }
  563. static void svc_udp_prep_reply_hdr(struct svc_rqst *rqstp)
  564. {
  565. }
  566. static int svc_udp_has_wspace(struct svc_xprt *xprt)
  567. {
  568. struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);
  569. struct svc_serv *serv = xprt->xpt_server;
  570. unsigned long required;
  571. /*
  572. * Set the SOCK_NOSPACE flag before checking the available
  573. * sock space.
  574. */
  575. set_bit(SOCK_NOSPACE, &svsk->sk_sock->flags);
  576. required = atomic_read(&svsk->sk_xprt.xpt_reserved) + serv->sv_max_mesg;
  577. if (required*2 > sock_wspace(svsk->sk_sk))
  578. return 0;
  579. clear_bit(SOCK_NOSPACE, &svsk->sk_sock->flags);
  580. return 1;
  581. }
  582. static struct svc_xprt *svc_udp_accept(struct svc_xprt *xprt)
  583. {
  584. BUG();
  585. return NULL;
  586. }
  587. static void svc_udp_kill_temp_xprt(struct svc_xprt *xprt)
  588. {
  589. }
  590. static struct svc_xprt *svc_udp_create(struct svc_serv *serv,
  591. struct net *net,
  592. struct sockaddr *sa, int salen,
  593. int flags)
  594. {
  595. return svc_create_socket(serv, IPPROTO_UDP, net, sa, salen, flags);
  596. }
  597. static const struct svc_xprt_ops svc_udp_ops = {
  598. .xpo_create = svc_udp_create,
  599. .xpo_recvfrom = svc_udp_recvfrom,
  600. .xpo_sendto = svc_udp_sendto,
  601. .xpo_release_rqst = svc_release_udp_skb,
  602. .xpo_detach = svc_sock_detach,
  603. .xpo_free = svc_sock_free,
  604. .xpo_prep_reply_hdr = svc_udp_prep_reply_hdr,
  605. .xpo_has_wspace = svc_udp_has_wspace,
  606. .xpo_accept = svc_udp_accept,
  607. .xpo_secure_port = svc_sock_secure_port,
  608. .xpo_kill_temp_xprt = svc_udp_kill_temp_xprt,
  609. };
  610. static struct svc_xprt_class svc_udp_class = {
  611. .xcl_name = "udp",
  612. .xcl_owner = THIS_MODULE,
  613. .xcl_ops = &svc_udp_ops,
  614. .xcl_max_payload = RPCSVC_MAXPAYLOAD_UDP,
  615. .xcl_ident = XPRT_TRANSPORT_UDP,
  616. };
  617. static void svc_udp_init(struct svc_sock *svsk, struct svc_serv *serv)
  618. {
  619. int err, level, optname, one = 1;
  620. svc_xprt_init(sock_net(svsk->sk_sock->sk), &svc_udp_class,
  621. &svsk->sk_xprt, serv);
  622. clear_bit(XPT_CACHE_AUTH, &svsk->sk_xprt.xpt_flags);
  623. svsk->sk_sk->sk_data_ready = svc_data_ready;
  624. svsk->sk_sk->sk_write_space = svc_write_space;
  625. /* initialise setting must have enough space to
  626. * receive and respond to one request.
  627. * svc_udp_recvfrom will re-adjust if necessary
  628. */
  629. svc_sock_setbufsize(svsk, 3);
  630. /* data might have come in before data_ready set up */
  631. set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
  632. set_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags);
  633. /* make sure we get destination address info */
  634. switch (svsk->sk_sk->sk_family) {
  635. case AF_INET:
  636. level = SOL_IP;
  637. optname = IP_PKTINFO;
  638. break;
  639. case AF_INET6:
  640. level = SOL_IPV6;
  641. optname = IPV6_RECVPKTINFO;
  642. break;
  643. default:
  644. BUG();
  645. }
  646. err = kernel_setsockopt(svsk->sk_sock, level, optname,
  647. (char *)&one, sizeof(one));
  648. dprintk("svc: kernel_setsockopt returned %d\n", err);
  649. }
  650. /*
  651. * A data_ready event on a listening socket means there's a connection
  652. * pending. Do not use state_change as a substitute for it.
  653. */
  654. static void svc_tcp_listen_data_ready(struct sock *sk)
  655. {
  656. struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data;
  657. dprintk("svc: socket %p TCP (listen) state change %d\n",
  658. sk, sk->sk_state);
  659. if (svsk) {
  660. /* Refer to svc_setup_socket() for details. */
  661. rmb();
  662. svsk->sk_odata(sk);
  663. }
  664. /*
  665. * This callback may called twice when a new connection
  666. * is established as a child socket inherits everything
  667. * from a parent LISTEN socket.
  668. * 1) data_ready method of the parent socket will be called
  669. * when one of child sockets become ESTABLISHED.
  670. * 2) data_ready method of the child socket may be called
  671. * when it receives data before the socket is accepted.
  672. * In case of 2, we should ignore it silently.
  673. */
  674. if (sk->sk_state == TCP_LISTEN) {
  675. if (svsk) {
  676. set_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags);
  677. svc_xprt_enqueue(&svsk->sk_xprt);
  678. } else
  679. printk("svc: socket %p: no user data\n", sk);
  680. }
  681. }
  682. /*
  683. * A state change on a connected socket means it's dying or dead.
  684. */
  685. static void svc_tcp_state_change(struct sock *sk)
  686. {
  687. struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data;
  688. dprintk("svc: socket %p TCP (connected) state change %d (svsk %p)\n",
  689. sk, sk->sk_state, sk->sk_user_data);
  690. if (!svsk)
  691. printk("svc: socket %p: no user data\n", sk);
  692. else {
  693. /* Refer to svc_setup_socket() for details. */
  694. rmb();
  695. svsk->sk_ostate(sk);
  696. if (sk->sk_state != TCP_ESTABLISHED) {
  697. set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
  698. svc_xprt_enqueue(&svsk->sk_xprt);
  699. }
  700. }
  701. }
  702. /*
  703. * Accept a TCP connection
  704. */
  705. static struct svc_xprt *svc_tcp_accept(struct svc_xprt *xprt)
  706. {
  707. struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);
  708. struct sockaddr_storage addr;
  709. struct sockaddr *sin = (struct sockaddr *) &addr;
  710. struct svc_serv *serv = svsk->sk_xprt.xpt_server;
  711. struct socket *sock = svsk->sk_sock;
  712. struct socket *newsock;
  713. struct svc_sock *newsvsk;
  714. int err, slen;
  715. RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
  716. dprintk("svc: tcp_accept %p sock %p\n", svsk, sock);
  717. if (!sock)
  718. return NULL;
  719. clear_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags);
  720. err = kernel_accept(sock, &newsock, O_NONBLOCK);
  721. if (err < 0) {
  722. if (err == -ENOMEM)
  723. printk(KERN_WARNING "%s: no more sockets!\n",
  724. serv->sv_name);
  725. else if (err != -EAGAIN)
  726. net_warn_ratelimited("%s: accept failed (err %d)!\n",
  727. serv->sv_name, -err);
  728. return NULL;
  729. }
  730. set_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags);
  731. err = kernel_getpeername(newsock, sin);
  732. if (err < 0) {
  733. net_warn_ratelimited("%s: peername failed (err %d)!\n",
  734. serv->sv_name, -err);
  735. goto failed; /* aborted connection or whatever */
  736. }
  737. slen = err;
  738. /* Ideally, we would want to reject connections from unauthorized
  739. * hosts here, but when we get encryption, the IP of the host won't
  740. * tell us anything. For now just warn about unpriv connections.
  741. */
  742. if (!svc_port_is_privileged(sin)) {
  743. dprintk("%s: connect from unprivileged port: %s\n",
  744. serv->sv_name,
  745. __svc_print_addr(sin, buf, sizeof(buf)));
  746. }
  747. dprintk("%s: connect from %s\n", serv->sv_name,
  748. __svc_print_addr(sin, buf, sizeof(buf)));
  749. /* Reset the inherited callbacks before calling svc_setup_socket */
  750. newsock->sk->sk_state_change = svsk->sk_ostate;
  751. newsock->sk->sk_data_ready = svsk->sk_odata;
  752. newsock->sk->sk_write_space = svsk->sk_owspace;
  753. /* make sure that a write doesn't block forever when
  754. * low on memory
  755. */
  756. newsock->sk->sk_sndtimeo = HZ*30;
  757. newsvsk = svc_setup_socket(serv, newsock,
  758. (SVC_SOCK_ANONYMOUS | SVC_SOCK_TEMPORARY));
  759. if (IS_ERR(newsvsk))
  760. goto failed;
  761. svc_xprt_set_remote(&newsvsk->sk_xprt, sin, slen);
  762. err = kernel_getsockname(newsock, sin);
  763. slen = err;
  764. if (unlikely(err < 0)) {
  765. dprintk("svc_tcp_accept: kernel_getsockname error %d\n", -err);
  766. slen = offsetof(struct sockaddr, sa_data);
  767. }
  768. svc_xprt_set_local(&newsvsk->sk_xprt, sin, slen);
  769. if (sock_is_loopback(newsock->sk))
  770. set_bit(XPT_LOCAL, &newsvsk->sk_xprt.xpt_flags);
  771. else
  772. clear_bit(XPT_LOCAL, &newsvsk->sk_xprt.xpt_flags);
  773. if (serv->sv_stats)
  774. serv->sv_stats->nettcpconn++;
  775. return &newsvsk->sk_xprt;
  776. failed:
  777. sock_release(newsock);
  778. return NULL;
  779. }
  780. static unsigned int svc_tcp_restore_pages(struct svc_sock *svsk, struct svc_rqst *rqstp)
  781. {
  782. unsigned int i, len, npages;
  783. if (svsk->sk_datalen == 0)
  784. return 0;
  785. len = svsk->sk_datalen;
  786. npages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
  787. for (i = 0; i < npages; i++) {
  788. if (rqstp->rq_pages[i] != NULL)
  789. put_page(rqstp->rq_pages[i]);
  790. BUG_ON(svsk->sk_pages[i] == NULL);
  791. rqstp->rq_pages[i] = svsk->sk_pages[i];
  792. svsk->sk_pages[i] = NULL;
  793. }
  794. rqstp->rq_arg.head[0].iov_base = page_address(rqstp->rq_pages[0]);
  795. return len;
  796. }
  797. static void svc_tcp_save_pages(struct svc_sock *svsk, struct svc_rqst *rqstp)
  798. {
  799. unsigned int i, len, npages;
  800. if (svsk->sk_datalen == 0)
  801. return;
  802. len = svsk->sk_datalen;
  803. npages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
  804. for (i = 0; i < npages; i++) {
  805. svsk->sk_pages[i] = rqstp->rq_pages[i];
  806. rqstp->rq_pages[i] = NULL;
  807. }
  808. }
  809. static void svc_tcp_clear_pages(struct svc_sock *svsk)
  810. {
  811. unsigned int i, len, npages;
  812. if (svsk->sk_datalen == 0)
  813. goto out;
  814. len = svsk->sk_datalen;
  815. npages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
  816. for (i = 0; i < npages; i++) {
  817. if (svsk->sk_pages[i] == NULL) {
  818. WARN_ON_ONCE(1);
  819. continue;
  820. }
  821. put_page(svsk->sk_pages[i]);
  822. svsk->sk_pages[i] = NULL;
  823. }
  824. out:
  825. svsk->sk_tcplen = 0;
  826. svsk->sk_datalen = 0;
  827. }
  828. /*
  829. * Receive fragment record header.
  830. * If we haven't gotten the record length yet, get the next four bytes.
  831. */
  832. static int svc_tcp_recv_record(struct svc_sock *svsk, struct svc_rqst *rqstp)
  833. {
  834. struct svc_serv *serv = svsk->sk_xprt.xpt_server;
  835. unsigned int want;
  836. int len;
  837. if (svsk->sk_tcplen < sizeof(rpc_fraghdr)) {
  838. struct kvec iov;
  839. want = sizeof(rpc_fraghdr) - svsk->sk_tcplen;
  840. iov.iov_base = ((char *) &svsk->sk_reclen) + svsk->sk_tcplen;
  841. iov.iov_len = want;
  842. if ((len = svc_recvfrom(rqstp, &iov, 1, want)) < 0)
  843. goto error;
  844. svsk->sk_tcplen += len;
  845. if (len < want) {
  846. dprintk("svc: short recvfrom while reading record "
  847. "length (%d of %d)\n", len, want);
  848. return -EAGAIN;
  849. }
  850. dprintk("svc: TCP record, %d bytes\n", svc_sock_reclen(svsk));
  851. if (svc_sock_reclen(svsk) + svsk->sk_datalen >
  852. serv->sv_max_mesg) {
  853. net_notice_ratelimited("RPC: fragment too large: %d\n",
  854. svc_sock_reclen(svsk));
  855. goto err_delete;
  856. }
  857. }
  858. return svc_sock_reclen(svsk);
  859. error:
  860. dprintk("RPC: TCP recv_record got %d\n", len);
  861. return len;
  862. err_delete:
  863. set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
  864. return -EAGAIN;
  865. }
  866. static int receive_cb_reply(struct svc_sock *svsk, struct svc_rqst *rqstp)
  867. {
  868. struct rpc_xprt *bc_xprt = svsk->sk_xprt.xpt_bc_xprt;
  869. struct rpc_rqst *req = NULL;
  870. struct kvec *src, *dst;
  871. __be32 *p = (__be32 *)rqstp->rq_arg.head[0].iov_base;
  872. __be32 xid;
  873. __be32 calldir;
  874. xid = *p++;
  875. calldir = *p;
  876. if (!bc_xprt)
  877. return -EAGAIN;
  878. spin_lock(&bc_xprt->recv_lock);
  879. req = xprt_lookup_rqst(bc_xprt, xid);
  880. if (!req)
  881. goto unlock_notfound;
  882. memcpy(&req->rq_private_buf, &req->rq_rcv_buf, sizeof(struct xdr_buf));
  883. /*
  884. * XXX!: cheating for now! Only copying HEAD.
  885. * But we know this is good enough for now (in fact, for any
  886. * callback reply in the forseeable future).
  887. */
  888. dst = &req->rq_private_buf.head[0];
  889. src = &rqstp->rq_arg.head[0];
  890. if (dst->iov_len < src->iov_len)
  891. goto unlock_eagain; /* whatever; just giving up. */
  892. memcpy(dst->iov_base, src->iov_base, src->iov_len);
  893. xprt_complete_rqst(req->rq_task, rqstp->rq_arg.len);
  894. rqstp->rq_arg.len = 0;
  895. spin_unlock(&bc_xprt->recv_lock);
  896. return 0;
  897. unlock_notfound:
  898. printk(KERN_NOTICE
  899. "%s: Got unrecognized reply: "
  900. "calldir 0x%x xpt_bc_xprt %p xid %08x\n",
  901. __func__, ntohl(calldir),
  902. bc_xprt, ntohl(xid));
  903. unlock_eagain:
  904. spin_unlock(&bc_xprt->recv_lock);
  905. return -EAGAIN;
  906. }
  907. static int copy_pages_to_kvecs(struct kvec *vec, struct page **pages, int len)
  908. {
  909. int i = 0;
  910. int t = 0;
  911. while (t < len) {
  912. vec[i].iov_base = page_address(pages[i]);
  913. vec[i].iov_len = PAGE_SIZE;
  914. i++;
  915. t += PAGE_SIZE;
  916. }
  917. return i;
  918. }
  919. static void svc_tcp_fragment_received(struct svc_sock *svsk)
  920. {
  921. /* If we have more data, signal svc_xprt_enqueue() to try again */
  922. dprintk("svc: TCP %s record (%d bytes)\n",
  923. svc_sock_final_rec(svsk) ? "final" : "nonfinal",
  924. svc_sock_reclen(svsk));
  925. svsk->sk_tcplen = 0;
  926. svsk->sk_reclen = 0;
  927. }
  928. /*
  929. * Receive data from a TCP socket.
  930. */
  931. static int svc_tcp_recvfrom(struct svc_rqst *rqstp)
  932. {
  933. struct svc_sock *svsk =
  934. container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);
  935. struct svc_serv *serv = svsk->sk_xprt.xpt_server;
  936. int len;
  937. struct kvec *vec;
  938. unsigned int want, base;
  939. __be32 *p;
  940. __be32 calldir;
  941. int pnum;
  942. dprintk("svc: tcp_recv %p data %d conn %d close %d\n",
  943. svsk, test_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags),
  944. test_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags),
  945. test_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags));
  946. len = svc_tcp_recv_record(svsk, rqstp);
  947. if (len < 0)
  948. goto error;
  949. base = svc_tcp_restore_pages(svsk, rqstp);
  950. want = svc_sock_reclen(svsk) - (svsk->sk_tcplen - sizeof(rpc_fraghdr));
  951. vec = rqstp->rq_vec;
  952. pnum = copy_pages_to_kvecs(&vec[0], &rqstp->rq_pages[0],
  953. svsk->sk_datalen + want);
  954. rqstp->rq_respages = &rqstp->rq_pages[pnum];
  955. rqstp->rq_next_page = rqstp->rq_respages + 1;
  956. /* Now receive data */
  957. len = svc_partial_recvfrom(rqstp, vec, pnum, want, base);
  958. if (len >= 0) {
  959. svsk->sk_tcplen += len;
  960. svsk->sk_datalen += len;
  961. }
  962. if (len != want || !svc_sock_final_rec(svsk)) {
  963. svc_tcp_save_pages(svsk, rqstp);
  964. if (len < 0 && len != -EAGAIN)
  965. goto err_delete;
  966. if (len == want)
  967. svc_tcp_fragment_received(svsk);
  968. else
  969. dprintk("svc: incomplete TCP record (%d of %d)\n",
  970. (int)(svsk->sk_tcplen - sizeof(rpc_fraghdr)),
  971. svc_sock_reclen(svsk));
  972. goto err_noclose;
  973. }
  974. if (svsk->sk_datalen < 8) {
  975. svsk->sk_datalen = 0;
  976. goto err_delete; /* client is nuts. */
  977. }
  978. rqstp->rq_arg.len = svsk->sk_datalen;
  979. rqstp->rq_arg.page_base = 0;
  980. if (rqstp->rq_arg.len <= rqstp->rq_arg.head[0].iov_len) {
  981. rqstp->rq_arg.head[0].iov_len = rqstp->rq_arg.len;
  982. rqstp->rq_arg.page_len = 0;
  983. } else
  984. rqstp->rq_arg.page_len = rqstp->rq_arg.len - rqstp->rq_arg.head[0].iov_len;
  985. rqstp->rq_xprt_ctxt = NULL;
  986. rqstp->rq_prot = IPPROTO_TCP;
  987. if (test_bit(XPT_LOCAL, &svsk->sk_xprt.xpt_flags))
  988. set_bit(RQ_LOCAL, &rqstp->rq_flags);
  989. else
  990. clear_bit(RQ_LOCAL, &rqstp->rq_flags);
  991. p = (__be32 *)rqstp->rq_arg.head[0].iov_base;
  992. calldir = p[1];
  993. if (calldir)
  994. len = receive_cb_reply(svsk, rqstp);
  995. /* Reset TCP read info */
  996. svsk->sk_datalen = 0;
  997. svc_tcp_fragment_received(svsk);
  998. if (len < 0)
  999. goto error;
  1000. svc_xprt_copy_addrs(rqstp, &svsk->sk_xprt);
  1001. if (serv->sv_stats)
  1002. serv->sv_stats->nettcpcnt++;
  1003. return rqstp->rq_arg.len;
  1004. error:
  1005. if (len != -EAGAIN)
  1006. goto err_delete;
  1007. dprintk("RPC: TCP recvfrom got EAGAIN\n");
  1008. return 0;
  1009. err_delete:
  1010. printk(KERN_NOTICE "%s: recvfrom returned errno %d\n",
  1011. svsk->sk_xprt.xpt_server->sv_name, -len);
  1012. set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
  1013. err_noclose:
  1014. return 0; /* record not complete */
  1015. }
  1016. /*
  1017. * Send out data on TCP socket.
  1018. */
  1019. static int svc_tcp_sendto(struct svc_rqst *rqstp)
  1020. {
  1021. struct xdr_buf *xbufp = &rqstp->rq_res;
  1022. int sent;
  1023. __be32 reclen;
  1024. svc_release_skb(rqstp);
  1025. /* Set up the first element of the reply kvec.
  1026. * Any other kvecs that may be in use have been taken
  1027. * care of by the server implementation itself.
  1028. */
  1029. reclen = htonl(0x80000000|((xbufp->len ) - 4));
  1030. memcpy(xbufp->head[0].iov_base, &reclen, 4);
  1031. sent = svc_sendto(rqstp, &rqstp->rq_res);
  1032. if (sent != xbufp->len) {
  1033. printk(KERN_NOTICE
  1034. "rpc-srv/tcp: %s: %s %d when sending %d bytes "
  1035. "- shutting down socket\n",
  1036. rqstp->rq_xprt->xpt_server->sv_name,
  1037. (sent<0)?"got error":"sent only",
  1038. sent, xbufp->len);
  1039. set_bit(XPT_CLOSE, &rqstp->rq_xprt->xpt_flags);
  1040. svc_xprt_enqueue(rqstp->rq_xprt);
  1041. sent = -EAGAIN;
  1042. }
  1043. return sent;
  1044. }
  1045. /*
  1046. * Setup response header. TCP has a 4B record length field.
  1047. */
  1048. void svc_tcp_prep_reply_hdr(struct svc_rqst *rqstp)
  1049. {
  1050. struct kvec *resv = &rqstp->rq_res.head[0];
  1051. /* tcp needs a space for the record length... */
  1052. svc_putnl(resv, 0);
  1053. }
  1054. static struct svc_xprt *svc_tcp_create(struct svc_serv *serv,
  1055. struct net *net,
  1056. struct sockaddr *sa, int salen,
  1057. int flags)
  1058. {
  1059. return svc_create_socket(serv, IPPROTO_TCP, net, sa, salen, flags);
  1060. }
  1061. #if defined(CONFIG_SUNRPC_BACKCHANNEL)
  1062. static struct svc_xprt *svc_bc_create_socket(struct svc_serv *, int,
  1063. struct net *, struct sockaddr *,
  1064. int, int);
  1065. static void svc_bc_sock_free(struct svc_xprt *xprt);
  1066. static struct svc_xprt *svc_bc_tcp_create(struct svc_serv *serv,
  1067. struct net *net,
  1068. struct sockaddr *sa, int salen,
  1069. int flags)
  1070. {
  1071. return svc_bc_create_socket(serv, IPPROTO_TCP, net, sa, salen, flags);
  1072. }
  1073. static void svc_bc_tcp_sock_detach(struct svc_xprt *xprt)
  1074. {
  1075. }
  1076. static const struct svc_xprt_ops svc_tcp_bc_ops = {
  1077. .xpo_create = svc_bc_tcp_create,
  1078. .xpo_detach = svc_bc_tcp_sock_detach,
  1079. .xpo_free = svc_bc_sock_free,
  1080. .xpo_prep_reply_hdr = svc_tcp_prep_reply_hdr,
  1081. .xpo_secure_port = svc_sock_secure_port,
  1082. };
  1083. static struct svc_xprt_class svc_tcp_bc_class = {
  1084. .xcl_name = "tcp-bc",
  1085. .xcl_owner = THIS_MODULE,
  1086. .xcl_ops = &svc_tcp_bc_ops,
  1087. .xcl_max_payload = RPCSVC_MAXPAYLOAD_TCP,
  1088. };
  1089. static void svc_init_bc_xprt_sock(void)
  1090. {
  1091. svc_reg_xprt_class(&svc_tcp_bc_class);
  1092. }
  1093. static void svc_cleanup_bc_xprt_sock(void)
  1094. {
  1095. svc_unreg_xprt_class(&svc_tcp_bc_class);
  1096. }
  1097. #else /* CONFIG_SUNRPC_BACKCHANNEL */
  1098. static void svc_init_bc_xprt_sock(void)
  1099. {
  1100. }
  1101. static void svc_cleanup_bc_xprt_sock(void)
  1102. {
  1103. }
  1104. #endif /* CONFIG_SUNRPC_BACKCHANNEL */
  1105. static const struct svc_xprt_ops svc_tcp_ops = {
  1106. .xpo_create = svc_tcp_create,
  1107. .xpo_recvfrom = svc_tcp_recvfrom,
  1108. .xpo_sendto = svc_tcp_sendto,
  1109. .xpo_release_rqst = svc_release_skb,
  1110. .xpo_detach = svc_tcp_sock_detach,
  1111. .xpo_free = svc_sock_free,
  1112. .xpo_prep_reply_hdr = svc_tcp_prep_reply_hdr,
  1113. .xpo_has_wspace = svc_tcp_has_wspace,
  1114. .xpo_accept = svc_tcp_accept,
  1115. .xpo_secure_port = svc_sock_secure_port,
  1116. .xpo_kill_temp_xprt = svc_tcp_kill_temp_xprt,
  1117. };
  1118. static struct svc_xprt_class svc_tcp_class = {
  1119. .xcl_name = "tcp",
  1120. .xcl_owner = THIS_MODULE,
  1121. .xcl_ops = &svc_tcp_ops,
  1122. .xcl_max_payload = RPCSVC_MAXPAYLOAD_TCP,
  1123. .xcl_ident = XPRT_TRANSPORT_TCP,
  1124. };
  1125. void svc_init_xprt_sock(void)
  1126. {
  1127. svc_reg_xprt_class(&svc_tcp_class);
  1128. svc_reg_xprt_class(&svc_udp_class);
  1129. svc_init_bc_xprt_sock();
  1130. }
  1131. void svc_cleanup_xprt_sock(void)
  1132. {
  1133. svc_unreg_xprt_class(&svc_tcp_class);
  1134. svc_unreg_xprt_class(&svc_udp_class);
  1135. svc_cleanup_bc_xprt_sock();
  1136. }
  1137. static void svc_tcp_init(struct svc_sock *svsk, struct svc_serv *serv)
  1138. {
  1139. struct sock *sk = svsk->sk_sk;
  1140. svc_xprt_init(sock_net(svsk->sk_sock->sk), &svc_tcp_class,
  1141. &svsk->sk_xprt, serv);
  1142. set_bit(XPT_CACHE_AUTH, &svsk->sk_xprt.xpt_flags);
  1143. set_bit(XPT_CONG_CTRL, &svsk->sk_xprt.xpt_flags);
  1144. if (sk->sk_state == TCP_LISTEN) {
  1145. dprintk("setting up TCP socket for listening\n");
  1146. strcpy(svsk->sk_xprt.xpt_remotebuf, "listener");
  1147. set_bit(XPT_LISTENER, &svsk->sk_xprt.xpt_flags);
  1148. sk->sk_data_ready = svc_tcp_listen_data_ready;
  1149. set_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags);
  1150. } else {
  1151. dprintk("setting up TCP socket for reading\n");
  1152. sk->sk_state_change = svc_tcp_state_change;
  1153. sk->sk_data_ready = svc_data_ready;
  1154. sk->sk_write_space = svc_write_space;
  1155. svsk->sk_reclen = 0;
  1156. svsk->sk_tcplen = 0;
  1157. svsk->sk_datalen = 0;
  1158. memset(&svsk->sk_pages[0], 0, sizeof(svsk->sk_pages));
  1159. tcp_sk(sk)->nonagle |= TCP_NAGLE_OFF;
  1160. set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
  1161. switch (sk->sk_state) {
  1162. case TCP_SYN_RECV:
  1163. case TCP_ESTABLISHED:
  1164. break;
  1165. default:
  1166. set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
  1167. }
  1168. }
  1169. }
  1170. void svc_sock_update_bufs(struct svc_serv *serv)
  1171. {
  1172. /*
  1173. * The number of server threads has changed. Update
  1174. * rcvbuf and sndbuf accordingly on all sockets
  1175. */
  1176. struct svc_sock *svsk;
  1177. spin_lock_bh(&serv->sv_lock);
  1178. list_for_each_entry(svsk, &serv->sv_permsocks, sk_xprt.xpt_list)
  1179. set_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags);
  1180. spin_unlock_bh(&serv->sv_lock);
  1181. }
  1182. EXPORT_SYMBOL_GPL(svc_sock_update_bufs);
  1183. /*
  1184. * Initialize socket for RPC use and create svc_sock struct
  1185. */
  1186. static struct svc_sock *svc_setup_socket(struct svc_serv *serv,
  1187. struct socket *sock,
  1188. int flags)
  1189. {
  1190. struct svc_sock *svsk;
  1191. struct sock *inet;
  1192. int pmap_register = !(flags & SVC_SOCK_ANONYMOUS);
  1193. int err = 0;
  1194. dprintk("svc: svc_setup_socket %p\n", sock);
  1195. svsk = kzalloc(sizeof(*svsk), GFP_KERNEL);
  1196. if (!svsk)
  1197. return ERR_PTR(-ENOMEM);
  1198. inet = sock->sk;
  1199. /* Register socket with portmapper */
  1200. if (pmap_register)
  1201. err = svc_register(serv, sock_net(sock->sk), inet->sk_family,
  1202. inet->sk_protocol,
  1203. ntohs(inet_sk(inet)->inet_sport));
  1204. if (err < 0) {
  1205. kfree(svsk);
  1206. return ERR_PTR(err);
  1207. }
  1208. svsk->sk_sock = sock;
  1209. svsk->sk_sk = inet;
  1210. svsk->sk_ostate = inet->sk_state_change;
  1211. svsk->sk_odata = inet->sk_data_ready;
  1212. svsk->sk_owspace = inet->sk_write_space;
  1213. /*
  1214. * This barrier is necessary in order to prevent race condition
  1215. * with svc_data_ready(), svc_listen_data_ready() and others
  1216. * when calling callbacks above.
  1217. */
  1218. wmb();
  1219. inet->sk_user_data = svsk;
  1220. /* Initialize the socket */
  1221. if (sock->type == SOCK_DGRAM)
  1222. svc_udp_init(svsk, serv);
  1223. else
  1224. svc_tcp_init(svsk, serv);
  1225. dprintk("svc: svc_setup_socket created %p (inet %p), "
  1226. "listen %d close %d\n",
  1227. svsk, svsk->sk_sk,
  1228. test_bit(XPT_LISTENER, &svsk->sk_xprt.xpt_flags),
  1229. test_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags));
  1230. return svsk;
  1231. }
  1232. bool svc_alien_sock(struct net *net, int fd)
  1233. {
  1234. int err;
  1235. struct socket *sock = sockfd_lookup(fd, &err);
  1236. bool ret = false;
  1237. if (!sock)
  1238. goto out;
  1239. if (sock_net(sock->sk) != net)
  1240. ret = true;
  1241. sockfd_put(sock);
  1242. out:
  1243. return ret;
  1244. }
  1245. EXPORT_SYMBOL_GPL(svc_alien_sock);
  1246. /**
  1247. * svc_addsock - add a listener socket to an RPC service
  1248. * @serv: pointer to RPC service to which to add a new listener
  1249. * @fd: file descriptor of the new listener
  1250. * @name_return: pointer to buffer to fill in with name of listener
  1251. * @len: size of the buffer
  1252. *
  1253. * Fills in socket name and returns positive length of name if successful.
  1254. * Name is terminated with '\n'. On error, returns a negative errno
  1255. * value.
  1256. */
  1257. int svc_addsock(struct svc_serv *serv, const int fd, char *name_return,
  1258. const size_t len)
  1259. {
  1260. int err = 0;
  1261. struct socket *so = sockfd_lookup(fd, &err);
  1262. struct svc_sock *svsk = NULL;
  1263. struct sockaddr_storage addr;
  1264. struct sockaddr *sin = (struct sockaddr *)&addr;
  1265. int salen;
  1266. if (!so)
  1267. return err;
  1268. err = -EAFNOSUPPORT;
  1269. if ((so->sk->sk_family != PF_INET) && (so->sk->sk_family != PF_INET6))
  1270. goto out;
  1271. err = -EPROTONOSUPPORT;
  1272. if (so->sk->sk_protocol != IPPROTO_TCP &&
  1273. so->sk->sk_protocol != IPPROTO_UDP)
  1274. goto out;
  1275. err = -EISCONN;
  1276. if (so->state > SS_UNCONNECTED)
  1277. goto out;
  1278. err = -ENOENT;
  1279. if (!try_module_get(THIS_MODULE))
  1280. goto out;
  1281. svsk = svc_setup_socket(serv, so, SVC_SOCK_DEFAULTS);
  1282. if (IS_ERR(svsk)) {
  1283. module_put(THIS_MODULE);
  1284. err = PTR_ERR(svsk);
  1285. goto out;
  1286. }
  1287. salen = kernel_getsockname(svsk->sk_sock, sin);
  1288. if (salen >= 0)
  1289. svc_xprt_set_local(&svsk->sk_xprt, sin, salen);
  1290. svc_add_new_perm_xprt(serv, &svsk->sk_xprt);
  1291. return svc_one_sock_name(svsk, name_return, len);
  1292. out:
  1293. sockfd_put(so);
  1294. return err;
  1295. }
  1296. EXPORT_SYMBOL_GPL(svc_addsock);
  1297. /*
  1298. * Create socket for RPC service.
  1299. */
  1300. static struct svc_xprt *svc_create_socket(struct svc_serv *serv,
  1301. int protocol,
  1302. struct net *net,
  1303. struct sockaddr *sin, int len,
  1304. int flags)
  1305. {
  1306. struct svc_sock *svsk;
  1307. struct socket *sock;
  1308. int error;
  1309. int type;
  1310. struct sockaddr_storage addr;
  1311. struct sockaddr *newsin = (struct sockaddr *)&addr;
  1312. int newlen;
  1313. int family;
  1314. int val;
  1315. RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
  1316. dprintk("svc: svc_create_socket(%s, %d, %s)\n",
  1317. serv->sv_program->pg_name, protocol,
  1318. __svc_print_addr(sin, buf, sizeof(buf)));
  1319. if (protocol != IPPROTO_UDP && protocol != IPPROTO_TCP) {
  1320. printk(KERN_WARNING "svc: only UDP and TCP "
  1321. "sockets supported\n");
  1322. return ERR_PTR(-EINVAL);
  1323. }
  1324. type = (protocol == IPPROTO_UDP)? SOCK_DGRAM : SOCK_STREAM;
  1325. switch (sin->sa_family) {
  1326. case AF_INET6:
  1327. family = PF_INET6;
  1328. break;
  1329. case AF_INET:
  1330. family = PF_INET;
  1331. break;
  1332. default:
  1333. return ERR_PTR(-EINVAL);
  1334. }
  1335. error = __sock_create(net, family, type, protocol, &sock, 1);
  1336. if (error < 0)
  1337. return ERR_PTR(error);
  1338. svc_reclassify_socket(sock);
  1339. /*
  1340. * If this is an PF_INET6 listener, we want to avoid
  1341. * getting requests from IPv4 remotes. Those should
  1342. * be shunted to a PF_INET listener via rpcbind.
  1343. */
  1344. val = 1;
  1345. if (family == PF_INET6)
  1346. kernel_setsockopt(sock, SOL_IPV6, IPV6_V6ONLY,
  1347. (char *)&val, sizeof(val));
  1348. if (type == SOCK_STREAM)
  1349. sock->sk->sk_reuse = SK_CAN_REUSE; /* allow address reuse */
  1350. error = kernel_bind(sock, sin, len);
  1351. if (error < 0)
  1352. goto bummer;
  1353. error = kernel_getsockname(sock, newsin);
  1354. if (error < 0)
  1355. goto bummer;
  1356. newlen = error;
  1357. if (protocol == IPPROTO_TCP) {
  1358. if ((error = kernel_listen(sock, 64)) < 0)
  1359. goto bummer;
  1360. }
  1361. svsk = svc_setup_socket(serv, sock, flags);
  1362. if (IS_ERR(svsk)) {
  1363. error = PTR_ERR(svsk);
  1364. goto bummer;
  1365. }
  1366. svc_xprt_set_local(&svsk->sk_xprt, newsin, newlen);
  1367. return (struct svc_xprt *)svsk;
  1368. bummer:
  1369. dprintk("svc: svc_create_socket error = %d\n", -error);
  1370. sock_release(sock);
  1371. return ERR_PTR(error);
  1372. }
  1373. /*
  1374. * Detach the svc_sock from the socket so that no
  1375. * more callbacks occur.
  1376. */
  1377. static void svc_sock_detach(struct svc_xprt *xprt)
  1378. {
  1379. struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);
  1380. struct sock *sk = svsk->sk_sk;
  1381. dprintk("svc: svc_sock_detach(%p)\n", svsk);
  1382. /* put back the old socket callbacks */
  1383. lock_sock(sk);
  1384. sk->sk_state_change = svsk->sk_ostate;
  1385. sk->sk_data_ready = svsk->sk_odata;
  1386. sk->sk_write_space = svsk->sk_owspace;
  1387. sk->sk_user_data = NULL;
  1388. release_sock(sk);
  1389. }
  1390. /*
  1391. * Disconnect the socket, and reset the callbacks
  1392. */
  1393. static void svc_tcp_sock_detach(struct svc_xprt *xprt)
  1394. {
  1395. struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);
  1396. dprintk("svc: svc_tcp_sock_detach(%p)\n", svsk);
  1397. svc_sock_detach(xprt);
  1398. if (!test_bit(XPT_LISTENER, &xprt->xpt_flags)) {
  1399. svc_tcp_clear_pages(svsk);
  1400. kernel_sock_shutdown(svsk->sk_sock, SHUT_RDWR);
  1401. }
  1402. }
  1403. /*
  1404. * Free the svc_sock's socket resources and the svc_sock itself.
  1405. */
  1406. static void svc_sock_free(struct svc_xprt *xprt)
  1407. {
  1408. struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);
  1409. dprintk("svc: svc_sock_free(%p)\n", svsk);
  1410. if (svsk->sk_sock->file)
  1411. sockfd_put(svsk->sk_sock);
  1412. else
  1413. sock_release(svsk->sk_sock);
  1414. kfree(svsk);
  1415. }
  1416. #if defined(CONFIG_SUNRPC_BACKCHANNEL)
  1417. /*
  1418. * Create a back channel svc_xprt which shares the fore channel socket.
  1419. */
  1420. static struct svc_xprt *svc_bc_create_socket(struct svc_serv *serv,
  1421. int protocol,
  1422. struct net *net,
  1423. struct sockaddr *sin, int len,
  1424. int flags)
  1425. {
  1426. struct svc_sock *svsk;
  1427. struct svc_xprt *xprt;
  1428. if (protocol != IPPROTO_TCP) {
  1429. printk(KERN_WARNING "svc: only TCP sockets"
  1430. " supported on shared back channel\n");
  1431. return ERR_PTR(-EINVAL);
  1432. }
  1433. svsk = kzalloc(sizeof(*svsk), GFP_KERNEL);
  1434. if (!svsk)
  1435. return ERR_PTR(-ENOMEM);
  1436. xprt = &svsk->sk_xprt;
  1437. svc_xprt_init(net, &svc_tcp_bc_class, xprt, serv);
  1438. set_bit(XPT_CONG_CTRL, &svsk->sk_xprt.xpt_flags);
  1439. serv->sv_bc_xprt = xprt;
  1440. return xprt;
  1441. }
  1442. /*
  1443. * Free a back channel svc_sock.
  1444. */
  1445. static void svc_bc_sock_free(struct svc_xprt *xprt)
  1446. {
  1447. if (xprt)
  1448. kfree(container_of(xprt, struct svc_sock, sk_xprt));
  1449. }
  1450. #endif /* CONFIG_SUNRPC_BACKCHANNEL */