PageRenderTime 43ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 1ms

/fs/nfs/client.c

https://bitbucket.org/codefirex/kernel_lge_kamakogeebang
C | 2077 lines | 1446 code | 334 blank | 297 comment | 223 complexity | 21d5420cd199ab08dc6374caadf99aa4 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0

Large files files are truncated, but you can click here to view the full file

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

Large files files are truncated, but you can click here to view the full file