nfs4client.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909
  1. /*
  2. * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
  3. * Written by David Howells (dhowells@redhat.com)
  4. */
  5. #include <linux/module.h>
  6. #include <linux/nfs_fs.h>
  7. #include <linux/nfs_idmap.h>
  8. #include <linux/nfs_mount.h>
  9. #include <linux/sunrpc/addr.h>
  10. #include <linux/sunrpc/auth.h>
  11. #include <linux/sunrpc/xprt.h>
  12. #include <linux/sunrpc/bc_xprt.h>
  13. #include "internal.h"
  14. #include "callback.h"
  15. #include "delegation.h"
  16. #include "nfs4session.h"
  17. #include "pnfs.h"
  18. #include "netns.h"
  19. #define NFSDBG_FACILITY NFSDBG_CLIENT
  20. /*
  21. * Get a unique NFSv4.0 callback identifier which will be used
  22. * by the V4.0 callback service to lookup the nfs_client struct
  23. */
  24. static int nfs_get_cb_ident_idr(struct nfs_client *clp, int minorversion)
  25. {
  26. int ret = 0;
  27. struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
  28. if (clp->rpc_ops->version != 4 || minorversion != 0)
  29. return ret;
  30. idr_preload(GFP_KERNEL);
  31. spin_lock(&nn->nfs_client_lock);
  32. ret = idr_alloc(&nn->cb_ident_idr, clp, 0, 0, GFP_NOWAIT);
  33. if (ret >= 0)
  34. clp->cl_cb_ident = ret;
  35. spin_unlock(&nn->nfs_client_lock);
  36. idr_preload_end();
  37. return ret < 0 ? ret : 0;
  38. }
  39. #ifdef CONFIG_NFS_V4_1
  40. static void nfs4_shutdown_session(struct nfs_client *clp)
  41. {
  42. if (nfs4_has_session(clp)) {
  43. nfs4_destroy_session(clp->cl_session);
  44. nfs4_destroy_clientid(clp);
  45. }
  46. }
  47. #else /* CONFIG_NFS_V4_1 */
  48. static void nfs4_shutdown_session(struct nfs_client *clp)
  49. {
  50. }
  51. #endif /* CONFIG_NFS_V4_1 */
  52. struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *cl_init)
  53. {
  54. int err;
  55. struct nfs_client *clp = nfs_alloc_client(cl_init);
  56. if (IS_ERR(clp))
  57. return clp;
  58. err = nfs_get_cb_ident_idr(clp, cl_init->minorversion);
  59. if (err)
  60. goto error;
  61. spin_lock_init(&clp->cl_lock);
  62. INIT_DELAYED_WORK(&clp->cl_renewd, nfs4_renew_state);
  63. rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");
  64. clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED;
  65. clp->cl_minorversion = cl_init->minorversion;
  66. clp->cl_mvops = nfs_v4_minor_ops[cl_init->minorversion];
  67. return clp;
  68. error:
  69. nfs_free_client(clp);
  70. return ERR_PTR(err);
  71. }
  72. /*
  73. * Destroy the NFS4 callback service
  74. */
  75. static void nfs4_destroy_callback(struct nfs_client *clp)
  76. {
  77. if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state))
  78. nfs_callback_down(clp->cl_mvops->minor_version, clp->cl_net);
  79. }
  80. static void nfs4_shutdown_client(struct nfs_client *clp)
  81. {
  82. if (__test_and_clear_bit(NFS_CS_RENEWD, &clp->cl_res_state))
  83. nfs4_kill_renewd(clp);
  84. nfs4_shutdown_session(clp);
  85. nfs4_destroy_callback(clp);
  86. if (__test_and_clear_bit(NFS_CS_IDMAP, &clp->cl_res_state))
  87. nfs_idmap_delete(clp);
  88. rpc_destroy_wait_queue(&clp->cl_rpcwaitq);
  89. kfree(clp->cl_serverowner);
  90. kfree(clp->cl_serverscope);
  91. kfree(clp->cl_implid);
  92. }
  93. void nfs4_free_client(struct nfs_client *clp)
  94. {
  95. nfs4_shutdown_client(clp);
  96. nfs_free_client(clp);
  97. }
  98. /*
  99. * Initialize the NFS4 callback service
  100. */
  101. static int nfs4_init_callback(struct nfs_client *clp)
  102. {
  103. int error;
  104. if (clp->rpc_ops->version == 4) {
  105. struct rpc_xprt *xprt;
  106. xprt = rcu_dereference_raw(clp->cl_rpcclient->cl_xprt);
  107. if (nfs4_has_session(clp)) {
  108. error = xprt_setup_backchannel(xprt,
  109. NFS41_BC_MIN_CALLBACKS);
  110. if (error < 0)
  111. return error;
  112. }
  113. error = nfs_callback_up(clp->cl_mvops->minor_version, xprt);
  114. if (error < 0) {
  115. dprintk("%s: failed to start callback. Error = %d\n",
  116. __func__, error);
  117. return error;
  118. }
  119. __set_bit(NFS_CS_CALLBACK, &clp->cl_res_state);
  120. }
  121. return 0;
  122. }
  123. /*
  124. * Initialize the minor version specific parts of an NFS4 client record
  125. */
  126. static int nfs4_init_client_minor_version(struct nfs_client *clp)
  127. {
  128. #if defined(CONFIG_NFS_V4_1)
  129. if (clp->cl_mvops->minor_version) {
  130. struct nfs4_session *session = NULL;
  131. /*
  132. * Create the session and mark it expired.
  133. * When a SEQUENCE operation encounters the expired session
  134. * it will do session recovery to initialize it.
  135. */
  136. session = nfs4_alloc_session(clp);
  137. if (!session)
  138. return -ENOMEM;
  139. clp->cl_session = session;
  140. /*
  141. * The create session reply races with the server back
  142. * channel probe. Mark the client NFS_CS_SESSION_INITING
  143. * so that the client back channel can find the
  144. * nfs_client struct
  145. */
  146. nfs_mark_client_ready(clp, NFS_CS_SESSION_INITING);
  147. }
  148. #endif /* CONFIG_NFS_V4_1 */
  149. return nfs4_init_callback(clp);
  150. }
  151. /**
  152. * nfs4_init_client - Initialise an NFS4 client record
  153. *
  154. * @clp: nfs_client to initialise
  155. * @timeparms: timeout parameters for underlying RPC transport
  156. * @ip_addr: callback IP address in presentation format
  157. * @authflavor: authentication flavor for underlying RPC transport
  158. *
  159. * Returns pointer to an NFS client, or an ERR_PTR value.
  160. */
  161. struct nfs_client *nfs4_init_client(struct nfs_client *clp,
  162. const struct rpc_timeout *timeparms,
  163. const char *ip_addr,
  164. rpc_authflavor_t authflavour)
  165. {
  166. char buf[INET6_ADDRSTRLEN + 1];
  167. struct nfs_client *old;
  168. int error;
  169. if (clp->cl_cons_state == NFS_CS_READY) {
  170. /* the client is initialised already */
  171. dprintk("<-- nfs4_init_client() = 0 [already %p]\n", clp);
  172. return clp;
  173. }
  174. /* Check NFS protocol revision and initialize RPC op vector */
  175. clp->rpc_ops = &nfs_v4_clientops;
  176. __set_bit(NFS_CS_DISCRTRY, &clp->cl_flags);
  177. error = nfs_create_rpc_client(clp, timeparms, authflavour);
  178. if (error < 0)
  179. goto error;
  180. /* If no clientaddr= option was specified, find a usable cb address */
  181. if (ip_addr == NULL) {
  182. struct sockaddr_storage cb_addr;
  183. struct sockaddr *sap = (struct sockaddr *)&cb_addr;
  184. error = rpc_localaddr(clp->cl_rpcclient, sap, sizeof(cb_addr));
  185. if (error < 0)
  186. goto error;
  187. error = rpc_ntop(sap, buf, sizeof(buf));
  188. if (error < 0)
  189. goto error;
  190. ip_addr = (const char *)buf;
  191. }
  192. strlcpy(clp->cl_ipaddr, ip_addr, sizeof(clp->cl_ipaddr));
  193. error = nfs_idmap_new(clp);
  194. if (error < 0) {
  195. dprintk("%s: failed to create idmapper. Error = %d\n",
  196. __func__, error);
  197. goto error;
  198. }
  199. __set_bit(NFS_CS_IDMAP, &clp->cl_res_state);
  200. error = nfs4_init_client_minor_version(clp);
  201. if (error < 0)
  202. goto error;
  203. if (!nfs4_has_session(clp))
  204. nfs_mark_client_ready(clp, NFS_CS_READY);
  205. error = nfs4_discover_server_trunking(clp, &old);
  206. if (error < 0)
  207. goto error;
  208. nfs_put_client(clp);
  209. if (clp != old) {
  210. clp->cl_preserve_clid = true;
  211. clp = old;
  212. }
  213. return clp;
  214. error:
  215. nfs_mark_client_ready(clp, error);
  216. nfs_put_client(clp);
  217. dprintk("<-- nfs4_init_client() = xerror %d\n", error);
  218. return ERR_PTR(error);
  219. }
  220. /*
  221. * SETCLIENTID just did a callback update with the callback ident in
  222. * "drop," but server trunking discovery claims "drop" and "keep" are
  223. * actually the same server. Swap the callback IDs so that "keep"
  224. * will continue to use the callback ident the server now knows about,
  225. * and so that "keep"'s original callback ident is destroyed when
  226. * "drop" is freed.
  227. */
  228. static void nfs4_swap_callback_idents(struct nfs_client *keep,
  229. struct nfs_client *drop)
  230. {
  231. struct nfs_net *nn = net_generic(keep->cl_net, nfs_net_id);
  232. unsigned int save = keep->cl_cb_ident;
  233. if (keep->cl_cb_ident == drop->cl_cb_ident)
  234. return;
  235. dprintk("%s: keeping callback ident %u and dropping ident %u\n",
  236. __func__, keep->cl_cb_ident, drop->cl_cb_ident);
  237. spin_lock(&nn->nfs_client_lock);
  238. idr_replace(&nn->cb_ident_idr, keep, drop->cl_cb_ident);
  239. keep->cl_cb_ident = drop->cl_cb_ident;
  240. idr_replace(&nn->cb_ident_idr, drop, save);
  241. drop->cl_cb_ident = save;
  242. spin_unlock(&nn->nfs_client_lock);
  243. }
  244. /**
  245. * nfs40_walk_client_list - Find server that recognizes a client ID
  246. *
  247. * @new: nfs_client with client ID to test
  248. * @result: OUT: found nfs_client, or new
  249. * @cred: credential to use for trunking test
  250. *
  251. * Returns zero, a negative errno, or a negative NFS4ERR status.
  252. * If zero is returned, an nfs_client pointer is planted in "result."
  253. *
  254. * NB: nfs40_walk_client_list() relies on the new nfs_client being
  255. * the last nfs_client on the list.
  256. */
  257. int nfs40_walk_client_list(struct nfs_client *new,
  258. struct nfs_client **result,
  259. struct rpc_cred *cred)
  260. {
  261. struct nfs_net *nn = net_generic(new->cl_net, nfs_net_id);
  262. struct nfs_client *pos, *prev = NULL;
  263. struct nfs4_setclientid_res clid = {
  264. .clientid = new->cl_clientid,
  265. .confirm = new->cl_confirm,
  266. };
  267. int status = -NFS4ERR_STALE_CLIENTID;
  268. spin_lock(&nn->nfs_client_lock);
  269. list_for_each_entry(pos, &nn->nfs_client_list, cl_share_link) {
  270. /* If "pos" isn't marked ready, we can't trust the
  271. * remaining fields in "pos" */
  272. if (pos->cl_cons_state > NFS_CS_READY) {
  273. atomic_inc(&pos->cl_count);
  274. spin_unlock(&nn->nfs_client_lock);
  275. if (prev)
  276. nfs_put_client(prev);
  277. prev = pos;
  278. status = nfs_wait_client_init_complete(pos);
  279. spin_lock(&nn->nfs_client_lock);
  280. if (status < 0)
  281. continue;
  282. }
  283. if (pos->cl_cons_state != NFS_CS_READY)
  284. continue;
  285. if (pos->rpc_ops != new->rpc_ops)
  286. continue;
  287. if (pos->cl_proto != new->cl_proto)
  288. continue;
  289. if (pos->cl_minorversion != new->cl_minorversion)
  290. continue;
  291. if (pos->cl_clientid != new->cl_clientid)
  292. continue;
  293. atomic_inc(&pos->cl_count);
  294. spin_unlock(&nn->nfs_client_lock);
  295. if (prev)
  296. nfs_put_client(prev);
  297. prev = pos;
  298. status = nfs4_proc_setclientid_confirm(pos, &clid, cred);
  299. switch (status) {
  300. case -NFS4ERR_STALE_CLIENTID:
  301. break;
  302. case 0:
  303. nfs4_swap_callback_idents(pos, new);
  304. prev = NULL;
  305. *result = pos;
  306. dprintk("NFS: <-- %s using nfs_client = %p ({%d})\n",
  307. __func__, pos, atomic_read(&pos->cl_count));
  308. default:
  309. goto out;
  310. }
  311. spin_lock(&nn->nfs_client_lock);
  312. }
  313. spin_unlock(&nn->nfs_client_lock);
  314. /* No match found. The server lost our clientid */
  315. out:
  316. if (prev)
  317. nfs_put_client(prev);
  318. dprintk("NFS: <-- %s status = %d\n", __func__, status);
  319. return status;
  320. }
  321. #ifdef CONFIG_NFS_V4_1
  322. /*
  323. * Returns true if the client IDs match
  324. */
  325. static bool nfs4_match_clientids(struct nfs_client *a, struct nfs_client *b)
  326. {
  327. if (a->cl_clientid != b->cl_clientid) {
  328. dprintk("NFS: --> %s client ID %llx does not match %llx\n",
  329. __func__, a->cl_clientid, b->cl_clientid);
  330. return false;
  331. }
  332. dprintk("NFS: --> %s client ID %llx matches %llx\n",
  333. __func__, a->cl_clientid, b->cl_clientid);
  334. return true;
  335. }
  336. /*
  337. * Returns true if the server owners match
  338. */
  339. static bool
  340. nfs4_match_serverowners(struct nfs_client *a, struct nfs_client *b)
  341. {
  342. struct nfs41_server_owner *o1 = a->cl_serverowner;
  343. struct nfs41_server_owner *o2 = b->cl_serverowner;
  344. if (o1->minor_id != o2->minor_id) {
  345. dprintk("NFS: --> %s server owner minor IDs do not match\n",
  346. __func__);
  347. return false;
  348. }
  349. if (o1->major_id_sz != o2->major_id_sz)
  350. goto out_major_mismatch;
  351. if (memcmp(o1->major_id, o2->major_id, o1->major_id_sz) != 0)
  352. goto out_major_mismatch;
  353. dprintk("NFS: --> %s server owners match\n", __func__);
  354. return true;
  355. out_major_mismatch:
  356. dprintk("NFS: --> %s server owner major IDs do not match\n",
  357. __func__);
  358. return false;
  359. }
  360. /**
  361. * nfs41_walk_client_list - Find nfs_client that matches a client/server owner
  362. *
  363. * @new: nfs_client with client ID to test
  364. * @result: OUT: found nfs_client, or new
  365. * @cred: credential to use for trunking test
  366. *
  367. * Returns zero, a negative errno, or a negative NFS4ERR status.
  368. * If zero is returned, an nfs_client pointer is planted in "result."
  369. *
  370. * NB: nfs41_walk_client_list() relies on the new nfs_client being
  371. * the last nfs_client on the list.
  372. */
  373. int nfs41_walk_client_list(struct nfs_client *new,
  374. struct nfs_client **result,
  375. struct rpc_cred *cred)
  376. {
  377. struct nfs_net *nn = net_generic(new->cl_net, nfs_net_id);
  378. struct nfs_client *pos, *prev = NULL;
  379. int status = -NFS4ERR_STALE_CLIENTID;
  380. spin_lock(&nn->nfs_client_lock);
  381. list_for_each_entry(pos, &nn->nfs_client_list, cl_share_link) {
  382. /* If "pos" isn't marked ready, we can't trust the
  383. * remaining fields in "pos", especially the client
  384. * ID and serverowner fields. Wait for CREATE_SESSION
  385. * to finish. */
  386. if (pos->cl_cons_state > NFS_CS_READY) {
  387. atomic_inc(&pos->cl_count);
  388. spin_unlock(&nn->nfs_client_lock);
  389. if (prev)
  390. nfs_put_client(prev);
  391. prev = pos;
  392. status = nfs_wait_client_init_complete(pos);
  393. if (status == 0) {
  394. nfs4_schedule_lease_recovery(pos);
  395. status = nfs4_wait_clnt_recover(pos);
  396. }
  397. spin_lock(&nn->nfs_client_lock);
  398. if (status < 0)
  399. continue;
  400. }
  401. if (pos->cl_cons_state != NFS_CS_READY)
  402. continue;
  403. if (pos->rpc_ops != new->rpc_ops)
  404. continue;
  405. if (pos->cl_proto != new->cl_proto)
  406. continue;
  407. if (pos->cl_minorversion != new->cl_minorversion)
  408. continue;
  409. if (!nfs4_match_clientids(pos, new))
  410. continue;
  411. if (!nfs4_match_serverowners(pos, new))
  412. continue;
  413. atomic_inc(&pos->cl_count);
  414. *result = pos;
  415. dprintk("NFS: <-- %s using nfs_client = %p ({%d})\n",
  416. __func__, pos, atomic_read(&pos->cl_count));
  417. break;
  418. }
  419. /* No matching nfs_client found. */
  420. spin_unlock(&nn->nfs_client_lock);
  421. dprintk("NFS: <-- %s status = %d\n", __func__, status);
  422. if (prev)
  423. nfs_put_client(prev);
  424. return status;
  425. }
  426. #endif /* CONFIG_NFS_V4_1 */
  427. static void nfs4_destroy_server(struct nfs_server *server)
  428. {
  429. nfs_server_return_all_delegations(server);
  430. unset_pnfs_layoutdriver(server);
  431. nfs4_purge_state_owners(server);
  432. }
  433. /*
  434. * NFSv4.0 callback thread helper
  435. *
  436. * Find a client by callback identifier
  437. */
  438. struct nfs_client *
  439. nfs4_find_client_ident(struct net *net, int cb_ident)
  440. {
  441. struct nfs_client *clp;
  442. struct nfs_net *nn = net_generic(net, nfs_net_id);
  443. spin_lock(&nn->nfs_client_lock);
  444. clp = idr_find(&nn->cb_ident_idr, cb_ident);
  445. if (clp)
  446. atomic_inc(&clp->cl_count);
  447. spin_unlock(&nn->nfs_client_lock);
  448. return clp;
  449. }
  450. #if defined(CONFIG_NFS_V4_1)
  451. /* Common match routine for v4.0 and v4.1 callback services */
  452. static bool nfs4_cb_match_client(const struct sockaddr *addr,
  453. struct nfs_client *clp, u32 minorversion)
  454. {
  455. struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;
  456. /* Don't match clients that failed to initialise */
  457. if (!(clp->cl_cons_state == NFS_CS_READY ||
  458. clp->cl_cons_state == NFS_CS_SESSION_INITING))
  459. return false;
  460. smp_rmb();
  461. /* Match the version and minorversion */
  462. if (clp->rpc_ops->version != 4 ||
  463. clp->cl_minorversion != minorversion)
  464. return false;
  465. /* Match only the IP address, not the port number */
  466. if (!nfs_sockaddr_match_ipaddr(addr, clap))
  467. return false;
  468. return true;
  469. }
  470. /*
  471. * NFSv4.1 callback thread helper
  472. * For CB_COMPOUND calls, find a client by IP address, protocol version,
  473. * minorversion, and sessionID
  474. *
  475. * Returns NULL if no such client
  476. */
  477. struct nfs_client *
  478. nfs4_find_client_sessionid(struct net *net, const struct sockaddr *addr,
  479. struct nfs4_sessionid *sid)
  480. {
  481. struct nfs_client *clp;
  482. struct nfs_net *nn = net_generic(net, nfs_net_id);
  483. spin_lock(&nn->nfs_client_lock);
  484. list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) {
  485. if (nfs4_cb_match_client(addr, clp, 1) == false)
  486. continue;
  487. if (!nfs4_has_session(clp))
  488. continue;
  489. /* Match sessionid*/
  490. if (memcmp(clp->cl_session->sess_id.data,
  491. sid->data, NFS4_MAX_SESSIONID_LEN) != 0)
  492. continue;
  493. atomic_inc(&clp->cl_count);
  494. spin_unlock(&nn->nfs_client_lock);
  495. return clp;
  496. }
  497. spin_unlock(&nn->nfs_client_lock);
  498. return NULL;
  499. }
  500. #else /* CONFIG_NFS_V4_1 */
  501. struct nfs_client *
  502. nfs4_find_client_sessionid(struct net *net, const struct sockaddr *addr,
  503. struct nfs4_sessionid *sid)
  504. {
  505. return NULL;
  506. }
  507. #endif /* CONFIG_NFS_V4_1 */
  508. /*
  509. * Set up an NFS4 client
  510. */
  511. static int nfs4_set_client(struct nfs_server *server,
  512. const char *hostname,
  513. const struct sockaddr *addr,
  514. const size_t addrlen,
  515. const char *ip_addr,
  516. rpc_authflavor_t authflavour,
  517. int proto, const struct rpc_timeout *timeparms,
  518. u32 minorversion, struct net *net)
  519. {
  520. struct nfs_client_initdata cl_init = {
  521. .hostname = hostname,
  522. .addr = addr,
  523. .addrlen = addrlen,
  524. .nfs_mod = &nfs_v4,
  525. .proto = proto,
  526. .minorversion = minorversion,
  527. .net = net,
  528. };
  529. struct nfs_client *clp;
  530. int error;
  531. dprintk("--> nfs4_set_client()\n");
  532. if (server->flags & NFS_MOUNT_NORESVPORT)
  533. set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
  534. /* Allocate or find a client reference we can use */
  535. clp = nfs_get_client(&cl_init, timeparms, ip_addr, authflavour);
  536. if (IS_ERR(clp)) {
  537. error = PTR_ERR(clp);
  538. goto error;
  539. }
  540. /*
  541. * Query for the lease time on clientid setup or renewal
  542. *
  543. * Note that this will be set on nfs_clients that were created
  544. * only for the DS role and did not set this bit, but now will
  545. * serve a dual role.
  546. */
  547. set_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state);
  548. server->nfs_client = clp;
  549. dprintk("<-- nfs4_set_client() = 0 [new %p]\n", clp);
  550. return 0;
  551. error:
  552. dprintk("<-- nfs4_set_client() = xerror %d\n", error);
  553. return error;
  554. }
  555. /*
  556. * Set up a pNFS Data Server client.
  557. *
  558. * Return any existing nfs_client that matches server address,port,version
  559. * and minorversion.
  560. *
  561. * For a new nfs_client, use a soft mount (default), a low retrans and a
  562. * low timeout interval so that if a connection is lost, we retry through
  563. * the MDS.
  564. */
  565. struct nfs_client *nfs4_set_ds_client(struct nfs_client* mds_clp,
  566. const struct sockaddr *ds_addr, int ds_addrlen,
  567. int ds_proto, unsigned int ds_timeo, unsigned int ds_retrans)
  568. {
  569. struct nfs_client_initdata cl_init = {
  570. .addr = ds_addr,
  571. .addrlen = ds_addrlen,
  572. .nfs_mod = &nfs_v4,
  573. .proto = ds_proto,
  574. .minorversion = mds_clp->cl_minorversion,
  575. .net = mds_clp->cl_net,
  576. };
  577. struct rpc_timeout ds_timeout;
  578. struct nfs_client *clp;
  579. /*
  580. * Set an authflavor equual to the MDS value. Use the MDS nfs_client
  581. * cl_ipaddr so as to use the same EXCHANGE_ID co_ownerid as the MDS
  582. * (section 13.1 RFC 5661).
  583. */
  584. nfs_init_timeout_values(&ds_timeout, ds_proto, ds_timeo, ds_retrans);
  585. clp = nfs_get_client(&cl_init, &ds_timeout, mds_clp->cl_ipaddr,
  586. mds_clp->cl_rpcclient->cl_auth->au_flavor);
  587. dprintk("<-- %s %p\n", __func__, clp);
  588. return clp;
  589. }
  590. EXPORT_SYMBOL_GPL(nfs4_set_ds_client);
  591. /*
  592. * Session has been established, and the client marked ready.
  593. * Set the mount rsize and wsize with negotiated fore channel
  594. * attributes which will be bound checked in nfs_server_set_fsinfo.
  595. */
  596. static void nfs4_session_set_rwsize(struct nfs_server *server)
  597. {
  598. #ifdef CONFIG_NFS_V4_1
  599. struct nfs4_session *sess;
  600. u32 server_resp_sz;
  601. u32 server_rqst_sz;
  602. if (!nfs4_has_session(server->nfs_client))
  603. return;
  604. sess = server->nfs_client->cl_session;
  605. server_resp_sz = sess->fc_attrs.max_resp_sz - nfs41_maxread_overhead;
  606. server_rqst_sz = sess->fc_attrs.max_rqst_sz - nfs41_maxwrite_overhead;
  607. if (server->rsize > server_resp_sz)
  608. server->rsize = server_resp_sz;
  609. if (server->wsize > server_rqst_sz)
  610. server->wsize = server_rqst_sz;
  611. #endif /* CONFIG_NFS_V4_1 */
  612. }
  613. static int nfs4_server_common_setup(struct nfs_server *server,
  614. struct nfs_fh *mntfh)
  615. {
  616. struct nfs_fattr *fattr;
  617. int error;
  618. /* data servers support only a subset of NFSv4.1 */
  619. if (is_ds_only_client(server->nfs_client))
  620. return -EPROTONOSUPPORT;
  621. fattr = nfs_alloc_fattr();
  622. if (fattr == NULL)
  623. return -ENOMEM;
  624. /* We must ensure the session is initialised first */
  625. error = nfs4_init_session(server);
  626. if (error < 0)
  627. goto out;
  628. /* Probe the root fh to retrieve its FSID and filehandle */
  629. error = nfs4_get_rootfh(server, mntfh);
  630. if (error < 0)
  631. goto out;
  632. dprintk("Server FSID: %llx:%llx\n",
  633. (unsigned long long) server->fsid.major,
  634. (unsigned long long) server->fsid.minor);
  635. dprintk("Mount FH: %d\n", mntfh->size);
  636. nfs4_session_set_rwsize(server);
  637. error = nfs_probe_fsinfo(server, mntfh, fattr);
  638. if (error < 0)
  639. goto out;
  640. if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
  641. server->namelen = NFS4_MAXNAMLEN;
  642. nfs_server_insert_lists(server);
  643. server->mount_time = jiffies;
  644. server->destroy = nfs4_destroy_server;
  645. out:
  646. nfs_free_fattr(fattr);
  647. return error;
  648. }
  649. /*
  650. * Create a version 4 volume record
  651. */
  652. static int nfs4_init_server(struct nfs_server *server,
  653. const struct nfs_parsed_mount_data *data)
  654. {
  655. struct rpc_timeout timeparms;
  656. int error;
  657. dprintk("--> nfs4_init_server()\n");
  658. nfs_init_timeout_values(&timeparms, data->nfs_server.protocol,
  659. data->timeo, data->retrans);
  660. /* Initialise the client representation from the mount data */
  661. server->flags = data->flags;
  662. server->caps |= NFS_CAP_ATOMIC_OPEN|NFS_CAP_CHANGE_ATTR|NFS_CAP_POSIX_LOCK;
  663. if (!(data->flags & NFS_MOUNT_NORDIRPLUS))
  664. server->caps |= NFS_CAP_READDIRPLUS;
  665. server->options = data->options;
  666. /* Get a client record */
  667. error = nfs4_set_client(server,
  668. data->nfs_server.hostname,
  669. (const struct sockaddr *)&data->nfs_server.address,
  670. data->nfs_server.addrlen,
  671. data->client_address,
  672. data->auth_flavors[0],
  673. data->nfs_server.protocol,
  674. &timeparms,
  675. data->minorversion,
  676. data->net);
  677. if (error < 0)
  678. goto error;
  679. /*
  680. * Don't use NFS uid/gid mapping if we're using AUTH_SYS or lower
  681. * authentication.
  682. */
  683. if (nfs4_disable_idmapping && data->auth_flavors[0] == RPC_AUTH_UNIX)
  684. server->caps |= NFS_CAP_UIDGID_NOMAP;
  685. if (data->rsize)
  686. server->rsize = nfs_block_size(data->rsize, NULL);
  687. if (data->wsize)
  688. server->wsize = nfs_block_size(data->wsize, NULL);
  689. server->acregmin = data->acregmin * HZ;
  690. server->acregmax = data->acregmax * HZ;
  691. server->acdirmin = data->acdirmin * HZ;
  692. server->acdirmax = data->acdirmax * HZ;
  693. server->port = data->nfs_server.port;
  694. error = nfs_init_server_rpcclient(server, &timeparms, data->auth_flavors[0]);
  695. error:
  696. /* Done */
  697. dprintk("<-- nfs4_init_server() = %d\n", error);
  698. return error;
  699. }
  700. /*
  701. * Create a version 4 volume record
  702. * - keyed on server and FSID
  703. */
  704. /*struct nfs_server *nfs4_create_server(const struct nfs_parsed_mount_data *data,
  705. struct nfs_fh *mntfh)*/
  706. struct nfs_server *nfs4_create_server(struct nfs_mount_info *mount_info,
  707. struct nfs_subversion *nfs_mod)
  708. {
  709. struct nfs_server *server;
  710. int error;
  711. dprintk("--> nfs4_create_server()\n");
  712. server = nfs_alloc_server();
  713. if (!server)
  714. return ERR_PTR(-ENOMEM);
  715. /* set up the general RPC client */
  716. error = nfs4_init_server(server, mount_info->parsed);
  717. if (error < 0)
  718. goto error;
  719. error = nfs4_server_common_setup(server, mount_info->mntfh);
  720. if (error < 0)
  721. goto error;
  722. dprintk("<-- nfs4_create_server() = %p\n", server);
  723. return server;
  724. error:
  725. nfs_free_server(server);
  726. dprintk("<-- nfs4_create_server() = error %d\n", error);
  727. return ERR_PTR(error);
  728. }
  729. /*
  730. * Create an NFS4 referral server record
  731. */
  732. struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
  733. struct nfs_fh *mntfh)
  734. {
  735. struct nfs_client *parent_client;
  736. struct nfs_server *server, *parent_server;
  737. int error;
  738. dprintk("--> nfs4_create_referral_server()\n");
  739. server = nfs_alloc_server();
  740. if (!server)
  741. return ERR_PTR(-ENOMEM);
  742. parent_server = NFS_SB(data->sb);
  743. parent_client = parent_server->nfs_client;
  744. /* Initialise the client representation from the parent server */
  745. nfs_server_copy_userdata(server, parent_server);
  746. server->caps |= NFS_CAP_ATOMIC_OPEN|NFS_CAP_CHANGE_ATTR;
  747. /* Get a client representation.
  748. * Note: NFSv4 always uses TCP, */
  749. error = nfs4_set_client(server, data->hostname,
  750. data->addr,
  751. data->addrlen,
  752. parent_client->cl_ipaddr,
  753. data->authflavor,
  754. rpc_protocol(parent_server->client),
  755. parent_server->client->cl_timeout,
  756. parent_client->cl_mvops->minor_version,
  757. parent_client->cl_net);
  758. if (error < 0)
  759. goto error;
  760. error = nfs_init_server_rpcclient(server, parent_server->client->cl_timeout, data->authflavor);
  761. if (error < 0)
  762. goto error;
  763. error = nfs4_server_common_setup(server, mntfh);
  764. if (error < 0)
  765. goto error;
  766. dprintk("<-- nfs_create_referral_server() = %p\n", server);
  767. return server;
  768. error:
  769. nfs_free_server(server);
  770. dprintk("<-- nfs4_create_referral_server() = error %d\n", error);
  771. return ERR_PTR(error);
  772. }