client.c 35 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451
  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/time.h>
  14. #include <linux/kernel.h>
  15. #include <linux/mm.h>
  16. #include <linux/string.h>
  17. #include <linux/stat.h>
  18. #include <linux/errno.h>
  19. #include <linux/unistd.h>
  20. #include <linux/sunrpc/clnt.h>
  21. #include <linux/sunrpc/stats.h>
  22. #include <linux/sunrpc/metrics.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/smp_lock.h>
  28. #include <linux/seq_file.h>
  29. #include <linux/mount.h>
  30. #include <linux/nfs_idmap.h>
  31. #include <linux/vfs.h>
  32. #include <linux/inet.h>
  33. #include <linux/nfs_xdr.h>
  34. #include <asm/system.h>
  35. #include "nfs4_fs.h"
  36. #include "callback.h"
  37. #include "delegation.h"
  38. #include "iostat.h"
  39. #include "internal.h"
  40. #define NFSDBG_FACILITY NFSDBG_CLIENT
  41. static DEFINE_SPINLOCK(nfs_client_lock);
  42. static LIST_HEAD(nfs_client_list);
  43. static LIST_HEAD(nfs_volume_list);
  44. static DECLARE_WAIT_QUEUE_HEAD(nfs_client_active_wq);
  45. /*
  46. * RPC cruft for NFS
  47. */
  48. static struct rpc_version *nfs_version[5] = {
  49. [2] = &nfs_version2,
  50. #ifdef CONFIG_NFS_V3
  51. [3] = &nfs_version3,
  52. #endif
  53. #ifdef CONFIG_NFS_V4
  54. [4] = &nfs_version4,
  55. #endif
  56. };
  57. struct rpc_program nfs_program = {
  58. .name = "nfs",
  59. .number = NFS_PROGRAM,
  60. .nrvers = ARRAY_SIZE(nfs_version),
  61. .version = nfs_version,
  62. .stats = &nfs_rpcstat,
  63. .pipe_dir_name = "/nfs",
  64. };
  65. struct rpc_stat nfs_rpcstat = {
  66. .program = &nfs_program
  67. };
  68. #ifdef CONFIG_NFS_V3_ACL
  69. static struct rpc_stat nfsacl_rpcstat = { &nfsacl_program };
  70. static struct rpc_version * nfsacl_version[] = {
  71. [3] = &nfsacl_version3,
  72. };
  73. struct rpc_program nfsacl_program = {
  74. .name = "nfsacl",
  75. .number = NFS_ACL_PROGRAM,
  76. .nrvers = ARRAY_SIZE(nfsacl_version),
  77. .version = nfsacl_version,
  78. .stats = &nfsacl_rpcstat,
  79. };
  80. #endif /* CONFIG_NFS_V3_ACL */
  81. /*
  82. * Allocate a shared client record
  83. *
  84. * Since these are allocated/deallocated very rarely, we don't
  85. * bother putting them in a slab cache...
  86. */
  87. static struct nfs_client *nfs_alloc_client(const char *hostname,
  88. const struct sockaddr_in *addr,
  89. int nfsversion)
  90. {
  91. struct nfs_client *clp;
  92. int error;
  93. if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)
  94. goto error_0;
  95. error = rpciod_up();
  96. if (error < 0) {
  97. dprintk("%s: couldn't start rpciod! Error = %d\n",
  98. __FUNCTION__, error);
  99. goto error_1;
  100. }
  101. __set_bit(NFS_CS_RPCIOD, &clp->cl_res_state);
  102. if (nfsversion == 4) {
  103. if (nfs_callback_up() < 0)
  104. goto error_2;
  105. __set_bit(NFS_CS_CALLBACK, &clp->cl_res_state);
  106. }
  107. atomic_set(&clp->cl_count, 1);
  108. clp->cl_cons_state = NFS_CS_INITING;
  109. clp->cl_nfsversion = nfsversion;
  110. memcpy(&clp->cl_addr, addr, sizeof(clp->cl_addr));
  111. if (hostname) {
  112. clp->cl_hostname = kstrdup(hostname, GFP_KERNEL);
  113. if (!clp->cl_hostname)
  114. goto error_3;
  115. }
  116. INIT_LIST_HEAD(&clp->cl_superblocks);
  117. clp->cl_rpcclient = ERR_PTR(-EINVAL);
  118. #ifdef CONFIG_NFS_V4
  119. init_rwsem(&clp->cl_sem);
  120. INIT_LIST_HEAD(&clp->cl_delegations);
  121. INIT_LIST_HEAD(&clp->cl_state_owners);
  122. INIT_LIST_HEAD(&clp->cl_unused);
  123. spin_lock_init(&clp->cl_lock);
  124. INIT_DELAYED_WORK(&clp->cl_renewd, nfs4_renew_state);
  125. rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");
  126. clp->cl_boot_time = CURRENT_TIME;
  127. clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED;
  128. #endif
  129. return clp;
  130. error_3:
  131. if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state))
  132. nfs_callback_down();
  133. error_2:
  134. rpciod_down();
  135. __clear_bit(NFS_CS_RPCIOD, &clp->cl_res_state);
  136. error_1:
  137. kfree(clp);
  138. error_0:
  139. return NULL;
  140. }
  141. static void nfs4_shutdown_client(struct nfs_client *clp)
  142. {
  143. #ifdef CONFIG_NFS_V4
  144. if (__test_and_clear_bit(NFS_CS_RENEWD, &clp->cl_res_state))
  145. nfs4_kill_renewd(clp);
  146. while (!list_empty(&clp->cl_unused)) {
  147. struct nfs4_state_owner *sp;
  148. sp = list_entry(clp->cl_unused.next,
  149. struct nfs4_state_owner,
  150. so_list);
  151. list_del(&sp->so_list);
  152. kfree(sp);
  153. }
  154. BUG_ON(!list_empty(&clp->cl_state_owners));
  155. if (__test_and_clear_bit(NFS_CS_IDMAP, &clp->cl_res_state))
  156. nfs_idmap_delete(clp);
  157. #endif
  158. }
  159. /*
  160. * Destroy a shared client record
  161. */
  162. static void nfs_free_client(struct nfs_client *clp)
  163. {
  164. dprintk("--> nfs_free_client(%d)\n", clp->cl_nfsversion);
  165. nfs4_shutdown_client(clp);
  166. /* -EIO all pending I/O */
  167. if (!IS_ERR(clp->cl_rpcclient))
  168. rpc_shutdown_client(clp->cl_rpcclient);
  169. if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state))
  170. nfs_callback_down();
  171. if (__test_and_clear_bit(NFS_CS_RPCIOD, &clp->cl_res_state))
  172. rpciod_down();
  173. kfree(clp->cl_hostname);
  174. kfree(clp);
  175. dprintk("<-- nfs_free_client()\n");
  176. }
  177. /*
  178. * Release a reference to a shared client record
  179. */
  180. void nfs_put_client(struct nfs_client *clp)
  181. {
  182. if (!clp)
  183. return;
  184. dprintk("--> nfs_put_client({%d})\n", atomic_read(&clp->cl_count));
  185. if (atomic_dec_and_lock(&clp->cl_count, &nfs_client_lock)) {
  186. list_del(&clp->cl_share_link);
  187. spin_unlock(&nfs_client_lock);
  188. BUG_ON(!list_empty(&clp->cl_superblocks));
  189. nfs_free_client(clp);
  190. }
  191. }
  192. /*
  193. * Find a client by address
  194. * - caller must hold nfs_client_lock
  195. */
  196. static struct nfs_client *__nfs_find_client(const struct sockaddr_in *addr, int nfsversion, int match_port)
  197. {
  198. struct nfs_client *clp;
  199. list_for_each_entry(clp, &nfs_client_list, cl_share_link) {
  200. /* Don't match clients that failed to initialise properly */
  201. if (clp->cl_cons_state < 0)
  202. continue;
  203. /* Different NFS versions cannot share the same nfs_client */
  204. if (clp->cl_nfsversion != nfsversion)
  205. continue;
  206. if (memcmp(&clp->cl_addr.sin_addr, &addr->sin_addr,
  207. sizeof(clp->cl_addr.sin_addr)) != 0)
  208. continue;
  209. if (!match_port || clp->cl_addr.sin_port == addr->sin_port)
  210. goto found;
  211. }
  212. return NULL;
  213. found:
  214. atomic_inc(&clp->cl_count);
  215. return clp;
  216. }
  217. /*
  218. * Find a client by IP address and protocol version
  219. * - returns NULL if no such client
  220. */
  221. struct nfs_client *nfs_find_client(const struct sockaddr_in *addr, int nfsversion)
  222. {
  223. struct nfs_client *clp;
  224. spin_lock(&nfs_client_lock);
  225. clp = __nfs_find_client(addr, nfsversion, 0);
  226. spin_unlock(&nfs_client_lock);
  227. if (clp != NULL && clp->cl_cons_state != NFS_CS_READY) {
  228. nfs_put_client(clp);
  229. clp = NULL;
  230. }
  231. return clp;
  232. }
  233. /*
  234. * Look up a client by IP address and protocol version
  235. * - creates a new record if one doesn't yet exist
  236. */
  237. static struct nfs_client *nfs_get_client(const char *hostname,
  238. const struct sockaddr_in *addr,
  239. int nfsversion)
  240. {
  241. struct nfs_client *clp, *new = NULL;
  242. int error;
  243. dprintk("--> nfs_get_client(%s,"NIPQUAD_FMT":%d,%d)\n",
  244. hostname ?: "", NIPQUAD(addr->sin_addr),
  245. addr->sin_port, nfsversion);
  246. /* see if the client already exists */
  247. do {
  248. spin_lock(&nfs_client_lock);
  249. clp = __nfs_find_client(addr, nfsversion, 1);
  250. if (clp)
  251. goto found_client;
  252. if (new)
  253. goto install_client;
  254. spin_unlock(&nfs_client_lock);
  255. new = nfs_alloc_client(hostname, addr, nfsversion);
  256. } while (new);
  257. return ERR_PTR(-ENOMEM);
  258. /* install a new client and return with it unready */
  259. install_client:
  260. clp = new;
  261. list_add(&clp->cl_share_link, &nfs_client_list);
  262. spin_unlock(&nfs_client_lock);
  263. dprintk("--> nfs_get_client() = %p [new]\n", clp);
  264. return clp;
  265. /* found an existing client
  266. * - make sure it's ready before returning
  267. */
  268. found_client:
  269. spin_unlock(&nfs_client_lock);
  270. if (new)
  271. nfs_free_client(new);
  272. error = wait_event_interruptible(nfs_client_active_wq,
  273. clp->cl_cons_state != NFS_CS_INITING);
  274. if (error < 0) {
  275. nfs_put_client(clp);
  276. return ERR_PTR(-ERESTARTSYS);
  277. }
  278. if (clp->cl_cons_state < NFS_CS_READY) {
  279. error = clp->cl_cons_state;
  280. nfs_put_client(clp);
  281. return ERR_PTR(error);
  282. }
  283. BUG_ON(clp->cl_cons_state != NFS_CS_READY);
  284. dprintk("--> nfs_get_client() = %p [share]\n", clp);
  285. return clp;
  286. }
  287. /*
  288. * Mark a server as ready or failed
  289. */
  290. static void nfs_mark_client_ready(struct nfs_client *clp, int state)
  291. {
  292. clp->cl_cons_state = state;
  293. wake_up_all(&nfs_client_active_wq);
  294. }
  295. /*
  296. * Initialise the timeout values for a connection
  297. */
  298. static void nfs_init_timeout_values(struct rpc_timeout *to, int proto,
  299. unsigned int timeo, unsigned int retrans)
  300. {
  301. to->to_initval = timeo * HZ / 10;
  302. to->to_retries = retrans;
  303. if (!to->to_retries)
  304. to->to_retries = 2;
  305. switch (proto) {
  306. case IPPROTO_TCP:
  307. if (!to->to_initval)
  308. to->to_initval = 60 * HZ;
  309. if (to->to_initval > NFS_MAX_TCP_TIMEOUT)
  310. to->to_initval = NFS_MAX_TCP_TIMEOUT;
  311. to->to_increment = to->to_initval;
  312. to->to_maxval = to->to_initval + (to->to_increment * to->to_retries);
  313. to->to_exponential = 0;
  314. break;
  315. case IPPROTO_UDP:
  316. default:
  317. if (!to->to_initval)
  318. to->to_initval = 11 * HZ / 10;
  319. if (to->to_initval > NFS_MAX_UDP_TIMEOUT)
  320. to->to_initval = NFS_MAX_UDP_TIMEOUT;
  321. to->to_maxval = NFS_MAX_UDP_TIMEOUT;
  322. to->to_exponential = 1;
  323. break;
  324. }
  325. }
  326. /*
  327. * Create an RPC client handle
  328. */
  329. static int nfs_create_rpc_client(struct nfs_client *clp, int proto,
  330. unsigned int timeo,
  331. unsigned int retrans,
  332. rpc_authflavor_t flavor,
  333. int flags)
  334. {
  335. struct rpc_timeout timeparms;
  336. struct rpc_clnt *clnt = NULL;
  337. struct rpc_create_args args = {
  338. .protocol = proto,
  339. .address = (struct sockaddr *)&clp->cl_addr,
  340. .addrsize = sizeof(clp->cl_addr),
  341. .timeout = &timeparms,
  342. .servername = clp->cl_hostname,
  343. .program = &nfs_program,
  344. .version = clp->rpc_ops->version,
  345. .authflavor = flavor,
  346. .flags = flags,
  347. };
  348. if (!IS_ERR(clp->cl_rpcclient))
  349. return 0;
  350. nfs_init_timeout_values(&timeparms, proto, timeo, retrans);
  351. clp->retrans_timeo = timeparms.to_initval;
  352. clp->retrans_count = timeparms.to_retries;
  353. clnt = rpc_create(&args);
  354. if (IS_ERR(clnt)) {
  355. dprintk("%s: cannot create RPC client. Error = %ld\n",
  356. __FUNCTION__, PTR_ERR(clnt));
  357. return PTR_ERR(clnt);
  358. }
  359. clp->cl_rpcclient = clnt;
  360. return 0;
  361. }
  362. /*
  363. * Version 2 or 3 client destruction
  364. */
  365. static void nfs_destroy_server(struct nfs_server *server)
  366. {
  367. if (!IS_ERR(server->client_acl))
  368. rpc_shutdown_client(server->client_acl);
  369. if (!(server->flags & NFS_MOUNT_NONLM))
  370. lockd_down(); /* release rpc.lockd */
  371. }
  372. /*
  373. * Version 2 or 3 lockd setup
  374. */
  375. static int nfs_start_lockd(struct nfs_server *server)
  376. {
  377. int error = 0;
  378. if (server->nfs_client->cl_nfsversion > 3)
  379. goto out;
  380. if (server->flags & NFS_MOUNT_NONLM)
  381. goto out;
  382. error = lockd_up((server->flags & NFS_MOUNT_TCP) ?
  383. IPPROTO_TCP : IPPROTO_UDP);
  384. if (error < 0)
  385. server->flags |= NFS_MOUNT_NONLM;
  386. else
  387. server->destroy = nfs_destroy_server;
  388. out:
  389. return error;
  390. }
  391. /*
  392. * Initialise an NFSv3 ACL client connection
  393. */
  394. #ifdef CONFIG_NFS_V3_ACL
  395. static void nfs_init_server_aclclient(struct nfs_server *server)
  396. {
  397. if (server->nfs_client->cl_nfsversion != 3)
  398. goto out_noacl;
  399. if (server->flags & NFS_MOUNT_NOACL)
  400. goto out_noacl;
  401. server->client_acl = rpc_bind_new_program(server->client, &nfsacl_program, 3);
  402. if (IS_ERR(server->client_acl))
  403. goto out_noacl;
  404. /* No errors! Assume that Sun nfsacls are supported */
  405. server->caps |= NFS_CAP_ACLS;
  406. return;
  407. out_noacl:
  408. server->caps &= ~NFS_CAP_ACLS;
  409. }
  410. #else
  411. static inline void nfs_init_server_aclclient(struct nfs_server *server)
  412. {
  413. server->flags &= ~NFS_MOUNT_NOACL;
  414. server->caps &= ~NFS_CAP_ACLS;
  415. }
  416. #endif
  417. /*
  418. * Create a general RPC client
  419. */
  420. static int nfs_init_server_rpcclient(struct nfs_server *server, rpc_authflavor_t pseudoflavour)
  421. {
  422. struct nfs_client *clp = server->nfs_client;
  423. server->client = rpc_clone_client(clp->cl_rpcclient);
  424. if (IS_ERR(server->client)) {
  425. dprintk("%s: couldn't create rpc_client!\n", __FUNCTION__);
  426. return PTR_ERR(server->client);
  427. }
  428. if (pseudoflavour != clp->cl_rpcclient->cl_auth->au_flavor) {
  429. struct rpc_auth *auth;
  430. auth = rpcauth_create(pseudoflavour, server->client);
  431. if (IS_ERR(auth)) {
  432. dprintk("%s: couldn't create credcache!\n", __FUNCTION__);
  433. return PTR_ERR(auth);
  434. }
  435. }
  436. server->client->cl_softrtry = 0;
  437. if (server->flags & NFS_MOUNT_SOFT)
  438. server->client->cl_softrtry = 1;
  439. server->client->cl_intr = 0;
  440. if (server->flags & NFS4_MOUNT_INTR)
  441. server->client->cl_intr = 1;
  442. return 0;
  443. }
  444. /*
  445. * Initialise an NFS2 or NFS3 client
  446. */
  447. static int nfs_init_client(struct nfs_client *clp, const struct nfs_mount_data *data)
  448. {
  449. int proto = (data->flags & NFS_MOUNT_TCP) ? IPPROTO_TCP : IPPROTO_UDP;
  450. int error;
  451. if (clp->cl_cons_state == NFS_CS_READY) {
  452. /* the client is already initialised */
  453. dprintk("<-- nfs_init_client() = 0 [already %p]\n", clp);
  454. return 0;
  455. }
  456. /* Check NFS protocol revision and initialize RPC op vector */
  457. clp->rpc_ops = &nfs_v2_clientops;
  458. #ifdef CONFIG_NFS_V3
  459. if (clp->cl_nfsversion == 3)
  460. clp->rpc_ops = &nfs_v3_clientops;
  461. #endif
  462. /*
  463. * Create a client RPC handle for doing FSSTAT with UNIX auth only
  464. * - RFC 2623, sec 2.3.2
  465. */
  466. error = nfs_create_rpc_client(clp, proto, data->timeo, data->retrans,
  467. RPC_AUTH_UNIX, 0);
  468. if (error < 0)
  469. goto error;
  470. nfs_mark_client_ready(clp, NFS_CS_READY);
  471. return 0;
  472. error:
  473. nfs_mark_client_ready(clp, error);
  474. dprintk("<-- nfs_init_client() = xerror %d\n", error);
  475. return error;
  476. }
  477. /*
  478. * Create a version 2 or 3 client
  479. */
  480. static int nfs_init_server(struct nfs_server *server, const struct nfs_mount_data *data)
  481. {
  482. struct nfs_client *clp;
  483. int error, nfsvers = 2;
  484. dprintk("--> nfs_init_server()\n");
  485. #ifdef CONFIG_NFS_V3
  486. if (data->flags & NFS_MOUNT_VER3)
  487. nfsvers = 3;
  488. #endif
  489. /* Allocate or find a client reference we can use */
  490. clp = nfs_get_client(data->hostname, &data->addr, nfsvers);
  491. if (IS_ERR(clp)) {
  492. dprintk("<-- nfs_init_server() = error %ld\n", PTR_ERR(clp));
  493. return PTR_ERR(clp);
  494. }
  495. error = nfs_init_client(clp, data);
  496. if (error < 0)
  497. goto error;
  498. server->nfs_client = clp;
  499. /* Initialise the client representation from the mount data */
  500. server->flags = data->flags & NFS_MOUNT_FLAGMASK;
  501. if (data->rsize)
  502. server->rsize = nfs_block_size(data->rsize, NULL);
  503. if (data->wsize)
  504. server->wsize = nfs_block_size(data->wsize, NULL);
  505. server->acregmin = data->acregmin * HZ;
  506. server->acregmax = data->acregmax * HZ;
  507. server->acdirmin = data->acdirmin * HZ;
  508. server->acdirmax = data->acdirmax * HZ;
  509. /* Start lockd here, before we might error out */
  510. error = nfs_start_lockd(server);
  511. if (error < 0)
  512. goto error;
  513. error = nfs_init_server_rpcclient(server, data->pseudoflavor);
  514. if (error < 0)
  515. goto error;
  516. server->namelen = data->namlen;
  517. /* Create a client RPC handle for the NFSv3 ACL management interface */
  518. nfs_init_server_aclclient(server);
  519. if (clp->cl_nfsversion == 3) {
  520. if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
  521. server->namelen = NFS3_MAXNAMLEN;
  522. server->caps |= NFS_CAP_READDIRPLUS;
  523. } else {
  524. if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
  525. server->namelen = NFS2_MAXNAMLEN;
  526. }
  527. dprintk("<-- nfs_init_server() = 0 [new %p]\n", clp);
  528. return 0;
  529. error:
  530. server->nfs_client = NULL;
  531. nfs_put_client(clp);
  532. dprintk("<-- nfs_init_server() = xerror %d\n", error);
  533. return error;
  534. }
  535. /*
  536. * Load up the server record from information gained in an fsinfo record
  537. */
  538. static void nfs_server_set_fsinfo(struct nfs_server *server, struct nfs_fsinfo *fsinfo)
  539. {
  540. unsigned long max_rpc_payload;
  541. /* Work out a lot of parameters */
  542. if (server->rsize == 0)
  543. server->rsize = nfs_block_size(fsinfo->rtpref, NULL);
  544. if (server->wsize == 0)
  545. server->wsize = nfs_block_size(fsinfo->wtpref, NULL);
  546. if (fsinfo->rtmax >= 512 && server->rsize > fsinfo->rtmax)
  547. server->rsize = nfs_block_size(fsinfo->rtmax, NULL);
  548. if (fsinfo->wtmax >= 512 && server->wsize > fsinfo->wtmax)
  549. server->wsize = nfs_block_size(fsinfo->wtmax, NULL);
  550. max_rpc_payload = nfs_block_size(rpc_max_payload(server->client), NULL);
  551. if (server->rsize > max_rpc_payload)
  552. server->rsize = max_rpc_payload;
  553. if (server->rsize > NFS_MAX_FILE_IO_SIZE)
  554. server->rsize = NFS_MAX_FILE_IO_SIZE;
  555. server->rpages = (server->rsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
  556. server->backing_dev_info.ra_pages = server->rpages * NFS_MAX_READAHEAD;
  557. if (server->wsize > max_rpc_payload)
  558. server->wsize = max_rpc_payload;
  559. if (server->wsize > NFS_MAX_FILE_IO_SIZE)
  560. server->wsize = NFS_MAX_FILE_IO_SIZE;
  561. server->wpages = (server->wsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
  562. server->wtmult = nfs_block_bits(fsinfo->wtmult, NULL);
  563. server->dtsize = nfs_block_size(fsinfo->dtpref, NULL);
  564. if (server->dtsize > PAGE_CACHE_SIZE)
  565. server->dtsize = PAGE_CACHE_SIZE;
  566. if (server->dtsize > server->rsize)
  567. server->dtsize = server->rsize;
  568. if (server->flags & NFS_MOUNT_NOAC) {
  569. server->acregmin = server->acregmax = 0;
  570. server->acdirmin = server->acdirmax = 0;
  571. }
  572. server->maxfilesize = fsinfo->maxfilesize;
  573. /* We're airborne Set socket buffersize */
  574. rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);
  575. }
  576. /*
  577. * Probe filesystem information, including the FSID on v2/v3
  578. */
  579. static int nfs_probe_fsinfo(struct nfs_server *server, struct nfs_fh *mntfh, struct nfs_fattr *fattr)
  580. {
  581. struct nfs_fsinfo fsinfo;
  582. struct nfs_client *clp = server->nfs_client;
  583. int error;
  584. dprintk("--> nfs_probe_fsinfo()\n");
  585. if (clp->rpc_ops->set_capabilities != NULL) {
  586. error = clp->rpc_ops->set_capabilities(server, mntfh);
  587. if (error < 0)
  588. goto out_error;
  589. }
  590. fsinfo.fattr = fattr;
  591. nfs_fattr_init(fattr);
  592. error = clp->rpc_ops->fsinfo(server, mntfh, &fsinfo);
  593. if (error < 0)
  594. goto out_error;
  595. nfs_server_set_fsinfo(server, &fsinfo);
  596. /* Get some general file system info */
  597. if (server->namelen == 0) {
  598. struct nfs_pathconf pathinfo;
  599. pathinfo.fattr = fattr;
  600. nfs_fattr_init(fattr);
  601. if (clp->rpc_ops->pathconf(server, mntfh, &pathinfo) >= 0)
  602. server->namelen = pathinfo.max_namelen;
  603. }
  604. dprintk("<-- nfs_probe_fsinfo() = 0\n");
  605. return 0;
  606. out_error:
  607. dprintk("nfs_probe_fsinfo: error = %d\n", -error);
  608. return error;
  609. }
  610. /*
  611. * Copy useful information when duplicating a server record
  612. */
  613. static void nfs_server_copy_userdata(struct nfs_server *target, struct nfs_server *source)
  614. {
  615. target->flags = source->flags;
  616. target->acregmin = source->acregmin;
  617. target->acregmax = source->acregmax;
  618. target->acdirmin = source->acdirmin;
  619. target->acdirmax = source->acdirmax;
  620. target->caps = source->caps;
  621. }
  622. /*
  623. * Allocate and initialise a server record
  624. */
  625. static struct nfs_server *nfs_alloc_server(void)
  626. {
  627. struct nfs_server *server;
  628. server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
  629. if (!server)
  630. return NULL;
  631. server->client = server->client_acl = ERR_PTR(-EINVAL);
  632. /* Zero out the NFS state stuff */
  633. INIT_LIST_HEAD(&server->client_link);
  634. INIT_LIST_HEAD(&server->master_link);
  635. server->io_stats = nfs_alloc_iostats();
  636. if (!server->io_stats) {
  637. kfree(server);
  638. return NULL;
  639. }
  640. return server;
  641. }
  642. /*
  643. * Free up a server record
  644. */
  645. void nfs_free_server(struct nfs_server *server)
  646. {
  647. dprintk("--> nfs_free_server()\n");
  648. spin_lock(&nfs_client_lock);
  649. list_del(&server->client_link);
  650. list_del(&server->master_link);
  651. spin_unlock(&nfs_client_lock);
  652. if (server->destroy != NULL)
  653. server->destroy(server);
  654. if (!IS_ERR(server->client))
  655. rpc_shutdown_client(server->client);
  656. nfs_put_client(server->nfs_client);
  657. nfs_free_iostats(server->io_stats);
  658. kfree(server);
  659. nfs_release_automount_timer();
  660. dprintk("<-- nfs_free_server()\n");
  661. }
  662. /*
  663. * Create a version 2 or 3 volume record
  664. * - keyed on server and FSID
  665. */
  666. struct nfs_server *nfs_create_server(const struct nfs_mount_data *data,
  667. struct nfs_fh *mntfh)
  668. {
  669. struct nfs_server *server;
  670. struct nfs_fattr fattr;
  671. int error;
  672. server = nfs_alloc_server();
  673. if (!server)
  674. return ERR_PTR(-ENOMEM);
  675. /* Get a client representation */
  676. error = nfs_init_server(server, data);
  677. if (error < 0)
  678. goto error;
  679. BUG_ON(!server->nfs_client);
  680. BUG_ON(!server->nfs_client->rpc_ops);
  681. BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
  682. /* Probe the root fh to retrieve its FSID */
  683. error = nfs_probe_fsinfo(server, mntfh, &fattr);
  684. if (error < 0)
  685. goto error;
  686. if (!(fattr.valid & NFS_ATTR_FATTR)) {
  687. error = server->nfs_client->rpc_ops->getattr(server, mntfh, &fattr);
  688. if (error < 0) {
  689. dprintk("nfs_create_server: getattr error = %d\n", -error);
  690. goto error;
  691. }
  692. }
  693. memcpy(&server->fsid, &fattr.fsid, sizeof(server->fsid));
  694. dprintk("Server FSID: %llx:%llx\n",
  695. (unsigned long long) server->fsid.major,
  696. (unsigned long long) server->fsid.minor);
  697. BUG_ON(!server->nfs_client);
  698. BUG_ON(!server->nfs_client->rpc_ops);
  699. BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
  700. spin_lock(&nfs_client_lock);
  701. list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
  702. list_add_tail(&server->master_link, &nfs_volume_list);
  703. spin_unlock(&nfs_client_lock);
  704. server->mount_time = jiffies;
  705. return server;
  706. error:
  707. nfs_free_server(server);
  708. return ERR_PTR(error);
  709. }
  710. #ifdef CONFIG_NFS_V4
  711. /*
  712. * Initialise an NFS4 client record
  713. */
  714. static int nfs4_init_client(struct nfs_client *clp,
  715. int proto, int timeo, int retrans,
  716. const char *ip_addr,
  717. rpc_authflavor_t authflavour)
  718. {
  719. int error;
  720. if (clp->cl_cons_state == NFS_CS_READY) {
  721. /* the client is initialised already */
  722. dprintk("<-- nfs4_init_client() = 0 [already %p]\n", clp);
  723. return 0;
  724. }
  725. /* Check NFS protocol revision and initialize RPC op vector */
  726. clp->rpc_ops = &nfs_v4_clientops;
  727. error = nfs_create_rpc_client(clp, proto, timeo, retrans, authflavour,
  728. RPC_CLNT_CREATE_DISCRTRY);
  729. if (error < 0)
  730. goto error;
  731. memcpy(clp->cl_ipaddr, ip_addr, sizeof(clp->cl_ipaddr));
  732. error = nfs_idmap_new(clp);
  733. if (error < 0) {
  734. dprintk("%s: failed to create idmapper. Error = %d\n",
  735. __FUNCTION__, error);
  736. goto error;
  737. }
  738. __set_bit(NFS_CS_IDMAP, &clp->cl_res_state);
  739. nfs_mark_client_ready(clp, NFS_CS_READY);
  740. return 0;
  741. error:
  742. nfs_mark_client_ready(clp, error);
  743. dprintk("<-- nfs4_init_client() = xerror %d\n", error);
  744. return error;
  745. }
  746. /*
  747. * Set up an NFS4 client
  748. */
  749. static int nfs4_set_client(struct nfs_server *server,
  750. const char *hostname, const struct sockaddr_in *addr,
  751. const char *ip_addr,
  752. rpc_authflavor_t authflavour,
  753. int proto, int timeo, int retrans)
  754. {
  755. struct nfs_client *clp;
  756. int error;
  757. dprintk("--> nfs4_set_client()\n");
  758. /* Allocate or find a client reference we can use */
  759. clp = nfs_get_client(hostname, addr, 4);
  760. if (IS_ERR(clp)) {
  761. error = PTR_ERR(clp);
  762. goto error;
  763. }
  764. error = nfs4_init_client(clp, proto, timeo, retrans, ip_addr, authflavour);
  765. if (error < 0)
  766. goto error_put;
  767. server->nfs_client = clp;
  768. dprintk("<-- nfs4_set_client() = 0 [new %p]\n", clp);
  769. return 0;
  770. error_put:
  771. nfs_put_client(clp);
  772. error:
  773. dprintk("<-- nfs4_set_client() = xerror %d\n", error);
  774. return error;
  775. }
  776. /*
  777. * Create a version 4 volume record
  778. */
  779. static int nfs4_init_server(struct nfs_server *server,
  780. const struct nfs4_mount_data *data, rpc_authflavor_t authflavour)
  781. {
  782. int error;
  783. dprintk("--> nfs4_init_server()\n");
  784. /* Initialise the client representation from the mount data */
  785. server->flags = data->flags & NFS_MOUNT_FLAGMASK;
  786. server->caps |= NFS_CAP_ATOMIC_OPEN;
  787. if (data->rsize)
  788. server->rsize = nfs_block_size(data->rsize, NULL);
  789. if (data->wsize)
  790. server->wsize = nfs_block_size(data->wsize, NULL);
  791. server->acregmin = data->acregmin * HZ;
  792. server->acregmax = data->acregmax * HZ;
  793. server->acdirmin = data->acdirmin * HZ;
  794. server->acdirmax = data->acdirmax * HZ;
  795. error = nfs_init_server_rpcclient(server, authflavour);
  796. /* Done */
  797. dprintk("<-- nfs4_init_server() = %d\n", error);
  798. return error;
  799. }
  800. /*
  801. * Create a version 4 volume record
  802. * - keyed on server and FSID
  803. */
  804. struct nfs_server *nfs4_create_server(const struct nfs4_mount_data *data,
  805. const char *hostname,
  806. const struct sockaddr_in *addr,
  807. const char *mntpath,
  808. const char *ip_addr,
  809. rpc_authflavor_t authflavour,
  810. struct nfs_fh *mntfh)
  811. {
  812. struct nfs_fattr fattr;
  813. struct nfs_server *server;
  814. int error;
  815. dprintk("--> nfs4_create_server()\n");
  816. server = nfs_alloc_server();
  817. if (!server)
  818. return ERR_PTR(-ENOMEM);
  819. /* Get a client record */
  820. error = nfs4_set_client(server, hostname, addr, ip_addr, authflavour,
  821. data->proto, data->timeo, data->retrans);
  822. if (error < 0)
  823. goto error;
  824. /* set up the general RPC client */
  825. error = nfs4_init_server(server, data, authflavour);
  826. if (error < 0)
  827. goto error;
  828. BUG_ON(!server->nfs_client);
  829. BUG_ON(!server->nfs_client->rpc_ops);
  830. BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
  831. /* Probe the root fh to retrieve its FSID */
  832. error = nfs4_path_walk(server, mntfh, mntpath);
  833. if (error < 0)
  834. goto error;
  835. dprintk("Server FSID: %llx:%llx\n",
  836. (unsigned long long) server->fsid.major,
  837. (unsigned long long) server->fsid.minor);
  838. dprintk("Mount FH: %d\n", mntfh->size);
  839. error = nfs_probe_fsinfo(server, mntfh, &fattr);
  840. if (error < 0)
  841. goto error;
  842. BUG_ON(!server->nfs_client);
  843. BUG_ON(!server->nfs_client->rpc_ops);
  844. BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
  845. spin_lock(&nfs_client_lock);
  846. list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
  847. list_add_tail(&server->master_link, &nfs_volume_list);
  848. spin_unlock(&nfs_client_lock);
  849. server->mount_time = jiffies;
  850. dprintk("<-- nfs4_create_server() = %p\n", server);
  851. return server;
  852. error:
  853. nfs_free_server(server);
  854. dprintk("<-- nfs4_create_server() = error %d\n", error);
  855. return ERR_PTR(error);
  856. }
  857. /*
  858. * Create an NFS4 referral server record
  859. */
  860. struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
  861. struct nfs_fh *mntfh)
  862. {
  863. struct nfs_client *parent_client;
  864. struct nfs_server *server, *parent_server;
  865. struct nfs_fattr fattr;
  866. int error;
  867. dprintk("--> nfs4_create_referral_server()\n");
  868. server = nfs_alloc_server();
  869. if (!server)
  870. return ERR_PTR(-ENOMEM);
  871. parent_server = NFS_SB(data->sb);
  872. parent_client = parent_server->nfs_client;
  873. /* Get a client representation.
  874. * Note: NFSv4 always uses TCP, */
  875. error = nfs4_set_client(server, data->hostname, data->addr,
  876. parent_client->cl_ipaddr,
  877. data->authflavor,
  878. parent_server->client->cl_xprt->prot,
  879. parent_client->retrans_timeo,
  880. parent_client->retrans_count);
  881. if (error < 0)
  882. goto error;
  883. /* Initialise the client representation from the parent server */
  884. nfs_server_copy_userdata(server, parent_server);
  885. server->caps |= NFS_CAP_ATOMIC_OPEN;
  886. error = nfs_init_server_rpcclient(server, data->authflavor);
  887. if (error < 0)
  888. goto error;
  889. BUG_ON(!server->nfs_client);
  890. BUG_ON(!server->nfs_client->rpc_ops);
  891. BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
  892. /* Probe the root fh to retrieve its FSID and filehandle */
  893. error = nfs4_path_walk(server, mntfh, data->mnt_path);
  894. if (error < 0)
  895. goto error;
  896. /* probe the filesystem info for this server filesystem */
  897. error = nfs_probe_fsinfo(server, mntfh, &fattr);
  898. if (error < 0)
  899. goto error;
  900. dprintk("Referral FSID: %llx:%llx\n",
  901. (unsigned long long) server->fsid.major,
  902. (unsigned long long) server->fsid.minor);
  903. spin_lock(&nfs_client_lock);
  904. list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
  905. list_add_tail(&server->master_link, &nfs_volume_list);
  906. spin_unlock(&nfs_client_lock);
  907. server->mount_time = jiffies;
  908. dprintk("<-- nfs_create_referral_server() = %p\n", server);
  909. return server;
  910. error:
  911. nfs_free_server(server);
  912. dprintk("<-- nfs4_create_referral_server() = error %d\n", error);
  913. return ERR_PTR(error);
  914. }
  915. #endif /* CONFIG_NFS_V4 */
  916. /*
  917. * Clone an NFS2, NFS3 or NFS4 server record
  918. */
  919. struct nfs_server *nfs_clone_server(struct nfs_server *source,
  920. struct nfs_fh *fh,
  921. struct nfs_fattr *fattr)
  922. {
  923. struct nfs_server *server;
  924. struct nfs_fattr fattr_fsinfo;
  925. int error;
  926. dprintk("--> nfs_clone_server(,%llx:%llx,)\n",
  927. (unsigned long long) fattr->fsid.major,
  928. (unsigned long long) fattr->fsid.minor);
  929. server = nfs_alloc_server();
  930. if (!server)
  931. return ERR_PTR(-ENOMEM);
  932. /* Copy data from the source */
  933. server->nfs_client = source->nfs_client;
  934. atomic_inc(&server->nfs_client->cl_count);
  935. nfs_server_copy_userdata(server, source);
  936. server->fsid = fattr->fsid;
  937. error = nfs_init_server_rpcclient(server, source->client->cl_auth->au_flavor);
  938. if (error < 0)
  939. goto out_free_server;
  940. if (!IS_ERR(source->client_acl))
  941. nfs_init_server_aclclient(server);
  942. /* probe the filesystem info for this server filesystem */
  943. error = nfs_probe_fsinfo(server, fh, &fattr_fsinfo);
  944. if (error < 0)
  945. goto out_free_server;
  946. dprintk("Cloned FSID: %llx:%llx\n",
  947. (unsigned long long) server->fsid.major,
  948. (unsigned long long) server->fsid.minor);
  949. error = nfs_start_lockd(server);
  950. if (error < 0)
  951. goto out_free_server;
  952. spin_lock(&nfs_client_lock);
  953. list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
  954. list_add_tail(&server->master_link, &nfs_volume_list);
  955. spin_unlock(&nfs_client_lock);
  956. server->mount_time = jiffies;
  957. dprintk("<-- nfs_clone_server() = %p\n", server);
  958. return server;
  959. out_free_server:
  960. nfs_free_server(server);
  961. dprintk("<-- nfs_clone_server() = error %d\n", error);
  962. return ERR_PTR(error);
  963. }
  964. #ifdef CONFIG_PROC_FS
  965. static struct proc_dir_entry *proc_fs_nfs;
  966. static int nfs_server_list_open(struct inode *inode, struct file *file);
  967. static void *nfs_server_list_start(struct seq_file *p, loff_t *pos);
  968. static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos);
  969. static void nfs_server_list_stop(struct seq_file *p, void *v);
  970. static int nfs_server_list_show(struct seq_file *m, void *v);
  971. static struct seq_operations nfs_server_list_ops = {
  972. .start = nfs_server_list_start,
  973. .next = nfs_server_list_next,
  974. .stop = nfs_server_list_stop,
  975. .show = nfs_server_list_show,
  976. };
  977. static const struct file_operations nfs_server_list_fops = {
  978. .open = nfs_server_list_open,
  979. .read = seq_read,
  980. .llseek = seq_lseek,
  981. .release = seq_release,
  982. };
  983. static int nfs_volume_list_open(struct inode *inode, struct file *file);
  984. static void *nfs_volume_list_start(struct seq_file *p, loff_t *pos);
  985. static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos);
  986. static void nfs_volume_list_stop(struct seq_file *p, void *v);
  987. static int nfs_volume_list_show(struct seq_file *m, void *v);
  988. static struct seq_operations nfs_volume_list_ops = {
  989. .start = nfs_volume_list_start,
  990. .next = nfs_volume_list_next,
  991. .stop = nfs_volume_list_stop,
  992. .show = nfs_volume_list_show,
  993. };
  994. static const struct file_operations nfs_volume_list_fops = {
  995. .open = nfs_volume_list_open,
  996. .read = seq_read,
  997. .llseek = seq_lseek,
  998. .release = seq_release,
  999. };
  1000. /*
  1001. * open "/proc/fs/nfsfs/servers" which provides a summary of servers with which
  1002. * we're dealing
  1003. */
  1004. static int nfs_server_list_open(struct inode *inode, struct file *file)
  1005. {
  1006. struct seq_file *m;
  1007. int ret;
  1008. ret = seq_open(file, &nfs_server_list_ops);
  1009. if (ret < 0)
  1010. return ret;
  1011. m = file->private_data;
  1012. m->private = PDE(inode)->data;
  1013. return 0;
  1014. }
  1015. /*
  1016. * set up the iterator to start reading from the server list and return the first item
  1017. */
  1018. static void *nfs_server_list_start(struct seq_file *m, loff_t *_pos)
  1019. {
  1020. struct list_head *_p;
  1021. loff_t pos = *_pos;
  1022. /* lock the list against modification */
  1023. spin_lock(&nfs_client_lock);
  1024. /* allow for the header line */
  1025. if (!pos)
  1026. return SEQ_START_TOKEN;
  1027. pos--;
  1028. /* find the n'th element in the list */
  1029. list_for_each(_p, &nfs_client_list)
  1030. if (!pos--)
  1031. break;
  1032. return _p != &nfs_client_list ? _p : NULL;
  1033. }
  1034. /*
  1035. * move to next server
  1036. */
  1037. static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos)
  1038. {
  1039. struct list_head *_p;
  1040. (*pos)++;
  1041. _p = v;
  1042. _p = (v == SEQ_START_TOKEN) ? nfs_client_list.next : _p->next;
  1043. return _p != &nfs_client_list ? _p : NULL;
  1044. }
  1045. /*
  1046. * clean up after reading from the transports list
  1047. */
  1048. static void nfs_server_list_stop(struct seq_file *p, void *v)
  1049. {
  1050. spin_unlock(&nfs_client_lock);
  1051. }
  1052. /*
  1053. * display a header line followed by a load of call lines
  1054. */
  1055. static int nfs_server_list_show(struct seq_file *m, void *v)
  1056. {
  1057. struct nfs_client *clp;
  1058. /* display header on line 1 */
  1059. if (v == SEQ_START_TOKEN) {
  1060. seq_puts(m, "NV SERVER PORT USE HOSTNAME\n");
  1061. return 0;
  1062. }
  1063. /* display one transport per line on subsequent lines */
  1064. clp = list_entry(v, struct nfs_client, cl_share_link);
  1065. seq_printf(m, "v%d %02x%02x%02x%02x %4hx %3d %s\n",
  1066. clp->cl_nfsversion,
  1067. NIPQUAD(clp->cl_addr.sin_addr),
  1068. ntohs(clp->cl_addr.sin_port),
  1069. atomic_read(&clp->cl_count),
  1070. clp->cl_hostname);
  1071. return 0;
  1072. }
  1073. /*
  1074. * open "/proc/fs/nfsfs/volumes" which provides a summary of extant volumes
  1075. */
  1076. static int nfs_volume_list_open(struct inode *inode, struct file *file)
  1077. {
  1078. struct seq_file *m;
  1079. int ret;
  1080. ret = seq_open(file, &nfs_volume_list_ops);
  1081. if (ret < 0)
  1082. return ret;
  1083. m = file->private_data;
  1084. m->private = PDE(inode)->data;
  1085. return 0;
  1086. }
  1087. /*
  1088. * set up the iterator to start reading from the volume list and return the first item
  1089. */
  1090. static void *nfs_volume_list_start(struct seq_file *m, loff_t *_pos)
  1091. {
  1092. struct list_head *_p;
  1093. loff_t pos = *_pos;
  1094. /* lock the list against modification */
  1095. spin_lock(&nfs_client_lock);
  1096. /* allow for the header line */
  1097. if (!pos)
  1098. return SEQ_START_TOKEN;
  1099. pos--;
  1100. /* find the n'th element in the list */
  1101. list_for_each(_p, &nfs_volume_list)
  1102. if (!pos--)
  1103. break;
  1104. return _p != &nfs_volume_list ? _p : NULL;
  1105. }
  1106. /*
  1107. * move to next volume
  1108. */
  1109. static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos)
  1110. {
  1111. struct list_head *_p;
  1112. (*pos)++;
  1113. _p = v;
  1114. _p = (v == SEQ_START_TOKEN) ? nfs_volume_list.next : _p->next;
  1115. return _p != &nfs_volume_list ? _p : NULL;
  1116. }
  1117. /*
  1118. * clean up after reading from the transports list
  1119. */
  1120. static void nfs_volume_list_stop(struct seq_file *p, void *v)
  1121. {
  1122. spin_unlock(&nfs_client_lock);
  1123. }
  1124. /*
  1125. * display a header line followed by a load of call lines
  1126. */
  1127. static int nfs_volume_list_show(struct seq_file *m, void *v)
  1128. {
  1129. struct nfs_server *server;
  1130. struct nfs_client *clp;
  1131. char dev[8], fsid[17];
  1132. /* display header on line 1 */
  1133. if (v == SEQ_START_TOKEN) {
  1134. seq_puts(m, "NV SERVER PORT DEV FSID\n");
  1135. return 0;
  1136. }
  1137. /* display one transport per line on subsequent lines */
  1138. server = list_entry(v, struct nfs_server, master_link);
  1139. clp = server->nfs_client;
  1140. snprintf(dev, 8, "%u:%u",
  1141. MAJOR(server->s_dev), MINOR(server->s_dev));
  1142. snprintf(fsid, 17, "%llx:%llx",
  1143. (unsigned long long) server->fsid.major,
  1144. (unsigned long long) server->fsid.minor);
  1145. seq_printf(m, "v%d %02x%02x%02x%02x %4hx %-7s %-17s\n",
  1146. clp->cl_nfsversion,
  1147. NIPQUAD(clp->cl_addr.sin_addr),
  1148. ntohs(clp->cl_addr.sin_port),
  1149. dev,
  1150. fsid);
  1151. return 0;
  1152. }
  1153. /*
  1154. * initialise the /proc/fs/nfsfs/ directory
  1155. */
  1156. int __init nfs_fs_proc_init(void)
  1157. {
  1158. struct proc_dir_entry *p;
  1159. proc_fs_nfs = proc_mkdir("nfsfs", proc_root_fs);
  1160. if (!proc_fs_nfs)
  1161. goto error_0;
  1162. proc_fs_nfs->owner = THIS_MODULE;
  1163. /* a file of servers with which we're dealing */
  1164. p = create_proc_entry("servers", S_IFREG|S_IRUGO, proc_fs_nfs);
  1165. if (!p)
  1166. goto error_1;
  1167. p->proc_fops = &nfs_server_list_fops;
  1168. p->owner = THIS_MODULE;
  1169. /* a file of volumes that we have mounted */
  1170. p = create_proc_entry("volumes", S_IFREG|S_IRUGO, proc_fs_nfs);
  1171. if (!p)
  1172. goto error_2;
  1173. p->proc_fops = &nfs_volume_list_fops;
  1174. p->owner = THIS_MODULE;
  1175. return 0;
  1176. error_2:
  1177. remove_proc_entry("servers", proc_fs_nfs);
  1178. error_1:
  1179. remove_proc_entry("nfsfs", proc_root_fs);
  1180. error_0:
  1181. return -ENOMEM;
  1182. }
  1183. /*
  1184. * clean up the /proc/fs/nfsfs/ directory
  1185. */
  1186. void nfs_fs_proc_exit(void)
  1187. {
  1188. remove_proc_entry("volumes", proc_fs_nfs);
  1189. remove_proc_entry("servers", proc_fs_nfs);
  1190. remove_proc_entry("nfsfs", proc_root_fs);
  1191. }
  1192. #endif /* CONFIG_PROC_FS */