client.c 44 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760
  1. /* client.c: NFS client sharing and management code
  2. *
  3. * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
  4. * Written by David Howells (dhowells@redhat.com)
  5. *
  6. * This program is free software; you can redistribute it and/or
  7. * modify it under the terms of the GNU General Public License
  8. * as published by the Free Software Foundation; either version
  9. * 2 of the License, or (at your option) any later version.
  10. */
  11. #include <linux/module.h>
  12. #include <linux/init.h>
  13. #include <linux/sched.h>
  14. #include <linux/time.h>
  15. #include <linux/kernel.h>
  16. #include <linux/mm.h>
  17. #include <linux/string.h>
  18. #include <linux/stat.h>
  19. #include <linux/errno.h>
  20. #include <linux/unistd.h>
  21. #include <linux/sunrpc/clnt.h>
  22. #include <linux/sunrpc/stats.h>
  23. #include <linux/sunrpc/metrics.h>
  24. #include <linux/sunrpc/xprtsock.h>
  25. #include <linux/sunrpc/xprtrdma.h>
  26. #include <linux/nfs_fs.h>
  27. #include <linux/nfs_mount.h>
  28. #include <linux/nfs4_mount.h>
  29. #include <linux/lockd/bind.h>
  30. #include <linux/seq_file.h>
  31. #include <linux/mount.h>
  32. #include <linux/nfs_idmap.h>
  33. #include <linux/vfs.h>
  34. #include <linux/inet.h>
  35. #include <linux/in6.h>
  36. #include <net/ipv6.h>
  37. #include <linux/nfs_xdr.h>
  38. #include <linux/sunrpc/bc_xprt.h>
  39. #include <asm/system.h>
  40. #include "nfs4_fs.h"
  41. #include "callback.h"
  42. #include "delegation.h"
  43. #include "iostat.h"
  44. #include "internal.h"
  45. #include "fscache.h"
  46. #define NFSDBG_FACILITY NFSDBG_CLIENT
  47. static DEFINE_SPINLOCK(nfs_client_lock);
  48. static LIST_HEAD(nfs_client_list);
  49. static LIST_HEAD(nfs_volume_list);
  50. static DECLARE_WAIT_QUEUE_HEAD(nfs_client_active_wq);
  51. /*
  52. * RPC cruft for NFS
  53. */
  54. static struct rpc_version *nfs_version[5] = {
  55. [2] = &nfs_version2,
  56. #ifdef CONFIG_NFS_V3
  57. [3] = &nfs_version3,
  58. #endif
  59. #ifdef CONFIG_NFS_V4
  60. [4] = &nfs_version4,
  61. #endif
  62. };
  63. struct rpc_program nfs_program = {
  64. .name = "nfs",
  65. .number = NFS_PROGRAM,
  66. .nrvers = ARRAY_SIZE(nfs_version),
  67. .version = nfs_version,
  68. .stats = &nfs_rpcstat,
  69. .pipe_dir_name = "/nfs",
  70. };
  71. struct rpc_stat nfs_rpcstat = {
  72. .program = &nfs_program
  73. };
  74. #ifdef CONFIG_NFS_V3_ACL
  75. static struct rpc_stat nfsacl_rpcstat = { &nfsacl_program };
  76. static struct rpc_version * nfsacl_version[] = {
  77. [3] = &nfsacl_version3,
  78. };
  79. struct rpc_program nfsacl_program = {
  80. .name = "nfsacl",
  81. .number = NFS_ACL_PROGRAM,
  82. .nrvers = ARRAY_SIZE(nfsacl_version),
  83. .version = nfsacl_version,
  84. .stats = &nfsacl_rpcstat,
  85. };
  86. #endif /* CONFIG_NFS_V3_ACL */
  87. struct nfs_client_initdata {
  88. const char *hostname;
  89. const struct sockaddr *addr;
  90. size_t addrlen;
  91. const struct nfs_rpc_ops *rpc_ops;
  92. int proto;
  93. u32 minorversion;
  94. };
  95. /*
  96. * Allocate a shared client record
  97. *
  98. * Since these are allocated/deallocated very rarely, we don't
  99. * bother putting them in a slab cache...
  100. */
  101. static struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *cl_init)
  102. {
  103. struct nfs_client *clp;
  104. struct rpc_cred *cred;
  105. int err = -ENOMEM;
  106. if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)
  107. goto error_0;
  108. clp->rpc_ops = cl_init->rpc_ops;
  109. atomic_set(&clp->cl_count, 1);
  110. clp->cl_cons_state = NFS_CS_INITING;
  111. memcpy(&clp->cl_addr, cl_init->addr, cl_init->addrlen);
  112. clp->cl_addrlen = cl_init->addrlen;
  113. if (cl_init->hostname) {
  114. err = -ENOMEM;
  115. clp->cl_hostname = kstrdup(cl_init->hostname, GFP_KERNEL);
  116. if (!clp->cl_hostname)
  117. goto error_cleanup;
  118. }
  119. INIT_LIST_HEAD(&clp->cl_superblocks);
  120. clp->cl_rpcclient = ERR_PTR(-EINVAL);
  121. clp->cl_proto = cl_init->proto;
  122. #ifdef CONFIG_NFS_V4
  123. INIT_LIST_HEAD(&clp->cl_delegations);
  124. spin_lock_init(&clp->cl_lock);
  125. INIT_DELAYED_WORK(&clp->cl_renewd, nfs4_renew_state);
  126. rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");
  127. clp->cl_boot_time = CURRENT_TIME;
  128. clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED;
  129. clp->cl_minorversion = cl_init->minorversion;
  130. #endif
  131. cred = rpc_lookup_machine_cred();
  132. if (!IS_ERR(cred))
  133. clp->cl_machine_cred = cred;
  134. nfs_fscache_get_client_cookie(clp);
  135. return clp;
  136. error_cleanup:
  137. kfree(clp);
  138. error_0:
  139. return ERR_PTR(err);
  140. }
  141. static void nfs4_shutdown_client(struct nfs_client *clp)
  142. {
  143. #ifdef CONFIG_NFS_V4
  144. if (__test_and_clear_bit(NFS_CS_RENEWD, &clp->cl_res_state))
  145. nfs4_kill_renewd(clp);
  146. BUG_ON(!RB_EMPTY_ROOT(&clp->cl_state_owners));
  147. if (__test_and_clear_bit(NFS_CS_IDMAP, &clp->cl_res_state))
  148. nfs_idmap_delete(clp);
  149. rpc_destroy_wait_queue(&clp->cl_rpcwaitq);
  150. #endif
  151. }
  152. /*
  153. * Destroy the NFS4 callback service
  154. */
  155. static void nfs4_destroy_callback(struct nfs_client *clp)
  156. {
  157. #ifdef CONFIG_NFS_V4
  158. if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state))
  159. nfs_callback_down(clp->cl_minorversion);
  160. #endif /* CONFIG_NFS_V4 */
  161. }
  162. /*
  163. * Clears/puts all minor version specific parts from an nfs_client struct
  164. * reverting it to minorversion 0.
  165. */
  166. static void nfs4_clear_client_minor_version(struct nfs_client *clp)
  167. {
  168. #ifdef CONFIG_NFS_V4_1
  169. if (nfs4_has_session(clp)) {
  170. nfs4_destroy_session(clp->cl_session);
  171. clp->cl_session = NULL;
  172. }
  173. clp->cl_call_sync = _nfs4_call_sync;
  174. #endif /* CONFIG_NFS_V4_1 */
  175. nfs4_destroy_callback(clp);
  176. }
  177. /*
  178. * Destroy a shared client record
  179. */
  180. static void nfs_free_client(struct nfs_client *clp)
  181. {
  182. dprintk("--> nfs_free_client(%u)\n", clp->rpc_ops->version);
  183. nfs4_clear_client_minor_version(clp);
  184. nfs4_shutdown_client(clp);
  185. nfs_fscache_release_client_cookie(clp);
  186. /* -EIO all pending I/O */
  187. if (!IS_ERR(clp->cl_rpcclient))
  188. rpc_shutdown_client(clp->cl_rpcclient);
  189. if (clp->cl_machine_cred != NULL)
  190. put_rpccred(clp->cl_machine_cred);
  191. kfree(clp->cl_hostname);
  192. kfree(clp);
  193. dprintk("<-- nfs_free_client()\n");
  194. }
  195. /*
  196. * Release a reference to a shared client record
  197. */
  198. void nfs_put_client(struct nfs_client *clp)
  199. {
  200. if (!clp)
  201. return;
  202. dprintk("--> nfs_put_client({%d})\n", atomic_read(&clp->cl_count));
  203. if (atomic_dec_and_lock(&clp->cl_count, &nfs_client_lock)) {
  204. list_del(&clp->cl_share_link);
  205. spin_unlock(&nfs_client_lock);
  206. BUG_ON(!list_empty(&clp->cl_superblocks));
  207. nfs_free_client(clp);
  208. }
  209. }
  210. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  211. /*
  212. * Test if two ip6 socket addresses refer to the same socket by
  213. * comparing relevant fields. The padding bytes specifically, are not
  214. * compared. sin6_flowinfo is not compared because it only affects QoS
  215. * and sin6_scope_id is only compared if the address is "link local"
  216. * because "link local" addresses need only be unique to a specific
  217. * link. Conversely, ordinary unicast addresses might have different
  218. * sin6_scope_id.
  219. *
  220. * The caller should ensure both socket addresses are AF_INET6.
  221. */
  222. static int nfs_sockaddr_match_ipaddr6(const struct sockaddr *sa1,
  223. const struct sockaddr *sa2)
  224. {
  225. const struct sockaddr_in6 *sin1 = (const struct sockaddr_in6 *)sa1;
  226. const struct sockaddr_in6 *sin2 = (const struct sockaddr_in6 *)sa2;
  227. if (ipv6_addr_scope(&sin1->sin6_addr) == IPV6_ADDR_SCOPE_LINKLOCAL &&
  228. sin1->sin6_scope_id != sin2->sin6_scope_id)
  229. return 0;
  230. return ipv6_addr_equal(&sin1->sin6_addr, &sin1->sin6_addr);
  231. }
  232. #else /* !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE) */
  233. static int nfs_sockaddr_match_ipaddr6(const struct sockaddr *sa1,
  234. const struct sockaddr *sa2)
  235. {
  236. return 0;
  237. }
  238. #endif
  239. /*
  240. * Test if two ip4 socket addresses refer to the same socket, by
  241. * comparing relevant fields. The padding bytes specifically, are
  242. * not compared.
  243. *
  244. * The caller should ensure both socket addresses are AF_INET.
  245. */
  246. static int nfs_sockaddr_match_ipaddr4(const struct sockaddr *sa1,
  247. const struct sockaddr *sa2)
  248. {
  249. const struct sockaddr_in *sin1 = (const struct sockaddr_in *)sa1;
  250. const struct sockaddr_in *sin2 = (const struct sockaddr_in *)sa2;
  251. return sin1->sin_addr.s_addr == sin2->sin_addr.s_addr;
  252. }
  253. static int nfs_sockaddr_cmp_ip6(const struct sockaddr *sa1,
  254. const struct sockaddr *sa2)
  255. {
  256. const struct sockaddr_in6 *sin1 = (const struct sockaddr_in6 *)sa1;
  257. const struct sockaddr_in6 *sin2 = (const struct sockaddr_in6 *)sa2;
  258. return nfs_sockaddr_match_ipaddr6(sa1, sa2) &&
  259. (sin1->sin6_port == sin2->sin6_port);
  260. }
  261. static int nfs_sockaddr_cmp_ip4(const struct sockaddr *sa1,
  262. const struct sockaddr *sa2)
  263. {
  264. const struct sockaddr_in *sin1 = (const struct sockaddr_in *)sa1;
  265. const struct sockaddr_in *sin2 = (const struct sockaddr_in *)sa2;
  266. return nfs_sockaddr_match_ipaddr4(sa1, sa2) &&
  267. (sin1->sin_port == sin2->sin_port);
  268. }
  269. /*
  270. * Test if two socket addresses represent the same actual socket,
  271. * by comparing (only) relevant fields, excluding the port number.
  272. */
  273. static int nfs_sockaddr_match_ipaddr(const struct sockaddr *sa1,
  274. const struct sockaddr *sa2)
  275. {
  276. if (sa1->sa_family != sa2->sa_family)
  277. return 0;
  278. switch (sa1->sa_family) {
  279. case AF_INET:
  280. return nfs_sockaddr_match_ipaddr4(sa1, sa2);
  281. case AF_INET6:
  282. return nfs_sockaddr_match_ipaddr6(sa1, sa2);
  283. }
  284. return 0;
  285. }
  286. /*
  287. * Test if two socket addresses represent the same actual socket,
  288. * by comparing (only) relevant fields, including the port number.
  289. */
  290. static int nfs_sockaddr_cmp(const struct sockaddr *sa1,
  291. const struct sockaddr *sa2)
  292. {
  293. if (sa1->sa_family != sa2->sa_family)
  294. return 0;
  295. switch (sa1->sa_family) {
  296. case AF_INET:
  297. return nfs_sockaddr_cmp_ip4(sa1, sa2);
  298. case AF_INET6:
  299. return nfs_sockaddr_cmp_ip6(sa1, sa2);
  300. }
  301. return 0;
  302. }
  303. /*
  304. * Find a client by IP address and protocol version
  305. * - returns NULL if no such client
  306. */
  307. struct nfs_client *nfs_find_client(const struct sockaddr *addr, u32 nfsversion)
  308. {
  309. struct nfs_client *clp;
  310. spin_lock(&nfs_client_lock);
  311. list_for_each_entry(clp, &nfs_client_list, cl_share_link) {
  312. struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;
  313. /* Don't match clients that failed to initialise properly */
  314. if (!(clp->cl_cons_state == NFS_CS_READY ||
  315. clp->cl_cons_state == NFS_CS_SESSION_INITING))
  316. continue;
  317. /* Different NFS versions cannot share the same nfs_client */
  318. if (clp->rpc_ops->version != nfsversion)
  319. continue;
  320. /* Match only the IP address, not the port number */
  321. if (!nfs_sockaddr_match_ipaddr(addr, clap))
  322. continue;
  323. atomic_inc(&clp->cl_count);
  324. spin_unlock(&nfs_client_lock);
  325. return clp;
  326. }
  327. spin_unlock(&nfs_client_lock);
  328. return NULL;
  329. }
  330. /*
  331. * Find a client by IP address and protocol version
  332. * - returns NULL if no such client
  333. */
  334. struct nfs_client *nfs_find_client_next(struct nfs_client *clp)
  335. {
  336. struct sockaddr *sap = (struct sockaddr *)&clp->cl_addr;
  337. u32 nfsvers = clp->rpc_ops->version;
  338. spin_lock(&nfs_client_lock);
  339. list_for_each_entry_continue(clp, &nfs_client_list, cl_share_link) {
  340. struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;
  341. /* Don't match clients that failed to initialise properly */
  342. if (clp->cl_cons_state != NFS_CS_READY)
  343. continue;
  344. /* Different NFS versions cannot share the same nfs_client */
  345. if (clp->rpc_ops->version != nfsvers)
  346. continue;
  347. /* Match only the IP address, not the port number */
  348. if (!nfs_sockaddr_match_ipaddr(sap, clap))
  349. continue;
  350. atomic_inc(&clp->cl_count);
  351. spin_unlock(&nfs_client_lock);
  352. return clp;
  353. }
  354. spin_unlock(&nfs_client_lock);
  355. return NULL;
  356. }
  357. /*
  358. * Find an nfs_client on the list that matches the initialisation data
  359. * that is supplied.
  360. */
  361. static struct nfs_client *nfs_match_client(const struct nfs_client_initdata *data)
  362. {
  363. struct nfs_client *clp;
  364. const struct sockaddr *sap = data->addr;
  365. list_for_each_entry(clp, &nfs_client_list, cl_share_link) {
  366. const struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;
  367. /* Don't match clients that failed to initialise properly */
  368. if (clp->cl_cons_state < 0)
  369. continue;
  370. /* Different NFS versions cannot share the same nfs_client */
  371. if (clp->rpc_ops != data->rpc_ops)
  372. continue;
  373. if (clp->cl_proto != data->proto)
  374. continue;
  375. /* Match nfsv4 minorversion */
  376. if (clp->cl_minorversion != data->minorversion)
  377. continue;
  378. /* Match the full socket address */
  379. if (!nfs_sockaddr_cmp(sap, clap))
  380. continue;
  381. atomic_inc(&clp->cl_count);
  382. return clp;
  383. }
  384. return NULL;
  385. }
  386. /*
  387. * Look up a client by IP address and protocol version
  388. * - creates a new record if one doesn't yet exist
  389. */
  390. static struct nfs_client *nfs_get_client(const struct nfs_client_initdata *cl_init)
  391. {
  392. struct nfs_client *clp, *new = NULL;
  393. int error;
  394. dprintk("--> nfs_get_client(%s,v%u)\n",
  395. cl_init->hostname ?: "", cl_init->rpc_ops->version);
  396. /* see if the client already exists */
  397. do {
  398. spin_lock(&nfs_client_lock);
  399. clp = nfs_match_client(cl_init);
  400. if (clp)
  401. goto found_client;
  402. if (new)
  403. goto install_client;
  404. spin_unlock(&nfs_client_lock);
  405. new = nfs_alloc_client(cl_init);
  406. } while (!IS_ERR(new));
  407. dprintk("--> nfs_get_client() = %ld [failed]\n", PTR_ERR(new));
  408. return new;
  409. /* install a new client and return with it unready */
  410. install_client:
  411. clp = new;
  412. list_add(&clp->cl_share_link, &nfs_client_list);
  413. spin_unlock(&nfs_client_lock);
  414. dprintk("--> nfs_get_client() = %p [new]\n", clp);
  415. return clp;
  416. /* found an existing client
  417. * - make sure it's ready before returning
  418. */
  419. found_client:
  420. spin_unlock(&nfs_client_lock);
  421. if (new)
  422. nfs_free_client(new);
  423. error = wait_event_killable(nfs_client_active_wq,
  424. clp->cl_cons_state < NFS_CS_INITING);
  425. if (error < 0) {
  426. nfs_put_client(clp);
  427. return ERR_PTR(-ERESTARTSYS);
  428. }
  429. if (clp->cl_cons_state < NFS_CS_READY) {
  430. error = clp->cl_cons_state;
  431. nfs_put_client(clp);
  432. return ERR_PTR(error);
  433. }
  434. BUG_ON(clp->cl_cons_state != NFS_CS_READY);
  435. dprintk("--> nfs_get_client() = %p [share]\n", clp);
  436. return clp;
  437. }
  438. /*
  439. * Mark a server as ready or failed
  440. */
  441. void nfs_mark_client_ready(struct nfs_client *clp, int state)
  442. {
  443. clp->cl_cons_state = state;
  444. wake_up_all(&nfs_client_active_wq);
  445. }
  446. /*
  447. * With sessions, the client is not marked ready until after a
  448. * successful EXCHANGE_ID and CREATE_SESSION.
  449. *
  450. * Map errors cl_cons_state errors to EPROTONOSUPPORT to indicate
  451. * other versions of NFS can be tried.
  452. */
  453. int nfs4_check_client_ready(struct nfs_client *clp)
  454. {
  455. if (!nfs4_has_session(clp))
  456. return 0;
  457. if (clp->cl_cons_state < NFS_CS_READY)
  458. return -EPROTONOSUPPORT;
  459. return 0;
  460. }
  461. /*
  462. * Initialise the timeout values for a connection
  463. */
  464. static void nfs_init_timeout_values(struct rpc_timeout *to, int proto,
  465. unsigned int timeo, unsigned int retrans)
  466. {
  467. to->to_initval = timeo * HZ / 10;
  468. to->to_retries = retrans;
  469. switch (proto) {
  470. case XPRT_TRANSPORT_TCP:
  471. case XPRT_TRANSPORT_RDMA:
  472. if (to->to_retries == 0)
  473. to->to_retries = NFS_DEF_TCP_RETRANS;
  474. if (to->to_initval == 0)
  475. to->to_initval = NFS_DEF_TCP_TIMEO * HZ / 10;
  476. if (to->to_initval > NFS_MAX_TCP_TIMEOUT)
  477. to->to_initval = NFS_MAX_TCP_TIMEOUT;
  478. to->to_increment = to->to_initval;
  479. to->to_maxval = to->to_initval + (to->to_increment * to->to_retries);
  480. if (to->to_maxval > NFS_MAX_TCP_TIMEOUT)
  481. to->to_maxval = NFS_MAX_TCP_TIMEOUT;
  482. if (to->to_maxval < to->to_initval)
  483. to->to_maxval = to->to_initval;
  484. to->to_exponential = 0;
  485. break;
  486. case XPRT_TRANSPORT_UDP:
  487. if (to->to_retries == 0)
  488. to->to_retries = NFS_DEF_UDP_RETRANS;
  489. if (!to->to_initval)
  490. to->to_initval = NFS_DEF_UDP_TIMEO * HZ / 10;
  491. if (to->to_initval > NFS_MAX_UDP_TIMEOUT)
  492. to->to_initval = NFS_MAX_UDP_TIMEOUT;
  493. to->to_maxval = NFS_MAX_UDP_TIMEOUT;
  494. to->to_exponential = 1;
  495. break;
  496. default:
  497. BUG();
  498. }
  499. }
  500. /*
  501. * Create an RPC client handle
  502. */
  503. static int nfs_create_rpc_client(struct nfs_client *clp,
  504. const struct rpc_timeout *timeparms,
  505. rpc_authflavor_t flavor,
  506. int discrtry, int noresvport)
  507. {
  508. struct rpc_clnt *clnt = NULL;
  509. struct rpc_create_args args = {
  510. .protocol = clp->cl_proto,
  511. .address = (struct sockaddr *)&clp->cl_addr,
  512. .addrsize = clp->cl_addrlen,
  513. .timeout = timeparms,
  514. .servername = clp->cl_hostname,
  515. .program = &nfs_program,
  516. .version = clp->rpc_ops->version,
  517. .authflavor = flavor,
  518. };
  519. if (discrtry)
  520. args.flags |= RPC_CLNT_CREATE_DISCRTRY;
  521. if (noresvport)
  522. args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
  523. if (!IS_ERR(clp->cl_rpcclient))
  524. return 0;
  525. clnt = rpc_create(&args);
  526. if (IS_ERR(clnt)) {
  527. dprintk("%s: cannot create RPC client. Error = %ld\n",
  528. __func__, PTR_ERR(clnt));
  529. return PTR_ERR(clnt);
  530. }
  531. clp->cl_rpcclient = clnt;
  532. return 0;
  533. }
  534. /*
  535. * Version 2 or 3 client destruction
  536. */
  537. static void nfs_destroy_server(struct nfs_server *server)
  538. {
  539. if (!(server->flags & NFS_MOUNT_NONLM))
  540. nlmclnt_done(server->nlm_host);
  541. }
  542. /*
  543. * Version 2 or 3 lockd setup
  544. */
  545. static int nfs_start_lockd(struct nfs_server *server)
  546. {
  547. struct nlm_host *host;
  548. struct nfs_client *clp = server->nfs_client;
  549. struct nlmclnt_initdata nlm_init = {
  550. .hostname = clp->cl_hostname,
  551. .address = (struct sockaddr *)&clp->cl_addr,
  552. .addrlen = clp->cl_addrlen,
  553. .protocol = server->flags & NFS_MOUNT_TCP ?
  554. IPPROTO_TCP : IPPROTO_UDP,
  555. .nfs_version = clp->rpc_ops->version,
  556. .noresvport = server->flags & NFS_MOUNT_NORESVPORT ?
  557. 1 : 0,
  558. };
  559. if (nlm_init.nfs_version > 3)
  560. return 0;
  561. if (server->flags & NFS_MOUNT_NONLM)
  562. return 0;
  563. host = nlmclnt_init(&nlm_init);
  564. if (IS_ERR(host))
  565. return PTR_ERR(host);
  566. server->nlm_host = host;
  567. server->destroy = nfs_destroy_server;
  568. return 0;
  569. }
  570. /*
  571. * Initialise an NFSv3 ACL client connection
  572. */
  573. #ifdef CONFIG_NFS_V3_ACL
  574. static void nfs_init_server_aclclient(struct nfs_server *server)
  575. {
  576. if (server->nfs_client->rpc_ops->version != 3)
  577. goto out_noacl;
  578. if (server->flags & NFS_MOUNT_NOACL)
  579. goto out_noacl;
  580. server->client_acl = rpc_bind_new_program(server->client, &nfsacl_program, 3);
  581. if (IS_ERR(server->client_acl))
  582. goto out_noacl;
  583. /* No errors! Assume that Sun nfsacls are supported */
  584. server->caps |= NFS_CAP_ACLS;
  585. return;
  586. out_noacl:
  587. server->caps &= ~NFS_CAP_ACLS;
  588. }
  589. #else
  590. static inline void nfs_init_server_aclclient(struct nfs_server *server)
  591. {
  592. server->flags &= ~NFS_MOUNT_NOACL;
  593. server->caps &= ~NFS_CAP_ACLS;
  594. }
  595. #endif
  596. /*
  597. * Create a general RPC client
  598. */
  599. static int nfs_init_server_rpcclient(struct nfs_server *server,
  600. const struct rpc_timeout *timeo,
  601. rpc_authflavor_t pseudoflavour)
  602. {
  603. struct nfs_client *clp = server->nfs_client;
  604. server->client = rpc_clone_client(clp->cl_rpcclient);
  605. if (IS_ERR(server->client)) {
  606. dprintk("%s: couldn't create rpc_client!\n", __func__);
  607. return PTR_ERR(server->client);
  608. }
  609. memcpy(&server->client->cl_timeout_default,
  610. timeo,
  611. sizeof(server->client->cl_timeout_default));
  612. server->client->cl_timeout = &server->client->cl_timeout_default;
  613. if (pseudoflavour != clp->cl_rpcclient->cl_auth->au_flavor) {
  614. struct rpc_auth *auth;
  615. auth = rpcauth_create(pseudoflavour, server->client);
  616. if (IS_ERR(auth)) {
  617. dprintk("%s: couldn't create credcache!\n", __func__);
  618. return PTR_ERR(auth);
  619. }
  620. }
  621. server->client->cl_softrtry = 0;
  622. if (server->flags & NFS_MOUNT_SOFT)
  623. server->client->cl_softrtry = 1;
  624. return 0;
  625. }
  626. /*
  627. * Initialise an NFS2 or NFS3 client
  628. */
  629. static int nfs_init_client(struct nfs_client *clp,
  630. const struct rpc_timeout *timeparms,
  631. const struct nfs_parsed_mount_data *data)
  632. {
  633. int error;
  634. if (clp->cl_cons_state == NFS_CS_READY) {
  635. /* the client is already initialised */
  636. dprintk("<-- nfs_init_client() = 0 [already %p]\n", clp);
  637. return 0;
  638. }
  639. /*
  640. * Create a client RPC handle for doing FSSTAT with UNIX auth only
  641. * - RFC 2623, sec 2.3.2
  642. */
  643. error = nfs_create_rpc_client(clp, timeparms, RPC_AUTH_UNIX,
  644. 0, data->flags & NFS_MOUNT_NORESVPORT);
  645. if (error < 0)
  646. goto error;
  647. nfs_mark_client_ready(clp, NFS_CS_READY);
  648. return 0;
  649. error:
  650. nfs_mark_client_ready(clp, error);
  651. dprintk("<-- nfs_init_client() = xerror %d\n", error);
  652. return error;
  653. }
  654. /*
  655. * Create a version 2 or 3 client
  656. */
  657. static int nfs_init_server(struct nfs_server *server,
  658. const struct nfs_parsed_mount_data *data)
  659. {
  660. struct nfs_client_initdata cl_init = {
  661. .hostname = data->nfs_server.hostname,
  662. .addr = (const struct sockaddr *)&data->nfs_server.address,
  663. .addrlen = data->nfs_server.addrlen,
  664. .rpc_ops = &nfs_v2_clientops,
  665. .proto = data->nfs_server.protocol,
  666. };
  667. struct rpc_timeout timeparms;
  668. struct nfs_client *clp;
  669. int error;
  670. dprintk("--> nfs_init_server()\n");
  671. #ifdef CONFIG_NFS_V3
  672. if (data->flags & NFS_MOUNT_VER3)
  673. cl_init.rpc_ops = &nfs_v3_clientops;
  674. #endif
  675. /* Allocate or find a client reference we can use */
  676. clp = nfs_get_client(&cl_init);
  677. if (IS_ERR(clp)) {
  678. dprintk("<-- nfs_init_server() = error %ld\n", PTR_ERR(clp));
  679. return PTR_ERR(clp);
  680. }
  681. nfs_init_timeout_values(&timeparms, data->nfs_server.protocol,
  682. data->timeo, data->retrans);
  683. error = nfs_init_client(clp, &timeparms, data);
  684. if (error < 0)
  685. goto error;
  686. server->nfs_client = clp;
  687. /* Initialise the client representation from the mount data */
  688. server->flags = data->flags;
  689. server->options = data->options;
  690. server->caps |= NFS_CAP_HARDLINKS|NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
  691. NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|NFS_CAP_OWNER_GROUP|
  692. NFS_CAP_ATIME|NFS_CAP_CTIME|NFS_CAP_MTIME;
  693. if (data->rsize)
  694. server->rsize = nfs_block_size(data->rsize, NULL);
  695. if (data->wsize)
  696. server->wsize = nfs_block_size(data->wsize, NULL);
  697. server->acregmin = data->acregmin * HZ;
  698. server->acregmax = data->acregmax * HZ;
  699. server->acdirmin = data->acdirmin * HZ;
  700. server->acdirmax = data->acdirmax * HZ;
  701. /* Start lockd here, before we might error out */
  702. error = nfs_start_lockd(server);
  703. if (error < 0)
  704. goto error;
  705. server->port = data->nfs_server.port;
  706. error = nfs_init_server_rpcclient(server, &timeparms, data->auth_flavors[0]);
  707. if (error < 0)
  708. goto error;
  709. /* Preserve the values of mount_server-related mount options */
  710. if (data->mount_server.addrlen) {
  711. memcpy(&server->mountd_address, &data->mount_server.address,
  712. data->mount_server.addrlen);
  713. server->mountd_addrlen = data->mount_server.addrlen;
  714. }
  715. server->mountd_version = data->mount_server.version;
  716. server->mountd_port = data->mount_server.port;
  717. server->mountd_protocol = data->mount_server.protocol;
  718. server->namelen = data->namlen;
  719. /* Create a client RPC handle for the NFSv3 ACL management interface */
  720. nfs_init_server_aclclient(server);
  721. dprintk("<-- nfs_init_server() = 0 [new %p]\n", clp);
  722. return 0;
  723. error:
  724. server->nfs_client = NULL;
  725. nfs_put_client(clp);
  726. dprintk("<-- nfs_init_server() = xerror %d\n", error);
  727. return error;
  728. }
  729. /*
  730. * Load up the server record from information gained in an fsinfo record
  731. */
  732. static void nfs_server_set_fsinfo(struct nfs_server *server, struct nfs_fsinfo *fsinfo)
  733. {
  734. unsigned long max_rpc_payload;
  735. /* Work out a lot of parameters */
  736. if (server->rsize == 0)
  737. server->rsize = nfs_block_size(fsinfo->rtpref, NULL);
  738. if (server->wsize == 0)
  739. server->wsize = nfs_block_size(fsinfo->wtpref, NULL);
  740. if (fsinfo->rtmax >= 512 && server->rsize > fsinfo->rtmax)
  741. server->rsize = nfs_block_size(fsinfo->rtmax, NULL);
  742. if (fsinfo->wtmax >= 512 && server->wsize > fsinfo->wtmax)
  743. server->wsize = nfs_block_size(fsinfo->wtmax, NULL);
  744. max_rpc_payload = nfs_block_size(rpc_max_payload(server->client), NULL);
  745. if (server->rsize > max_rpc_payload)
  746. server->rsize = max_rpc_payload;
  747. if (server->rsize > NFS_MAX_FILE_IO_SIZE)
  748. server->rsize = NFS_MAX_FILE_IO_SIZE;
  749. server->rpages = (server->rsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
  750. server->backing_dev_info.ra_pages = server->rpages * NFS_MAX_READAHEAD;
  751. if (server->wsize > max_rpc_payload)
  752. server->wsize = max_rpc_payload;
  753. if (server->wsize > NFS_MAX_FILE_IO_SIZE)
  754. server->wsize = NFS_MAX_FILE_IO_SIZE;
  755. server->wpages = (server->wsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
  756. server->wtmult = nfs_block_bits(fsinfo->wtmult, NULL);
  757. server->dtsize = nfs_block_size(fsinfo->dtpref, NULL);
  758. if (server->dtsize > PAGE_CACHE_SIZE)
  759. server->dtsize = PAGE_CACHE_SIZE;
  760. if (server->dtsize > server->rsize)
  761. server->dtsize = server->rsize;
  762. if (server->flags & NFS_MOUNT_NOAC) {
  763. server->acregmin = server->acregmax = 0;
  764. server->acdirmin = server->acdirmax = 0;
  765. }
  766. server->maxfilesize = fsinfo->maxfilesize;
  767. /* We're airborne Set socket buffersize */
  768. rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);
  769. }
  770. /*
  771. * Probe filesystem information, including the FSID on v2/v3
  772. */
  773. static int nfs_probe_fsinfo(struct nfs_server *server, struct nfs_fh *mntfh, struct nfs_fattr *fattr)
  774. {
  775. struct nfs_fsinfo fsinfo;
  776. struct nfs_client *clp = server->nfs_client;
  777. int error;
  778. dprintk("--> nfs_probe_fsinfo()\n");
  779. if (clp->rpc_ops->set_capabilities != NULL) {
  780. error = clp->rpc_ops->set_capabilities(server, mntfh);
  781. if (error < 0)
  782. goto out_error;
  783. }
  784. fsinfo.fattr = fattr;
  785. nfs_fattr_init(fattr);
  786. error = clp->rpc_ops->fsinfo(server, mntfh, &fsinfo);
  787. if (error < 0)
  788. goto out_error;
  789. nfs_server_set_fsinfo(server, &fsinfo);
  790. error = bdi_init(&server->backing_dev_info);
  791. if (error)
  792. goto out_error;
  793. /* Get some general file system info */
  794. if (server->namelen == 0) {
  795. struct nfs_pathconf pathinfo;
  796. pathinfo.fattr = fattr;
  797. nfs_fattr_init(fattr);
  798. if (clp->rpc_ops->pathconf(server, mntfh, &pathinfo) >= 0)
  799. server->namelen = pathinfo.max_namelen;
  800. }
  801. dprintk("<-- nfs_probe_fsinfo() = 0\n");
  802. return 0;
  803. out_error:
  804. dprintk("nfs_probe_fsinfo: error = %d\n", -error);
  805. return error;
  806. }
  807. /*
  808. * Copy useful information when duplicating a server record
  809. */
  810. static void nfs_server_copy_userdata(struct nfs_server *target, struct nfs_server *source)
  811. {
  812. target->flags = source->flags;
  813. target->acregmin = source->acregmin;
  814. target->acregmax = source->acregmax;
  815. target->acdirmin = source->acdirmin;
  816. target->acdirmax = source->acdirmax;
  817. target->caps = source->caps;
  818. }
  819. /*
  820. * Allocate and initialise a server record
  821. */
  822. static struct nfs_server *nfs_alloc_server(void)
  823. {
  824. struct nfs_server *server;
  825. server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
  826. if (!server)
  827. return NULL;
  828. server->client = server->client_acl = ERR_PTR(-EINVAL);
  829. /* Zero out the NFS state stuff */
  830. INIT_LIST_HEAD(&server->client_link);
  831. INIT_LIST_HEAD(&server->master_link);
  832. atomic_set(&server->active, 0);
  833. server->io_stats = nfs_alloc_iostats();
  834. if (!server->io_stats) {
  835. kfree(server);
  836. return NULL;
  837. }
  838. return server;
  839. }
  840. /*
  841. * Free up a server record
  842. */
  843. void nfs_free_server(struct nfs_server *server)
  844. {
  845. dprintk("--> nfs_free_server()\n");
  846. spin_lock(&nfs_client_lock);
  847. list_del(&server->client_link);
  848. list_del(&server->master_link);
  849. spin_unlock(&nfs_client_lock);
  850. if (server->destroy != NULL)
  851. server->destroy(server);
  852. if (!IS_ERR(server->client_acl))
  853. rpc_shutdown_client(server->client_acl);
  854. if (!IS_ERR(server->client))
  855. rpc_shutdown_client(server->client);
  856. nfs_put_client(server->nfs_client);
  857. nfs_free_iostats(server->io_stats);
  858. bdi_destroy(&server->backing_dev_info);
  859. kfree(server);
  860. nfs_release_automount_timer();
  861. dprintk("<-- nfs_free_server()\n");
  862. }
  863. /*
  864. * Create a version 2 or 3 volume record
  865. * - keyed on server and FSID
  866. */
  867. struct nfs_server *nfs_create_server(const struct nfs_parsed_mount_data *data,
  868. struct nfs_fh *mntfh)
  869. {
  870. struct nfs_server *server;
  871. struct nfs_fattr fattr;
  872. int error;
  873. server = nfs_alloc_server();
  874. if (!server)
  875. return ERR_PTR(-ENOMEM);
  876. /* Get a client representation */
  877. error = nfs_init_server(server, data);
  878. if (error < 0)
  879. goto error;
  880. BUG_ON(!server->nfs_client);
  881. BUG_ON(!server->nfs_client->rpc_ops);
  882. BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
  883. /* Probe the root fh to retrieve its FSID */
  884. error = nfs_probe_fsinfo(server, mntfh, &fattr);
  885. if (error < 0)
  886. goto error;
  887. if (server->nfs_client->rpc_ops->version == 3) {
  888. if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
  889. server->namelen = NFS3_MAXNAMLEN;
  890. if (!(data->flags & NFS_MOUNT_NORDIRPLUS))
  891. server->caps |= NFS_CAP_READDIRPLUS;
  892. } else {
  893. if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
  894. server->namelen = NFS2_MAXNAMLEN;
  895. }
  896. if (!(fattr.valid & NFS_ATTR_FATTR)) {
  897. error = server->nfs_client->rpc_ops->getattr(server, mntfh, &fattr);
  898. if (error < 0) {
  899. dprintk("nfs_create_server: getattr error = %d\n", -error);
  900. goto error;
  901. }
  902. }
  903. memcpy(&server->fsid, &fattr.fsid, sizeof(server->fsid));
  904. dprintk("Server FSID: %llx:%llx\n",
  905. (unsigned long long) server->fsid.major,
  906. (unsigned long long) server->fsid.minor);
  907. spin_lock(&nfs_client_lock);
  908. list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
  909. list_add_tail(&server->master_link, &nfs_volume_list);
  910. spin_unlock(&nfs_client_lock);
  911. server->mount_time = jiffies;
  912. return server;
  913. error:
  914. nfs_free_server(server);
  915. return ERR_PTR(error);
  916. }
  917. #ifdef CONFIG_NFS_V4
  918. /*
  919. * Initialize the NFS4 callback service
  920. */
  921. static int nfs4_init_callback(struct nfs_client *clp)
  922. {
  923. int error;
  924. if (clp->rpc_ops->version == 4) {
  925. if (nfs4_has_session(clp)) {
  926. error = xprt_setup_backchannel(
  927. clp->cl_rpcclient->cl_xprt,
  928. NFS41_BC_MIN_CALLBACKS);
  929. if (error < 0)
  930. return error;
  931. }
  932. error = nfs_callback_up(clp->cl_minorversion,
  933. clp->cl_rpcclient->cl_xprt);
  934. if (error < 0) {
  935. dprintk("%s: failed to start callback. Error = %d\n",
  936. __func__, error);
  937. return error;
  938. }
  939. __set_bit(NFS_CS_CALLBACK, &clp->cl_res_state);
  940. }
  941. return 0;
  942. }
  943. /*
  944. * Initialize the minor version specific parts of an NFS4 client record
  945. */
  946. static int nfs4_init_client_minor_version(struct nfs_client *clp)
  947. {
  948. clp->cl_call_sync = _nfs4_call_sync;
  949. #if defined(CONFIG_NFS_V4_1)
  950. if (clp->cl_minorversion) {
  951. struct nfs4_session *session = NULL;
  952. /*
  953. * Create the session and mark it expired.
  954. * When a SEQUENCE operation encounters the expired session
  955. * it will do session recovery to initialize it.
  956. */
  957. session = nfs4_alloc_session(clp);
  958. if (!session)
  959. return -ENOMEM;
  960. clp->cl_session = session;
  961. clp->cl_call_sync = _nfs4_call_sync_session;
  962. }
  963. #endif /* CONFIG_NFS_V4_1 */
  964. return nfs4_init_callback(clp);
  965. }
  966. /*
  967. * Initialise an NFS4 client record
  968. */
  969. static int nfs4_init_client(struct nfs_client *clp,
  970. const struct rpc_timeout *timeparms,
  971. const char *ip_addr,
  972. rpc_authflavor_t authflavour,
  973. int flags)
  974. {
  975. int error;
  976. if (clp->cl_cons_state == NFS_CS_READY) {
  977. /* the client is initialised already */
  978. dprintk("<-- nfs4_init_client() = 0 [already %p]\n", clp);
  979. return 0;
  980. }
  981. /* Check NFS protocol revision and initialize RPC op vector */
  982. clp->rpc_ops = &nfs_v4_clientops;
  983. error = nfs_create_rpc_client(clp, timeparms, authflavour,
  984. 1, flags & NFS_MOUNT_NORESVPORT);
  985. if (error < 0)
  986. goto error;
  987. memcpy(clp->cl_ipaddr, ip_addr, sizeof(clp->cl_ipaddr));
  988. error = nfs_idmap_new(clp);
  989. if (error < 0) {
  990. dprintk("%s: failed to create idmapper. Error = %d\n",
  991. __func__, error);
  992. goto error;
  993. }
  994. __set_bit(NFS_CS_IDMAP, &clp->cl_res_state);
  995. error = nfs4_init_client_minor_version(clp);
  996. if (error < 0)
  997. goto error;
  998. if (!nfs4_has_session(clp))
  999. nfs_mark_client_ready(clp, NFS_CS_READY);
  1000. return 0;
  1001. error:
  1002. nfs_mark_client_ready(clp, error);
  1003. dprintk("<-- nfs4_init_client() = xerror %d\n", error);
  1004. return error;
  1005. }
  1006. /*
  1007. * Set up an NFS4 client
  1008. */
  1009. static int nfs4_set_client(struct nfs_server *server,
  1010. const char *hostname,
  1011. const struct sockaddr *addr,
  1012. const size_t addrlen,
  1013. const char *ip_addr,
  1014. rpc_authflavor_t authflavour,
  1015. int proto, const struct rpc_timeout *timeparms,
  1016. u32 minorversion)
  1017. {
  1018. struct nfs_client_initdata cl_init = {
  1019. .hostname = hostname,
  1020. .addr = addr,
  1021. .addrlen = addrlen,
  1022. .rpc_ops = &nfs_v4_clientops,
  1023. .proto = proto,
  1024. .minorversion = minorversion,
  1025. };
  1026. struct nfs_client *clp;
  1027. int error;
  1028. dprintk("--> nfs4_set_client()\n");
  1029. /* Allocate or find a client reference we can use */
  1030. clp = nfs_get_client(&cl_init);
  1031. if (IS_ERR(clp)) {
  1032. error = PTR_ERR(clp);
  1033. goto error;
  1034. }
  1035. error = nfs4_init_client(clp, timeparms, ip_addr, authflavour,
  1036. server->flags);
  1037. if (error < 0)
  1038. goto error_put;
  1039. server->nfs_client = clp;
  1040. dprintk("<-- nfs4_set_client() = 0 [new %p]\n", clp);
  1041. return 0;
  1042. error_put:
  1043. nfs_put_client(clp);
  1044. error:
  1045. dprintk("<-- nfs4_set_client() = xerror %d\n", error);
  1046. return error;
  1047. }
  1048. /*
  1049. * Session has been established, and the client marked ready.
  1050. * Set the mount rsize and wsize with negotiated fore channel
  1051. * attributes which will be bound checked in nfs_server_set_fsinfo.
  1052. */
  1053. static void nfs4_session_set_rwsize(struct nfs_server *server)
  1054. {
  1055. #ifdef CONFIG_NFS_V4_1
  1056. if (!nfs4_has_session(server->nfs_client))
  1057. return;
  1058. server->rsize = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
  1059. server->wsize = server->nfs_client->cl_session->fc_attrs.max_rqst_sz;
  1060. #endif /* CONFIG_NFS_V4_1 */
  1061. }
  1062. /*
  1063. * Create a version 4 volume record
  1064. */
  1065. static int nfs4_init_server(struct nfs_server *server,
  1066. const struct nfs_parsed_mount_data *data)
  1067. {
  1068. struct rpc_timeout timeparms;
  1069. int error;
  1070. dprintk("--> nfs4_init_server()\n");
  1071. nfs_init_timeout_values(&timeparms, data->nfs_server.protocol,
  1072. data->timeo, data->retrans);
  1073. /* Initialise the client representation from the mount data */
  1074. server->flags = data->flags;
  1075. server->caps |= NFS_CAP_ATOMIC_OPEN|NFS_CAP_CHANGE_ATTR;
  1076. server->options = data->options;
  1077. /* Get a client record */
  1078. error = nfs4_set_client(server,
  1079. data->nfs_server.hostname,
  1080. (const struct sockaddr *)&data->nfs_server.address,
  1081. data->nfs_server.addrlen,
  1082. data->client_address,
  1083. data->auth_flavors[0],
  1084. data->nfs_server.protocol,
  1085. &timeparms,
  1086. data->minorversion);
  1087. if (error < 0)
  1088. goto error;
  1089. if (data->rsize)
  1090. server->rsize = nfs_block_size(data->rsize, NULL);
  1091. if (data->wsize)
  1092. server->wsize = nfs_block_size(data->wsize, NULL);
  1093. server->acregmin = data->acregmin * HZ;
  1094. server->acregmax = data->acregmax * HZ;
  1095. server->acdirmin = data->acdirmin * HZ;
  1096. server->acdirmax = data->acdirmax * HZ;
  1097. server->port = data->nfs_server.port;
  1098. error = nfs_init_server_rpcclient(server, &timeparms, data->auth_flavors[0]);
  1099. error:
  1100. /* Done */
  1101. dprintk("<-- nfs4_init_server() = %d\n", error);
  1102. return error;
  1103. }
  1104. /*
  1105. * Create a version 4 volume record
  1106. * - keyed on server and FSID
  1107. */
  1108. struct nfs_server *nfs4_create_server(const struct nfs_parsed_mount_data *data,
  1109. struct nfs_fh *mntfh)
  1110. {
  1111. struct nfs_fattr fattr;
  1112. struct nfs_server *server;
  1113. int error;
  1114. dprintk("--> nfs4_create_server()\n");
  1115. server = nfs_alloc_server();
  1116. if (!server)
  1117. return ERR_PTR(-ENOMEM);
  1118. /* set up the general RPC client */
  1119. error = nfs4_init_server(server, data);
  1120. if (error < 0)
  1121. goto error;
  1122. BUG_ON(!server->nfs_client);
  1123. BUG_ON(!server->nfs_client->rpc_ops);
  1124. BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
  1125. error = nfs4_init_session(server);
  1126. if (error < 0)
  1127. goto error;
  1128. /* Probe the root fh to retrieve its FSID */
  1129. error = nfs4_path_walk(server, mntfh, data->nfs_server.export_path);
  1130. if (error < 0)
  1131. goto error;
  1132. dprintk("Server FSID: %llx:%llx\n",
  1133. (unsigned long long) server->fsid.major,
  1134. (unsigned long long) server->fsid.minor);
  1135. dprintk("Mount FH: %d\n", mntfh->size);
  1136. nfs4_session_set_rwsize(server);
  1137. error = nfs_probe_fsinfo(server, mntfh, &fattr);
  1138. if (error < 0)
  1139. goto error;
  1140. if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
  1141. server->namelen = NFS4_MAXNAMLEN;
  1142. spin_lock(&nfs_client_lock);
  1143. list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
  1144. list_add_tail(&server->master_link, &nfs_volume_list);
  1145. spin_unlock(&nfs_client_lock);
  1146. server->mount_time = jiffies;
  1147. dprintk("<-- nfs4_create_server() = %p\n", server);
  1148. return server;
  1149. error:
  1150. nfs_free_server(server);
  1151. dprintk("<-- nfs4_create_server() = error %d\n", error);
  1152. return ERR_PTR(error);
  1153. }
  1154. /*
  1155. * Create an NFS4 referral server record
  1156. */
  1157. struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
  1158. struct nfs_fh *mntfh)
  1159. {
  1160. struct nfs_client *parent_client;
  1161. struct nfs_server *server, *parent_server;
  1162. struct nfs_fattr fattr;
  1163. int error;
  1164. dprintk("--> nfs4_create_referral_server()\n");
  1165. server = nfs_alloc_server();
  1166. if (!server)
  1167. return ERR_PTR(-ENOMEM);
  1168. parent_server = NFS_SB(data->sb);
  1169. parent_client = parent_server->nfs_client;
  1170. /* Initialise the client representation from the parent server */
  1171. nfs_server_copy_userdata(server, parent_server);
  1172. server->caps |= NFS_CAP_ATOMIC_OPEN|NFS_CAP_CHANGE_ATTR;
  1173. /* Get a client representation.
  1174. * Note: NFSv4 always uses TCP, */
  1175. error = nfs4_set_client(server, data->hostname,
  1176. data->addr,
  1177. data->addrlen,
  1178. parent_client->cl_ipaddr,
  1179. data->authflavor,
  1180. parent_server->client->cl_xprt->prot,
  1181. parent_server->client->cl_timeout,
  1182. parent_client->cl_minorversion);
  1183. if (error < 0)
  1184. goto error;
  1185. error = nfs_init_server_rpcclient(server, parent_server->client->cl_timeout, data->authflavor);
  1186. if (error < 0)
  1187. goto error;
  1188. BUG_ON(!server->nfs_client);
  1189. BUG_ON(!server->nfs_client->rpc_ops);
  1190. BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
  1191. /* Probe the root fh to retrieve its FSID and filehandle */
  1192. error = nfs4_path_walk(server, mntfh, data->mnt_path);
  1193. if (error < 0)
  1194. goto error;
  1195. /* probe the filesystem info for this server filesystem */
  1196. error = nfs_probe_fsinfo(server, mntfh, &fattr);
  1197. if (error < 0)
  1198. goto error;
  1199. if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
  1200. server->namelen = NFS4_MAXNAMLEN;
  1201. dprintk("Referral FSID: %llx:%llx\n",
  1202. (unsigned long long) server->fsid.major,
  1203. (unsigned long long) server->fsid.minor);
  1204. spin_lock(&nfs_client_lock);
  1205. list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
  1206. list_add_tail(&server->master_link, &nfs_volume_list);
  1207. spin_unlock(&nfs_client_lock);
  1208. server->mount_time = jiffies;
  1209. dprintk("<-- nfs_create_referral_server() = %p\n", server);
  1210. return server;
  1211. error:
  1212. nfs_free_server(server);
  1213. dprintk("<-- nfs4_create_referral_server() = error %d\n", error);
  1214. return ERR_PTR(error);
  1215. }
  1216. #endif /* CONFIG_NFS_V4 */
  1217. /*
  1218. * Clone an NFS2, NFS3 or NFS4 server record
  1219. */
  1220. struct nfs_server *nfs_clone_server(struct nfs_server *source,
  1221. struct nfs_fh *fh,
  1222. struct nfs_fattr *fattr)
  1223. {
  1224. struct nfs_server *server;
  1225. struct nfs_fattr fattr_fsinfo;
  1226. int error;
  1227. dprintk("--> nfs_clone_server(,%llx:%llx,)\n",
  1228. (unsigned long long) fattr->fsid.major,
  1229. (unsigned long long) fattr->fsid.minor);
  1230. server = nfs_alloc_server();
  1231. if (!server)
  1232. return ERR_PTR(-ENOMEM);
  1233. /* Copy data from the source */
  1234. server->nfs_client = source->nfs_client;
  1235. atomic_inc(&server->nfs_client->cl_count);
  1236. nfs_server_copy_userdata(server, source);
  1237. server->fsid = fattr->fsid;
  1238. error = nfs_init_server_rpcclient(server,
  1239. source->client->cl_timeout,
  1240. source->client->cl_auth->au_flavor);
  1241. if (error < 0)
  1242. goto out_free_server;
  1243. if (!IS_ERR(source->client_acl))
  1244. nfs_init_server_aclclient(server);
  1245. /* probe the filesystem info for this server filesystem */
  1246. error = nfs_probe_fsinfo(server, fh, &fattr_fsinfo);
  1247. if (error < 0)
  1248. goto out_free_server;
  1249. if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
  1250. server->namelen = NFS4_MAXNAMLEN;
  1251. dprintk("Cloned FSID: %llx:%llx\n",
  1252. (unsigned long long) server->fsid.major,
  1253. (unsigned long long) server->fsid.minor);
  1254. error = nfs_start_lockd(server);
  1255. if (error < 0)
  1256. goto out_free_server;
  1257. spin_lock(&nfs_client_lock);
  1258. list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
  1259. list_add_tail(&server->master_link, &nfs_volume_list);
  1260. spin_unlock(&nfs_client_lock);
  1261. server->mount_time = jiffies;
  1262. dprintk("<-- nfs_clone_server() = %p\n", server);
  1263. return server;
  1264. out_free_server:
  1265. nfs_free_server(server);
  1266. dprintk("<-- nfs_clone_server() = error %d\n", error);
  1267. return ERR_PTR(error);
  1268. }
  1269. #ifdef CONFIG_PROC_FS
  1270. static struct proc_dir_entry *proc_fs_nfs;
  1271. static int nfs_server_list_open(struct inode *inode, struct file *file);
  1272. static void *nfs_server_list_start(struct seq_file *p, loff_t *pos);
  1273. static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos);
  1274. static void nfs_server_list_stop(struct seq_file *p, void *v);
  1275. static int nfs_server_list_show(struct seq_file *m, void *v);
  1276. static struct seq_operations nfs_server_list_ops = {
  1277. .start = nfs_server_list_start,
  1278. .next = nfs_server_list_next,
  1279. .stop = nfs_server_list_stop,
  1280. .show = nfs_server_list_show,
  1281. };
  1282. static const struct file_operations nfs_server_list_fops = {
  1283. .open = nfs_server_list_open,
  1284. .read = seq_read,
  1285. .llseek = seq_lseek,
  1286. .release = seq_release,
  1287. .owner = THIS_MODULE,
  1288. };
  1289. static int nfs_volume_list_open(struct inode *inode, struct file *file);
  1290. static void *nfs_volume_list_start(struct seq_file *p, loff_t *pos);
  1291. static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos);
  1292. static void nfs_volume_list_stop(struct seq_file *p, void *v);
  1293. static int nfs_volume_list_show(struct seq_file *m, void *v);
  1294. static struct seq_operations nfs_volume_list_ops = {
  1295. .start = nfs_volume_list_start,
  1296. .next = nfs_volume_list_next,
  1297. .stop = nfs_volume_list_stop,
  1298. .show = nfs_volume_list_show,
  1299. };
  1300. static const struct file_operations nfs_volume_list_fops = {
  1301. .open = nfs_volume_list_open,
  1302. .read = seq_read,
  1303. .llseek = seq_lseek,
  1304. .release = seq_release,
  1305. .owner = THIS_MODULE,
  1306. };
  1307. /*
  1308. * open "/proc/fs/nfsfs/servers" which provides a summary of servers with which
  1309. * we're dealing
  1310. */
  1311. static int nfs_server_list_open(struct inode *inode, struct file *file)
  1312. {
  1313. struct seq_file *m;
  1314. int ret;
  1315. ret = seq_open(file, &nfs_server_list_ops);
  1316. if (ret < 0)
  1317. return ret;
  1318. m = file->private_data;
  1319. m->private = PDE(inode)->data;
  1320. return 0;
  1321. }
  1322. /*
  1323. * set up the iterator to start reading from the server list and return the first item
  1324. */
  1325. static void *nfs_server_list_start(struct seq_file *m, loff_t *_pos)
  1326. {
  1327. /* lock the list against modification */
  1328. spin_lock(&nfs_client_lock);
  1329. return seq_list_start_head(&nfs_client_list, *_pos);
  1330. }
  1331. /*
  1332. * move to next server
  1333. */
  1334. static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos)
  1335. {
  1336. return seq_list_next(v, &nfs_client_list, pos);
  1337. }
  1338. /*
  1339. * clean up after reading from the transports list
  1340. */
  1341. static void nfs_server_list_stop(struct seq_file *p, void *v)
  1342. {
  1343. spin_unlock(&nfs_client_lock);
  1344. }
  1345. /*
  1346. * display a header line followed by a load of call lines
  1347. */
  1348. static int nfs_server_list_show(struct seq_file *m, void *v)
  1349. {
  1350. struct nfs_client *clp;
  1351. /* display header on line 1 */
  1352. if (v == &nfs_client_list) {
  1353. seq_puts(m, "NV SERVER PORT USE HOSTNAME\n");
  1354. return 0;
  1355. }
  1356. /* display one transport per line on subsequent lines */
  1357. clp = list_entry(v, struct nfs_client, cl_share_link);
  1358. seq_printf(m, "v%u %s %s %3d %s\n",
  1359. clp->rpc_ops->version,
  1360. rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR),
  1361. rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT),
  1362. atomic_read(&clp->cl_count),
  1363. clp->cl_hostname);
  1364. return 0;
  1365. }
  1366. /*
  1367. * open "/proc/fs/nfsfs/volumes" which provides a summary of extant volumes
  1368. */
  1369. static int nfs_volume_list_open(struct inode *inode, struct file *file)
  1370. {
  1371. struct seq_file *m;
  1372. int ret;
  1373. ret = seq_open(file, &nfs_volume_list_ops);
  1374. if (ret < 0)
  1375. return ret;
  1376. m = file->private_data;
  1377. m->private = PDE(inode)->data;
  1378. return 0;
  1379. }
  1380. /*
  1381. * set up the iterator to start reading from the volume list and return the first item
  1382. */
  1383. static void *nfs_volume_list_start(struct seq_file *m, loff_t *_pos)
  1384. {
  1385. /* lock the list against modification */
  1386. spin_lock(&nfs_client_lock);
  1387. return seq_list_start_head(&nfs_volume_list, *_pos);
  1388. }
  1389. /*
  1390. * move to next volume
  1391. */
  1392. static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos)
  1393. {
  1394. return seq_list_next(v, &nfs_volume_list, pos);
  1395. }
  1396. /*
  1397. * clean up after reading from the transports list
  1398. */
  1399. static void nfs_volume_list_stop(struct seq_file *p, void *v)
  1400. {
  1401. spin_unlock(&nfs_client_lock);
  1402. }
  1403. /*
  1404. * display a header line followed by a load of call lines
  1405. */
  1406. static int nfs_volume_list_show(struct seq_file *m, void *v)
  1407. {
  1408. struct nfs_server *server;
  1409. struct nfs_client *clp;
  1410. char dev[8], fsid[17];
  1411. /* display header on line 1 */
  1412. if (v == &nfs_volume_list) {
  1413. seq_puts(m, "NV SERVER PORT DEV FSID FSC\n");
  1414. return 0;
  1415. }
  1416. /* display one transport per line on subsequent lines */
  1417. server = list_entry(v, struct nfs_server, master_link);
  1418. clp = server->nfs_client;
  1419. snprintf(dev, 8, "%u:%u",
  1420. MAJOR(server->s_dev), MINOR(server->s_dev));
  1421. snprintf(fsid, 17, "%llx:%llx",
  1422. (unsigned long long) server->fsid.major,
  1423. (unsigned long long) server->fsid.minor);
  1424. seq_printf(m, "v%u %s %s %-7s %-17s %s\n",
  1425. clp->rpc_ops->version,
  1426. rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR),
  1427. rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT),
  1428. dev,
  1429. fsid,
  1430. nfs_server_fscache_state(server));
  1431. return 0;
  1432. }
  1433. /*
  1434. * initialise the /proc/fs/nfsfs/ directory
  1435. */
  1436. int __init nfs_fs_proc_init(void)
  1437. {
  1438. struct proc_dir_entry *p;
  1439. proc_fs_nfs = proc_mkdir("fs/nfsfs", NULL);
  1440. if (!proc_fs_nfs)
  1441. goto error_0;
  1442. /* a file of servers with which we're dealing */
  1443. p = proc_create("servers", S_IFREG|S_IRUGO,
  1444. proc_fs_nfs, &nfs_server_list_fops);
  1445. if (!p)
  1446. goto error_1;
  1447. /* a file of volumes that we have mounted */
  1448. p = proc_create("volumes", S_IFREG|S_IRUGO,
  1449. proc_fs_nfs, &nfs_volume_list_fops);
  1450. if (!p)
  1451. goto error_2;
  1452. return 0;
  1453. error_2:
  1454. remove_proc_entry("servers", proc_fs_nfs);
  1455. error_1:
  1456. remove_proc_entry("fs/nfsfs", NULL);
  1457. error_0:
  1458. return -ENOMEM;
  1459. }
  1460. /*
  1461. * clean up the /proc/fs/nfsfs/ directory
  1462. */
  1463. void nfs_fs_proc_exit(void)
  1464. {
  1465. remove_proc_entry("volumes", proc_fs_nfs);
  1466. remove_proc_entry("servers", proc_fs_nfs);
  1467. remove_proc_entry("fs/nfsfs", NULL);
  1468. }
  1469. #endif /* CONFIG_PROC_FS */