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