client.c 34 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /* client.c: NFS client sharing and management code
  3. *
  4. * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
  5. * Written by David Howells (dhowells@redhat.com)
  6. */
  7. #include <linux/module.h>
  8. #include <linux/init.h>
  9. #include <linux/sched.h>
  10. #include <linux/time.h>
  11. #include <linux/kernel.h>
  12. #include <linux/mm.h>
  13. #include <linux/string.h>
  14. #include <linux/stat.h>
  15. #include <linux/errno.h>
  16. #include <linux/unistd.h>
  17. #include <linux/sunrpc/addr.h>
  18. #include <linux/sunrpc/clnt.h>
  19. #include <linux/sunrpc/stats.h>
  20. #include <linux/sunrpc/metrics.h>
  21. #include <linux/sunrpc/xprtsock.h>
  22. #include <linux/sunrpc/xprtrdma.h>
  23. #include <linux/nfs_fs.h>
  24. #include <linux/nfs_mount.h>
  25. #include <linux/nfs4_mount.h>
  26. #include <linux/lockd/bind.h>
  27. #include <linux/seq_file.h>
  28. #include <linux/mount.h>
  29. #include <linux/vfs.h>
  30. #include <linux/inet.h>
  31. #include <linux/in6.h>
  32. #include <linux/slab.h>
  33. #include <linux/idr.h>
  34. #include <net/ipv6.h>
  35. #include <linux/nfs_xdr.h>
  36. #include <linux/sunrpc/bc_xprt.h>
  37. #include <linux/nsproxy.h>
  38. #include <linux/pid_namespace.h>
  39. #include "nfs4_fs.h"
  40. #include "callback.h"
  41. #include "delegation.h"
  42. #include "iostat.h"
  43. #include "internal.h"
  44. #include "fscache.h"
  45. #include "pnfs.h"
  46. #include "nfs.h"
  47. #include "netns.h"
  48. #include "sysfs.h"
  49. #include "nfs42.h"
  50. #define NFSDBG_FACILITY NFSDBG_CLIENT
  51. static DECLARE_WAIT_QUEUE_HEAD(nfs_client_active_wq);
  52. static DEFINE_SPINLOCK(nfs_version_lock);
  53. static DEFINE_MUTEX(nfs_version_mutex);
  54. static LIST_HEAD(nfs_versions);
  55. /*
  56. * RPC cruft for NFS
  57. */
  58. static const struct rpc_version *nfs_version[5] = {
  59. [2] = NULL,
  60. [3] = NULL,
  61. [4] = NULL,
  62. };
  63. const 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_PIPE_DIRNAME,
  70. };
  71. struct rpc_stat nfs_rpcstat = {
  72. .program = &nfs_program
  73. };
  74. static struct nfs_subversion *find_nfs_version(unsigned int version)
  75. {
  76. struct nfs_subversion *nfs;
  77. spin_lock(&nfs_version_lock);
  78. list_for_each_entry(nfs, &nfs_versions, list) {
  79. if (nfs->rpc_ops->version == version) {
  80. spin_unlock(&nfs_version_lock);
  81. return nfs;
  82. }
  83. }
  84. spin_unlock(&nfs_version_lock);
  85. return ERR_PTR(-EPROTONOSUPPORT);
  86. }
  87. struct nfs_subversion *get_nfs_version(unsigned int version)
  88. {
  89. struct nfs_subversion *nfs = find_nfs_version(version);
  90. if (IS_ERR(nfs)) {
  91. mutex_lock(&nfs_version_mutex);
  92. request_module("nfsv%d", version);
  93. nfs = find_nfs_version(version);
  94. mutex_unlock(&nfs_version_mutex);
  95. }
  96. if (!IS_ERR(nfs) && !try_module_get(nfs->owner))
  97. return ERR_PTR(-EAGAIN);
  98. return nfs;
  99. }
  100. void put_nfs_version(struct nfs_subversion *nfs)
  101. {
  102. module_put(nfs->owner);
  103. }
  104. void register_nfs_version(struct nfs_subversion *nfs)
  105. {
  106. spin_lock(&nfs_version_lock);
  107. list_add(&nfs->list, &nfs_versions);
  108. nfs_version[nfs->rpc_ops->version] = nfs->rpc_vers;
  109. spin_unlock(&nfs_version_lock);
  110. }
  111. EXPORT_SYMBOL_GPL(register_nfs_version);
  112. void unregister_nfs_version(struct nfs_subversion *nfs)
  113. {
  114. spin_lock(&nfs_version_lock);
  115. nfs_version[nfs->rpc_ops->version] = NULL;
  116. list_del(&nfs->list);
  117. spin_unlock(&nfs_version_lock);
  118. }
  119. EXPORT_SYMBOL_GPL(unregister_nfs_version);
  120. /*
  121. * Allocate a shared client record
  122. *
  123. * Since these are allocated/deallocated very rarely, we don't
  124. * bother putting them in a slab cache...
  125. */
  126. struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *cl_init)
  127. {
  128. struct nfs_client *clp;
  129. int err = -ENOMEM;
  130. if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)
  131. goto error_0;
  132. clp->cl_minorversion = cl_init->minorversion;
  133. clp->cl_nfs_mod = cl_init->nfs_mod;
  134. if (!try_module_get(clp->cl_nfs_mod->owner))
  135. goto error_dealloc;
  136. clp->rpc_ops = clp->cl_nfs_mod->rpc_ops;
  137. refcount_set(&clp->cl_count, 1);
  138. clp->cl_cons_state = NFS_CS_INITING;
  139. memcpy(&clp->cl_addr, cl_init->addr, cl_init->addrlen);
  140. clp->cl_addrlen = cl_init->addrlen;
  141. if (cl_init->hostname) {
  142. err = -ENOMEM;
  143. clp->cl_hostname = kstrdup(cl_init->hostname, GFP_KERNEL);
  144. if (!clp->cl_hostname)
  145. goto error_cleanup;
  146. }
  147. INIT_LIST_HEAD(&clp->cl_superblocks);
  148. clp->cl_rpcclient = ERR_PTR(-EINVAL);
  149. clp->cl_flags = cl_init->init_flags;
  150. clp->cl_proto = cl_init->proto;
  151. clp->cl_nconnect = cl_init->nconnect;
  152. clp->cl_net = get_net(cl_init->net);
  153. clp->cl_principal = "*";
  154. nfs_fscache_get_client_cookie(clp);
  155. return clp;
  156. error_cleanup:
  157. put_nfs_version(clp->cl_nfs_mod);
  158. error_dealloc:
  159. kfree(clp);
  160. error_0:
  161. return ERR_PTR(err);
  162. }
  163. EXPORT_SYMBOL_GPL(nfs_alloc_client);
  164. #if IS_ENABLED(CONFIG_NFS_V4)
  165. static void nfs_cleanup_cb_ident_idr(struct net *net)
  166. {
  167. struct nfs_net *nn = net_generic(net, nfs_net_id);
  168. idr_destroy(&nn->cb_ident_idr);
  169. }
  170. /* nfs_client_lock held */
  171. static void nfs_cb_idr_remove_locked(struct nfs_client *clp)
  172. {
  173. struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
  174. if (clp->cl_cb_ident)
  175. idr_remove(&nn->cb_ident_idr, clp->cl_cb_ident);
  176. }
  177. static void pnfs_init_server(struct nfs_server *server)
  178. {
  179. rpc_init_wait_queue(&server->roc_rpcwaitq, "pNFS ROC");
  180. }
  181. #else
  182. static void nfs_cleanup_cb_ident_idr(struct net *net)
  183. {
  184. }
  185. static void nfs_cb_idr_remove_locked(struct nfs_client *clp)
  186. {
  187. }
  188. static void pnfs_init_server(struct nfs_server *server)
  189. {
  190. }
  191. #endif /* CONFIG_NFS_V4 */
  192. /*
  193. * Destroy a shared client record
  194. */
  195. void nfs_free_client(struct nfs_client *clp)
  196. {
  197. nfs_fscache_release_client_cookie(clp);
  198. /* -EIO all pending I/O */
  199. if (!IS_ERR(clp->cl_rpcclient))
  200. rpc_shutdown_client(clp->cl_rpcclient);
  201. put_net(clp->cl_net);
  202. put_nfs_version(clp->cl_nfs_mod);
  203. kfree(clp->cl_hostname);
  204. kfree(clp->cl_acceptor);
  205. kfree(clp);
  206. }
  207. EXPORT_SYMBOL_GPL(nfs_free_client);
  208. /*
  209. * Release a reference to a shared client record
  210. */
  211. void nfs_put_client(struct nfs_client *clp)
  212. {
  213. struct nfs_net *nn;
  214. if (!clp)
  215. return;
  216. nn = net_generic(clp->cl_net, nfs_net_id);
  217. if (refcount_dec_and_lock(&clp->cl_count, &nn->nfs_client_lock)) {
  218. list_del(&clp->cl_share_link);
  219. nfs_cb_idr_remove_locked(clp);
  220. spin_unlock(&nn->nfs_client_lock);
  221. WARN_ON_ONCE(!list_empty(&clp->cl_superblocks));
  222. clp->rpc_ops->free_client(clp);
  223. }
  224. }
  225. EXPORT_SYMBOL_GPL(nfs_put_client);
  226. /*
  227. * Find an nfs_client on the list that matches the initialisation data
  228. * that is supplied.
  229. */
  230. static struct nfs_client *nfs_match_client(const struct nfs_client_initdata *data)
  231. {
  232. struct nfs_client *clp;
  233. const struct sockaddr *sap = data->addr;
  234. struct nfs_net *nn = net_generic(data->net, nfs_net_id);
  235. int error;
  236. again:
  237. list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) {
  238. const struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;
  239. /* Don't match clients that failed to initialise properly */
  240. if (clp->cl_cons_state < 0)
  241. continue;
  242. /* If a client is still initializing then we need to wait */
  243. if (clp->cl_cons_state > NFS_CS_READY) {
  244. refcount_inc(&clp->cl_count);
  245. spin_unlock(&nn->nfs_client_lock);
  246. error = nfs_wait_client_init_complete(clp);
  247. nfs_put_client(clp);
  248. spin_lock(&nn->nfs_client_lock);
  249. if (error < 0)
  250. return ERR_PTR(error);
  251. goto again;
  252. }
  253. /* Different NFS versions cannot share the same nfs_client */
  254. if (clp->rpc_ops != data->nfs_mod->rpc_ops)
  255. continue;
  256. if (clp->cl_proto != data->proto)
  257. continue;
  258. /* Match nfsv4 minorversion */
  259. if (clp->cl_minorversion != data->minorversion)
  260. continue;
  261. /* Match request for a dedicated DS */
  262. if (test_bit(NFS_CS_DS, &data->init_flags) !=
  263. test_bit(NFS_CS_DS, &clp->cl_flags))
  264. continue;
  265. /* Match the full socket address */
  266. if (!rpc_cmp_addr_port(sap, clap))
  267. /* Match all xprt_switch full socket addresses */
  268. if (IS_ERR(clp->cl_rpcclient) ||
  269. !rpc_clnt_xprt_switch_has_addr(clp->cl_rpcclient,
  270. sap))
  271. continue;
  272. refcount_inc(&clp->cl_count);
  273. return clp;
  274. }
  275. return NULL;
  276. }
  277. /*
  278. * Return true if @clp is done initializing, false if still working on it.
  279. *
  280. * Use nfs_client_init_status to check if it was successful.
  281. */
  282. bool nfs_client_init_is_complete(const struct nfs_client *clp)
  283. {
  284. return clp->cl_cons_state <= NFS_CS_READY;
  285. }
  286. EXPORT_SYMBOL_GPL(nfs_client_init_is_complete);
  287. /*
  288. * Return 0 if @clp was successfully initialized, -errno otherwise.
  289. *
  290. * This must be called *after* nfs_client_init_is_complete() returns true,
  291. * otherwise it will pop WARN_ON_ONCE and return -EINVAL
  292. */
  293. int nfs_client_init_status(const struct nfs_client *clp)
  294. {
  295. /* called without checking nfs_client_init_is_complete */
  296. if (clp->cl_cons_state > NFS_CS_READY) {
  297. WARN_ON_ONCE(1);
  298. return -EINVAL;
  299. }
  300. return clp->cl_cons_state;
  301. }
  302. EXPORT_SYMBOL_GPL(nfs_client_init_status);
  303. int nfs_wait_client_init_complete(const struct nfs_client *clp)
  304. {
  305. return wait_event_killable(nfs_client_active_wq,
  306. nfs_client_init_is_complete(clp));
  307. }
  308. EXPORT_SYMBOL_GPL(nfs_wait_client_init_complete);
  309. /*
  310. * Found an existing client. Make sure it's ready before returning.
  311. */
  312. static struct nfs_client *
  313. nfs_found_client(const struct nfs_client_initdata *cl_init,
  314. struct nfs_client *clp)
  315. {
  316. int error;
  317. error = nfs_wait_client_init_complete(clp);
  318. if (error < 0) {
  319. nfs_put_client(clp);
  320. return ERR_PTR(-ERESTARTSYS);
  321. }
  322. if (clp->cl_cons_state < NFS_CS_READY) {
  323. error = clp->cl_cons_state;
  324. nfs_put_client(clp);
  325. return ERR_PTR(error);
  326. }
  327. smp_rmb();
  328. return clp;
  329. }
  330. /*
  331. * Look up a client by IP address and protocol version
  332. * - creates a new record if one doesn't yet exist
  333. */
  334. struct nfs_client *nfs_get_client(const struct nfs_client_initdata *cl_init)
  335. {
  336. struct nfs_client *clp, *new = NULL;
  337. struct nfs_net *nn = net_generic(cl_init->net, nfs_net_id);
  338. const struct nfs_rpc_ops *rpc_ops = cl_init->nfs_mod->rpc_ops;
  339. if (cl_init->hostname == NULL) {
  340. WARN_ON(1);
  341. return ERR_PTR(-EINVAL);
  342. }
  343. /* see if the client already exists */
  344. do {
  345. spin_lock(&nn->nfs_client_lock);
  346. clp = nfs_match_client(cl_init);
  347. if (clp) {
  348. spin_unlock(&nn->nfs_client_lock);
  349. if (new)
  350. new->rpc_ops->free_client(new);
  351. if (IS_ERR(clp))
  352. return clp;
  353. return nfs_found_client(cl_init, clp);
  354. }
  355. if (new) {
  356. list_add_tail(&new->cl_share_link,
  357. &nn->nfs_client_list);
  358. spin_unlock(&nn->nfs_client_lock);
  359. return rpc_ops->init_client(new, cl_init);
  360. }
  361. spin_unlock(&nn->nfs_client_lock);
  362. new = rpc_ops->alloc_client(cl_init);
  363. } while (!IS_ERR(new));
  364. return new;
  365. }
  366. EXPORT_SYMBOL_GPL(nfs_get_client);
  367. /*
  368. * Mark a server as ready or failed
  369. */
  370. void nfs_mark_client_ready(struct nfs_client *clp, int state)
  371. {
  372. smp_wmb();
  373. clp->cl_cons_state = state;
  374. wake_up_all(&nfs_client_active_wq);
  375. }
  376. EXPORT_SYMBOL_GPL(nfs_mark_client_ready);
  377. /*
  378. * Initialise the timeout values for a connection
  379. */
  380. void nfs_init_timeout_values(struct rpc_timeout *to, int proto,
  381. int timeo, int retrans)
  382. {
  383. to->to_initval = timeo * HZ / 10;
  384. to->to_retries = retrans;
  385. switch (proto) {
  386. case XPRT_TRANSPORT_TCP:
  387. case XPRT_TRANSPORT_RDMA:
  388. if (retrans == NFS_UNSPEC_RETRANS)
  389. to->to_retries = NFS_DEF_TCP_RETRANS;
  390. if (timeo == NFS_UNSPEC_TIMEO || to->to_initval == 0)
  391. to->to_initval = NFS_DEF_TCP_TIMEO * HZ / 10;
  392. if (to->to_initval > NFS_MAX_TCP_TIMEOUT)
  393. to->to_initval = NFS_MAX_TCP_TIMEOUT;
  394. to->to_increment = to->to_initval;
  395. to->to_maxval = to->to_initval + (to->to_increment * to->to_retries);
  396. if (to->to_maxval > NFS_MAX_TCP_TIMEOUT)
  397. to->to_maxval = NFS_MAX_TCP_TIMEOUT;
  398. if (to->to_maxval < to->to_initval)
  399. to->to_maxval = to->to_initval;
  400. to->to_exponential = 0;
  401. break;
  402. #ifndef CONFIG_NFS_DISABLE_UDP_SUPPORT
  403. case XPRT_TRANSPORT_UDP:
  404. if (retrans == NFS_UNSPEC_RETRANS)
  405. to->to_retries = NFS_DEF_UDP_RETRANS;
  406. if (timeo == NFS_UNSPEC_TIMEO || to->to_initval == 0)
  407. to->to_initval = NFS_DEF_UDP_TIMEO * HZ / 10;
  408. if (to->to_initval > NFS_MAX_UDP_TIMEOUT)
  409. to->to_initval = NFS_MAX_UDP_TIMEOUT;
  410. to->to_maxval = NFS_MAX_UDP_TIMEOUT;
  411. to->to_exponential = 1;
  412. break;
  413. #endif
  414. default:
  415. BUG();
  416. }
  417. }
  418. EXPORT_SYMBOL_GPL(nfs_init_timeout_values);
  419. /*
  420. * Create an RPC client handle
  421. */
  422. int nfs_create_rpc_client(struct nfs_client *clp,
  423. const struct nfs_client_initdata *cl_init,
  424. rpc_authflavor_t flavor)
  425. {
  426. struct rpc_clnt *clnt = NULL;
  427. struct rpc_create_args args = {
  428. .net = clp->cl_net,
  429. .protocol = clp->cl_proto,
  430. .nconnect = clp->cl_nconnect,
  431. .address = (struct sockaddr *)&clp->cl_addr,
  432. .addrsize = clp->cl_addrlen,
  433. .timeout = cl_init->timeparms,
  434. .servername = clp->cl_hostname,
  435. .nodename = cl_init->nodename,
  436. .program = &nfs_program,
  437. .version = clp->rpc_ops->version,
  438. .authflavor = flavor,
  439. .cred = cl_init->cred,
  440. };
  441. if (test_bit(NFS_CS_DISCRTRY, &clp->cl_flags))
  442. args.flags |= RPC_CLNT_CREATE_DISCRTRY;
  443. if (test_bit(NFS_CS_NO_RETRANS_TIMEOUT, &clp->cl_flags))
  444. args.flags |= RPC_CLNT_CREATE_NO_RETRANS_TIMEOUT;
  445. if (test_bit(NFS_CS_NORESVPORT, &clp->cl_flags))
  446. args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
  447. if (test_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags))
  448. args.flags |= RPC_CLNT_CREATE_INFINITE_SLOTS;
  449. if (test_bit(NFS_CS_NOPING, &clp->cl_flags))
  450. args.flags |= RPC_CLNT_CREATE_NOPING;
  451. if (test_bit(NFS_CS_REUSEPORT, &clp->cl_flags))
  452. args.flags |= RPC_CLNT_CREATE_REUSEPORT;
  453. if (!IS_ERR(clp->cl_rpcclient))
  454. return 0;
  455. clnt = rpc_create(&args);
  456. if (IS_ERR(clnt)) {
  457. dprintk("%s: cannot create RPC client. Error = %ld\n",
  458. __func__, PTR_ERR(clnt));
  459. return PTR_ERR(clnt);
  460. }
  461. clnt->cl_principal = clp->cl_principal;
  462. clp->cl_rpcclient = clnt;
  463. return 0;
  464. }
  465. EXPORT_SYMBOL_GPL(nfs_create_rpc_client);
  466. /*
  467. * Version 2 or 3 client destruction
  468. */
  469. static void nfs_destroy_server(struct nfs_server *server)
  470. {
  471. if (server->nlm_host)
  472. nlmclnt_done(server->nlm_host);
  473. }
  474. /*
  475. * Version 2 or 3 lockd setup
  476. */
  477. static int nfs_start_lockd(struct nfs_server *server)
  478. {
  479. struct nlm_host *host;
  480. struct nfs_client *clp = server->nfs_client;
  481. struct nlmclnt_initdata nlm_init = {
  482. .hostname = clp->cl_hostname,
  483. .address = (struct sockaddr *)&clp->cl_addr,
  484. .addrlen = clp->cl_addrlen,
  485. .nfs_version = clp->rpc_ops->version,
  486. .noresvport = server->flags & NFS_MOUNT_NORESVPORT ?
  487. 1 : 0,
  488. .net = clp->cl_net,
  489. .nlmclnt_ops = clp->cl_nfs_mod->rpc_ops->nlmclnt_ops,
  490. .cred = current_cred(),
  491. };
  492. if (nlm_init.nfs_version > 3)
  493. return 0;
  494. if ((server->flags & NFS_MOUNT_LOCAL_FLOCK) &&
  495. (server->flags & NFS_MOUNT_LOCAL_FCNTL))
  496. return 0;
  497. switch (clp->cl_proto) {
  498. default:
  499. nlm_init.protocol = IPPROTO_TCP;
  500. break;
  501. #ifndef CONFIG_NFS_DISABLE_UDP_SUPPORT
  502. case XPRT_TRANSPORT_UDP:
  503. nlm_init.protocol = IPPROTO_UDP;
  504. #endif
  505. }
  506. host = nlmclnt_init(&nlm_init);
  507. if (IS_ERR(host))
  508. return PTR_ERR(host);
  509. server->nlm_host = host;
  510. server->destroy = nfs_destroy_server;
  511. return 0;
  512. }
  513. /*
  514. * Create a general RPC client
  515. */
  516. int nfs_init_server_rpcclient(struct nfs_server *server,
  517. const struct rpc_timeout *timeo,
  518. rpc_authflavor_t pseudoflavour)
  519. {
  520. struct nfs_client *clp = server->nfs_client;
  521. server->client = rpc_clone_client_set_auth(clp->cl_rpcclient,
  522. pseudoflavour);
  523. if (IS_ERR(server->client)) {
  524. dprintk("%s: couldn't create rpc_client!\n", __func__);
  525. return PTR_ERR(server->client);
  526. }
  527. memcpy(&server->client->cl_timeout_default,
  528. timeo,
  529. sizeof(server->client->cl_timeout_default));
  530. server->client->cl_timeout = &server->client->cl_timeout_default;
  531. server->client->cl_softrtry = 0;
  532. if (server->flags & NFS_MOUNT_SOFTERR)
  533. server->client->cl_softerr = 1;
  534. if (server->flags & NFS_MOUNT_SOFT)
  535. server->client->cl_softrtry = 1;
  536. return 0;
  537. }
  538. EXPORT_SYMBOL_GPL(nfs_init_server_rpcclient);
  539. /**
  540. * nfs_init_client - Initialise an NFS2 or NFS3 client
  541. *
  542. * @clp: nfs_client to initialise
  543. * @cl_init: Initialisation parameters
  544. *
  545. * Returns pointer to an NFS client, or an ERR_PTR value.
  546. */
  547. struct nfs_client *nfs_init_client(struct nfs_client *clp,
  548. const struct nfs_client_initdata *cl_init)
  549. {
  550. int error;
  551. /* the client is already initialised */
  552. if (clp->cl_cons_state == NFS_CS_READY)
  553. return clp;
  554. /*
  555. * Create a client RPC handle for doing FSSTAT with UNIX auth only
  556. * - RFC 2623, sec 2.3.2
  557. */
  558. error = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_UNIX);
  559. nfs_mark_client_ready(clp, error == 0 ? NFS_CS_READY : error);
  560. if (error < 0) {
  561. nfs_put_client(clp);
  562. clp = ERR_PTR(error);
  563. }
  564. return clp;
  565. }
  566. EXPORT_SYMBOL_GPL(nfs_init_client);
  567. /*
  568. * Create a version 2 or 3 client
  569. */
  570. static int nfs_init_server(struct nfs_server *server,
  571. const struct fs_context *fc)
  572. {
  573. const struct nfs_fs_context *ctx = nfs_fc2context(fc);
  574. struct rpc_timeout timeparms;
  575. struct nfs_client_initdata cl_init = {
  576. .hostname = ctx->nfs_server.hostname,
  577. .addr = (const struct sockaddr *)&ctx->nfs_server.address,
  578. .addrlen = ctx->nfs_server.addrlen,
  579. .nfs_mod = ctx->nfs_mod,
  580. .proto = ctx->nfs_server.protocol,
  581. .net = fc->net_ns,
  582. .timeparms = &timeparms,
  583. .cred = server->cred,
  584. .nconnect = ctx->nfs_server.nconnect,
  585. .init_flags = (1UL << NFS_CS_REUSEPORT),
  586. };
  587. struct nfs_client *clp;
  588. int error;
  589. nfs_init_timeout_values(&timeparms, ctx->nfs_server.protocol,
  590. ctx->timeo, ctx->retrans);
  591. if (ctx->flags & NFS_MOUNT_NORESVPORT)
  592. set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
  593. /* Allocate or find a client reference we can use */
  594. clp = nfs_get_client(&cl_init);
  595. if (IS_ERR(clp))
  596. return PTR_ERR(clp);
  597. server->nfs_client = clp;
  598. /* Initialise the client representation from the mount data */
  599. server->flags = ctx->flags;
  600. server->options = ctx->options;
  601. server->caps |= NFS_CAP_HARDLINKS|NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
  602. NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|NFS_CAP_OWNER_GROUP|
  603. NFS_CAP_ATIME|NFS_CAP_CTIME|NFS_CAP_MTIME;
  604. if (ctx->rsize)
  605. server->rsize = nfs_block_size(ctx->rsize, NULL);
  606. if (ctx->wsize)
  607. server->wsize = nfs_block_size(ctx->wsize, NULL);
  608. server->acregmin = ctx->acregmin * HZ;
  609. server->acregmax = ctx->acregmax * HZ;
  610. server->acdirmin = ctx->acdirmin * HZ;
  611. server->acdirmax = ctx->acdirmax * HZ;
  612. /* Start lockd here, before we might error out */
  613. error = nfs_start_lockd(server);
  614. if (error < 0)
  615. goto error;
  616. server->port = ctx->nfs_server.port;
  617. server->auth_info = ctx->auth_info;
  618. error = nfs_init_server_rpcclient(server, &timeparms,
  619. ctx->selected_flavor);
  620. if (error < 0)
  621. goto error;
  622. /* Preserve the values of mount_server-related mount options */
  623. if (ctx->mount_server.addrlen) {
  624. memcpy(&server->mountd_address, &ctx->mount_server.address,
  625. ctx->mount_server.addrlen);
  626. server->mountd_addrlen = ctx->mount_server.addrlen;
  627. }
  628. server->mountd_version = ctx->mount_server.version;
  629. server->mountd_port = ctx->mount_server.port;
  630. server->mountd_protocol = ctx->mount_server.protocol;
  631. server->namelen = ctx->namlen;
  632. return 0;
  633. error:
  634. server->nfs_client = NULL;
  635. nfs_put_client(clp);
  636. return error;
  637. }
  638. /*
  639. * Load up the server record from information gained in an fsinfo record
  640. */
  641. static void nfs_server_set_fsinfo(struct nfs_server *server,
  642. struct nfs_fsinfo *fsinfo)
  643. {
  644. unsigned long max_rpc_payload, raw_max_rpc_payload;
  645. /* Work out a lot of parameters */
  646. if (server->rsize == 0)
  647. server->rsize = nfs_block_size(fsinfo->rtpref, NULL);
  648. if (server->wsize == 0)
  649. server->wsize = nfs_block_size(fsinfo->wtpref, NULL);
  650. if (fsinfo->rtmax >= 512 && server->rsize > fsinfo->rtmax)
  651. server->rsize = nfs_block_size(fsinfo->rtmax, NULL);
  652. if (fsinfo->wtmax >= 512 && server->wsize > fsinfo->wtmax)
  653. server->wsize = nfs_block_size(fsinfo->wtmax, NULL);
  654. raw_max_rpc_payload = rpc_max_payload(server->client);
  655. max_rpc_payload = nfs_block_size(raw_max_rpc_payload, NULL);
  656. if (server->rsize > max_rpc_payload)
  657. server->rsize = max_rpc_payload;
  658. if (server->rsize > NFS_MAX_FILE_IO_SIZE)
  659. server->rsize = NFS_MAX_FILE_IO_SIZE;
  660. server->rpages = (server->rsize + PAGE_SIZE - 1) >> PAGE_SHIFT;
  661. if (server->wsize > max_rpc_payload)
  662. server->wsize = max_rpc_payload;
  663. if (server->wsize > NFS_MAX_FILE_IO_SIZE)
  664. server->wsize = NFS_MAX_FILE_IO_SIZE;
  665. server->wpages = (server->wsize + PAGE_SIZE - 1) >> PAGE_SHIFT;
  666. server->wtmult = nfs_block_bits(fsinfo->wtmult, NULL);
  667. server->dtsize = nfs_block_size(fsinfo->dtpref, NULL);
  668. if (server->dtsize > PAGE_SIZE * NFS_MAX_READDIR_PAGES)
  669. server->dtsize = PAGE_SIZE * NFS_MAX_READDIR_PAGES;
  670. if (server->dtsize > server->rsize)
  671. server->dtsize = server->rsize;
  672. if (server->flags & NFS_MOUNT_NOAC) {
  673. server->acregmin = server->acregmax = 0;
  674. server->acdirmin = server->acdirmax = 0;
  675. }
  676. server->maxfilesize = fsinfo->maxfilesize;
  677. server->time_delta = fsinfo->time_delta;
  678. server->clone_blksize = fsinfo->clone_blksize;
  679. /* We're airborne Set socket buffersize */
  680. rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);
  681. #ifdef CONFIG_NFS_V4_2
  682. /*
  683. * Defaults until limited by the session parameters.
  684. */
  685. server->gxasize = min_t(unsigned int, raw_max_rpc_payload,
  686. XATTR_SIZE_MAX);
  687. server->sxasize = min_t(unsigned int, raw_max_rpc_payload,
  688. XATTR_SIZE_MAX);
  689. server->lxasize = min_t(unsigned int, raw_max_rpc_payload,
  690. nfs42_listxattr_xdrsize(XATTR_LIST_MAX));
  691. if (fsinfo->xattr_support)
  692. server->caps |= NFS_CAP_XATTR;
  693. #endif
  694. }
  695. /*
  696. * Probe filesystem information, including the FSID on v2/v3
  697. */
  698. int nfs_probe_fsinfo(struct nfs_server *server, struct nfs_fh *mntfh, struct nfs_fattr *fattr)
  699. {
  700. struct nfs_fsinfo fsinfo;
  701. struct nfs_client *clp = server->nfs_client;
  702. int error;
  703. if (clp->rpc_ops->set_capabilities != NULL) {
  704. error = clp->rpc_ops->set_capabilities(server, mntfh);
  705. if (error < 0)
  706. return error;
  707. }
  708. fsinfo.fattr = fattr;
  709. fsinfo.nlayouttypes = 0;
  710. memset(fsinfo.layouttype, 0, sizeof(fsinfo.layouttype));
  711. error = clp->rpc_ops->fsinfo(server, mntfh, &fsinfo);
  712. if (error < 0)
  713. return error;
  714. nfs_server_set_fsinfo(server, &fsinfo);
  715. /* Get some general file system info */
  716. if (server->namelen == 0) {
  717. struct nfs_pathconf pathinfo;
  718. pathinfo.fattr = fattr;
  719. nfs_fattr_init(fattr);
  720. if (clp->rpc_ops->pathconf(server, mntfh, &pathinfo) >= 0)
  721. server->namelen = pathinfo.max_namelen;
  722. }
  723. return 0;
  724. }
  725. EXPORT_SYMBOL_GPL(nfs_probe_fsinfo);
  726. /*
  727. * Copy useful information when duplicating a server record
  728. */
  729. void nfs_server_copy_userdata(struct nfs_server *target, struct nfs_server *source)
  730. {
  731. target->flags = source->flags;
  732. target->rsize = source->rsize;
  733. target->wsize = source->wsize;
  734. target->acregmin = source->acregmin;
  735. target->acregmax = source->acregmax;
  736. target->acdirmin = source->acdirmin;
  737. target->acdirmax = source->acdirmax;
  738. target->caps = source->caps;
  739. target->options = source->options;
  740. target->auth_info = source->auth_info;
  741. target->port = source->port;
  742. }
  743. EXPORT_SYMBOL_GPL(nfs_server_copy_userdata);
  744. void nfs_server_insert_lists(struct nfs_server *server)
  745. {
  746. struct nfs_client *clp = server->nfs_client;
  747. struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
  748. spin_lock(&nn->nfs_client_lock);
  749. list_add_tail_rcu(&server->client_link, &clp->cl_superblocks);
  750. list_add_tail(&server->master_link, &nn->nfs_volume_list);
  751. clear_bit(NFS_CS_STOP_RENEW, &clp->cl_res_state);
  752. spin_unlock(&nn->nfs_client_lock);
  753. }
  754. EXPORT_SYMBOL_GPL(nfs_server_insert_lists);
  755. void nfs_server_remove_lists(struct nfs_server *server)
  756. {
  757. struct nfs_client *clp = server->nfs_client;
  758. struct nfs_net *nn;
  759. if (clp == NULL)
  760. return;
  761. nn = net_generic(clp->cl_net, nfs_net_id);
  762. spin_lock(&nn->nfs_client_lock);
  763. list_del_rcu(&server->client_link);
  764. if (list_empty(&clp->cl_superblocks))
  765. set_bit(NFS_CS_STOP_RENEW, &clp->cl_res_state);
  766. list_del(&server->master_link);
  767. spin_unlock(&nn->nfs_client_lock);
  768. synchronize_rcu();
  769. }
  770. EXPORT_SYMBOL_GPL(nfs_server_remove_lists);
  771. /*
  772. * Allocate and initialise a server record
  773. */
  774. struct nfs_server *nfs_alloc_server(void)
  775. {
  776. struct nfs_server *server;
  777. server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
  778. if (!server)
  779. return NULL;
  780. server->client = server->client_acl = ERR_PTR(-EINVAL);
  781. /* Zero out the NFS state stuff */
  782. INIT_LIST_HEAD(&server->client_link);
  783. INIT_LIST_HEAD(&server->master_link);
  784. INIT_LIST_HEAD(&server->delegations);
  785. INIT_LIST_HEAD(&server->layouts);
  786. INIT_LIST_HEAD(&server->state_owners_lru);
  787. INIT_LIST_HEAD(&server->ss_copies);
  788. atomic_set(&server->active, 0);
  789. server->io_stats = nfs_alloc_iostats();
  790. if (!server->io_stats) {
  791. kfree(server);
  792. return NULL;
  793. }
  794. ida_init(&server->openowner_id);
  795. ida_init(&server->lockowner_id);
  796. pnfs_init_server(server);
  797. rpc_init_wait_queue(&server->uoc_rpcwaitq, "NFS UOC");
  798. return server;
  799. }
  800. EXPORT_SYMBOL_GPL(nfs_alloc_server);
  801. /*
  802. * Free up a server record
  803. */
  804. void nfs_free_server(struct nfs_server *server)
  805. {
  806. nfs_server_remove_lists(server);
  807. if (server->destroy != NULL)
  808. server->destroy(server);
  809. if (!IS_ERR(server->client_acl))
  810. rpc_shutdown_client(server->client_acl);
  811. if (!IS_ERR(server->client))
  812. rpc_shutdown_client(server->client);
  813. nfs_put_client(server->nfs_client);
  814. ida_destroy(&server->lockowner_id);
  815. ida_destroy(&server->openowner_id);
  816. nfs_free_iostats(server->io_stats);
  817. put_cred(server->cred);
  818. kfree(server);
  819. nfs_release_automount_timer();
  820. }
  821. EXPORT_SYMBOL_GPL(nfs_free_server);
  822. /*
  823. * Create a version 2 or 3 volume record
  824. * - keyed on server and FSID
  825. */
  826. struct nfs_server *nfs_create_server(struct fs_context *fc)
  827. {
  828. struct nfs_fs_context *ctx = nfs_fc2context(fc);
  829. struct nfs_server *server;
  830. struct nfs_fattr *fattr;
  831. int error;
  832. server = nfs_alloc_server();
  833. if (!server)
  834. return ERR_PTR(-ENOMEM);
  835. server->cred = get_cred(current_cred());
  836. error = -ENOMEM;
  837. fattr = nfs_alloc_fattr();
  838. if (fattr == NULL)
  839. goto error;
  840. /* Get a client representation */
  841. error = nfs_init_server(server, fc);
  842. if (error < 0)
  843. goto error;
  844. /* Probe the root fh to retrieve its FSID */
  845. error = nfs_probe_fsinfo(server, ctx->mntfh, fattr);
  846. if (error < 0)
  847. goto error;
  848. if (server->nfs_client->rpc_ops->version == 3) {
  849. if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
  850. server->namelen = NFS3_MAXNAMLEN;
  851. if (!(ctx->flags & NFS_MOUNT_NORDIRPLUS))
  852. server->caps |= NFS_CAP_READDIRPLUS;
  853. } else {
  854. if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
  855. server->namelen = NFS2_MAXNAMLEN;
  856. }
  857. if (!(fattr->valid & NFS_ATTR_FATTR)) {
  858. error = ctx->nfs_mod->rpc_ops->getattr(server, ctx->mntfh,
  859. fattr, NULL, NULL);
  860. if (error < 0) {
  861. dprintk("nfs_create_server: getattr error = %d\n", -error);
  862. goto error;
  863. }
  864. }
  865. memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
  866. dprintk("Server FSID: %llx:%llx\n",
  867. (unsigned long long) server->fsid.major,
  868. (unsigned long long) server->fsid.minor);
  869. nfs_server_insert_lists(server);
  870. server->mount_time = jiffies;
  871. nfs_free_fattr(fattr);
  872. return server;
  873. error:
  874. nfs_free_fattr(fattr);
  875. nfs_free_server(server);
  876. return ERR_PTR(error);
  877. }
  878. EXPORT_SYMBOL_GPL(nfs_create_server);
  879. /*
  880. * Clone an NFS2, NFS3 or NFS4 server record
  881. */
  882. struct nfs_server *nfs_clone_server(struct nfs_server *source,
  883. struct nfs_fh *fh,
  884. struct nfs_fattr *fattr,
  885. rpc_authflavor_t flavor)
  886. {
  887. struct nfs_server *server;
  888. struct nfs_fattr *fattr_fsinfo;
  889. int error;
  890. server = nfs_alloc_server();
  891. if (!server)
  892. return ERR_PTR(-ENOMEM);
  893. server->cred = get_cred(source->cred);
  894. error = -ENOMEM;
  895. fattr_fsinfo = nfs_alloc_fattr();
  896. if (fattr_fsinfo == NULL)
  897. goto out_free_server;
  898. /* Copy data from the source */
  899. server->nfs_client = source->nfs_client;
  900. server->destroy = source->destroy;
  901. refcount_inc(&server->nfs_client->cl_count);
  902. nfs_server_copy_userdata(server, source);
  903. server->fsid = fattr->fsid;
  904. error = nfs_init_server_rpcclient(server,
  905. source->client->cl_timeout,
  906. flavor);
  907. if (error < 0)
  908. goto out_free_server;
  909. /* probe the filesystem info for this server filesystem */
  910. error = nfs_probe_fsinfo(server, fh, fattr_fsinfo);
  911. if (error < 0)
  912. goto out_free_server;
  913. if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
  914. server->namelen = NFS4_MAXNAMLEN;
  915. error = nfs_start_lockd(server);
  916. if (error < 0)
  917. goto out_free_server;
  918. nfs_server_insert_lists(server);
  919. server->mount_time = jiffies;
  920. nfs_free_fattr(fattr_fsinfo);
  921. return server;
  922. out_free_server:
  923. nfs_free_fattr(fattr_fsinfo);
  924. nfs_free_server(server);
  925. return ERR_PTR(error);
  926. }
  927. EXPORT_SYMBOL_GPL(nfs_clone_server);
  928. void nfs_clients_init(struct net *net)
  929. {
  930. struct nfs_net *nn = net_generic(net, nfs_net_id);
  931. INIT_LIST_HEAD(&nn->nfs_client_list);
  932. INIT_LIST_HEAD(&nn->nfs_volume_list);
  933. #if IS_ENABLED(CONFIG_NFS_V4)
  934. idr_init(&nn->cb_ident_idr);
  935. #endif
  936. spin_lock_init(&nn->nfs_client_lock);
  937. nn->boot_time = ktime_get_real();
  938. nfs_netns_sysfs_setup(nn, net);
  939. }
  940. void nfs_clients_exit(struct net *net)
  941. {
  942. struct nfs_net *nn = net_generic(net, nfs_net_id);
  943. nfs_netns_sysfs_destroy(nn);
  944. nfs_cleanup_cb_ident_idr(net);
  945. WARN_ON_ONCE(!list_empty(&nn->nfs_client_list));
  946. WARN_ON_ONCE(!list_empty(&nn->nfs_volume_list));
  947. }
  948. #ifdef CONFIG_PROC_FS
  949. static void *nfs_server_list_start(struct seq_file *p, loff_t *pos);
  950. static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos);
  951. static void nfs_server_list_stop(struct seq_file *p, void *v);
  952. static int nfs_server_list_show(struct seq_file *m, void *v);
  953. static const struct seq_operations nfs_server_list_ops = {
  954. .start = nfs_server_list_start,
  955. .next = nfs_server_list_next,
  956. .stop = nfs_server_list_stop,
  957. .show = nfs_server_list_show,
  958. };
  959. static void *nfs_volume_list_start(struct seq_file *p, loff_t *pos);
  960. static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos);
  961. static void nfs_volume_list_stop(struct seq_file *p, void *v);
  962. static int nfs_volume_list_show(struct seq_file *m, void *v);
  963. static const struct seq_operations nfs_volume_list_ops = {
  964. .start = nfs_volume_list_start,
  965. .next = nfs_volume_list_next,
  966. .stop = nfs_volume_list_stop,
  967. .show = nfs_volume_list_show,
  968. };
  969. /*
  970. * set up the iterator to start reading from the server list and return the first item
  971. */
  972. static void *nfs_server_list_start(struct seq_file *m, loff_t *_pos)
  973. __acquires(&nn->nfs_client_lock)
  974. {
  975. struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
  976. /* lock the list against modification */
  977. spin_lock(&nn->nfs_client_lock);
  978. return seq_list_start_head(&nn->nfs_client_list, *_pos);
  979. }
  980. /*
  981. * move to next server
  982. */
  983. static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos)
  984. {
  985. struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
  986. return seq_list_next(v, &nn->nfs_client_list, pos);
  987. }
  988. /*
  989. * clean up after reading from the transports list
  990. */
  991. static void nfs_server_list_stop(struct seq_file *p, void *v)
  992. __releases(&nn->nfs_client_lock)
  993. {
  994. struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
  995. spin_unlock(&nn->nfs_client_lock);
  996. }
  997. /*
  998. * display a header line followed by a load of call lines
  999. */
  1000. static int nfs_server_list_show(struct seq_file *m, void *v)
  1001. {
  1002. struct nfs_client *clp;
  1003. struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
  1004. /* display header on line 1 */
  1005. if (v == &nn->nfs_client_list) {
  1006. seq_puts(m, "NV SERVER PORT USE HOSTNAME\n");
  1007. return 0;
  1008. }
  1009. /* display one transport per line on subsequent lines */
  1010. clp = list_entry(v, struct nfs_client, cl_share_link);
  1011. /* Check if the client is initialized */
  1012. if (clp->cl_cons_state != NFS_CS_READY)
  1013. return 0;
  1014. rcu_read_lock();
  1015. seq_printf(m, "v%u %s %s %3d %s\n",
  1016. clp->rpc_ops->version,
  1017. rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR),
  1018. rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT),
  1019. refcount_read(&clp->cl_count),
  1020. clp->cl_hostname);
  1021. rcu_read_unlock();
  1022. return 0;
  1023. }
  1024. /*
  1025. * set up the iterator to start reading from the volume list and return the first item
  1026. */
  1027. static void *nfs_volume_list_start(struct seq_file *m, loff_t *_pos)
  1028. __acquires(&nn->nfs_client_lock)
  1029. {
  1030. struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
  1031. /* lock the list against modification */
  1032. spin_lock(&nn->nfs_client_lock);
  1033. return seq_list_start_head(&nn->nfs_volume_list, *_pos);
  1034. }
  1035. /*
  1036. * move to next volume
  1037. */
  1038. static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos)
  1039. {
  1040. struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
  1041. return seq_list_next(v, &nn->nfs_volume_list, pos);
  1042. }
  1043. /*
  1044. * clean up after reading from the transports list
  1045. */
  1046. static void nfs_volume_list_stop(struct seq_file *p, void *v)
  1047. __releases(&nn->nfs_client_lock)
  1048. {
  1049. struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
  1050. spin_unlock(&nn->nfs_client_lock);
  1051. }
  1052. /*
  1053. * display a header line followed by a load of call lines
  1054. */
  1055. static int nfs_volume_list_show(struct seq_file *m, void *v)
  1056. {
  1057. struct nfs_server *server;
  1058. struct nfs_client *clp;
  1059. char dev[13]; // 8 for 2^24, 1 for ':', 3 for 2^8, 1 for '\0'
  1060. char fsid[34]; // 2 * 16 for %llx, 1 for ':', 1 for '\0'
  1061. struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
  1062. /* display header on line 1 */
  1063. if (v == &nn->nfs_volume_list) {
  1064. seq_puts(m, "NV SERVER PORT DEV FSID"
  1065. " FSC\n");
  1066. return 0;
  1067. }
  1068. /* display one transport per line on subsequent lines */
  1069. server = list_entry(v, struct nfs_server, master_link);
  1070. clp = server->nfs_client;
  1071. snprintf(dev, sizeof(dev), "%u:%u",
  1072. MAJOR(server->s_dev), MINOR(server->s_dev));
  1073. snprintf(fsid, sizeof(fsid), "%llx:%llx",
  1074. (unsigned long long) server->fsid.major,
  1075. (unsigned long long) server->fsid.minor);
  1076. rcu_read_lock();
  1077. seq_printf(m, "v%u %s %s %-12s %-33s %s\n",
  1078. clp->rpc_ops->version,
  1079. rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR),
  1080. rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT),
  1081. dev,
  1082. fsid,
  1083. nfs_server_fscache_state(server));
  1084. rcu_read_unlock();
  1085. return 0;
  1086. }
  1087. int nfs_fs_proc_net_init(struct net *net)
  1088. {
  1089. struct nfs_net *nn = net_generic(net, nfs_net_id);
  1090. struct proc_dir_entry *p;
  1091. nn->proc_nfsfs = proc_net_mkdir(net, "nfsfs", net->proc_net);
  1092. if (!nn->proc_nfsfs)
  1093. goto error_0;
  1094. /* a file of servers with which we're dealing */
  1095. p = proc_create_net("servers", S_IFREG|S_IRUGO, nn->proc_nfsfs,
  1096. &nfs_server_list_ops, sizeof(struct seq_net_private));
  1097. if (!p)
  1098. goto error_1;
  1099. /* a file of volumes that we have mounted */
  1100. p = proc_create_net("volumes", S_IFREG|S_IRUGO, nn->proc_nfsfs,
  1101. &nfs_volume_list_ops, sizeof(struct seq_net_private));
  1102. if (!p)
  1103. goto error_1;
  1104. return 0;
  1105. error_1:
  1106. remove_proc_subtree("nfsfs", net->proc_net);
  1107. error_0:
  1108. return -ENOMEM;
  1109. }
  1110. void nfs_fs_proc_net_exit(struct net *net)
  1111. {
  1112. remove_proc_subtree("nfsfs", net->proc_net);
  1113. }
  1114. /*
  1115. * initialise the /proc/fs/nfsfs/ directory
  1116. */
  1117. int __init nfs_fs_proc_init(void)
  1118. {
  1119. if (!proc_mkdir("fs/nfsfs", NULL))
  1120. goto error_0;
  1121. /* a file of servers with which we're dealing */
  1122. if (!proc_symlink("fs/nfsfs/servers", NULL, "../../net/nfsfs/servers"))
  1123. goto error_1;
  1124. /* a file of volumes that we have mounted */
  1125. if (!proc_symlink("fs/nfsfs/volumes", NULL, "../../net/nfsfs/volumes"))
  1126. goto error_1;
  1127. return 0;
  1128. error_1:
  1129. remove_proc_subtree("fs/nfsfs", NULL);
  1130. error_0:
  1131. return -ENOMEM;
  1132. }
  1133. /*
  1134. * clean up the /proc/fs/nfsfs/ directory
  1135. */
  1136. void nfs_fs_proc_exit(void)
  1137. {
  1138. remove_proc_subtree("fs/nfsfs", NULL);
  1139. }
  1140. #endif /* CONFIG_PROC_FS */