client.c 45 KB

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