xprtsock.c 68 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662
  1. /*
  2. * linux/net/sunrpc/xprtsock.c
  3. *
  4. * Client-side transport implementation for sockets.
  5. *
  6. * TCP callback races fixes (C) 1998 Red Hat
  7. * TCP send fixes (C) 1998 Red Hat
  8. * TCP NFS related read + write fixes
  9. * (C) 1999 Dave Airlie, University of Limerick, Ireland <airlied@linux.ie>
  10. *
  11. * Rewrite of larges part of the code in order to stabilize TCP stuff.
  12. * Fix behaviour when socket buffer is full.
  13. * (C) 1999 Trond Myklebust <trond.myklebust@fys.uio.no>
  14. *
  15. * IP socket transport implementation, (C) 2005 Chuck Lever <cel@netapp.com>
  16. *
  17. * IPv6 support contributed by Gilles Quillard, Bull Open Source, 2005.
  18. * <gilles.quillard@bull.net>
  19. */
  20. #include <linux/types.h>
  21. #include <linux/slab.h>
  22. #include <linux/module.h>
  23. #include <linux/capability.h>
  24. #include <linux/pagemap.h>
  25. #include <linux/errno.h>
  26. #include <linux/socket.h>
  27. #include <linux/in.h>
  28. #include <linux/net.h>
  29. #include <linux/mm.h>
  30. #include <linux/udp.h>
  31. #include <linux/tcp.h>
  32. #include <linux/sunrpc/clnt.h>
  33. #include <linux/sunrpc/sched.h>
  34. #include <linux/sunrpc/svcsock.h>
  35. #include <linux/sunrpc/xprtsock.h>
  36. #include <linux/file.h>
  37. #ifdef CONFIG_NFS_V4_1
  38. #include <linux/sunrpc/bc_xprt.h>
  39. #endif
  40. #include <net/sock.h>
  41. #include <net/checksum.h>
  42. #include <net/udp.h>
  43. #include <net/tcp.h>
  44. #include "sunrpc.h"
  45. /*
  46. * xprtsock tunables
  47. */
  48. unsigned int xprt_udp_slot_table_entries = RPC_DEF_SLOT_TABLE;
  49. unsigned int xprt_tcp_slot_table_entries = RPC_DEF_SLOT_TABLE;
  50. unsigned int xprt_min_resvport = RPC_DEF_MIN_RESVPORT;
  51. unsigned int xprt_max_resvport = RPC_DEF_MAX_RESVPORT;
  52. #define XS_TCP_LINGER_TO (15U * HZ)
  53. static unsigned int xs_tcp_fin_timeout __read_mostly = XS_TCP_LINGER_TO;
  54. /*
  55. * We can register our own files under /proc/sys/sunrpc by
  56. * calling register_sysctl_table() again. The files in that
  57. * directory become the union of all files registered there.
  58. *
  59. * We simply need to make sure that we don't collide with
  60. * someone else's file names!
  61. */
  62. #ifdef RPC_DEBUG
  63. static unsigned int min_slot_table_size = RPC_MIN_SLOT_TABLE;
  64. static unsigned int max_slot_table_size = RPC_MAX_SLOT_TABLE;
  65. static unsigned int xprt_min_resvport_limit = RPC_MIN_RESVPORT;
  66. static unsigned int xprt_max_resvport_limit = RPC_MAX_RESVPORT;
  67. static struct ctl_table_header *sunrpc_table_header;
  68. /*
  69. * FIXME: changing the UDP slot table size should also resize the UDP
  70. * socket buffers for existing UDP transports
  71. */
  72. static ctl_table xs_tunables_table[] = {
  73. {
  74. .procname = "udp_slot_table_entries",
  75. .data = &xprt_udp_slot_table_entries,
  76. .maxlen = sizeof(unsigned int),
  77. .mode = 0644,
  78. .proc_handler = proc_dointvec_minmax,
  79. .extra1 = &min_slot_table_size,
  80. .extra2 = &max_slot_table_size
  81. },
  82. {
  83. .procname = "tcp_slot_table_entries",
  84. .data = &xprt_tcp_slot_table_entries,
  85. .maxlen = sizeof(unsigned int),
  86. .mode = 0644,
  87. .proc_handler = proc_dointvec_minmax,
  88. .extra1 = &min_slot_table_size,
  89. .extra2 = &max_slot_table_size
  90. },
  91. {
  92. .procname = "min_resvport",
  93. .data = &xprt_min_resvport,
  94. .maxlen = sizeof(unsigned int),
  95. .mode = 0644,
  96. .proc_handler = proc_dointvec_minmax,
  97. .extra1 = &xprt_min_resvport_limit,
  98. .extra2 = &xprt_max_resvport_limit
  99. },
  100. {
  101. .procname = "max_resvport",
  102. .data = &xprt_max_resvport,
  103. .maxlen = sizeof(unsigned int),
  104. .mode = 0644,
  105. .proc_handler = proc_dointvec_minmax,
  106. .extra1 = &xprt_min_resvport_limit,
  107. .extra2 = &xprt_max_resvport_limit
  108. },
  109. {
  110. .procname = "tcp_fin_timeout",
  111. .data = &xs_tcp_fin_timeout,
  112. .maxlen = sizeof(xs_tcp_fin_timeout),
  113. .mode = 0644,
  114. .proc_handler = proc_dointvec_jiffies,
  115. },
  116. { },
  117. };
  118. static ctl_table sunrpc_table[] = {
  119. {
  120. .procname = "sunrpc",
  121. .mode = 0555,
  122. .child = xs_tunables_table
  123. },
  124. { },
  125. };
  126. #endif
  127. /*
  128. * Time out for an RPC UDP socket connect. UDP socket connects are
  129. * synchronous, but we set a timeout anyway in case of resource
  130. * exhaustion on the local host.
  131. */
  132. #define XS_UDP_CONN_TO (5U * HZ)
  133. /*
  134. * Wait duration for an RPC TCP connection to be established. Solaris
  135. * NFS over TCP uses 60 seconds, for example, which is in line with how
  136. * long a server takes to reboot.
  137. */
  138. #define XS_TCP_CONN_TO (60U * HZ)
  139. /*
  140. * Wait duration for a reply from the RPC portmapper.
  141. */
  142. #define XS_BIND_TO (60U * HZ)
  143. /*
  144. * Delay if a UDP socket connect error occurs. This is most likely some
  145. * kind of resource problem on the local host.
  146. */
  147. #define XS_UDP_REEST_TO (2U * HZ)
  148. /*
  149. * The reestablish timeout allows clients to delay for a bit before attempting
  150. * to reconnect to a server that just dropped our connection.
  151. *
  152. * We implement an exponential backoff when trying to reestablish a TCP
  153. * transport connection with the server. Some servers like to drop a TCP
  154. * connection when they are overworked, so we start with a short timeout and
  155. * increase over time if the server is down or not responding.
  156. */
  157. #define XS_TCP_INIT_REEST_TO (3U * HZ)
  158. #define XS_TCP_MAX_REEST_TO (5U * 60 * HZ)
  159. /*
  160. * TCP idle timeout; client drops the transport socket if it is idle
  161. * for this long. Note that we also timeout UDP sockets to prevent
  162. * holding port numbers when there is no RPC traffic.
  163. */
  164. #define XS_IDLE_DISC_TO (5U * 60 * HZ)
  165. #ifdef RPC_DEBUG
  166. # undef RPC_DEBUG_DATA
  167. # define RPCDBG_FACILITY RPCDBG_TRANS
  168. #endif
  169. #ifdef RPC_DEBUG_DATA
  170. static void xs_pktdump(char *msg, u32 *packet, unsigned int count)
  171. {
  172. u8 *buf = (u8 *) packet;
  173. int j;
  174. dprintk("RPC: %s\n", msg);
  175. for (j = 0; j < count && j < 128; j += 4) {
  176. if (!(j & 31)) {
  177. if (j)
  178. dprintk("\n");
  179. dprintk("0x%04x ", j);
  180. }
  181. dprintk("%02x%02x%02x%02x ",
  182. buf[j], buf[j+1], buf[j+2], buf[j+3]);
  183. }
  184. dprintk("\n");
  185. }
  186. #else
  187. static inline void xs_pktdump(char *msg, u32 *packet, unsigned int count)
  188. {
  189. /* NOP */
  190. }
  191. #endif
  192. struct sock_xprt {
  193. struct rpc_xprt xprt;
  194. /*
  195. * Network layer
  196. */
  197. struct socket * sock;
  198. struct sock * inet;
  199. /*
  200. * State of TCP reply receive
  201. */
  202. __be32 tcp_fraghdr,
  203. tcp_xid;
  204. u32 tcp_offset,
  205. tcp_reclen;
  206. unsigned long tcp_copied,
  207. tcp_flags;
  208. /*
  209. * Connection of transports
  210. */
  211. struct delayed_work connect_worker;
  212. struct sockaddr_storage srcaddr;
  213. unsigned short srcport;
  214. /*
  215. * UDP socket buffer size parameters
  216. */
  217. size_t rcvsize,
  218. sndsize;
  219. /*
  220. * Saved socket callback addresses
  221. */
  222. void (*old_data_ready)(struct sock *, int);
  223. void (*old_state_change)(struct sock *);
  224. void (*old_write_space)(struct sock *);
  225. void (*old_error_report)(struct sock *);
  226. };
  227. /*
  228. * TCP receive state flags
  229. */
  230. #define TCP_RCV_LAST_FRAG (1UL << 0)
  231. #define TCP_RCV_COPY_FRAGHDR (1UL << 1)
  232. #define TCP_RCV_COPY_XID (1UL << 2)
  233. #define TCP_RCV_COPY_DATA (1UL << 3)
  234. #define TCP_RCV_READ_CALLDIR (1UL << 4)
  235. #define TCP_RCV_COPY_CALLDIR (1UL << 5)
  236. /*
  237. * TCP RPC flags
  238. */
  239. #define TCP_RPC_REPLY (1UL << 6)
  240. static inline struct sockaddr *xs_addr(struct rpc_xprt *xprt)
  241. {
  242. return (struct sockaddr *) &xprt->addr;
  243. }
  244. static inline struct sockaddr_in *xs_addr_in(struct rpc_xprt *xprt)
  245. {
  246. return (struct sockaddr_in *) &xprt->addr;
  247. }
  248. static inline struct sockaddr_in6 *xs_addr_in6(struct rpc_xprt *xprt)
  249. {
  250. return (struct sockaddr_in6 *) &xprt->addr;
  251. }
  252. static void xs_format_common_peer_addresses(struct rpc_xprt *xprt)
  253. {
  254. struct sockaddr *sap = xs_addr(xprt);
  255. struct sockaddr_in6 *sin6;
  256. struct sockaddr_in *sin;
  257. char buf[128];
  258. (void)rpc_ntop(sap, buf, sizeof(buf));
  259. xprt->address_strings[RPC_DISPLAY_ADDR] = kstrdup(buf, GFP_KERNEL);
  260. switch (sap->sa_family) {
  261. case AF_INET:
  262. sin = xs_addr_in(xprt);
  263. snprintf(buf, sizeof(buf), "%08x", ntohl(sin->sin_addr.s_addr));
  264. break;
  265. case AF_INET6:
  266. sin6 = xs_addr_in6(xprt);
  267. snprintf(buf, sizeof(buf), "%pi6", &sin6->sin6_addr);
  268. break;
  269. default:
  270. BUG();
  271. }
  272. xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = kstrdup(buf, GFP_KERNEL);
  273. }
  274. static void xs_format_common_peer_ports(struct rpc_xprt *xprt)
  275. {
  276. struct sockaddr *sap = xs_addr(xprt);
  277. char buf[128];
  278. snprintf(buf, sizeof(buf), "%u", rpc_get_port(sap));
  279. xprt->address_strings[RPC_DISPLAY_PORT] = kstrdup(buf, GFP_KERNEL);
  280. snprintf(buf, sizeof(buf), "%4hx", rpc_get_port(sap));
  281. xprt->address_strings[RPC_DISPLAY_HEX_PORT] = kstrdup(buf, GFP_KERNEL);
  282. }
  283. static void xs_format_peer_addresses(struct rpc_xprt *xprt,
  284. const char *protocol,
  285. const char *netid)
  286. {
  287. xprt->address_strings[RPC_DISPLAY_PROTO] = protocol;
  288. xprt->address_strings[RPC_DISPLAY_NETID] = netid;
  289. xs_format_common_peer_addresses(xprt);
  290. xs_format_common_peer_ports(xprt);
  291. }
  292. static void xs_update_peer_port(struct rpc_xprt *xprt)
  293. {
  294. kfree(xprt->address_strings[RPC_DISPLAY_HEX_PORT]);
  295. kfree(xprt->address_strings[RPC_DISPLAY_PORT]);
  296. xs_format_common_peer_ports(xprt);
  297. }
  298. static void xs_free_peer_addresses(struct rpc_xprt *xprt)
  299. {
  300. unsigned int i;
  301. for (i = 0; i < RPC_DISPLAY_MAX; i++)
  302. switch (i) {
  303. case RPC_DISPLAY_PROTO:
  304. case RPC_DISPLAY_NETID:
  305. continue;
  306. default:
  307. kfree(xprt->address_strings[i]);
  308. }
  309. }
  310. #define XS_SENDMSG_FLAGS (MSG_DONTWAIT | MSG_NOSIGNAL)
  311. static int xs_send_kvec(struct socket *sock, struct sockaddr *addr, int addrlen, struct kvec *vec, unsigned int base, int more)
  312. {
  313. struct msghdr msg = {
  314. .msg_name = addr,
  315. .msg_namelen = addrlen,
  316. .msg_flags = XS_SENDMSG_FLAGS | (more ? MSG_MORE : 0),
  317. };
  318. struct kvec iov = {
  319. .iov_base = vec->iov_base + base,
  320. .iov_len = vec->iov_len - base,
  321. };
  322. if (iov.iov_len != 0)
  323. return kernel_sendmsg(sock, &msg, &iov, 1, iov.iov_len);
  324. return kernel_sendmsg(sock, &msg, NULL, 0, 0);
  325. }
  326. static int xs_send_pagedata(struct socket *sock, struct xdr_buf *xdr, unsigned int base, int more)
  327. {
  328. struct page **ppage;
  329. unsigned int remainder;
  330. int err, sent = 0;
  331. remainder = xdr->page_len - base;
  332. base += xdr->page_base;
  333. ppage = xdr->pages + (base >> PAGE_SHIFT);
  334. base &= ~PAGE_MASK;
  335. for(;;) {
  336. unsigned int len = min_t(unsigned int, PAGE_SIZE - base, remainder);
  337. int flags = XS_SENDMSG_FLAGS;
  338. remainder -= len;
  339. if (remainder != 0 || more)
  340. flags |= MSG_MORE;
  341. err = sock->ops->sendpage(sock, *ppage, base, len, flags);
  342. if (remainder == 0 || err != len)
  343. break;
  344. sent += err;
  345. ppage++;
  346. base = 0;
  347. }
  348. if (sent == 0)
  349. return err;
  350. if (err > 0)
  351. sent += err;
  352. return sent;
  353. }
  354. /**
  355. * xs_sendpages - write pages directly to a socket
  356. * @sock: socket to send on
  357. * @addr: UDP only -- address of destination
  358. * @addrlen: UDP only -- length of destination address
  359. * @xdr: buffer containing this request
  360. * @base: starting position in the buffer
  361. *
  362. */
  363. static int xs_sendpages(struct socket *sock, struct sockaddr *addr, int addrlen, struct xdr_buf *xdr, unsigned int base)
  364. {
  365. unsigned int remainder = xdr->len - base;
  366. int err, sent = 0;
  367. if (unlikely(!sock))
  368. return -ENOTSOCK;
  369. clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags);
  370. if (base != 0) {
  371. addr = NULL;
  372. addrlen = 0;
  373. }
  374. if (base < xdr->head[0].iov_len || addr != NULL) {
  375. unsigned int len = xdr->head[0].iov_len - base;
  376. remainder -= len;
  377. err = xs_send_kvec(sock, addr, addrlen, &xdr->head[0], base, remainder != 0);
  378. if (remainder == 0 || err != len)
  379. goto out;
  380. sent += err;
  381. base = 0;
  382. } else
  383. base -= xdr->head[0].iov_len;
  384. if (base < xdr->page_len) {
  385. unsigned int len = xdr->page_len - base;
  386. remainder -= len;
  387. err = xs_send_pagedata(sock, xdr, base, remainder != 0);
  388. if (remainder == 0 || err != len)
  389. goto out;
  390. sent += err;
  391. base = 0;
  392. } else
  393. base -= xdr->page_len;
  394. if (base >= xdr->tail[0].iov_len)
  395. return sent;
  396. err = xs_send_kvec(sock, NULL, 0, &xdr->tail[0], base, 0);
  397. out:
  398. if (sent == 0)
  399. return err;
  400. if (err > 0)
  401. sent += err;
  402. return sent;
  403. }
  404. static void xs_nospace_callback(struct rpc_task *task)
  405. {
  406. struct sock_xprt *transport = container_of(task->tk_rqstp->rq_xprt, struct sock_xprt, xprt);
  407. transport->inet->sk_write_pending--;
  408. clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
  409. }
  410. /**
  411. * xs_nospace - place task on wait queue if transmit was incomplete
  412. * @task: task to put to sleep
  413. *
  414. */
  415. static int xs_nospace(struct rpc_task *task)
  416. {
  417. struct rpc_rqst *req = task->tk_rqstp;
  418. struct rpc_xprt *xprt = req->rq_xprt;
  419. struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
  420. int ret = 0;
  421. dprintk("RPC: %5u xmit incomplete (%u left of %u)\n",
  422. task->tk_pid, req->rq_slen - req->rq_bytes_sent,
  423. req->rq_slen);
  424. /* Protect against races with write_space */
  425. spin_lock_bh(&xprt->transport_lock);
  426. /* Don't race with disconnect */
  427. if (xprt_connected(xprt)) {
  428. if (test_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags)) {
  429. ret = -EAGAIN;
  430. /*
  431. * Notify TCP that we're limited by the application
  432. * window size
  433. */
  434. set_bit(SOCK_NOSPACE, &transport->sock->flags);
  435. transport->inet->sk_write_pending++;
  436. /* ...and wait for more buffer space */
  437. xprt_wait_for_buffer_space(task, xs_nospace_callback);
  438. }
  439. } else {
  440. clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
  441. ret = -ENOTCONN;
  442. }
  443. spin_unlock_bh(&xprt->transport_lock);
  444. return ret;
  445. }
  446. /**
  447. * xs_udp_send_request - write an RPC request to a UDP socket
  448. * @task: address of RPC task that manages the state of an RPC request
  449. *
  450. * Return values:
  451. * 0: The request has been sent
  452. * EAGAIN: The socket was blocked, please call again later to
  453. * complete the request
  454. * ENOTCONN: Caller needs to invoke connect logic then call again
  455. * other: Some other error occured, the request was not sent
  456. */
  457. static int xs_udp_send_request(struct rpc_task *task)
  458. {
  459. struct rpc_rqst *req = task->tk_rqstp;
  460. struct rpc_xprt *xprt = req->rq_xprt;
  461. struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
  462. struct xdr_buf *xdr = &req->rq_snd_buf;
  463. int status;
  464. xs_pktdump("packet data:",
  465. req->rq_svec->iov_base,
  466. req->rq_svec->iov_len);
  467. if (!xprt_bound(xprt))
  468. return -ENOTCONN;
  469. status = xs_sendpages(transport->sock,
  470. xs_addr(xprt),
  471. xprt->addrlen, xdr,
  472. req->rq_bytes_sent);
  473. dprintk("RPC: xs_udp_send_request(%u) = %d\n",
  474. xdr->len - req->rq_bytes_sent, status);
  475. if (status >= 0) {
  476. task->tk_bytes_sent += status;
  477. if (status >= req->rq_slen)
  478. return 0;
  479. /* Still some bytes left; set up for a retry later. */
  480. status = -EAGAIN;
  481. }
  482. if (!transport->sock)
  483. goto out;
  484. switch (status) {
  485. case -ENOTSOCK:
  486. status = -ENOTCONN;
  487. /* Should we call xs_close() here? */
  488. break;
  489. case -EAGAIN:
  490. status = xs_nospace(task);
  491. break;
  492. default:
  493. dprintk("RPC: sendmsg returned unrecognized error %d\n",
  494. -status);
  495. case -ENETUNREACH:
  496. case -EPIPE:
  497. case -ECONNREFUSED:
  498. /* When the server has died, an ICMP port unreachable message
  499. * prompts ECONNREFUSED. */
  500. clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
  501. }
  502. out:
  503. return status;
  504. }
  505. /**
  506. * xs_tcp_shutdown - gracefully shut down a TCP socket
  507. * @xprt: transport
  508. *
  509. * Initiates a graceful shutdown of the TCP socket by calling the
  510. * equivalent of shutdown(SHUT_WR);
  511. */
  512. static void xs_tcp_shutdown(struct rpc_xprt *xprt)
  513. {
  514. struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
  515. struct socket *sock = transport->sock;
  516. if (sock != NULL)
  517. kernel_sock_shutdown(sock, SHUT_WR);
  518. }
  519. static inline void xs_encode_tcp_record_marker(struct xdr_buf *buf)
  520. {
  521. u32 reclen = buf->len - sizeof(rpc_fraghdr);
  522. rpc_fraghdr *base = buf->head[0].iov_base;
  523. *base = htonl(RPC_LAST_STREAM_FRAGMENT | reclen);
  524. }
  525. /**
  526. * xs_tcp_send_request - write an RPC request to a TCP socket
  527. * @task: address of RPC task that manages the state of an RPC request
  528. *
  529. * Return values:
  530. * 0: The request has been sent
  531. * EAGAIN: The socket was blocked, please call again later to
  532. * complete the request
  533. * ENOTCONN: Caller needs to invoke connect logic then call again
  534. * other: Some other error occured, the request was not sent
  535. *
  536. * XXX: In the case of soft timeouts, should we eventually give up
  537. * if sendmsg is not able to make progress?
  538. */
  539. static int xs_tcp_send_request(struct rpc_task *task)
  540. {
  541. struct rpc_rqst *req = task->tk_rqstp;
  542. struct rpc_xprt *xprt = req->rq_xprt;
  543. struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
  544. struct xdr_buf *xdr = &req->rq_snd_buf;
  545. int status;
  546. xs_encode_tcp_record_marker(&req->rq_snd_buf);
  547. xs_pktdump("packet data:",
  548. req->rq_svec->iov_base,
  549. req->rq_svec->iov_len);
  550. /* Continue transmitting the packet/record. We must be careful
  551. * to cope with writespace callbacks arriving _after_ we have
  552. * called sendmsg(). */
  553. while (1) {
  554. status = xs_sendpages(transport->sock,
  555. NULL, 0, xdr, req->rq_bytes_sent);
  556. dprintk("RPC: xs_tcp_send_request(%u) = %d\n",
  557. xdr->len - req->rq_bytes_sent, status);
  558. if (unlikely(status < 0))
  559. break;
  560. /* If we've sent the entire packet, immediately
  561. * reset the count of bytes sent. */
  562. req->rq_bytes_sent += status;
  563. task->tk_bytes_sent += status;
  564. if (likely(req->rq_bytes_sent >= req->rq_slen)) {
  565. req->rq_bytes_sent = 0;
  566. return 0;
  567. }
  568. if (status != 0)
  569. continue;
  570. status = -EAGAIN;
  571. break;
  572. }
  573. if (!transport->sock)
  574. goto out;
  575. switch (status) {
  576. case -ENOTSOCK:
  577. status = -ENOTCONN;
  578. /* Should we call xs_close() here? */
  579. break;
  580. case -EAGAIN:
  581. status = xs_nospace(task);
  582. break;
  583. default:
  584. dprintk("RPC: sendmsg returned unrecognized error %d\n",
  585. -status);
  586. case -ECONNRESET:
  587. case -EPIPE:
  588. xs_tcp_shutdown(xprt);
  589. case -ECONNREFUSED:
  590. case -ENOTCONN:
  591. clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
  592. }
  593. out:
  594. return status;
  595. }
  596. /**
  597. * xs_tcp_release_xprt - clean up after a tcp transmission
  598. * @xprt: transport
  599. * @task: rpc task
  600. *
  601. * This cleans up if an error causes us to abort the transmission of a request.
  602. * In this case, the socket may need to be reset in order to avoid confusing
  603. * the server.
  604. */
  605. static void xs_tcp_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task)
  606. {
  607. struct rpc_rqst *req;
  608. if (task != xprt->snd_task)
  609. return;
  610. if (task == NULL)
  611. goto out_release;
  612. req = task->tk_rqstp;
  613. if (req->rq_bytes_sent == 0)
  614. goto out_release;
  615. if (req->rq_bytes_sent == req->rq_snd_buf.len)
  616. goto out_release;
  617. set_bit(XPRT_CLOSE_WAIT, &task->tk_xprt->state);
  618. out_release:
  619. xprt_release_xprt(xprt, task);
  620. }
  621. static void xs_save_old_callbacks(struct sock_xprt *transport, struct sock *sk)
  622. {
  623. transport->old_data_ready = sk->sk_data_ready;
  624. transport->old_state_change = sk->sk_state_change;
  625. transport->old_write_space = sk->sk_write_space;
  626. transport->old_error_report = sk->sk_error_report;
  627. }
  628. static void xs_restore_old_callbacks(struct sock_xprt *transport, struct sock *sk)
  629. {
  630. sk->sk_data_ready = transport->old_data_ready;
  631. sk->sk_state_change = transport->old_state_change;
  632. sk->sk_write_space = transport->old_write_space;
  633. sk->sk_error_report = transport->old_error_report;
  634. }
  635. static void xs_reset_transport(struct sock_xprt *transport)
  636. {
  637. struct socket *sock = transport->sock;
  638. struct sock *sk = transport->inet;
  639. if (sk == NULL)
  640. return;
  641. write_lock_bh(&sk->sk_callback_lock);
  642. transport->inet = NULL;
  643. transport->sock = NULL;
  644. sk->sk_user_data = NULL;
  645. xs_restore_old_callbacks(transport, sk);
  646. write_unlock_bh(&sk->sk_callback_lock);
  647. sk->sk_no_check = 0;
  648. sock_release(sock);
  649. }
  650. /**
  651. * xs_close - close a socket
  652. * @xprt: transport
  653. *
  654. * This is used when all requests are complete; ie, no DRC state remains
  655. * on the server we want to save.
  656. *
  657. * The caller _must_ be holding XPRT_LOCKED in order to avoid issues with
  658. * xs_reset_transport() zeroing the socket from underneath a writer.
  659. */
  660. static void xs_close(struct rpc_xprt *xprt)
  661. {
  662. struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
  663. dprintk("RPC: xs_close xprt %p\n", xprt);
  664. xs_reset_transport(transport);
  665. xprt->reestablish_timeout = 0;
  666. smp_mb__before_clear_bit();
  667. clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
  668. clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
  669. clear_bit(XPRT_CLOSING, &xprt->state);
  670. smp_mb__after_clear_bit();
  671. xprt_disconnect_done(xprt);
  672. }
  673. static void xs_tcp_close(struct rpc_xprt *xprt)
  674. {
  675. if (test_and_clear_bit(XPRT_CONNECTION_CLOSE, &xprt->state))
  676. xs_close(xprt);
  677. else
  678. xs_tcp_shutdown(xprt);
  679. }
  680. /**
  681. * xs_destroy - prepare to shutdown a transport
  682. * @xprt: doomed transport
  683. *
  684. */
  685. static void xs_destroy(struct rpc_xprt *xprt)
  686. {
  687. struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
  688. dprintk("RPC: xs_destroy xprt %p\n", xprt);
  689. cancel_rearming_delayed_work(&transport->connect_worker);
  690. xs_close(xprt);
  691. xs_free_peer_addresses(xprt);
  692. kfree(xprt->slot);
  693. kfree(xprt);
  694. module_put(THIS_MODULE);
  695. }
  696. static inline struct rpc_xprt *xprt_from_sock(struct sock *sk)
  697. {
  698. return (struct rpc_xprt *) sk->sk_user_data;
  699. }
  700. /**
  701. * xs_udp_data_ready - "data ready" callback for UDP sockets
  702. * @sk: socket with data to read
  703. * @len: how much data to read
  704. *
  705. */
  706. static void xs_udp_data_ready(struct sock *sk, int len)
  707. {
  708. struct rpc_task *task;
  709. struct rpc_xprt *xprt;
  710. struct rpc_rqst *rovr;
  711. struct sk_buff *skb;
  712. int err, repsize, copied;
  713. u32 _xid;
  714. __be32 *xp;
  715. read_lock(&sk->sk_callback_lock);
  716. dprintk("RPC: xs_udp_data_ready...\n");
  717. if (!(xprt = xprt_from_sock(sk)))
  718. goto out;
  719. if ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL)
  720. goto out;
  721. if (xprt->shutdown)
  722. goto dropit;
  723. repsize = skb->len - sizeof(struct udphdr);
  724. if (repsize < 4) {
  725. dprintk("RPC: impossible RPC reply size %d!\n", repsize);
  726. goto dropit;
  727. }
  728. /* Copy the XID from the skb... */
  729. xp = skb_header_pointer(skb, sizeof(struct udphdr),
  730. sizeof(_xid), &_xid);
  731. if (xp == NULL)
  732. goto dropit;
  733. /* Look up and lock the request corresponding to the given XID */
  734. spin_lock(&xprt->transport_lock);
  735. rovr = xprt_lookup_rqst(xprt, *xp);
  736. if (!rovr)
  737. goto out_unlock;
  738. task = rovr->rq_task;
  739. if ((copied = rovr->rq_private_buf.buflen) > repsize)
  740. copied = repsize;
  741. /* Suck it into the iovec, verify checksum if not done by hw. */
  742. if (csum_partial_copy_to_xdr(&rovr->rq_private_buf, skb)) {
  743. UDPX_INC_STATS_BH(sk, UDP_MIB_INERRORS);
  744. goto out_unlock;
  745. }
  746. UDPX_INC_STATS_BH(sk, UDP_MIB_INDATAGRAMS);
  747. /* Something worked... */
  748. dst_confirm(skb_dst(skb));
  749. xprt_adjust_cwnd(task, copied);
  750. xprt_update_rtt(task);
  751. xprt_complete_rqst(task, copied);
  752. out_unlock:
  753. spin_unlock(&xprt->transport_lock);
  754. dropit:
  755. skb_free_datagram(sk, skb);
  756. out:
  757. read_unlock(&sk->sk_callback_lock);
  758. }
  759. static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, struct xdr_skb_reader *desc)
  760. {
  761. struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
  762. size_t len, used;
  763. char *p;
  764. p = ((char *) &transport->tcp_fraghdr) + transport->tcp_offset;
  765. len = sizeof(transport->tcp_fraghdr) - transport->tcp_offset;
  766. used = xdr_skb_read_bits(desc, p, len);
  767. transport->tcp_offset += used;
  768. if (used != len)
  769. return;
  770. transport->tcp_reclen = ntohl(transport->tcp_fraghdr);
  771. if (transport->tcp_reclen & RPC_LAST_STREAM_FRAGMENT)
  772. transport->tcp_flags |= TCP_RCV_LAST_FRAG;
  773. else
  774. transport->tcp_flags &= ~TCP_RCV_LAST_FRAG;
  775. transport->tcp_reclen &= RPC_FRAGMENT_SIZE_MASK;
  776. transport->tcp_flags &= ~TCP_RCV_COPY_FRAGHDR;
  777. transport->tcp_offset = 0;
  778. /* Sanity check of the record length */
  779. if (unlikely(transport->tcp_reclen < 8)) {
  780. dprintk("RPC: invalid TCP record fragment length\n");
  781. xprt_force_disconnect(xprt);
  782. return;
  783. }
  784. dprintk("RPC: reading TCP record fragment of length %d\n",
  785. transport->tcp_reclen);
  786. }
  787. static void xs_tcp_check_fraghdr(struct sock_xprt *transport)
  788. {
  789. if (transport->tcp_offset == transport->tcp_reclen) {
  790. transport->tcp_flags |= TCP_RCV_COPY_FRAGHDR;
  791. transport->tcp_offset = 0;
  792. if (transport->tcp_flags & TCP_RCV_LAST_FRAG) {
  793. transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
  794. transport->tcp_flags |= TCP_RCV_COPY_XID;
  795. transport->tcp_copied = 0;
  796. }
  797. }
  798. }
  799. static inline void xs_tcp_read_xid(struct sock_xprt *transport, struct xdr_skb_reader *desc)
  800. {
  801. size_t len, used;
  802. char *p;
  803. len = sizeof(transport->tcp_xid) - transport->tcp_offset;
  804. dprintk("RPC: reading XID (%Zu bytes)\n", len);
  805. p = ((char *) &transport->tcp_xid) + transport->tcp_offset;
  806. used = xdr_skb_read_bits(desc, p, len);
  807. transport->tcp_offset += used;
  808. if (used != len)
  809. return;
  810. transport->tcp_flags &= ~TCP_RCV_COPY_XID;
  811. transport->tcp_flags |= TCP_RCV_READ_CALLDIR;
  812. transport->tcp_copied = 4;
  813. dprintk("RPC: reading %s XID %08x\n",
  814. (transport->tcp_flags & TCP_RPC_REPLY) ? "reply for"
  815. : "request with",
  816. ntohl(transport->tcp_xid));
  817. xs_tcp_check_fraghdr(transport);
  818. }
  819. static inline void xs_tcp_read_calldir(struct sock_xprt *transport,
  820. struct xdr_skb_reader *desc)
  821. {
  822. size_t len, used;
  823. u32 offset;
  824. __be32 calldir;
  825. /*
  826. * We want transport->tcp_offset to be 8 at the end of this routine
  827. * (4 bytes for the xid and 4 bytes for the call/reply flag).
  828. * When this function is called for the first time,
  829. * transport->tcp_offset is 4 (after having already read the xid).
  830. */
  831. offset = transport->tcp_offset - sizeof(transport->tcp_xid);
  832. len = sizeof(calldir) - offset;
  833. dprintk("RPC: reading CALL/REPLY flag (%Zu bytes)\n", len);
  834. used = xdr_skb_read_bits(desc, &calldir, len);
  835. transport->tcp_offset += used;
  836. if (used != len)
  837. return;
  838. transport->tcp_flags &= ~TCP_RCV_READ_CALLDIR;
  839. transport->tcp_flags |= TCP_RCV_COPY_CALLDIR;
  840. transport->tcp_flags |= TCP_RCV_COPY_DATA;
  841. /*
  842. * We don't yet have the XDR buffer, so we will write the calldir
  843. * out after we get the buffer from the 'struct rpc_rqst'
  844. */
  845. if (ntohl(calldir) == RPC_REPLY)
  846. transport->tcp_flags |= TCP_RPC_REPLY;
  847. else
  848. transport->tcp_flags &= ~TCP_RPC_REPLY;
  849. dprintk("RPC: reading %s CALL/REPLY flag %08x\n",
  850. (transport->tcp_flags & TCP_RPC_REPLY) ?
  851. "reply for" : "request with", calldir);
  852. xs_tcp_check_fraghdr(transport);
  853. }
  854. static inline void xs_tcp_read_common(struct rpc_xprt *xprt,
  855. struct xdr_skb_reader *desc,
  856. struct rpc_rqst *req)
  857. {
  858. struct sock_xprt *transport =
  859. container_of(xprt, struct sock_xprt, xprt);
  860. struct xdr_buf *rcvbuf;
  861. size_t len;
  862. ssize_t r;
  863. rcvbuf = &req->rq_private_buf;
  864. if (transport->tcp_flags & TCP_RCV_COPY_CALLDIR) {
  865. /*
  866. * Save the RPC direction in the XDR buffer
  867. */
  868. __be32 calldir = transport->tcp_flags & TCP_RPC_REPLY ?
  869. htonl(RPC_REPLY) : 0;
  870. memcpy(rcvbuf->head[0].iov_base + transport->tcp_copied,
  871. &calldir, sizeof(calldir));
  872. transport->tcp_copied += sizeof(calldir);
  873. transport->tcp_flags &= ~TCP_RCV_COPY_CALLDIR;
  874. }
  875. len = desc->count;
  876. if (len > transport->tcp_reclen - transport->tcp_offset) {
  877. struct xdr_skb_reader my_desc;
  878. len = transport->tcp_reclen - transport->tcp_offset;
  879. memcpy(&my_desc, desc, sizeof(my_desc));
  880. my_desc.count = len;
  881. r = xdr_partial_copy_from_skb(rcvbuf, transport->tcp_copied,
  882. &my_desc, xdr_skb_read_bits);
  883. desc->count -= r;
  884. desc->offset += r;
  885. } else
  886. r = xdr_partial_copy_from_skb(rcvbuf, transport->tcp_copied,
  887. desc, xdr_skb_read_bits);
  888. if (r > 0) {
  889. transport->tcp_copied += r;
  890. transport->tcp_offset += r;
  891. }
  892. if (r != len) {
  893. /* Error when copying to the receive buffer,
  894. * usually because we weren't able to allocate
  895. * additional buffer pages. All we can do now
  896. * is turn off TCP_RCV_COPY_DATA, so the request
  897. * will not receive any additional updates,
  898. * and time out.
  899. * Any remaining data from this record will
  900. * be discarded.
  901. */
  902. transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
  903. dprintk("RPC: XID %08x truncated request\n",
  904. ntohl(transport->tcp_xid));
  905. dprintk("RPC: xprt = %p, tcp_copied = %lu, "
  906. "tcp_offset = %u, tcp_reclen = %u\n",
  907. xprt, transport->tcp_copied,
  908. transport->tcp_offset, transport->tcp_reclen);
  909. return;
  910. }
  911. dprintk("RPC: XID %08x read %Zd bytes\n",
  912. ntohl(transport->tcp_xid), r);
  913. dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, "
  914. "tcp_reclen = %u\n", xprt, transport->tcp_copied,
  915. transport->tcp_offset, transport->tcp_reclen);
  916. if (transport->tcp_copied == req->rq_private_buf.buflen)
  917. transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
  918. else if (transport->tcp_offset == transport->tcp_reclen) {
  919. if (transport->tcp_flags & TCP_RCV_LAST_FRAG)
  920. transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
  921. }
  922. return;
  923. }
  924. /*
  925. * Finds the request corresponding to the RPC xid and invokes the common
  926. * tcp read code to read the data.
  927. */
  928. static inline int xs_tcp_read_reply(struct rpc_xprt *xprt,
  929. struct xdr_skb_reader *desc)
  930. {
  931. struct sock_xprt *transport =
  932. container_of(xprt, struct sock_xprt, xprt);
  933. struct rpc_rqst *req;
  934. dprintk("RPC: read reply XID %08x\n", ntohl(transport->tcp_xid));
  935. /* Find and lock the request corresponding to this xid */
  936. spin_lock(&xprt->transport_lock);
  937. req = xprt_lookup_rqst(xprt, transport->tcp_xid);
  938. if (!req) {
  939. dprintk("RPC: XID %08x request not found!\n",
  940. ntohl(transport->tcp_xid));
  941. spin_unlock(&xprt->transport_lock);
  942. return -1;
  943. }
  944. xs_tcp_read_common(xprt, desc, req);
  945. if (!(transport->tcp_flags & TCP_RCV_COPY_DATA))
  946. xprt_complete_rqst(req->rq_task, transport->tcp_copied);
  947. spin_unlock(&xprt->transport_lock);
  948. return 0;
  949. }
  950. #if defined(CONFIG_NFS_V4_1)
  951. /*
  952. * Obtains an rpc_rqst previously allocated and invokes the common
  953. * tcp read code to read the data. The result is placed in the callback
  954. * queue.
  955. * If we're unable to obtain the rpc_rqst we schedule the closing of the
  956. * connection and return -1.
  957. */
  958. static inline int xs_tcp_read_callback(struct rpc_xprt *xprt,
  959. struct xdr_skb_reader *desc)
  960. {
  961. struct sock_xprt *transport =
  962. container_of(xprt, struct sock_xprt, xprt);
  963. struct rpc_rqst *req;
  964. req = xprt_alloc_bc_request(xprt);
  965. if (req == NULL) {
  966. printk(KERN_WARNING "Callback slot table overflowed\n");
  967. xprt_force_disconnect(xprt);
  968. return -1;
  969. }
  970. req->rq_xid = transport->tcp_xid;
  971. dprintk("RPC: read callback XID %08x\n", ntohl(req->rq_xid));
  972. xs_tcp_read_common(xprt, desc, req);
  973. if (!(transport->tcp_flags & TCP_RCV_COPY_DATA)) {
  974. struct svc_serv *bc_serv = xprt->bc_serv;
  975. /*
  976. * Add callback request to callback list. The callback
  977. * service sleeps on the sv_cb_waitq waiting for new
  978. * requests. Wake it up after adding enqueing the
  979. * request.
  980. */
  981. dprintk("RPC: add callback request to list\n");
  982. spin_lock(&bc_serv->sv_cb_lock);
  983. list_add(&req->rq_bc_list, &bc_serv->sv_cb_list);
  984. spin_unlock(&bc_serv->sv_cb_lock);
  985. wake_up(&bc_serv->sv_cb_waitq);
  986. }
  987. req->rq_private_buf.len = transport->tcp_copied;
  988. return 0;
  989. }
  990. static inline int _xs_tcp_read_data(struct rpc_xprt *xprt,
  991. struct xdr_skb_reader *desc)
  992. {
  993. struct sock_xprt *transport =
  994. container_of(xprt, struct sock_xprt, xprt);
  995. return (transport->tcp_flags & TCP_RPC_REPLY) ?
  996. xs_tcp_read_reply(xprt, desc) :
  997. xs_tcp_read_callback(xprt, desc);
  998. }
  999. #else
  1000. static inline int _xs_tcp_read_data(struct rpc_xprt *xprt,
  1001. struct xdr_skb_reader *desc)
  1002. {
  1003. return xs_tcp_read_reply(xprt, desc);
  1004. }
  1005. #endif /* CONFIG_NFS_V4_1 */
  1006. /*
  1007. * Read data off the transport. This can be either an RPC_CALL or an
  1008. * RPC_REPLY. Relay the processing to helper functions.
  1009. */
  1010. static void xs_tcp_read_data(struct rpc_xprt *xprt,
  1011. struct xdr_skb_reader *desc)
  1012. {
  1013. struct sock_xprt *transport =
  1014. container_of(xprt, struct sock_xprt, xprt);
  1015. if (_xs_tcp_read_data(xprt, desc) == 0)
  1016. xs_tcp_check_fraghdr(transport);
  1017. else {
  1018. /*
  1019. * The transport_lock protects the request handling.
  1020. * There's no need to hold it to update the tcp_flags.
  1021. */
  1022. transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
  1023. }
  1024. }
  1025. static inline void xs_tcp_read_discard(struct sock_xprt *transport, struct xdr_skb_reader *desc)
  1026. {
  1027. size_t len;
  1028. len = transport->tcp_reclen - transport->tcp_offset;
  1029. if (len > desc->count)
  1030. len = desc->count;
  1031. desc->count -= len;
  1032. desc->offset += len;
  1033. transport->tcp_offset += len;
  1034. dprintk("RPC: discarded %Zu bytes\n", len);
  1035. xs_tcp_check_fraghdr(transport);
  1036. }
  1037. static int xs_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, unsigned int offset, size_t len)
  1038. {
  1039. struct rpc_xprt *xprt = rd_desc->arg.data;
  1040. struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
  1041. struct xdr_skb_reader desc = {
  1042. .skb = skb,
  1043. .offset = offset,
  1044. .count = len,
  1045. };
  1046. dprintk("RPC: xs_tcp_data_recv started\n");
  1047. do {
  1048. /* Read in a new fragment marker if necessary */
  1049. /* Can we ever really expect to get completely empty fragments? */
  1050. if (transport->tcp_flags & TCP_RCV_COPY_FRAGHDR) {
  1051. xs_tcp_read_fraghdr(xprt, &desc);
  1052. continue;
  1053. }
  1054. /* Read in the xid if necessary */
  1055. if (transport->tcp_flags & TCP_RCV_COPY_XID) {
  1056. xs_tcp_read_xid(transport, &desc);
  1057. continue;
  1058. }
  1059. /* Read in the call/reply flag */
  1060. if (transport->tcp_flags & TCP_RCV_READ_CALLDIR) {
  1061. xs_tcp_read_calldir(transport, &desc);
  1062. continue;
  1063. }
  1064. /* Read in the request data */
  1065. if (transport->tcp_flags & TCP_RCV_COPY_DATA) {
  1066. xs_tcp_read_data(xprt, &desc);
  1067. continue;
  1068. }
  1069. /* Skip over any trailing bytes on short reads */
  1070. xs_tcp_read_discard(transport, &desc);
  1071. } while (desc.count);
  1072. dprintk("RPC: xs_tcp_data_recv done\n");
  1073. return len - desc.count;
  1074. }
  1075. /**
  1076. * xs_tcp_data_ready - "data ready" callback for TCP sockets
  1077. * @sk: socket with data to read
  1078. * @bytes: how much data to read
  1079. *
  1080. */
  1081. static void xs_tcp_data_ready(struct sock *sk, int bytes)
  1082. {
  1083. struct rpc_xprt *xprt;
  1084. read_descriptor_t rd_desc;
  1085. int read;
  1086. dprintk("RPC: xs_tcp_data_ready...\n");
  1087. read_lock(&sk->sk_callback_lock);
  1088. if (!(xprt = xprt_from_sock(sk)))
  1089. goto out;
  1090. if (xprt->shutdown)
  1091. goto out;
  1092. /* Any data means we had a useful conversation, so
  1093. * the we don't need to delay the next reconnect
  1094. */
  1095. if (xprt->reestablish_timeout)
  1096. xprt->reestablish_timeout = 0;
  1097. /* We use rd_desc to pass struct xprt to xs_tcp_data_recv */
  1098. rd_desc.arg.data = xprt;
  1099. do {
  1100. rd_desc.count = 65536;
  1101. read = tcp_read_sock(sk, &rd_desc, xs_tcp_data_recv);
  1102. } while (read > 0);
  1103. out:
  1104. read_unlock(&sk->sk_callback_lock);
  1105. }
  1106. /*
  1107. * Do the equivalent of linger/linger2 handling for dealing with
  1108. * broken servers that don't close the socket in a timely
  1109. * fashion
  1110. */
  1111. static void xs_tcp_schedule_linger_timeout(struct rpc_xprt *xprt,
  1112. unsigned long timeout)
  1113. {
  1114. struct sock_xprt *transport;
  1115. if (xprt_test_and_set_connecting(xprt))
  1116. return;
  1117. set_bit(XPRT_CONNECTION_ABORT, &xprt->state);
  1118. transport = container_of(xprt, struct sock_xprt, xprt);
  1119. queue_delayed_work(rpciod_workqueue, &transport->connect_worker,
  1120. timeout);
  1121. }
  1122. static void xs_tcp_cancel_linger_timeout(struct rpc_xprt *xprt)
  1123. {
  1124. struct sock_xprt *transport;
  1125. transport = container_of(xprt, struct sock_xprt, xprt);
  1126. if (!test_bit(XPRT_CONNECTION_ABORT, &xprt->state) ||
  1127. !cancel_delayed_work(&transport->connect_worker))
  1128. return;
  1129. clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
  1130. xprt_clear_connecting(xprt);
  1131. }
  1132. static void xs_sock_mark_closed(struct rpc_xprt *xprt)
  1133. {
  1134. smp_mb__before_clear_bit();
  1135. clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
  1136. clear_bit(XPRT_CLOSING, &xprt->state);
  1137. smp_mb__after_clear_bit();
  1138. /* Mark transport as closed and wake up all pending tasks */
  1139. xprt_disconnect_done(xprt);
  1140. }
  1141. /**
  1142. * xs_tcp_state_change - callback to handle TCP socket state changes
  1143. * @sk: socket whose state has changed
  1144. *
  1145. */
  1146. static void xs_tcp_state_change(struct sock *sk)
  1147. {
  1148. struct rpc_xprt *xprt;
  1149. read_lock(&sk->sk_callback_lock);
  1150. if (!(xprt = xprt_from_sock(sk)))
  1151. goto out;
  1152. dprintk("RPC: xs_tcp_state_change client %p...\n", xprt);
  1153. dprintk("RPC: state %x conn %d dead %d zapped %d\n",
  1154. sk->sk_state, xprt_connected(xprt),
  1155. sock_flag(sk, SOCK_DEAD),
  1156. sock_flag(sk, SOCK_ZAPPED));
  1157. switch (sk->sk_state) {
  1158. case TCP_ESTABLISHED:
  1159. spin_lock_bh(&xprt->transport_lock);
  1160. if (!xprt_test_and_set_connected(xprt)) {
  1161. struct sock_xprt *transport = container_of(xprt,
  1162. struct sock_xprt, xprt);
  1163. /* Reset TCP record info */
  1164. transport->tcp_offset = 0;
  1165. transport->tcp_reclen = 0;
  1166. transport->tcp_copied = 0;
  1167. transport->tcp_flags =
  1168. TCP_RCV_COPY_FRAGHDR | TCP_RCV_COPY_XID;
  1169. xprt_wake_pending_tasks(xprt, -EAGAIN);
  1170. }
  1171. spin_unlock_bh(&xprt->transport_lock);
  1172. break;
  1173. case TCP_FIN_WAIT1:
  1174. /* The client initiated a shutdown of the socket */
  1175. xprt->connect_cookie++;
  1176. xprt->reestablish_timeout = 0;
  1177. set_bit(XPRT_CLOSING, &xprt->state);
  1178. smp_mb__before_clear_bit();
  1179. clear_bit(XPRT_CONNECTED, &xprt->state);
  1180. clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
  1181. smp_mb__after_clear_bit();
  1182. xs_tcp_schedule_linger_timeout(xprt, xs_tcp_fin_timeout);
  1183. break;
  1184. case TCP_CLOSE_WAIT:
  1185. /* The server initiated a shutdown of the socket */
  1186. xprt_force_disconnect(xprt);
  1187. case TCP_SYN_SENT:
  1188. xprt->connect_cookie++;
  1189. case TCP_CLOSING:
  1190. /*
  1191. * If the server closed down the connection, make sure that
  1192. * we back off before reconnecting
  1193. */
  1194. if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO)
  1195. xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
  1196. break;
  1197. case TCP_LAST_ACK:
  1198. set_bit(XPRT_CLOSING, &xprt->state);
  1199. xs_tcp_schedule_linger_timeout(xprt, xs_tcp_fin_timeout);
  1200. smp_mb__before_clear_bit();
  1201. clear_bit(XPRT_CONNECTED, &xprt->state);
  1202. smp_mb__after_clear_bit();
  1203. break;
  1204. case TCP_CLOSE:
  1205. xs_tcp_cancel_linger_timeout(xprt);
  1206. xs_sock_mark_closed(xprt);
  1207. }
  1208. out:
  1209. read_unlock(&sk->sk_callback_lock);
  1210. }
  1211. /**
  1212. * xs_error_report - callback mainly for catching socket errors
  1213. * @sk: socket
  1214. */
  1215. static void xs_error_report(struct sock *sk)
  1216. {
  1217. struct rpc_xprt *xprt;
  1218. read_lock(&sk->sk_callback_lock);
  1219. if (!(xprt = xprt_from_sock(sk)))
  1220. goto out;
  1221. dprintk("RPC: %s client %p...\n"
  1222. "RPC: error %d\n",
  1223. __func__, xprt, sk->sk_err);
  1224. xprt_wake_pending_tasks(xprt, -EAGAIN);
  1225. out:
  1226. read_unlock(&sk->sk_callback_lock);
  1227. }
  1228. static void xs_write_space(struct sock *sk)
  1229. {
  1230. struct socket *sock;
  1231. struct rpc_xprt *xprt;
  1232. if (unlikely(!(sock = sk->sk_socket)))
  1233. return;
  1234. clear_bit(SOCK_NOSPACE, &sock->flags);
  1235. if (unlikely(!(xprt = xprt_from_sock(sk))))
  1236. return;
  1237. if (test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags) == 0)
  1238. return;
  1239. xprt_write_space(xprt);
  1240. }
  1241. /**
  1242. * xs_udp_write_space - callback invoked when socket buffer space
  1243. * becomes available
  1244. * @sk: socket whose state has changed
  1245. *
  1246. * Called when more output buffer space is available for this socket.
  1247. * We try not to wake our writers until they can make "significant"
  1248. * progress, otherwise we'll waste resources thrashing kernel_sendmsg
  1249. * with a bunch of small requests.
  1250. */
  1251. static void xs_udp_write_space(struct sock *sk)
  1252. {
  1253. read_lock(&sk->sk_callback_lock);
  1254. /* from net/core/sock.c:sock_def_write_space */
  1255. if (sock_writeable(sk))
  1256. xs_write_space(sk);
  1257. read_unlock(&sk->sk_callback_lock);
  1258. }
  1259. /**
  1260. * xs_tcp_write_space - callback invoked when socket buffer space
  1261. * becomes available
  1262. * @sk: socket whose state has changed
  1263. *
  1264. * Called when more output buffer space is available for this socket.
  1265. * We try not to wake our writers until they can make "significant"
  1266. * progress, otherwise we'll waste resources thrashing kernel_sendmsg
  1267. * with a bunch of small requests.
  1268. */
  1269. static void xs_tcp_write_space(struct sock *sk)
  1270. {
  1271. read_lock(&sk->sk_callback_lock);
  1272. /* from net/core/stream.c:sk_stream_write_space */
  1273. if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
  1274. xs_write_space(sk);
  1275. read_unlock(&sk->sk_callback_lock);
  1276. }
  1277. static void xs_udp_do_set_buffer_size(struct rpc_xprt *xprt)
  1278. {
  1279. struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
  1280. struct sock *sk = transport->inet;
  1281. if (transport->rcvsize) {
  1282. sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
  1283. sk->sk_rcvbuf = transport->rcvsize * xprt->max_reqs * 2;
  1284. }
  1285. if (transport->sndsize) {
  1286. sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
  1287. sk->sk_sndbuf = transport->sndsize * xprt->max_reqs * 2;
  1288. sk->sk_write_space(sk);
  1289. }
  1290. }
  1291. /**
  1292. * xs_udp_set_buffer_size - set send and receive limits
  1293. * @xprt: generic transport
  1294. * @sndsize: requested size of send buffer, in bytes
  1295. * @rcvsize: requested size of receive buffer, in bytes
  1296. *
  1297. * Set socket send and receive buffer size limits.
  1298. */
  1299. static void xs_udp_set_buffer_size(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize)
  1300. {
  1301. struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
  1302. transport->sndsize = 0;
  1303. if (sndsize)
  1304. transport->sndsize = sndsize + 1024;
  1305. transport->rcvsize = 0;
  1306. if (rcvsize)
  1307. transport->rcvsize = rcvsize + 1024;
  1308. xs_udp_do_set_buffer_size(xprt);
  1309. }
  1310. /**
  1311. * xs_udp_timer - called when a retransmit timeout occurs on a UDP transport
  1312. * @task: task that timed out
  1313. *
  1314. * Adjust the congestion window after a retransmit timeout has occurred.
  1315. */
  1316. static void xs_udp_timer(struct rpc_task *task)
  1317. {
  1318. xprt_adjust_cwnd(task, -ETIMEDOUT);
  1319. }
  1320. static unsigned short xs_get_random_port(void)
  1321. {
  1322. unsigned short range = xprt_max_resvport - xprt_min_resvport;
  1323. unsigned short rand = (unsigned short) net_random() % range;
  1324. return rand + xprt_min_resvport;
  1325. }
  1326. /**
  1327. * xs_set_port - reset the port number in the remote endpoint address
  1328. * @xprt: generic transport
  1329. * @port: new port number
  1330. *
  1331. */
  1332. static void xs_set_port(struct rpc_xprt *xprt, unsigned short port)
  1333. {
  1334. dprintk("RPC: setting port for xprt %p to %u\n", xprt, port);
  1335. rpc_set_port(xs_addr(xprt), port);
  1336. xs_update_peer_port(xprt);
  1337. }
  1338. static unsigned short xs_get_srcport(struct sock_xprt *transport, struct socket *sock)
  1339. {
  1340. unsigned short port = transport->srcport;
  1341. if (port == 0 && transport->xprt.resvport)
  1342. port = xs_get_random_port();
  1343. return port;
  1344. }
  1345. static unsigned short xs_next_srcport(struct sock_xprt *transport, struct socket *sock, unsigned short port)
  1346. {
  1347. if (transport->srcport != 0)
  1348. transport->srcport = 0;
  1349. if (!transport->xprt.resvport)
  1350. return 0;
  1351. if (port <= xprt_min_resvport || port > xprt_max_resvport)
  1352. return xprt_max_resvport;
  1353. return --port;
  1354. }
  1355. static int xs_bind4(struct sock_xprt *transport, struct socket *sock)
  1356. {
  1357. struct sockaddr_in myaddr = {
  1358. .sin_family = AF_INET,
  1359. };
  1360. struct sockaddr_in *sa;
  1361. int err, nloop = 0;
  1362. unsigned short port = xs_get_srcport(transport, sock);
  1363. unsigned short last;
  1364. sa = (struct sockaddr_in *)&transport->srcaddr;
  1365. myaddr.sin_addr = sa->sin_addr;
  1366. do {
  1367. myaddr.sin_port = htons(port);
  1368. err = kernel_bind(sock, (struct sockaddr *) &myaddr,
  1369. sizeof(myaddr));
  1370. if (port == 0)
  1371. break;
  1372. if (err == 0) {
  1373. transport->srcport = port;
  1374. break;
  1375. }
  1376. last = port;
  1377. port = xs_next_srcport(transport, sock, port);
  1378. if (port > last)
  1379. nloop++;
  1380. } while (err == -EADDRINUSE && nloop != 2);
  1381. dprintk("RPC: %s %pI4:%u: %s (%d)\n",
  1382. __func__, &myaddr.sin_addr,
  1383. port, err ? "failed" : "ok", err);
  1384. return err;
  1385. }
  1386. static int xs_bind6(struct sock_xprt *transport, struct socket *sock)
  1387. {
  1388. struct sockaddr_in6 myaddr = {
  1389. .sin6_family = AF_INET6,
  1390. };
  1391. struct sockaddr_in6 *sa;
  1392. int err, nloop = 0;
  1393. unsigned short port = xs_get_srcport(transport, sock);
  1394. unsigned short last;
  1395. sa = (struct sockaddr_in6 *)&transport->srcaddr;
  1396. myaddr.sin6_addr = sa->sin6_addr;
  1397. do {
  1398. myaddr.sin6_port = htons(port);
  1399. err = kernel_bind(sock, (struct sockaddr *) &myaddr,
  1400. sizeof(myaddr));
  1401. if (port == 0)
  1402. break;
  1403. if (err == 0) {
  1404. transport->srcport = port;
  1405. break;
  1406. }
  1407. last = port;
  1408. port = xs_next_srcport(transport, sock, port);
  1409. if (port > last)
  1410. nloop++;
  1411. } while (err == -EADDRINUSE && nloop != 2);
  1412. dprintk("RPC: xs_bind6 %pI6:%u: %s (%d)\n",
  1413. &myaddr.sin6_addr, port, err ? "failed" : "ok", err);
  1414. return err;
  1415. }
  1416. #ifdef CONFIG_DEBUG_LOCK_ALLOC
  1417. static struct lock_class_key xs_key[2];
  1418. static struct lock_class_key xs_slock_key[2];
  1419. static inline void xs_reclassify_socket4(struct socket *sock)
  1420. {
  1421. struct sock *sk = sock->sk;
  1422. BUG_ON(sock_owned_by_user(sk));
  1423. sock_lock_init_class_and_name(sk, "slock-AF_INET-RPC",
  1424. &xs_slock_key[0], "sk_lock-AF_INET-RPC", &xs_key[0]);
  1425. }
  1426. static inline void xs_reclassify_socket6(struct socket *sock)
  1427. {
  1428. struct sock *sk = sock->sk;
  1429. BUG_ON(sock_owned_by_user(sk));
  1430. sock_lock_init_class_and_name(sk, "slock-AF_INET6-RPC",
  1431. &xs_slock_key[1], "sk_lock-AF_INET6-RPC", &xs_key[1]);
  1432. }
  1433. #else
  1434. static inline void xs_reclassify_socket4(struct socket *sock)
  1435. {
  1436. }
  1437. static inline void xs_reclassify_socket6(struct socket *sock)
  1438. {
  1439. }
  1440. #endif
  1441. static void xs_udp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
  1442. {
  1443. struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
  1444. if (!transport->inet) {
  1445. struct sock *sk = sock->sk;
  1446. write_lock_bh(&sk->sk_callback_lock);
  1447. xs_save_old_callbacks(transport, sk);
  1448. sk->sk_user_data = xprt;
  1449. sk->sk_data_ready = xs_udp_data_ready;
  1450. sk->sk_write_space = xs_udp_write_space;
  1451. sk->sk_error_report = xs_error_report;
  1452. sk->sk_no_check = UDP_CSUM_NORCV;
  1453. sk->sk_allocation = GFP_ATOMIC;
  1454. xprt_set_connected(xprt);
  1455. /* Reset to new socket */
  1456. transport->sock = sock;
  1457. transport->inet = sk;
  1458. write_unlock_bh(&sk->sk_callback_lock);
  1459. }
  1460. xs_udp_do_set_buffer_size(xprt);
  1461. }
  1462. /**
  1463. * xs_udp_connect_worker4 - set up a UDP socket
  1464. * @work: RPC transport to connect
  1465. *
  1466. * Invoked by a work queue tasklet.
  1467. */
  1468. static void xs_udp_connect_worker4(struct work_struct *work)
  1469. {
  1470. struct sock_xprt *transport =
  1471. container_of(work, struct sock_xprt, connect_worker.work);
  1472. struct rpc_xprt *xprt = &transport->xprt;
  1473. struct socket *sock = transport->sock;
  1474. int err, status = -EIO;
  1475. if (xprt->shutdown)
  1476. goto out;
  1477. /* Start by resetting any existing state */
  1478. xs_reset_transport(transport);
  1479. err = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);
  1480. if (err < 0) {
  1481. dprintk("RPC: can't create UDP transport socket (%d).\n", -err);
  1482. goto out;
  1483. }
  1484. xs_reclassify_socket4(sock);
  1485. if (xs_bind4(transport, sock)) {
  1486. sock_release(sock);
  1487. goto out;
  1488. }
  1489. dprintk("RPC: worker connecting xprt %p via %s to "
  1490. "%s (port %s)\n", xprt,
  1491. xprt->address_strings[RPC_DISPLAY_PROTO],
  1492. xprt->address_strings[RPC_DISPLAY_ADDR],
  1493. xprt->address_strings[RPC_DISPLAY_PORT]);
  1494. xs_udp_finish_connecting(xprt, sock);
  1495. status = 0;
  1496. out:
  1497. xprt_clear_connecting(xprt);
  1498. xprt_wake_pending_tasks(xprt, status);
  1499. }
  1500. /**
  1501. * xs_udp_connect_worker6 - set up a UDP socket
  1502. * @work: RPC transport to connect
  1503. *
  1504. * Invoked by a work queue tasklet.
  1505. */
  1506. static void xs_udp_connect_worker6(struct work_struct *work)
  1507. {
  1508. struct sock_xprt *transport =
  1509. container_of(work, struct sock_xprt, connect_worker.work);
  1510. struct rpc_xprt *xprt = &transport->xprt;
  1511. struct socket *sock = transport->sock;
  1512. int err, status = -EIO;
  1513. if (xprt->shutdown)
  1514. goto out;
  1515. /* Start by resetting any existing state */
  1516. xs_reset_transport(transport);
  1517. err = sock_create_kern(PF_INET6, SOCK_DGRAM, IPPROTO_UDP, &sock);
  1518. if (err < 0) {
  1519. dprintk("RPC: can't create UDP transport socket (%d).\n", -err);
  1520. goto out;
  1521. }
  1522. xs_reclassify_socket6(sock);
  1523. if (xs_bind6(transport, sock) < 0) {
  1524. sock_release(sock);
  1525. goto out;
  1526. }
  1527. dprintk("RPC: worker connecting xprt %p via %s to "
  1528. "%s (port %s)\n", xprt,
  1529. xprt->address_strings[RPC_DISPLAY_PROTO],
  1530. xprt->address_strings[RPC_DISPLAY_ADDR],
  1531. xprt->address_strings[RPC_DISPLAY_PORT]);
  1532. xs_udp_finish_connecting(xprt, sock);
  1533. status = 0;
  1534. out:
  1535. xprt_clear_connecting(xprt);
  1536. xprt_wake_pending_tasks(xprt, status);
  1537. }
  1538. /*
  1539. * We need to preserve the port number so the reply cache on the server can
  1540. * find our cached RPC replies when we get around to reconnecting.
  1541. */
  1542. static void xs_abort_connection(struct rpc_xprt *xprt, struct sock_xprt *transport)
  1543. {
  1544. int result;
  1545. struct sockaddr any;
  1546. dprintk("RPC: disconnecting xprt %p to reuse port\n", xprt);
  1547. /*
  1548. * Disconnect the transport socket by doing a connect operation
  1549. * with AF_UNSPEC. This should return immediately...
  1550. */
  1551. memset(&any, 0, sizeof(any));
  1552. any.sa_family = AF_UNSPEC;
  1553. result = kernel_connect(transport->sock, &any, sizeof(any), 0);
  1554. if (!result)
  1555. xs_sock_mark_closed(xprt);
  1556. else
  1557. dprintk("RPC: AF_UNSPEC connect return code %d\n",
  1558. result);
  1559. }
  1560. static void xs_tcp_reuse_connection(struct rpc_xprt *xprt, struct sock_xprt *transport)
  1561. {
  1562. unsigned int state = transport->inet->sk_state;
  1563. if (state == TCP_CLOSE && transport->sock->state == SS_UNCONNECTED)
  1564. return;
  1565. if ((1 << state) & (TCPF_ESTABLISHED|TCPF_SYN_SENT))
  1566. return;
  1567. xs_abort_connection(xprt, transport);
  1568. }
  1569. static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
  1570. {
  1571. struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
  1572. if (!transport->inet) {
  1573. struct sock *sk = sock->sk;
  1574. write_lock_bh(&sk->sk_callback_lock);
  1575. xs_save_old_callbacks(transport, sk);
  1576. sk->sk_user_data = xprt;
  1577. sk->sk_data_ready = xs_tcp_data_ready;
  1578. sk->sk_state_change = xs_tcp_state_change;
  1579. sk->sk_write_space = xs_tcp_write_space;
  1580. sk->sk_error_report = xs_error_report;
  1581. sk->sk_allocation = GFP_ATOMIC;
  1582. /* socket options */
  1583. sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
  1584. sock_reset_flag(sk, SOCK_LINGER);
  1585. tcp_sk(sk)->linger2 = 0;
  1586. tcp_sk(sk)->nonagle |= TCP_NAGLE_OFF;
  1587. xprt_clear_connected(xprt);
  1588. /* Reset to new socket */
  1589. transport->sock = sock;
  1590. transport->inet = sk;
  1591. write_unlock_bh(&sk->sk_callback_lock);
  1592. }
  1593. if (!xprt_bound(xprt))
  1594. return -ENOTCONN;
  1595. /* Tell the socket layer to start connecting... */
  1596. xprt->stat.connect_count++;
  1597. xprt->stat.connect_start = jiffies;
  1598. return kernel_connect(sock, xs_addr(xprt), xprt->addrlen, O_NONBLOCK);
  1599. }
  1600. /**
  1601. * xs_tcp_setup_socket - create a TCP socket and connect to a remote endpoint
  1602. * @xprt: RPC transport to connect
  1603. * @transport: socket transport to connect
  1604. * @create_sock: function to create a socket of the correct type
  1605. *
  1606. * Invoked by a work queue tasklet.
  1607. */
  1608. static void xs_tcp_setup_socket(struct rpc_xprt *xprt,
  1609. struct sock_xprt *transport,
  1610. struct socket *(*create_sock)(struct rpc_xprt *,
  1611. struct sock_xprt *))
  1612. {
  1613. struct socket *sock = transport->sock;
  1614. int status = -EIO;
  1615. if (xprt->shutdown)
  1616. goto out;
  1617. if (!sock) {
  1618. clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
  1619. sock = create_sock(xprt, transport);
  1620. if (IS_ERR(sock)) {
  1621. status = PTR_ERR(sock);
  1622. goto out;
  1623. }
  1624. } else {
  1625. int abort_and_exit;
  1626. abort_and_exit = test_and_clear_bit(XPRT_CONNECTION_ABORT,
  1627. &xprt->state);
  1628. /* "close" the socket, preserving the local port */
  1629. xs_tcp_reuse_connection(xprt, transport);
  1630. if (abort_and_exit)
  1631. goto out_eagain;
  1632. }
  1633. dprintk("RPC: worker connecting xprt %p via %s to "
  1634. "%s (port %s)\n", xprt,
  1635. xprt->address_strings[RPC_DISPLAY_PROTO],
  1636. xprt->address_strings[RPC_DISPLAY_ADDR],
  1637. xprt->address_strings[RPC_DISPLAY_PORT]);
  1638. status = xs_tcp_finish_connecting(xprt, sock);
  1639. dprintk("RPC: %p connect status %d connected %d sock state %d\n",
  1640. xprt, -status, xprt_connected(xprt),
  1641. sock->sk->sk_state);
  1642. switch (status) {
  1643. default:
  1644. printk("%s: connect returned unhandled error %d\n",
  1645. __func__, status);
  1646. case -EADDRNOTAVAIL:
  1647. /* We're probably in TIME_WAIT. Get rid of existing socket,
  1648. * and retry
  1649. */
  1650. set_bit(XPRT_CONNECTION_CLOSE, &xprt->state);
  1651. xprt_force_disconnect(xprt);
  1652. break;
  1653. case -ECONNREFUSED:
  1654. case -ECONNRESET:
  1655. case -ENETUNREACH:
  1656. /* retry with existing socket, after a delay */
  1657. case 0:
  1658. case -EINPROGRESS:
  1659. case -EALREADY:
  1660. xprt_clear_connecting(xprt);
  1661. return;
  1662. case -EINVAL:
  1663. /* Happens, for instance, if the user specified a link
  1664. * local IPv6 address without a scope-id.
  1665. */
  1666. goto out;
  1667. }
  1668. out_eagain:
  1669. status = -EAGAIN;
  1670. out:
  1671. xprt_clear_connecting(xprt);
  1672. xprt_wake_pending_tasks(xprt, status);
  1673. }
  1674. static struct socket *xs_create_tcp_sock4(struct rpc_xprt *xprt,
  1675. struct sock_xprt *transport)
  1676. {
  1677. struct socket *sock;
  1678. int err;
  1679. /* start from scratch */
  1680. err = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
  1681. if (err < 0) {
  1682. dprintk("RPC: can't create TCP transport socket (%d).\n",
  1683. -err);
  1684. goto out_err;
  1685. }
  1686. xs_reclassify_socket4(sock);
  1687. if (xs_bind4(transport, sock) < 0) {
  1688. sock_release(sock);
  1689. goto out_err;
  1690. }
  1691. return sock;
  1692. out_err:
  1693. return ERR_PTR(-EIO);
  1694. }
  1695. /**
  1696. * xs_tcp_connect_worker4 - connect a TCP socket to a remote endpoint
  1697. * @work: RPC transport to connect
  1698. *
  1699. * Invoked by a work queue tasklet.
  1700. */
  1701. static void xs_tcp_connect_worker4(struct work_struct *work)
  1702. {
  1703. struct sock_xprt *transport =
  1704. container_of(work, struct sock_xprt, connect_worker.work);
  1705. struct rpc_xprt *xprt = &transport->xprt;
  1706. xs_tcp_setup_socket(xprt, transport, xs_create_tcp_sock4);
  1707. }
  1708. static struct socket *xs_create_tcp_sock6(struct rpc_xprt *xprt,
  1709. struct sock_xprt *transport)
  1710. {
  1711. struct socket *sock;
  1712. int err;
  1713. /* start from scratch */
  1714. err = sock_create_kern(PF_INET6, SOCK_STREAM, IPPROTO_TCP, &sock);
  1715. if (err < 0) {
  1716. dprintk("RPC: can't create TCP transport socket (%d).\n",
  1717. -err);
  1718. goto out_err;
  1719. }
  1720. xs_reclassify_socket6(sock);
  1721. if (xs_bind6(transport, sock) < 0) {
  1722. sock_release(sock);
  1723. goto out_err;
  1724. }
  1725. return sock;
  1726. out_err:
  1727. return ERR_PTR(-EIO);
  1728. }
  1729. /**
  1730. * xs_tcp_connect_worker6 - connect a TCP socket to a remote endpoint
  1731. * @work: RPC transport to connect
  1732. *
  1733. * Invoked by a work queue tasklet.
  1734. */
  1735. static void xs_tcp_connect_worker6(struct work_struct *work)
  1736. {
  1737. struct sock_xprt *transport =
  1738. container_of(work, struct sock_xprt, connect_worker.work);
  1739. struct rpc_xprt *xprt = &transport->xprt;
  1740. xs_tcp_setup_socket(xprt, transport, xs_create_tcp_sock6);
  1741. }
  1742. /**
  1743. * xs_connect - connect a socket to a remote endpoint
  1744. * @task: address of RPC task that manages state of connect request
  1745. *
  1746. * TCP: If the remote end dropped the connection, delay reconnecting.
  1747. *
  1748. * UDP socket connects are synchronous, but we use a work queue anyway
  1749. * to guarantee that even unprivileged user processes can set up a
  1750. * socket on a privileged port.
  1751. *
  1752. * If a UDP socket connect fails, the delay behavior here prevents
  1753. * retry floods (hard mounts).
  1754. */
  1755. static void xs_connect(struct rpc_task *task)
  1756. {
  1757. struct rpc_xprt *xprt = task->tk_xprt;
  1758. struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
  1759. if (xprt_test_and_set_connecting(xprt))
  1760. return;
  1761. if (transport->sock != NULL && !RPC_IS_SOFTCONN(task)) {
  1762. dprintk("RPC: xs_connect delayed xprt %p for %lu "
  1763. "seconds\n",
  1764. xprt, xprt->reestablish_timeout / HZ);
  1765. queue_delayed_work(rpciod_workqueue,
  1766. &transport->connect_worker,
  1767. xprt->reestablish_timeout);
  1768. xprt->reestablish_timeout <<= 1;
  1769. if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO)
  1770. xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
  1771. if (xprt->reestablish_timeout > XS_TCP_MAX_REEST_TO)
  1772. xprt->reestablish_timeout = XS_TCP_MAX_REEST_TO;
  1773. } else {
  1774. dprintk("RPC: xs_connect scheduled xprt %p\n", xprt);
  1775. queue_delayed_work(rpciod_workqueue,
  1776. &transport->connect_worker, 0);
  1777. }
  1778. }
  1779. static void xs_tcp_connect(struct rpc_task *task)
  1780. {
  1781. struct rpc_xprt *xprt = task->tk_xprt;
  1782. /* Exit if we need to wait for socket shutdown to complete */
  1783. if (test_bit(XPRT_CLOSING, &xprt->state))
  1784. return;
  1785. xs_connect(task);
  1786. }
  1787. /**
  1788. * xs_udp_print_stats - display UDP socket-specifc stats
  1789. * @xprt: rpc_xprt struct containing statistics
  1790. * @seq: output file
  1791. *
  1792. */
  1793. static void xs_udp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
  1794. {
  1795. struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
  1796. seq_printf(seq, "\txprt:\tudp %u %lu %lu %lu %lu %Lu %Lu\n",
  1797. transport->srcport,
  1798. xprt->stat.bind_count,
  1799. xprt->stat.sends,
  1800. xprt->stat.recvs,
  1801. xprt->stat.bad_xids,
  1802. xprt->stat.req_u,
  1803. xprt->stat.bklog_u);
  1804. }
  1805. /**
  1806. * xs_tcp_print_stats - display TCP socket-specifc stats
  1807. * @xprt: rpc_xprt struct containing statistics
  1808. * @seq: output file
  1809. *
  1810. */
  1811. static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
  1812. {
  1813. struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
  1814. long idle_time = 0;
  1815. if (xprt_connected(xprt))
  1816. idle_time = (long)(jiffies - xprt->last_used) / HZ;
  1817. seq_printf(seq, "\txprt:\ttcp %u %lu %lu %lu %ld %lu %lu %lu %Lu %Lu\n",
  1818. transport->srcport,
  1819. xprt->stat.bind_count,
  1820. xprt->stat.connect_count,
  1821. xprt->stat.connect_time,
  1822. idle_time,
  1823. xprt->stat.sends,
  1824. xprt->stat.recvs,
  1825. xprt->stat.bad_xids,
  1826. xprt->stat.req_u,
  1827. xprt->stat.bklog_u);
  1828. }
  1829. /*
  1830. * Allocate a bunch of pages for a scratch buffer for the rpc code. The reason
  1831. * we allocate pages instead doing a kmalloc like rpc_malloc is because we want
  1832. * to use the server side send routines.
  1833. */
  1834. static void *bc_malloc(struct rpc_task *task, size_t size)
  1835. {
  1836. struct page *page;
  1837. struct rpc_buffer *buf;
  1838. BUG_ON(size > PAGE_SIZE - sizeof(struct rpc_buffer));
  1839. page = alloc_page(GFP_KERNEL);
  1840. if (!page)
  1841. return NULL;
  1842. buf = page_address(page);
  1843. buf->len = PAGE_SIZE;
  1844. return buf->data;
  1845. }
  1846. /*
  1847. * Free the space allocated in the bc_alloc routine
  1848. */
  1849. static void bc_free(void *buffer)
  1850. {
  1851. struct rpc_buffer *buf;
  1852. if (!buffer)
  1853. return;
  1854. buf = container_of(buffer, struct rpc_buffer, data);
  1855. free_page((unsigned long)buf);
  1856. }
  1857. /*
  1858. * Use the svc_sock to send the callback. Must be called with svsk->sk_mutex
  1859. * held. Borrows heavily from svc_tcp_sendto and xs_tcp_send_request.
  1860. */
  1861. static int bc_sendto(struct rpc_rqst *req)
  1862. {
  1863. int len;
  1864. struct xdr_buf *xbufp = &req->rq_snd_buf;
  1865. struct rpc_xprt *xprt = req->rq_xprt;
  1866. struct sock_xprt *transport =
  1867. container_of(xprt, struct sock_xprt, xprt);
  1868. struct socket *sock = transport->sock;
  1869. unsigned long headoff;
  1870. unsigned long tailoff;
  1871. /*
  1872. * Set up the rpc header and record marker stuff
  1873. */
  1874. xs_encode_tcp_record_marker(xbufp);
  1875. tailoff = (unsigned long)xbufp->tail[0].iov_base & ~PAGE_MASK;
  1876. headoff = (unsigned long)xbufp->head[0].iov_base & ~PAGE_MASK;
  1877. len = svc_send_common(sock, xbufp,
  1878. virt_to_page(xbufp->head[0].iov_base), headoff,
  1879. xbufp->tail[0].iov_base, tailoff);
  1880. if (len != xbufp->len) {
  1881. printk(KERN_NOTICE "Error sending entire callback!\n");
  1882. len = -EAGAIN;
  1883. }
  1884. return len;
  1885. }
  1886. /*
  1887. * The send routine. Borrows from svc_send
  1888. */
  1889. static int bc_send_request(struct rpc_task *task)
  1890. {
  1891. struct rpc_rqst *req = task->tk_rqstp;
  1892. struct svc_xprt *xprt;
  1893. struct svc_sock *svsk;
  1894. u32 len;
  1895. dprintk("sending request with xid: %08x\n", ntohl(req->rq_xid));
  1896. /*
  1897. * Get the server socket associated with this callback xprt
  1898. */
  1899. xprt = req->rq_xprt->bc_xprt;
  1900. svsk = container_of(xprt, struct svc_sock, sk_xprt);
  1901. /*
  1902. * Grab the mutex to serialize data as the connection is shared
  1903. * with the fore channel
  1904. */
  1905. if (!mutex_trylock(&xprt->xpt_mutex)) {
  1906. rpc_sleep_on(&xprt->xpt_bc_pending, task, NULL);
  1907. if (!mutex_trylock(&xprt->xpt_mutex))
  1908. return -EAGAIN;
  1909. rpc_wake_up_queued_task(&xprt->xpt_bc_pending, task);
  1910. }
  1911. if (test_bit(XPT_DEAD, &xprt->xpt_flags))
  1912. len = -ENOTCONN;
  1913. else
  1914. len = bc_sendto(req);
  1915. mutex_unlock(&xprt->xpt_mutex);
  1916. if (len > 0)
  1917. len = 0;
  1918. return len;
  1919. }
  1920. /*
  1921. * The close routine. Since this is client initiated, we do nothing
  1922. */
  1923. static void bc_close(struct rpc_xprt *xprt)
  1924. {
  1925. return;
  1926. }
  1927. /*
  1928. * The xprt destroy routine. Again, because this connection is client
  1929. * initiated, we do nothing
  1930. */
  1931. static void bc_destroy(struct rpc_xprt *xprt)
  1932. {
  1933. return;
  1934. }
  1935. static struct rpc_xprt_ops xs_udp_ops = {
  1936. .set_buffer_size = xs_udp_set_buffer_size,
  1937. .reserve_xprt = xprt_reserve_xprt_cong,
  1938. .release_xprt = xprt_release_xprt_cong,
  1939. .rpcbind = rpcb_getport_async,
  1940. .set_port = xs_set_port,
  1941. .connect = xs_connect,
  1942. .buf_alloc = rpc_malloc,
  1943. .buf_free = rpc_free,
  1944. .send_request = xs_udp_send_request,
  1945. .set_retrans_timeout = xprt_set_retrans_timeout_rtt,
  1946. .timer = xs_udp_timer,
  1947. .release_request = xprt_release_rqst_cong,
  1948. .close = xs_close,
  1949. .destroy = xs_destroy,
  1950. .print_stats = xs_udp_print_stats,
  1951. };
  1952. static struct rpc_xprt_ops xs_tcp_ops = {
  1953. .reserve_xprt = xprt_reserve_xprt,
  1954. .release_xprt = xs_tcp_release_xprt,
  1955. .rpcbind = rpcb_getport_async,
  1956. .set_port = xs_set_port,
  1957. .connect = xs_tcp_connect,
  1958. .buf_alloc = rpc_malloc,
  1959. .buf_free = rpc_free,
  1960. .send_request = xs_tcp_send_request,
  1961. .set_retrans_timeout = xprt_set_retrans_timeout_def,
  1962. #if defined(CONFIG_NFS_V4_1)
  1963. .release_request = bc_release_request,
  1964. #endif /* CONFIG_NFS_V4_1 */
  1965. .close = xs_tcp_close,
  1966. .destroy = xs_destroy,
  1967. .print_stats = xs_tcp_print_stats,
  1968. };
  1969. /*
  1970. * The rpc_xprt_ops for the server backchannel
  1971. */
  1972. static struct rpc_xprt_ops bc_tcp_ops = {
  1973. .reserve_xprt = xprt_reserve_xprt,
  1974. .release_xprt = xprt_release_xprt,
  1975. .buf_alloc = bc_malloc,
  1976. .buf_free = bc_free,
  1977. .send_request = bc_send_request,
  1978. .set_retrans_timeout = xprt_set_retrans_timeout_def,
  1979. .close = bc_close,
  1980. .destroy = bc_destroy,
  1981. .print_stats = xs_tcp_print_stats,
  1982. };
  1983. static struct rpc_xprt *xs_setup_xprt(struct xprt_create *args,
  1984. unsigned int slot_table_size)
  1985. {
  1986. struct rpc_xprt *xprt;
  1987. struct sock_xprt *new;
  1988. if (args->addrlen > sizeof(xprt->addr)) {
  1989. dprintk("RPC: xs_setup_xprt: address too large\n");
  1990. return ERR_PTR(-EBADF);
  1991. }
  1992. new = kzalloc(sizeof(*new), GFP_KERNEL);
  1993. if (new == NULL) {
  1994. dprintk("RPC: xs_setup_xprt: couldn't allocate "
  1995. "rpc_xprt\n");
  1996. return ERR_PTR(-ENOMEM);
  1997. }
  1998. xprt = &new->xprt;
  1999. xprt->max_reqs = slot_table_size;
  2000. xprt->slot = kcalloc(xprt->max_reqs, sizeof(struct rpc_rqst), GFP_KERNEL);
  2001. if (xprt->slot == NULL) {
  2002. kfree(xprt);
  2003. dprintk("RPC: xs_setup_xprt: couldn't allocate slot "
  2004. "table\n");
  2005. return ERR_PTR(-ENOMEM);
  2006. }
  2007. memcpy(&xprt->addr, args->dstaddr, args->addrlen);
  2008. xprt->addrlen = args->addrlen;
  2009. if (args->srcaddr)
  2010. memcpy(&new->srcaddr, args->srcaddr, args->addrlen);
  2011. return xprt;
  2012. }
  2013. static const struct rpc_timeout xs_udp_default_timeout = {
  2014. .to_initval = 5 * HZ,
  2015. .to_maxval = 30 * HZ,
  2016. .to_increment = 5 * HZ,
  2017. .to_retries = 5,
  2018. };
  2019. /**
  2020. * xs_setup_udp - Set up transport to use a UDP socket
  2021. * @args: rpc transport creation arguments
  2022. *
  2023. */
  2024. static struct rpc_xprt *xs_setup_udp(struct xprt_create *args)
  2025. {
  2026. struct sockaddr *addr = args->dstaddr;
  2027. struct rpc_xprt *xprt;
  2028. struct sock_xprt *transport;
  2029. xprt = xs_setup_xprt(args, xprt_udp_slot_table_entries);
  2030. if (IS_ERR(xprt))
  2031. return xprt;
  2032. transport = container_of(xprt, struct sock_xprt, xprt);
  2033. xprt->prot = IPPROTO_UDP;
  2034. xprt->tsh_size = 0;
  2035. /* XXX: header size can vary due to auth type, IPv6, etc. */
  2036. xprt->max_payload = (1U << 16) - (MAX_HEADER << 3);
  2037. xprt->bind_timeout = XS_BIND_TO;
  2038. xprt->connect_timeout = XS_UDP_CONN_TO;
  2039. xprt->reestablish_timeout = XS_UDP_REEST_TO;
  2040. xprt->idle_timeout = XS_IDLE_DISC_TO;
  2041. xprt->ops = &xs_udp_ops;
  2042. xprt->timeout = &xs_udp_default_timeout;
  2043. switch (addr->sa_family) {
  2044. case AF_INET:
  2045. if (((struct sockaddr_in *)addr)->sin_port != htons(0))
  2046. xprt_set_bound(xprt);
  2047. INIT_DELAYED_WORK(&transport->connect_worker,
  2048. xs_udp_connect_worker4);
  2049. xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP);
  2050. break;
  2051. case AF_INET6:
  2052. if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0))
  2053. xprt_set_bound(xprt);
  2054. INIT_DELAYED_WORK(&transport->connect_worker,
  2055. xs_udp_connect_worker6);
  2056. xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP6);
  2057. break;
  2058. default:
  2059. kfree(xprt);
  2060. return ERR_PTR(-EAFNOSUPPORT);
  2061. }
  2062. if (xprt_bound(xprt))
  2063. dprintk("RPC: set up xprt to %s (port %s) via %s\n",
  2064. xprt->address_strings[RPC_DISPLAY_ADDR],
  2065. xprt->address_strings[RPC_DISPLAY_PORT],
  2066. xprt->address_strings[RPC_DISPLAY_PROTO]);
  2067. else
  2068. dprintk("RPC: set up xprt to %s (autobind) via %s\n",
  2069. xprt->address_strings[RPC_DISPLAY_ADDR],
  2070. xprt->address_strings[RPC_DISPLAY_PROTO]);
  2071. if (try_module_get(THIS_MODULE))
  2072. return xprt;
  2073. kfree(xprt->slot);
  2074. kfree(xprt);
  2075. return ERR_PTR(-EINVAL);
  2076. }
  2077. static const struct rpc_timeout xs_tcp_default_timeout = {
  2078. .to_initval = 60 * HZ,
  2079. .to_maxval = 60 * HZ,
  2080. .to_retries = 2,
  2081. };
  2082. /**
  2083. * xs_setup_tcp - Set up transport to use a TCP socket
  2084. * @args: rpc transport creation arguments
  2085. *
  2086. */
  2087. static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args)
  2088. {
  2089. struct sockaddr *addr = args->dstaddr;
  2090. struct rpc_xprt *xprt;
  2091. struct sock_xprt *transport;
  2092. xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries);
  2093. if (IS_ERR(xprt))
  2094. return xprt;
  2095. transport = container_of(xprt, struct sock_xprt, xprt);
  2096. xprt->prot = IPPROTO_TCP;
  2097. xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32);
  2098. xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
  2099. xprt->bind_timeout = XS_BIND_TO;
  2100. xprt->connect_timeout = XS_TCP_CONN_TO;
  2101. xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
  2102. xprt->idle_timeout = XS_IDLE_DISC_TO;
  2103. xprt->ops = &xs_tcp_ops;
  2104. xprt->timeout = &xs_tcp_default_timeout;
  2105. switch (addr->sa_family) {
  2106. case AF_INET:
  2107. if (((struct sockaddr_in *)addr)->sin_port != htons(0))
  2108. xprt_set_bound(xprt);
  2109. INIT_DELAYED_WORK(&transport->connect_worker,
  2110. xs_tcp_connect_worker4);
  2111. xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP);
  2112. break;
  2113. case AF_INET6:
  2114. if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0))
  2115. xprt_set_bound(xprt);
  2116. INIT_DELAYED_WORK(&transport->connect_worker,
  2117. xs_tcp_connect_worker6);
  2118. xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6);
  2119. break;
  2120. default:
  2121. kfree(xprt);
  2122. return ERR_PTR(-EAFNOSUPPORT);
  2123. }
  2124. if (xprt_bound(xprt))
  2125. dprintk("RPC: set up xprt to %s (port %s) via %s\n",
  2126. xprt->address_strings[RPC_DISPLAY_ADDR],
  2127. xprt->address_strings[RPC_DISPLAY_PORT],
  2128. xprt->address_strings[RPC_DISPLAY_PROTO]);
  2129. else
  2130. dprintk("RPC: set up xprt to %s (autobind) via %s\n",
  2131. xprt->address_strings[RPC_DISPLAY_ADDR],
  2132. xprt->address_strings[RPC_DISPLAY_PROTO]);
  2133. if (try_module_get(THIS_MODULE))
  2134. return xprt;
  2135. kfree(xprt->slot);
  2136. kfree(xprt);
  2137. return ERR_PTR(-EINVAL);
  2138. }
  2139. /**
  2140. * xs_setup_bc_tcp - Set up transport to use a TCP backchannel socket
  2141. * @args: rpc transport creation arguments
  2142. *
  2143. */
  2144. static struct rpc_xprt *xs_setup_bc_tcp(struct xprt_create *args)
  2145. {
  2146. struct sockaddr *addr = args->dstaddr;
  2147. struct rpc_xprt *xprt;
  2148. struct sock_xprt *transport;
  2149. struct svc_sock *bc_sock;
  2150. if (!args->bc_xprt)
  2151. ERR_PTR(-EINVAL);
  2152. xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries);
  2153. if (IS_ERR(xprt))
  2154. return xprt;
  2155. transport = container_of(xprt, struct sock_xprt, xprt);
  2156. xprt->prot = IPPROTO_TCP;
  2157. xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32);
  2158. xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
  2159. xprt->timeout = &xs_tcp_default_timeout;
  2160. /* backchannel */
  2161. xprt_set_bound(xprt);
  2162. xprt->bind_timeout = 0;
  2163. xprt->connect_timeout = 0;
  2164. xprt->reestablish_timeout = 0;
  2165. xprt->idle_timeout = 0;
  2166. /*
  2167. * The backchannel uses the same socket connection as the
  2168. * forechannel
  2169. */
  2170. xprt->bc_xprt = args->bc_xprt;
  2171. bc_sock = container_of(args->bc_xprt, struct svc_sock, sk_xprt);
  2172. bc_sock->sk_bc_xprt = xprt;
  2173. transport->sock = bc_sock->sk_sock;
  2174. transport->inet = bc_sock->sk_sk;
  2175. xprt->ops = &bc_tcp_ops;
  2176. switch (addr->sa_family) {
  2177. case AF_INET:
  2178. xs_format_peer_addresses(xprt, "tcp",
  2179. RPCBIND_NETID_TCP);
  2180. break;
  2181. case AF_INET6:
  2182. xs_format_peer_addresses(xprt, "tcp",
  2183. RPCBIND_NETID_TCP6);
  2184. break;
  2185. default:
  2186. kfree(xprt);
  2187. return ERR_PTR(-EAFNOSUPPORT);
  2188. }
  2189. if (xprt_bound(xprt))
  2190. dprintk("RPC: set up xprt to %s (port %s) via %s\n",
  2191. xprt->address_strings[RPC_DISPLAY_ADDR],
  2192. xprt->address_strings[RPC_DISPLAY_PORT],
  2193. xprt->address_strings[RPC_DISPLAY_PROTO]);
  2194. else
  2195. dprintk("RPC: set up xprt to %s (autobind) via %s\n",
  2196. xprt->address_strings[RPC_DISPLAY_ADDR],
  2197. xprt->address_strings[RPC_DISPLAY_PROTO]);
  2198. /*
  2199. * Since we don't want connections for the backchannel, we set
  2200. * the xprt status to connected
  2201. */
  2202. xprt_set_connected(xprt);
  2203. if (try_module_get(THIS_MODULE))
  2204. return xprt;
  2205. kfree(xprt->slot);
  2206. kfree(xprt);
  2207. return ERR_PTR(-EINVAL);
  2208. }
  2209. static struct xprt_class xs_udp_transport = {
  2210. .list = LIST_HEAD_INIT(xs_udp_transport.list),
  2211. .name = "udp",
  2212. .owner = THIS_MODULE,
  2213. .ident = XPRT_TRANSPORT_UDP,
  2214. .setup = xs_setup_udp,
  2215. };
  2216. static struct xprt_class xs_tcp_transport = {
  2217. .list = LIST_HEAD_INIT(xs_tcp_transport.list),
  2218. .name = "tcp",
  2219. .owner = THIS_MODULE,
  2220. .ident = XPRT_TRANSPORT_TCP,
  2221. .setup = xs_setup_tcp,
  2222. };
  2223. static struct xprt_class xs_bc_tcp_transport = {
  2224. .list = LIST_HEAD_INIT(xs_bc_tcp_transport.list),
  2225. .name = "tcp NFSv4.1 backchannel",
  2226. .owner = THIS_MODULE,
  2227. .ident = XPRT_TRANSPORT_BC_TCP,
  2228. .setup = xs_setup_bc_tcp,
  2229. };
  2230. /**
  2231. * init_socket_xprt - set up xprtsock's sysctls, register with RPC client
  2232. *
  2233. */
  2234. int init_socket_xprt(void)
  2235. {
  2236. #ifdef RPC_DEBUG
  2237. if (!sunrpc_table_header)
  2238. sunrpc_table_header = register_sysctl_table(sunrpc_table);
  2239. #endif
  2240. xprt_register_transport(&xs_udp_transport);
  2241. xprt_register_transport(&xs_tcp_transport);
  2242. xprt_register_transport(&xs_bc_tcp_transport);
  2243. return 0;
  2244. }
  2245. /**
  2246. * cleanup_socket_xprt - remove xprtsock's sysctls, unregister
  2247. *
  2248. */
  2249. void cleanup_socket_xprt(void)
  2250. {
  2251. #ifdef RPC_DEBUG
  2252. if (sunrpc_table_header) {
  2253. unregister_sysctl_table(sunrpc_table_header);
  2254. sunrpc_table_header = NULL;
  2255. }
  2256. #endif
  2257. xprt_unregister_transport(&xs_udp_transport);
  2258. xprt_unregister_transport(&xs_tcp_transport);
  2259. xprt_unregister_transport(&xs_bc_tcp_transport);
  2260. }
  2261. static int param_set_uint_minmax(const char *val, struct kernel_param *kp,
  2262. unsigned int min, unsigned int max)
  2263. {
  2264. unsigned long num;
  2265. int ret;
  2266. if (!val)
  2267. return -EINVAL;
  2268. ret = strict_strtoul(val, 0, &num);
  2269. if (ret == -EINVAL || num < min || num > max)
  2270. return -EINVAL;
  2271. *((unsigned int *)kp->arg) = num;
  2272. return 0;
  2273. }
  2274. static int param_set_portnr(const char *val, struct kernel_param *kp)
  2275. {
  2276. return param_set_uint_minmax(val, kp,
  2277. RPC_MIN_RESVPORT,
  2278. RPC_MAX_RESVPORT);
  2279. }
  2280. static int param_get_portnr(char *buffer, struct kernel_param *kp)
  2281. {
  2282. return param_get_uint(buffer, kp);
  2283. }
  2284. #define param_check_portnr(name, p) \
  2285. __param_check(name, p, unsigned int);
  2286. module_param_named(min_resvport, xprt_min_resvport, portnr, 0644);
  2287. module_param_named(max_resvport, xprt_max_resvport, portnr, 0644);
  2288. static int param_set_slot_table_size(const char *val, struct kernel_param *kp)
  2289. {
  2290. return param_set_uint_minmax(val, kp,
  2291. RPC_MIN_SLOT_TABLE,
  2292. RPC_MAX_SLOT_TABLE);
  2293. }
  2294. static int param_get_slot_table_size(char *buffer, struct kernel_param *kp)
  2295. {
  2296. return param_get_uint(buffer, kp);
  2297. }
  2298. #define param_check_slot_table_size(name, p) \
  2299. __param_check(name, p, unsigned int);
  2300. module_param_named(tcp_slot_table_entries, xprt_tcp_slot_table_entries,
  2301. slot_table_size, 0644);
  2302. module_param_named(udp_slot_table_entries, xprt_udp_slot_table_entries,
  2303. slot_table_size, 0644);