nfs4client.c revision 7e134205
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
5 */
6#include <linux/module.h>
7#include <linux/nfs_fs.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 <linux/sunrpc/rpc_pipe_fs.h>
14#include "internal.h"
15#include "callback.h"
16#include "delegation.h"
17#include "nfs4session.h"
18#include "nfs4idmap.h"
19#include "pnfs.h"
20#include "netns.h"
21
22#define NFSDBG_FACILITY		NFSDBG_CLIENT
23
24/*
25 * Get a unique NFSv4.0 callback identifier which will be used
26 * by the V4.0 callback service to lookup the nfs_client struct
27 */
28static int nfs_get_cb_ident_idr(struct nfs_client *clp, int minorversion)
29{
30	int ret = 0;
31	struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
32
33	if (clp->rpc_ops->version != 4 || minorversion != 0)
34		return ret;
35	idr_preload(GFP_KERNEL);
36	spin_lock(&nn->nfs_client_lock);
37	ret = idr_alloc(&nn->cb_ident_idr, clp, 1, 0, GFP_NOWAIT);
38	if (ret >= 0)
39		clp->cl_cb_ident = ret;
40	spin_unlock(&nn->nfs_client_lock);
41	idr_preload_end();
42	return ret < 0 ? ret : 0;
43}
44
45#ifdef CONFIG_NFS_V4_1
46/*
47 * Per auth flavor data server rpc clients
48 */
49struct nfs4_ds_server {
50	struct list_head	list;   /* ds_clp->cl_ds_clients */
51	struct rpc_clnt		*rpc_clnt;
52};
53
54/**
55 * nfs4_find_ds_client - Common lookup case for DS I/O
56 * @ds_clp: pointer to the DS's nfs_client
57 * @flavor: rpc auth flavour to match
58 */
59static struct nfs4_ds_server *
60nfs4_find_ds_client(struct nfs_client *ds_clp, rpc_authflavor_t flavor)
61{
62	struct nfs4_ds_server *dss;
63
64	rcu_read_lock();
65	list_for_each_entry_rcu(dss, &ds_clp->cl_ds_clients, list) {
66		if (dss->rpc_clnt->cl_auth->au_flavor != flavor)
67			continue;
68		goto out;
69	}
70	dss = NULL;
71out:
72	rcu_read_unlock();
73	return dss;
74}
75
76static struct nfs4_ds_server *
77nfs4_add_ds_client(struct nfs_client *ds_clp, rpc_authflavor_t flavor,
78			   struct nfs4_ds_server *new)
79{
80	struct nfs4_ds_server *dss;
81
82	spin_lock(&ds_clp->cl_lock);
83	list_for_each_entry(dss, &ds_clp->cl_ds_clients, list) {
84		if (dss->rpc_clnt->cl_auth->au_flavor != flavor)
85			continue;
86		goto out;
87	}
88	if (new)
89		list_add_rcu(&new->list, &ds_clp->cl_ds_clients);
90	dss = new;
91out:
92	spin_unlock(&ds_clp->cl_lock); /* need some lock to protect list */
93	return dss;
94}
95
96static struct nfs4_ds_server *
97nfs4_alloc_ds_server(struct nfs_client *ds_clp, rpc_authflavor_t flavor)
98{
99	struct nfs4_ds_server *dss;
100
101	dss = kmalloc(sizeof(*dss), GFP_NOFS);
102	if (dss == NULL)
103		return ERR_PTR(-ENOMEM);
104
105	dss->rpc_clnt = rpc_clone_client_set_auth(ds_clp->cl_rpcclient, flavor);
106	if (IS_ERR(dss->rpc_clnt)) {
107		int err = PTR_ERR(dss->rpc_clnt);
108		kfree (dss);
109		return ERR_PTR(err);
110	}
111	INIT_LIST_HEAD(&dss->list);
112
113	return dss;
114}
115
116static void
117nfs4_free_ds_server(struct nfs4_ds_server *dss)
118{
119	rpc_release_client(dss->rpc_clnt);
120	kfree(dss);
121}
122
123/**
124 * nfs4_find_or_create_ds_client - Find or create a DS rpc client
125 * @ds_clp: pointer to the DS's nfs_client
126 * @inode: pointer to the inode
127 *
128 * Find or create a DS rpc client with th MDS server rpc client auth flavor
129 * in the nfs_client cl_ds_clients list.
130 */
131struct rpc_clnt *
132nfs4_find_or_create_ds_client(struct nfs_client *ds_clp, struct inode *inode)
133{
134	struct nfs4_ds_server *dss, *new;
135	rpc_authflavor_t flavor = NFS_SERVER(inode)->client->cl_auth->au_flavor;
136
137	dss = nfs4_find_ds_client(ds_clp, flavor);
138	if (dss != NULL)
139		goto out;
140	new = nfs4_alloc_ds_server(ds_clp, flavor);
141	if (IS_ERR(new))
142		return ERR_CAST(new);
143	dss = nfs4_add_ds_client(ds_clp, flavor, new);
144	if (dss != new)
145		nfs4_free_ds_server(new);
146out:
147	return dss->rpc_clnt;
148}
149EXPORT_SYMBOL_GPL(nfs4_find_or_create_ds_client);
150
151static void
152nfs4_shutdown_ds_clients(struct nfs_client *clp)
153{
154	struct nfs4_ds_server *dss;
155
156	while (!list_empty(&clp->cl_ds_clients)) {
157		dss = list_entry(clp->cl_ds_clients.next,
158					struct nfs4_ds_server, list);
159		list_del(&dss->list);
160		rpc_shutdown_client(dss->rpc_clnt);
161		kfree (dss);
162	}
163}
164
165static void
166nfs4_cleanup_callback(struct nfs_client *clp)
167{
168	struct nfs4_copy_state *cp_state;
169
170	while (!list_empty(&clp->pending_cb_stateids)) {
171		cp_state = list_entry(clp->pending_cb_stateids.next,
172					struct nfs4_copy_state, copies);
173		list_del(&cp_state->copies);
174		kfree(cp_state);
175	}
176}
177
178void nfs41_shutdown_client(struct nfs_client *clp)
179{
180	if (nfs4_has_session(clp)) {
181		nfs4_cleanup_callback(clp);
182		nfs4_shutdown_ds_clients(clp);
183		nfs4_destroy_session(clp->cl_session);
184		nfs4_destroy_clientid(clp);
185	}
186
187}
188#endif	/* CONFIG_NFS_V4_1 */
189
190void nfs40_shutdown_client(struct nfs_client *clp)
191{
192	if (clp->cl_slot_tbl) {
193		nfs4_shutdown_slot_table(clp->cl_slot_tbl);
194		kfree(clp->cl_slot_tbl);
195	}
196}
197
198struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *cl_init)
199{
200	char buf[INET6_ADDRSTRLEN + 1];
201	const char *ip_addr = cl_init->ip_addr;
202	struct nfs_client *clp = nfs_alloc_client(cl_init);
203	int err;
204
205	if (IS_ERR(clp))
206		return clp;
207
208	err = nfs_get_cb_ident_idr(clp, cl_init->minorversion);
209	if (err)
210		goto error;
211
212	if (cl_init->minorversion > NFS4_MAX_MINOR_VERSION) {
213		err = -EINVAL;
214		goto error;
215	}
216
217	spin_lock_init(&clp->cl_lock);
218	INIT_DELAYED_WORK(&clp->cl_renewd, nfs4_renew_state);
219	INIT_LIST_HEAD(&clp->cl_ds_clients);
220	rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");
221	clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED;
222	clp->cl_mvops = nfs_v4_minor_ops[cl_init->minorversion];
223	clp->cl_mig_gen = 1;
224#if IS_ENABLED(CONFIG_NFS_V4_1)
225	init_waitqueue_head(&clp->cl_lock_waitq);
226#endif
227	INIT_LIST_HEAD(&clp->pending_cb_stateids);
228
229	if (cl_init->minorversion != 0)
230		__set_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags);
231	__set_bit(NFS_CS_DISCRTRY, &clp->cl_flags);
232	__set_bit(NFS_CS_NO_RETRANS_TIMEOUT, &clp->cl_flags);
233
234	/*
235	 * Set up the connection to the server before we add add to the
236	 * global list.
237	 */
238	err = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_GSS_KRB5I);
239	if (err == -EINVAL)
240		err = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_UNIX);
241	if (err < 0)
242		goto error;
243
244	/* If no clientaddr= option was specified, find a usable cb address */
245	if (ip_addr == NULL) {
246		struct sockaddr_storage cb_addr;
247		struct sockaddr *sap = (struct sockaddr *)&cb_addr;
248
249		err = rpc_localaddr(clp->cl_rpcclient, sap, sizeof(cb_addr));
250		if (err < 0)
251			goto error;
252		err = rpc_ntop(sap, buf, sizeof(buf));
253		if (err < 0)
254			goto error;
255		ip_addr = (const char *)buf;
256	}
257	strlcpy(clp->cl_ipaddr, ip_addr, sizeof(clp->cl_ipaddr));
258
259	err = nfs_idmap_new(clp);
260	if (err < 0) {
261		dprintk("%s: failed to create idmapper. Error = %d\n",
262			__func__, err);
263		goto error;
264	}
265	__set_bit(NFS_CS_IDMAP, &clp->cl_res_state);
266	return clp;
267
268error:
269	nfs_free_client(clp);
270	return ERR_PTR(err);
271}
272
273/*
274 * Destroy the NFS4 callback service
275 */
276static void nfs4_destroy_callback(struct nfs_client *clp)
277{
278	if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state))
279		nfs_callback_down(clp->cl_mvops->minor_version, clp->cl_net);
280}
281
282static void nfs4_shutdown_client(struct nfs_client *clp)
283{
284	if (__test_and_clear_bit(NFS_CS_RENEWD, &clp->cl_res_state))
285		nfs4_kill_renewd(clp);
286	clp->cl_mvops->shutdown_client(clp);
287	nfs4_destroy_callback(clp);
288	if (__test_and_clear_bit(NFS_CS_IDMAP, &clp->cl_res_state))
289		nfs_idmap_delete(clp);
290
291	rpc_destroy_wait_queue(&clp->cl_rpcwaitq);
292	kfree(clp->cl_serverowner);
293	kfree(clp->cl_serverscope);
294	kfree(clp->cl_implid);
295	kfree(clp->cl_owner_id);
296}
297
298void nfs4_free_client(struct nfs_client *clp)
299{
300	nfs4_shutdown_client(clp);
301	nfs_free_client(clp);
302}
303
304/*
305 * Initialize the NFS4 callback service
306 */
307static int nfs4_init_callback(struct nfs_client *clp)
308{
309	struct rpc_xprt *xprt;
310	int error;
311
312	xprt = rcu_dereference_raw(clp->cl_rpcclient->cl_xprt);
313
314	if (nfs4_has_session(clp)) {
315		error = xprt_setup_backchannel(xprt, NFS41_BC_MIN_CALLBACKS);
316		if (error < 0)
317			return error;
318	}
319
320	error = nfs_callback_up(clp->cl_mvops->minor_version, xprt);
321	if (error < 0) {
322		dprintk("%s: failed to start callback. Error = %d\n",
323			__func__, error);
324		return error;
325	}
326	__set_bit(NFS_CS_CALLBACK, &clp->cl_res_state);
327
328	return 0;
329}
330
331/**
332 * nfs40_init_client - nfs_client initialization tasks for NFSv4.0
333 * @clp: nfs_client to initialize
334 *
335 * Returns zero on success, or a negative errno if some error occurred.
336 */
337int nfs40_init_client(struct nfs_client *clp)
338{
339	struct nfs4_slot_table *tbl;
340	int ret;
341
342	tbl = kzalloc(sizeof(*tbl), GFP_NOFS);
343	if (tbl == NULL)
344		return -ENOMEM;
345
346	ret = nfs4_setup_slot_table(tbl, NFS4_MAX_SLOT_TABLE,
347					"NFSv4.0 transport Slot table");
348	if (ret) {
349		kfree(tbl);
350		return ret;
351	}
352
353	clp->cl_slot_tbl = tbl;
354	return 0;
355}
356
357#if defined(CONFIG_NFS_V4_1)
358
359/**
360 * nfs41_init_client - nfs_client initialization tasks for NFSv4.1+
361 * @clp: nfs_client to initialize
362 *
363 * Returns zero on success, or a negative errno if some error occurred.
364 */
365int nfs41_init_client(struct nfs_client *clp)
366{
367	struct nfs4_session *session = NULL;
368
369	/*
370	 * Create the session and mark it expired.
371	 * When a SEQUENCE operation encounters the expired session
372	 * it will do session recovery to initialize it.
373	 */
374	session = nfs4_alloc_session(clp);
375	if (!session)
376		return -ENOMEM;
377
378	clp->cl_session = session;
379
380	/*
381	 * The create session reply races with the server back
382	 * channel probe. Mark the client NFS_CS_SESSION_INITING
383	 * so that the client back channel can find the
384	 * nfs_client struct
385	 */
386	nfs_mark_client_ready(clp, NFS_CS_SESSION_INITING);
387	return 0;
388}
389
390#endif	/* CONFIG_NFS_V4_1 */
391
392/*
393 * Initialize the minor version specific parts of an NFS4 client record
394 */
395static int nfs4_init_client_minor_version(struct nfs_client *clp)
396{
397	int ret;
398
399	ret = clp->cl_mvops->init_client(clp);
400	if (ret)
401		return ret;
402	return nfs4_init_callback(clp);
403}
404
405/**
406 * nfs4_init_client - Initialise an NFS4 client record
407 *
408 * @clp: nfs_client to initialise
409 * @cl_init: pointer to nfs_client_initdata
410 *
411 * Returns pointer to an NFS client, or an ERR_PTR value.
412 */
413struct nfs_client *nfs4_init_client(struct nfs_client *clp,
414				    const struct nfs_client_initdata *cl_init)
415{
416	struct nfs_client *old;
417	int error;
418
419	if (clp->cl_cons_state == NFS_CS_READY)
420		/* the client is initialised already */
421		return clp;
422
423	error = nfs4_init_client_minor_version(clp);
424	if (error < 0)
425		goto error;
426
427	error = nfs4_discover_server_trunking(clp, &old);
428	if (error < 0)
429		goto error;
430
431	if (clp != old) {
432		clp->cl_preserve_clid = true;
433		/*
434		 * Mark the client as having failed initialization so other
435		 * processes walking the nfs_client_list in nfs_match_client()
436		 * won't try to use it.
437		 */
438		nfs_mark_client_ready(clp, -EPERM);
439	}
440	clear_bit(NFS_CS_TSM_POSSIBLE, &clp->cl_flags);
441	nfs_put_client(clp);
442	return old;
443
444error:
445	nfs_mark_client_ready(clp, error);
446	nfs_put_client(clp);
447	return ERR_PTR(error);
448}
449
450/*
451 * SETCLIENTID just did a callback update with the callback ident in
452 * "drop," but server trunking discovery claims "drop" and "keep" are
453 * actually the same server.  Swap the callback IDs so that "keep"
454 * will continue to use the callback ident the server now knows about,
455 * and so that "keep"'s original callback ident is destroyed when
456 * "drop" is freed.
457 */
458static void nfs4_swap_callback_idents(struct nfs_client *keep,
459				      struct nfs_client *drop)
460{
461	struct nfs_net *nn = net_generic(keep->cl_net, nfs_net_id);
462	unsigned int save = keep->cl_cb_ident;
463
464	if (keep->cl_cb_ident == drop->cl_cb_ident)
465		return;
466
467	dprintk("%s: keeping callback ident %u and dropping ident %u\n",
468		__func__, keep->cl_cb_ident, drop->cl_cb_ident);
469
470	spin_lock(&nn->nfs_client_lock);
471
472	idr_replace(&nn->cb_ident_idr, keep, drop->cl_cb_ident);
473	keep->cl_cb_ident = drop->cl_cb_ident;
474
475	idr_replace(&nn->cb_ident_idr, drop, save);
476	drop->cl_cb_ident = save;
477
478	spin_unlock(&nn->nfs_client_lock);
479}
480
481static bool nfs4_match_client_owner_id(const struct nfs_client *clp1,
482		const struct nfs_client *clp2)
483{
484	if (clp1->cl_owner_id == NULL || clp2->cl_owner_id == NULL)
485		return true;
486	return strcmp(clp1->cl_owner_id, clp2->cl_owner_id) == 0;
487}
488
489static bool nfs4_same_verifier(nfs4_verifier *v1, nfs4_verifier *v2)
490{
491	return memcmp(v1->data, v2->data, sizeof(v1->data)) == 0;
492}
493
494static int nfs4_match_client(struct nfs_client  *pos,  struct nfs_client *new,
495			     struct nfs_client **prev, struct nfs_net *nn)
496{
497	int status;
498
499	if (pos->rpc_ops != new->rpc_ops)
500		return 1;
501
502	if (pos->cl_minorversion != new->cl_minorversion)
503		return 1;
504
505	/* If "pos" isn't marked ready, we can't trust the
506	 * remaining fields in "pos", especially the client
507	 * ID and serverowner fields.  Wait for CREATE_SESSION
508	 * to finish. */
509	if (pos->cl_cons_state > NFS_CS_READY) {
510		refcount_inc(&pos->cl_count);
511		spin_unlock(&nn->nfs_client_lock);
512
513		nfs_put_client(*prev);
514		*prev = pos;
515
516		status = nfs_wait_client_init_complete(pos);
517		spin_lock(&nn->nfs_client_lock);
518
519		if (status < 0)
520			return status;
521	}
522
523	if (pos->cl_cons_state != NFS_CS_READY)
524		return 1;
525
526	if (pos->cl_clientid != new->cl_clientid)
527		return 1;
528
529	/* NFSv4.1 always uses the uniform string, however someone
530	 * might switch the uniquifier string on us.
531	 */
532	if (!nfs4_match_client_owner_id(pos, new))
533		return 1;
534
535	return 0;
536}
537
538/**
539 * nfs40_walk_client_list - Find server that recognizes a client ID
540 *
541 * @new: nfs_client with client ID to test
542 * @result: OUT: found nfs_client, or new
543 * @cred: credential to use for trunking test
544 *
545 * Returns zero, a negative errno, or a negative NFS4ERR status.
546 * If zero is returned, an nfs_client pointer is planted in "result."
547 *
548 * NB: nfs40_walk_client_list() relies on the new nfs_client being
549 *     the last nfs_client on the list.
550 */
551int nfs40_walk_client_list(struct nfs_client *new,
552			   struct nfs_client **result,
553			   const struct cred *cred)
554{
555	struct nfs_net *nn = net_generic(new->cl_net, nfs_net_id);
556	struct nfs_client *pos, *prev = NULL;
557	struct nfs4_setclientid_res clid = {
558		.clientid	= new->cl_clientid,
559		.confirm	= new->cl_confirm,
560	};
561	int status = -NFS4ERR_STALE_CLIENTID;
562
563	spin_lock(&nn->nfs_client_lock);
564	list_for_each_entry(pos, &nn->nfs_client_list, cl_share_link) {
565
566		if (pos == new)
567			goto found;
568
569		status = nfs4_match_client(pos, new, &prev, nn);
570		if (status < 0)
571			goto out_unlock;
572		if (status != 0)
573			continue;
574		/*
575		 * We just sent a new SETCLIENTID, which should have
576		 * caused the server to return a new cl_confirm.  So if
577		 * cl_confirm is the same, then this is a different
578		 * server that just returned the same cl_confirm by
579		 * coincidence:
580		 */
581		if ((new != pos) && nfs4_same_verifier(&pos->cl_confirm,
582						       &new->cl_confirm))
583			continue;
584		/*
585		 * But if the cl_confirm's are different, then the only
586		 * way that a SETCLIENTID_CONFIRM to pos can succeed is
587		 * if new and pos point to the same server:
588		 */
589found:
590		refcount_inc(&pos->cl_count);
591		spin_unlock(&nn->nfs_client_lock);
592
593		nfs_put_client(prev);
594		prev = pos;
595
596		status = nfs4_proc_setclientid_confirm(pos, &clid, cred);
597		switch (status) {
598		case -NFS4ERR_STALE_CLIENTID:
599			break;
600		case 0:
601			nfs4_swap_callback_idents(pos, new);
602			pos->cl_confirm = new->cl_confirm;
603			nfs_mark_client_ready(pos, NFS_CS_READY);
604
605			prev = NULL;
606			*result = pos;
607			goto out;
608		case -ERESTARTSYS:
609		case -ETIMEDOUT:
610			/* The callback path may have been inadvertently
611			 * changed. Schedule recovery!
612			 */
613			nfs4_schedule_path_down_recovery(pos);
614			goto out;
615		default:
616			goto out;
617		}
618
619		spin_lock(&nn->nfs_client_lock);
620	}
621out_unlock:
622	spin_unlock(&nn->nfs_client_lock);
623
624	/* No match found. The server lost our clientid */
625out:
626	nfs_put_client(prev);
627	return status;
628}
629
630#ifdef CONFIG_NFS_V4_1
631/*
632 * Returns true if the server major ids match
633 */
634bool
635nfs4_check_serverowner_major_id(struct nfs41_server_owner *o1,
636				struct nfs41_server_owner *o2)
637{
638	if (o1->major_id_sz != o2->major_id_sz)
639		return false;
640	return memcmp(o1->major_id, o2->major_id, o1->major_id_sz) == 0;
641}
642
643/*
644 * Returns true if the server scopes match
645 */
646static bool
647nfs4_check_server_scope(struct nfs41_server_scope *s1,
648			struct nfs41_server_scope *s2)
649{
650	if (s1->server_scope_sz != s2->server_scope_sz)
651		return false;
652	return memcmp(s1->server_scope, s2->server_scope,
653					s1->server_scope_sz) == 0;
654}
655
656/**
657 * nfs4_detect_session_trunking - Checks for session trunking.
658 * @clp:    original mount nfs_client
659 * @res:    result structure from an exchange_id using the original mount
660 *          nfs_client with a new multi_addr transport
661 * @xprt:   pointer to the transport to add.
662 *
663 * Called after a successful EXCHANGE_ID on a multi-addr connection.
664 * Upon success, add the transport.
665 *
666 * Returns zero on success, otherwise -EINVAL
667 *
668 * Note: since the exchange_id for the new multi_addr transport uses the
669 * same nfs_client from the original mount, the cl_owner_id is reused,
670 * so eir_clientowner is the same.
671 */
672int nfs4_detect_session_trunking(struct nfs_client *clp,
673				 struct nfs41_exchange_id_res *res,
674				 struct rpc_xprt *xprt)
675{
676	/* Check eir_clientid */
677	if (clp->cl_clientid != res->clientid)
678		goto out_err;
679
680	/* Check eir_server_owner so_major_id */
681	if (!nfs4_check_serverowner_major_id(clp->cl_serverowner,
682					     res->server_owner))
683		goto out_err;
684
685	/* Check eir_server_owner so_minor_id */
686	if (clp->cl_serverowner->minor_id != res->server_owner->minor_id)
687		goto out_err;
688
689	/* Check eir_server_scope */
690	if (!nfs4_check_server_scope(clp->cl_serverscope, res->server_scope))
691		goto out_err;
692
693	pr_info("NFS:  %s: Session trunking succeeded for %s\n",
694		clp->cl_hostname,
695		xprt->address_strings[RPC_DISPLAY_ADDR]);
696
697	return 0;
698out_err:
699	pr_info("NFS:  %s: Session trunking failed for %s\n", clp->cl_hostname,
700		xprt->address_strings[RPC_DISPLAY_ADDR]);
701
702	return -EINVAL;
703}
704
705/**
706 * nfs41_walk_client_list - Find nfs_client that matches a client/server owner
707 *
708 * @new: nfs_client with client ID to test
709 * @result: OUT: found nfs_client, or new
710 * @cred: credential to use for trunking test
711 *
712 * Returns zero, a negative errno, or a negative NFS4ERR status.
713 * If zero is returned, an nfs_client pointer is planted in "result."
714 *
715 * NB: nfs41_walk_client_list() relies on the new nfs_client being
716 *     the last nfs_client on the list.
717 */
718int nfs41_walk_client_list(struct nfs_client *new,
719			   struct nfs_client **result,
720			   const struct cred *cred)
721{
722	struct nfs_net *nn = net_generic(new->cl_net, nfs_net_id);
723	struct nfs_client *pos, *prev = NULL;
724	int status = -NFS4ERR_STALE_CLIENTID;
725
726	spin_lock(&nn->nfs_client_lock);
727	list_for_each_entry(pos, &nn->nfs_client_list, cl_share_link) {
728
729		if (pos == new)
730			goto found;
731
732		status = nfs4_match_client(pos, new, &prev, nn);
733		if (status < 0)
734			goto out;
735		if (status != 0)
736			continue;
737
738		/*
739		 * Note that session trunking is just a special subcase of
740		 * client id trunking. In either case, we want to fall back
741		 * to using the existing nfs_client.
742		 */
743		if (!nfs4_check_serverowner_major_id(pos->cl_serverowner,
744						     new->cl_serverowner))
745			continue;
746
747found:
748		refcount_inc(&pos->cl_count);
749		*result = pos;
750		status = 0;
751		break;
752	}
753
754out:
755	spin_unlock(&nn->nfs_client_lock);
756	nfs_put_client(prev);
757	return status;
758}
759#endif	/* CONFIG_NFS_V4_1 */
760
761static void nfs4_destroy_server(struct nfs_server *server)
762{
763	LIST_HEAD(freeme);
764
765	nfs_server_return_all_delegations(server);
766	unset_pnfs_layoutdriver(server);
767	nfs4_purge_state_owners(server, &freeme);
768	nfs4_free_state_owners(&freeme);
769}
770
771/*
772 * NFSv4.0 callback thread helper
773 *
774 * Find a client by callback identifier
775 */
776struct nfs_client *
777nfs4_find_client_ident(struct net *net, int cb_ident)
778{
779	struct nfs_client *clp;
780	struct nfs_net *nn = net_generic(net, nfs_net_id);
781
782	spin_lock(&nn->nfs_client_lock);
783	clp = idr_find(&nn->cb_ident_idr, cb_ident);
784	if (clp)
785		refcount_inc(&clp->cl_count);
786	spin_unlock(&nn->nfs_client_lock);
787	return clp;
788}
789
790#if defined(CONFIG_NFS_V4_1)
791/* Common match routine for v4.0 and v4.1 callback services */
792static bool nfs4_cb_match_client(const struct sockaddr *addr,
793		struct nfs_client *clp, u32 minorversion)
794{
795	struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;
796
797	/* Don't match clients that failed to initialise */
798	if (!(clp->cl_cons_state == NFS_CS_READY ||
799	    clp->cl_cons_state == NFS_CS_SESSION_INITING))
800		return false;
801
802	smp_rmb();
803
804	/* Match the version and minorversion */
805	if (clp->rpc_ops->version != 4 ||
806	    clp->cl_minorversion != minorversion)
807		return false;
808
809	/* Match only the IP address, not the port number */
810	return rpc_cmp_addr(addr, clap);
811}
812
813/*
814 * NFSv4.1 callback thread helper
815 * For CB_COMPOUND calls, find a client by IP address, protocol version,
816 * minorversion, and sessionID
817 *
818 * Returns NULL if no such client
819 */
820struct nfs_client *
821nfs4_find_client_sessionid(struct net *net, const struct sockaddr *addr,
822			   struct nfs4_sessionid *sid, u32 minorversion)
823{
824	struct nfs_client *clp;
825	struct nfs_net *nn = net_generic(net, nfs_net_id);
826
827	spin_lock(&nn->nfs_client_lock);
828	list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) {
829		if (!nfs4_cb_match_client(addr, clp, minorversion))
830			continue;
831
832		if (!nfs4_has_session(clp))
833			continue;
834
835		/* Match sessionid*/
836		if (memcmp(clp->cl_session->sess_id.data,
837		    sid->data, NFS4_MAX_SESSIONID_LEN) != 0)
838			continue;
839
840		refcount_inc(&clp->cl_count);
841		spin_unlock(&nn->nfs_client_lock);
842		return clp;
843	}
844	spin_unlock(&nn->nfs_client_lock);
845	return NULL;
846}
847
848#else /* CONFIG_NFS_V4_1 */
849
850struct nfs_client *
851nfs4_find_client_sessionid(struct net *net, const struct sockaddr *addr,
852			   struct nfs4_sessionid *sid, u32 minorversion)
853{
854	return NULL;
855}
856#endif /* CONFIG_NFS_V4_1 */
857
858/*
859 * Set up an NFS4 client
860 */
861static int nfs4_set_client(struct nfs_server *server,
862		const char *hostname,
863		const struct sockaddr *addr,
864		const size_t addrlen,
865		const char *ip_addr,
866		int proto, const struct rpc_timeout *timeparms,
867		u32 minorversion, unsigned int nconnect,
868		unsigned int max_connect,
869		struct net *net)
870{
871	struct nfs_client_initdata cl_init = {
872		.hostname = hostname,
873		.addr = addr,
874		.addrlen = addrlen,
875		.ip_addr = ip_addr,
876		.nfs_mod = &nfs_v4,
877		.proto = proto,
878		.minorversion = minorversion,
879		.net = net,
880		.timeparms = timeparms,
881		.cred = server->cred,
882	};
883	struct nfs_client *clp;
884
885	if (minorversion == 0)
886		__set_bit(NFS_CS_REUSEPORT, &cl_init.init_flags);
887	else
888		cl_init.max_connect = max_connect;
889	if (proto == XPRT_TRANSPORT_TCP)
890		cl_init.nconnect = nconnect;
891
892	if (server->flags & NFS_MOUNT_NORESVPORT)
893		__set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
894	if (server->options & NFS_OPTION_MIGRATION)
895		__set_bit(NFS_CS_MIGRATION, &cl_init.init_flags);
896	if (test_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status))
897		__set_bit(NFS_CS_TSM_POSSIBLE, &cl_init.init_flags);
898	server->port = rpc_get_port(addr);
899
900	/* Allocate or find a client reference we can use */
901	clp = nfs_get_client(&cl_init);
902	if (IS_ERR(clp))
903		return PTR_ERR(clp);
904
905	if (server->nfs_client == clp) {
906		nfs_put_client(clp);
907		return -ELOOP;
908	}
909
910	/*
911	 * Query for the lease time on clientid setup or renewal
912	 *
913	 * Note that this will be set on nfs_clients that were created
914	 * only for the DS role and did not set this bit, but now will
915	 * serve a dual role.
916	 */
917	set_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state);
918
919	server->nfs_client = clp;
920	return 0;
921}
922
923/*
924 * Set up a pNFS Data Server client.
925 *
926 * Return any existing nfs_client that matches server address,port,version
927 * and minorversion.
928 *
929 * For a new nfs_client, use a soft mount (default), a low retrans and a
930 * low timeout interval so that if a connection is lost, we retry through
931 * the MDS.
932 */
933struct nfs_client *nfs4_set_ds_client(struct nfs_server *mds_srv,
934		const struct sockaddr *ds_addr, int ds_addrlen,
935		int ds_proto, unsigned int ds_timeo, unsigned int ds_retrans,
936		u32 minor_version)
937{
938	struct rpc_timeout ds_timeout;
939	struct nfs_client *mds_clp = mds_srv->nfs_client;
940	struct nfs_client_initdata cl_init = {
941		.addr = ds_addr,
942		.addrlen = ds_addrlen,
943		.nodename = mds_clp->cl_rpcclient->cl_nodename,
944		.ip_addr = mds_clp->cl_ipaddr,
945		.nfs_mod = &nfs_v4,
946		.proto = ds_proto,
947		.minorversion = minor_version,
948		.net = mds_clp->cl_net,
949		.timeparms = &ds_timeout,
950		.cred = mds_srv->cred,
951	};
952	char buf[INET6_ADDRSTRLEN + 1];
953
954	if (rpc_ntop(ds_addr, buf, sizeof(buf)) <= 0)
955		return ERR_PTR(-EINVAL);
956	cl_init.hostname = buf;
957
958	if (mds_clp->cl_nconnect > 1 && ds_proto == XPRT_TRANSPORT_TCP) {
959		cl_init.nconnect = mds_clp->cl_nconnect;
960		cl_init.max_connect = NFS_MAX_TRANSPORTS;
961	}
962
963	if (mds_srv->flags & NFS_MOUNT_NORESVPORT)
964		__set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
965
966	/*
967	 * Set an authflavor equual to the MDS value. Use the MDS nfs_client
968	 * cl_ipaddr so as to use the same EXCHANGE_ID co_ownerid as the MDS
969	 * (section 13.1 RFC 5661).
970	 */
971	nfs_init_timeout_values(&ds_timeout, ds_proto, ds_timeo, ds_retrans);
972	return nfs_get_client(&cl_init);
973}
974EXPORT_SYMBOL_GPL(nfs4_set_ds_client);
975
976/*
977 * Session has been established, and the client marked ready.
978 * Limit the mount rsize, wsize and dtsize using negotiated fore
979 * channel attributes.
980 */
981static void nfs4_session_limit_rwsize(struct nfs_server *server)
982{
983#ifdef CONFIG_NFS_V4_1
984	struct nfs4_session *sess;
985	u32 server_resp_sz;
986	u32 server_rqst_sz;
987
988	if (!nfs4_has_session(server->nfs_client))
989		return;
990	sess = server->nfs_client->cl_session;
991	server_resp_sz = sess->fc_attrs.max_resp_sz - nfs41_maxread_overhead;
992	server_rqst_sz = sess->fc_attrs.max_rqst_sz - nfs41_maxwrite_overhead;
993
994	if (server->dtsize > server_resp_sz)
995		server->dtsize = server_resp_sz;
996	if (server->rsize > server_resp_sz)
997		server->rsize = server_resp_sz;
998	if (server->wsize > server_rqst_sz)
999		server->wsize = server_rqst_sz;
1000#endif /* CONFIG_NFS_V4_1 */
1001}
1002
1003/*
1004 * Limit xattr sizes using the channel attributes.
1005 */
1006static void nfs4_session_limit_xasize(struct nfs_server *server)
1007{
1008#ifdef CONFIG_NFS_V4_2
1009	struct nfs4_session *sess;
1010	u32 server_gxa_sz;
1011	u32 server_sxa_sz;
1012	u32 server_lxa_sz;
1013
1014	if (!nfs4_has_session(server->nfs_client))
1015		return;
1016
1017	sess = server->nfs_client->cl_session;
1018
1019	server_gxa_sz = sess->fc_attrs.max_resp_sz - nfs42_maxgetxattr_overhead;
1020	server_sxa_sz = sess->fc_attrs.max_rqst_sz - nfs42_maxsetxattr_overhead;
1021	server_lxa_sz = sess->fc_attrs.max_resp_sz -
1022	    nfs42_maxlistxattrs_overhead;
1023
1024	if (server->gxasize > server_gxa_sz)
1025		server->gxasize = server_gxa_sz;
1026	if (server->sxasize > server_sxa_sz)
1027		server->sxasize = server_sxa_sz;
1028	if (server->lxasize > server_lxa_sz)
1029		server->lxasize = server_lxa_sz;
1030#endif
1031}
1032
1033static int nfs4_server_common_setup(struct nfs_server *server,
1034		struct nfs_fh *mntfh, bool auth_probe)
1035{
1036	struct nfs_fattr *fattr;
1037	int error;
1038
1039	/* data servers support only a subset of NFSv4.1 */
1040	if (is_ds_only_client(server->nfs_client))
1041		return -EPROTONOSUPPORT;
1042
1043	fattr = nfs_alloc_fattr();
1044	if (fattr == NULL)
1045		return -ENOMEM;
1046
1047	/* We must ensure the session is initialised first */
1048	error = nfs4_init_session(server->nfs_client);
1049	if (error < 0)
1050		goto out;
1051
1052	/* Set the basic capabilities */
1053	server->caps |= server->nfs_client->cl_mvops->init_caps;
1054	if (server->flags & NFS_MOUNT_NORDIRPLUS)
1055			server->caps &= ~NFS_CAP_READDIRPLUS;
1056	if (server->nfs_client->cl_proto == XPRT_TRANSPORT_RDMA)
1057		server->caps &= ~NFS_CAP_READ_PLUS;
1058	/*
1059	 * Don't use NFS uid/gid mapping if we're using AUTH_SYS or lower
1060	 * authentication.
1061	 */
1062	if (nfs4_disable_idmapping &&
1063			server->client->cl_auth->au_flavor == RPC_AUTH_UNIX)
1064		server->caps |= NFS_CAP_UIDGID_NOMAP;
1065
1066
1067	/* Probe the root fh to retrieve its FSID and filehandle */
1068	error = nfs4_get_rootfh(server, mntfh, auth_probe);
1069	if (error < 0)
1070		goto out;
1071
1072	dprintk("Server FSID: %llx:%llx\n",
1073			(unsigned long long) server->fsid.major,
1074			(unsigned long long) server->fsid.minor);
1075	nfs_display_fhandle(mntfh, "Pseudo-fs root FH");
1076
1077	error = nfs_probe_fsinfo(server, mntfh, fattr);
1078	if (error < 0)
1079		goto out;
1080
1081	nfs4_session_limit_rwsize(server);
1082	nfs4_session_limit_xasize(server);
1083
1084	if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
1085		server->namelen = NFS4_MAXNAMLEN;
1086
1087	nfs_server_insert_lists(server);
1088	server->mount_time = jiffies;
1089	server->destroy = nfs4_destroy_server;
1090out:
1091	nfs_free_fattr(fattr);
1092	return error;
1093}
1094
1095/*
1096 * Create a version 4 volume record
1097 */
1098static int nfs4_init_server(struct nfs_server *server, struct fs_context *fc)
1099{
1100	struct nfs_fs_context *ctx = nfs_fc2context(fc);
1101	struct rpc_timeout timeparms;
1102	int error;
1103
1104	nfs_init_timeout_values(&timeparms, ctx->nfs_server.protocol,
1105				ctx->timeo, ctx->retrans);
1106
1107	/* Initialise the client representation from the mount data */
1108	server->flags = ctx->flags;
1109	server->options = ctx->options;
1110	server->auth_info = ctx->auth_info;
1111
1112	/* Use the first specified auth flavor. If this flavor isn't
1113	 * allowed by the server, use the SECINFO path to try the
1114	 * other specified flavors */
1115	if (ctx->auth_info.flavor_len >= 1)
1116		ctx->selected_flavor = ctx->auth_info.flavors[0];
1117	else
1118		ctx->selected_flavor = RPC_AUTH_UNIX;
1119
1120	/* Get a client record */
1121	error = nfs4_set_client(server,
1122				ctx->nfs_server.hostname,
1123				&ctx->nfs_server.address,
1124				ctx->nfs_server.addrlen,
1125				ctx->client_address,
1126				ctx->nfs_server.protocol,
1127				&timeparms,
1128				ctx->minorversion,
1129				ctx->nfs_server.nconnect,
1130				ctx->nfs_server.max_connect,
1131				fc->net_ns);
1132	if (error < 0)
1133		return error;
1134
1135	if (ctx->rsize)
1136		server->rsize = nfs_block_size(ctx->rsize, NULL);
1137	if (ctx->wsize)
1138		server->wsize = nfs_block_size(ctx->wsize, NULL);
1139
1140	server->acregmin = ctx->acregmin * HZ;
1141	server->acregmax = ctx->acregmax * HZ;
1142	server->acdirmin = ctx->acdirmin * HZ;
1143	server->acdirmax = ctx->acdirmax * HZ;
1144	server->port     = ctx->nfs_server.port;
1145
1146	return nfs_init_server_rpcclient(server, &timeparms,
1147					 ctx->selected_flavor);
1148}
1149
1150/*
1151 * Create a version 4 volume record
1152 * - keyed on server and FSID
1153 */
1154struct nfs_server *nfs4_create_server(struct fs_context *fc)
1155{
1156	struct nfs_fs_context *ctx = nfs_fc2context(fc);
1157	struct nfs_server *server;
1158	bool auth_probe;
1159	int error;
1160
1161	server = nfs_alloc_server();
1162	if (!server)
1163		return ERR_PTR(-ENOMEM);
1164
1165	server->cred = get_cred(fc->cred);
1166
1167	auth_probe = ctx->auth_info.flavor_len < 1;
1168
1169	/* set up the general RPC client */
1170	error = nfs4_init_server(server, fc);
1171	if (error < 0)
1172		goto error;
1173
1174	error = nfs4_server_common_setup(server, ctx->mntfh, auth_probe);
1175	if (error < 0)
1176		goto error;
1177
1178	return server;
1179
1180error:
1181	nfs_free_server(server);
1182	return ERR_PTR(error);
1183}
1184
1185/*
1186 * Create an NFS4 referral server record
1187 */
1188struct nfs_server *nfs4_create_referral_server(struct fs_context *fc)
1189{
1190	struct nfs_fs_context *ctx = nfs_fc2context(fc);
1191	struct nfs_client *parent_client;
1192	struct nfs_server *server, *parent_server;
1193	bool auth_probe;
1194	int error;
1195
1196	server = nfs_alloc_server();
1197	if (!server)
1198		return ERR_PTR(-ENOMEM);
1199
1200	parent_server = NFS_SB(ctx->clone_data.sb);
1201	parent_client = parent_server->nfs_client;
1202
1203	server->cred = get_cred(parent_server->cred);
1204
1205	/* Initialise the client representation from the parent server */
1206	nfs_server_copy_userdata(server, parent_server);
1207
1208	/* Get a client representation */
1209#if IS_ENABLED(CONFIG_SUNRPC_XPRT_RDMA)
1210	rpc_set_port(&ctx->nfs_server.address, NFS_RDMA_PORT);
1211	error = nfs4_set_client(server,
1212				ctx->nfs_server.hostname,
1213				&ctx->nfs_server.address,
1214				ctx->nfs_server.addrlen,
1215				parent_client->cl_ipaddr,
1216				XPRT_TRANSPORT_RDMA,
1217				parent_server->client->cl_timeout,
1218				parent_client->cl_mvops->minor_version,
1219				parent_client->cl_nconnect,
1220				parent_client->cl_max_connect,
1221				parent_client->cl_net);
1222	if (!error)
1223		goto init_server;
1224#endif	/* IS_ENABLED(CONFIG_SUNRPC_XPRT_RDMA) */
1225
1226	rpc_set_port(&ctx->nfs_server.address, NFS_PORT);
1227	error = nfs4_set_client(server,
1228				ctx->nfs_server.hostname,
1229				&ctx->nfs_server.address,
1230				ctx->nfs_server.addrlen,
1231				parent_client->cl_ipaddr,
1232				XPRT_TRANSPORT_TCP,
1233				parent_server->client->cl_timeout,
1234				parent_client->cl_mvops->minor_version,
1235				parent_client->cl_nconnect,
1236				parent_client->cl_max_connect,
1237				parent_client->cl_net);
1238	if (error < 0)
1239		goto error;
1240
1241#if IS_ENABLED(CONFIG_SUNRPC_XPRT_RDMA)
1242init_server:
1243#endif
1244	error = nfs_init_server_rpcclient(server, parent_server->client->cl_timeout,
1245					  ctx->selected_flavor);
1246	if (error < 0)
1247		goto error;
1248
1249	auth_probe = parent_server->auth_info.flavor_len < 1;
1250
1251	error = nfs4_server_common_setup(server, ctx->mntfh, auth_probe);
1252	if (error < 0)
1253		goto error;
1254
1255	return server;
1256
1257error:
1258	nfs_free_server(server);
1259	return ERR_PTR(error);
1260}
1261
1262/*
1263 * Grab the destination's particulars, including lease expiry time.
1264 *
1265 * Returns zero if probe succeeded and retrieved FSID matches the FSID
1266 * we have cached.
1267 */
1268static int nfs_probe_destination(struct nfs_server *server)
1269{
1270	struct inode *inode = d_inode(server->super->s_root);
1271	struct nfs_fattr *fattr;
1272	int error;
1273
1274	fattr = nfs_alloc_fattr();
1275	if (fattr == NULL)
1276		return -ENOMEM;
1277
1278	/* Sanity: the probe won't work if the destination server
1279	 * does not recognize the migrated FH. */
1280	error = nfs_probe_fsinfo(server, NFS_FH(inode), fattr);
1281
1282	nfs_free_fattr(fattr);
1283	return error;
1284}
1285
1286/**
1287 * nfs4_update_server - Move an nfs_server to a different nfs_client
1288 *
1289 * @server: represents FSID to be moved
1290 * @hostname: new end-point's hostname
1291 * @sap: new end-point's socket address
1292 * @salen: size of "sap"
1293 * @net: net namespace
1294 *
1295 * The nfs_server must be quiescent before this function is invoked.
1296 * Either its session is drained (NFSv4.1+), or its transport is
1297 * plugged and drained (NFSv4.0).
1298 *
1299 * Returns zero on success, or a negative errno value.
1300 */
1301int nfs4_update_server(struct nfs_server *server, const char *hostname,
1302		       struct sockaddr *sap, size_t salen, struct net *net)
1303{
1304	struct nfs_client *clp = server->nfs_client;
1305	struct rpc_clnt *clnt = server->client;
1306	struct xprt_create xargs = {
1307		.ident		= clp->cl_proto,
1308		.net		= net,
1309		.dstaddr	= sap,
1310		.addrlen	= salen,
1311		.servername	= hostname,
1312	};
1313	char buf[INET6_ADDRSTRLEN + 1];
1314	struct sockaddr_storage address;
1315	struct sockaddr *localaddr = (struct sockaddr *)&address;
1316	int error;
1317
1318	error = rpc_switch_client_transport(clnt, &xargs, clnt->cl_timeout);
1319	if (error != 0)
1320		return error;
1321
1322	error = rpc_localaddr(clnt, localaddr, sizeof(address));
1323	if (error != 0)
1324		return error;
1325
1326	if (rpc_ntop(localaddr, buf, sizeof(buf)) == 0)
1327		return -EAFNOSUPPORT;
1328
1329	nfs_server_remove_lists(server);
1330	set_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status);
1331	error = nfs4_set_client(server, hostname, sap, salen, buf,
1332				clp->cl_proto, clnt->cl_timeout,
1333				clp->cl_minorversion,
1334				clp->cl_nconnect, clp->cl_max_connect, net);
1335	clear_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status);
1336	if (error != 0) {
1337		nfs_server_insert_lists(server);
1338		return error;
1339	}
1340	nfs_put_client(clp);
1341
1342	if (server->nfs_client->cl_hostname == NULL)
1343		server->nfs_client->cl_hostname = kstrdup(hostname, GFP_KERNEL);
1344	nfs_server_insert_lists(server);
1345
1346	return nfs_probe_destination(server);
1347}
1348