client.c 44 KB

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