xref: /openbmc/linux/fs/nfs/client.c (revision 07d9a767)
1  // SPDX-License-Identifier: GPL-2.0-or-later
2  /* client.c: NFS client sharing and management code
3   *
4   * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
5   * Written by David Howells (dhowells@redhat.com)
6   */
7  
8  
9  #include <linux/module.h>
10  #include <linux/init.h>
11  #include <linux/sched.h>
12  #include <linux/time.h>
13  #include <linux/kernel.h>
14  #include <linux/mm.h>
15  #include <linux/string.h>
16  #include <linux/stat.h>
17  #include <linux/errno.h>
18  #include <linux/unistd.h>
19  #include <linux/sunrpc/addr.h>
20  #include <linux/sunrpc/clnt.h>
21  #include <linux/sunrpc/stats.h>
22  #include <linux/sunrpc/metrics.h>
23  #include <linux/sunrpc/xprtsock.h>
24  #include <linux/sunrpc/xprtrdma.h>
25  #include <linux/nfs_fs.h>
26  #include <linux/nfs_mount.h>
27  #include <linux/nfs4_mount.h>
28  #include <linux/lockd/bind.h>
29  #include <linux/seq_file.h>
30  #include <linux/mount.h>
31  #include <linux/vfs.h>
32  #include <linux/inet.h>
33  #include <linux/in6.h>
34  #include <linux/slab.h>
35  #include <linux/idr.h>
36  #include <net/ipv6.h>
37  #include <linux/nfs_xdr.h>
38  #include <linux/sunrpc/bc_xprt.h>
39  #include <linux/nsproxy.h>
40  #include <linux/pid_namespace.h>
41  
42  
43  #include "nfs4_fs.h"
44  #include "callback.h"
45  #include "delegation.h"
46  #include "iostat.h"
47  #include "internal.h"
48  #include "fscache.h"
49  #include "pnfs.h"
50  #include "nfs.h"
51  #include "netns.h"
52  #include "sysfs.h"
53  #include "nfs42.h"
54  
55  #define NFSDBG_FACILITY		NFSDBG_CLIENT
56  
57  static DECLARE_WAIT_QUEUE_HEAD(nfs_client_active_wq);
58  static DEFINE_SPINLOCK(nfs_version_lock);
59  static DEFINE_MUTEX(nfs_version_mutex);
60  static LIST_HEAD(nfs_versions);
61  
62  /*
63   * RPC cruft for NFS
64   */
65  static const struct rpc_version *nfs_version[5] = {
66  	[2] = NULL,
67  	[3] = NULL,
68  	[4] = NULL,
69  };
70  
71  const struct rpc_program nfs_program = {
72  	.name			= "nfs",
73  	.number			= NFS_PROGRAM,
74  	.nrvers			= ARRAY_SIZE(nfs_version),
75  	.version		= nfs_version,
76  	.stats			= &nfs_rpcstat,
77  	.pipe_dir_name		= NFS_PIPE_DIRNAME,
78  };
79  
80  struct rpc_stat nfs_rpcstat = {
81  	.program		= &nfs_program
82  };
83  
84  static struct nfs_subversion *find_nfs_version(unsigned int version)
85  {
86  	struct nfs_subversion *nfs;
87  	spin_lock(&nfs_version_lock);
88  
89  	list_for_each_entry(nfs, &nfs_versions, list) {
90  		if (nfs->rpc_ops->version == version) {
91  			spin_unlock(&nfs_version_lock);
92  			return nfs;
93  		}
94  	}
95  
96  	spin_unlock(&nfs_version_lock);
97  	return ERR_PTR(-EPROTONOSUPPORT);
98  }
99  
100  struct nfs_subversion *get_nfs_version(unsigned int version)
101  {
102  	struct nfs_subversion *nfs = find_nfs_version(version);
103  
104  	if (IS_ERR(nfs)) {
105  		mutex_lock(&nfs_version_mutex);
106  		request_module("nfsv%d", version);
107  		nfs = find_nfs_version(version);
108  		mutex_unlock(&nfs_version_mutex);
109  	}
110  
111  	if (!IS_ERR(nfs) && !try_module_get(nfs->owner))
112  		return ERR_PTR(-EAGAIN);
113  	return nfs;
114  }
115  
116  void put_nfs_version(struct nfs_subversion *nfs)
117  {
118  	module_put(nfs->owner);
119  }
120  
121  void register_nfs_version(struct nfs_subversion *nfs)
122  {
123  	spin_lock(&nfs_version_lock);
124  
125  	list_add(&nfs->list, &nfs_versions);
126  	nfs_version[nfs->rpc_ops->version] = nfs->rpc_vers;
127  
128  	spin_unlock(&nfs_version_lock);
129  }
130  EXPORT_SYMBOL_GPL(register_nfs_version);
131  
132  void unregister_nfs_version(struct nfs_subversion *nfs)
133  {
134  	spin_lock(&nfs_version_lock);
135  
136  	nfs_version[nfs->rpc_ops->version] = NULL;
137  	list_del(&nfs->list);
138  
139  	spin_unlock(&nfs_version_lock);
140  }
141  EXPORT_SYMBOL_GPL(unregister_nfs_version);
142  
143  /*
144   * Allocate a shared client record
145   *
146   * Since these are allocated/deallocated very rarely, we don't
147   * bother putting them in a slab cache...
148   */
149  struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *cl_init)
150  {
151  	struct nfs_client *clp;
152  	int err = -ENOMEM;
153  
154  	if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)
155  		goto error_0;
156  
157  	clp->cl_minorversion = cl_init->minorversion;
158  	clp->cl_nfs_mod = cl_init->nfs_mod;
159  	if (!try_module_get(clp->cl_nfs_mod->owner))
160  		goto error_dealloc;
161  
162  	clp->rpc_ops = clp->cl_nfs_mod->rpc_ops;
163  
164  	refcount_set(&clp->cl_count, 1);
165  	clp->cl_cons_state = NFS_CS_INITING;
166  
167  	memcpy(&clp->cl_addr, cl_init->addr, cl_init->addrlen);
168  	clp->cl_addrlen = cl_init->addrlen;
169  
170  	if (cl_init->hostname) {
171  		err = -ENOMEM;
172  		clp->cl_hostname = kstrdup(cl_init->hostname, GFP_KERNEL);
173  		if (!clp->cl_hostname)
174  			goto error_cleanup;
175  	}
176  
177  	INIT_LIST_HEAD(&clp->cl_superblocks);
178  	clp->cl_rpcclient = ERR_PTR(-EINVAL);
179  
180  	clp->cl_proto = cl_init->proto;
181  	clp->cl_nconnect = cl_init->nconnect;
182  	clp->cl_net = get_net(cl_init->net);
183  
184  	clp->cl_principal = "*";
185  	nfs_fscache_get_client_cookie(clp);
186  
187  	return clp;
188  
189  error_cleanup:
190  	put_nfs_version(clp->cl_nfs_mod);
191  error_dealloc:
192  	kfree(clp);
193  error_0:
194  	return ERR_PTR(err);
195  }
196  EXPORT_SYMBOL_GPL(nfs_alloc_client);
197  
198  #if IS_ENABLED(CONFIG_NFS_V4)
199  static void nfs_cleanup_cb_ident_idr(struct net *net)
200  {
201  	struct nfs_net *nn = net_generic(net, nfs_net_id);
202  
203  	idr_destroy(&nn->cb_ident_idr);
204  }
205  
206  /* nfs_client_lock held */
207  static void nfs_cb_idr_remove_locked(struct nfs_client *clp)
208  {
209  	struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
210  
211  	if (clp->cl_cb_ident)
212  		idr_remove(&nn->cb_ident_idr, clp->cl_cb_ident);
213  }
214  
215  static void pnfs_init_server(struct nfs_server *server)
216  {
217  	rpc_init_wait_queue(&server->roc_rpcwaitq, "pNFS ROC");
218  }
219  
220  #else
221  static void nfs_cleanup_cb_ident_idr(struct net *net)
222  {
223  }
224  
225  static void nfs_cb_idr_remove_locked(struct nfs_client *clp)
226  {
227  }
228  
229  static void pnfs_init_server(struct nfs_server *server)
230  {
231  }
232  
233  #endif /* CONFIG_NFS_V4 */
234  
235  /*
236   * Destroy a shared client record
237   */
238  void nfs_free_client(struct nfs_client *clp)
239  {
240  	nfs_fscache_release_client_cookie(clp);
241  
242  	/* -EIO all pending I/O */
243  	if (!IS_ERR(clp->cl_rpcclient))
244  		rpc_shutdown_client(clp->cl_rpcclient);
245  
246  	put_net(clp->cl_net);
247  	put_nfs_version(clp->cl_nfs_mod);
248  	kfree(clp->cl_hostname);
249  	kfree(clp->cl_acceptor);
250  	kfree(clp);
251  }
252  EXPORT_SYMBOL_GPL(nfs_free_client);
253  
254  /*
255   * Release a reference to a shared client record
256   */
257  void nfs_put_client(struct nfs_client *clp)
258  {
259  	struct nfs_net *nn;
260  
261  	if (!clp)
262  		return;
263  
264  	nn = net_generic(clp->cl_net, nfs_net_id);
265  
266  	if (refcount_dec_and_lock(&clp->cl_count, &nn->nfs_client_lock)) {
267  		list_del(&clp->cl_share_link);
268  		nfs_cb_idr_remove_locked(clp);
269  		spin_unlock(&nn->nfs_client_lock);
270  
271  		WARN_ON_ONCE(!list_empty(&clp->cl_superblocks));
272  
273  		clp->rpc_ops->free_client(clp);
274  	}
275  }
276  EXPORT_SYMBOL_GPL(nfs_put_client);
277  
278  /*
279   * Find an nfs_client on the list that matches the initialisation data
280   * that is supplied.
281   */
282  static struct nfs_client *nfs_match_client(const struct nfs_client_initdata *data)
283  {
284  	struct nfs_client *clp;
285  	const struct sockaddr *sap = data->addr;
286  	struct nfs_net *nn = net_generic(data->net, nfs_net_id);
287  	int error;
288  
289  again:
290  	list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) {
291  	        const struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;
292  		/* Don't match clients that failed to initialise properly */
293  		if (clp->cl_cons_state < 0)
294  			continue;
295  
296  		/* If a client is still initializing then we need to wait */
297  		if (clp->cl_cons_state > NFS_CS_READY) {
298  			refcount_inc(&clp->cl_count);
299  			spin_unlock(&nn->nfs_client_lock);
300  			error = nfs_wait_client_init_complete(clp);
301  			nfs_put_client(clp);
302  			spin_lock(&nn->nfs_client_lock);
303  			if (error < 0)
304  				return ERR_PTR(error);
305  			goto again;
306  		}
307  
308  		/* Different NFS versions cannot share the same nfs_client */
309  		if (clp->rpc_ops != data->nfs_mod->rpc_ops)
310  			continue;
311  
312  		if (clp->cl_proto != data->proto)
313  			continue;
314  		/* Match nfsv4 minorversion */
315  		if (clp->cl_minorversion != data->minorversion)
316  			continue;
317  
318  		/* Match request for a dedicated DS */
319  		if (test_bit(NFS_CS_DS, &data->init_flags) !=
320  		    test_bit(NFS_CS_DS, &clp->cl_flags))
321  			continue;
322  
323  		/* Match the full socket address */
324  		if (!rpc_cmp_addr_port(sap, clap))
325  			/* Match all xprt_switch full socket addresses */
326  			if (IS_ERR(clp->cl_rpcclient) ||
327                              !rpc_clnt_xprt_switch_has_addr(clp->cl_rpcclient,
328  							   sap))
329  				continue;
330  
331  		refcount_inc(&clp->cl_count);
332  		return clp;
333  	}
334  	return NULL;
335  }
336  
337  /*
338   * Return true if @clp is done initializing, false if still working on it.
339   *
340   * Use nfs_client_init_status to check if it was successful.
341   */
342  bool nfs_client_init_is_complete(const struct nfs_client *clp)
343  {
344  	return clp->cl_cons_state <= NFS_CS_READY;
345  }
346  EXPORT_SYMBOL_GPL(nfs_client_init_is_complete);
347  
348  /*
349   * Return 0 if @clp was successfully initialized, -errno otherwise.
350   *
351   * This must be called *after* nfs_client_init_is_complete() returns true,
352   * otherwise it will pop WARN_ON_ONCE and return -EINVAL
353   */
354  int nfs_client_init_status(const struct nfs_client *clp)
355  {
356  	/* called without checking nfs_client_init_is_complete */
357  	if (clp->cl_cons_state > NFS_CS_READY) {
358  		WARN_ON_ONCE(1);
359  		return -EINVAL;
360  	}
361  	return clp->cl_cons_state;
362  }
363  EXPORT_SYMBOL_GPL(nfs_client_init_status);
364  
365  int nfs_wait_client_init_complete(const struct nfs_client *clp)
366  {
367  	return wait_event_killable(nfs_client_active_wq,
368  			nfs_client_init_is_complete(clp));
369  }
370  EXPORT_SYMBOL_GPL(nfs_wait_client_init_complete);
371  
372  /*
373   * Found an existing client.  Make sure it's ready before returning.
374   */
375  static struct nfs_client *
376  nfs_found_client(const struct nfs_client_initdata *cl_init,
377  		 struct nfs_client *clp)
378  {
379  	int error;
380  
381  	error = nfs_wait_client_init_complete(clp);
382  	if (error < 0) {
383  		nfs_put_client(clp);
384  		return ERR_PTR(-ERESTARTSYS);
385  	}
386  
387  	if (clp->cl_cons_state < NFS_CS_READY) {
388  		error = clp->cl_cons_state;
389  		nfs_put_client(clp);
390  		return ERR_PTR(error);
391  	}
392  
393  	smp_rmb();
394  	return clp;
395  }
396  
397  /*
398   * Look up a client by IP address and protocol version
399   * - creates a new record if one doesn't yet exist
400   */
401  struct nfs_client *nfs_get_client(const struct nfs_client_initdata *cl_init)
402  {
403  	struct nfs_client *clp, *new = NULL;
404  	struct nfs_net *nn = net_generic(cl_init->net, nfs_net_id);
405  	const struct nfs_rpc_ops *rpc_ops = cl_init->nfs_mod->rpc_ops;
406  
407  	if (cl_init->hostname == NULL) {
408  		WARN_ON(1);
409  		return NULL;
410  	}
411  
412  	/* see if the client already exists */
413  	do {
414  		spin_lock(&nn->nfs_client_lock);
415  
416  		clp = nfs_match_client(cl_init);
417  		if (clp) {
418  			spin_unlock(&nn->nfs_client_lock);
419  			if (new)
420  				new->rpc_ops->free_client(new);
421  			if (IS_ERR(clp))
422  				return clp;
423  			return nfs_found_client(cl_init, clp);
424  		}
425  		if (new) {
426  			list_add_tail(&new->cl_share_link,
427  					&nn->nfs_client_list);
428  			spin_unlock(&nn->nfs_client_lock);
429  			new->cl_flags = cl_init->init_flags;
430  			return rpc_ops->init_client(new, cl_init);
431  		}
432  
433  		spin_unlock(&nn->nfs_client_lock);
434  
435  		new = rpc_ops->alloc_client(cl_init);
436  	} while (!IS_ERR(new));
437  
438  	return new;
439  }
440  EXPORT_SYMBOL_GPL(nfs_get_client);
441  
442  /*
443   * Mark a server as ready or failed
444   */
445  void nfs_mark_client_ready(struct nfs_client *clp, int state)
446  {
447  	smp_wmb();
448  	clp->cl_cons_state = state;
449  	wake_up_all(&nfs_client_active_wq);
450  }
451  EXPORT_SYMBOL_GPL(nfs_mark_client_ready);
452  
453  /*
454   * Initialise the timeout values for a connection
455   */
456  void nfs_init_timeout_values(struct rpc_timeout *to, int proto,
457  				    int timeo, int retrans)
458  {
459  	to->to_initval = timeo * HZ / 10;
460  	to->to_retries = retrans;
461  
462  	switch (proto) {
463  	case XPRT_TRANSPORT_TCP:
464  	case XPRT_TRANSPORT_RDMA:
465  		if (retrans == NFS_UNSPEC_RETRANS)
466  			to->to_retries = NFS_DEF_TCP_RETRANS;
467  		if (timeo == NFS_UNSPEC_TIMEO || to->to_initval == 0)
468  			to->to_initval = NFS_DEF_TCP_TIMEO * HZ / 10;
469  		if (to->to_initval > NFS_MAX_TCP_TIMEOUT)
470  			to->to_initval = NFS_MAX_TCP_TIMEOUT;
471  		to->to_increment = to->to_initval;
472  		to->to_maxval = to->to_initval + (to->to_increment * to->to_retries);
473  		if (to->to_maxval > NFS_MAX_TCP_TIMEOUT)
474  			to->to_maxval = NFS_MAX_TCP_TIMEOUT;
475  		if (to->to_maxval < to->to_initval)
476  			to->to_maxval = to->to_initval;
477  		to->to_exponential = 0;
478  		break;
479  #ifndef CONFIG_NFS_DISABLE_UDP_SUPPORT
480  	case XPRT_TRANSPORT_UDP:
481  		if (retrans == NFS_UNSPEC_RETRANS)
482  			to->to_retries = NFS_DEF_UDP_RETRANS;
483  		if (timeo == NFS_UNSPEC_TIMEO || to->to_initval == 0)
484  			to->to_initval = NFS_DEF_UDP_TIMEO * HZ / 10;
485  		if (to->to_initval > NFS_MAX_UDP_TIMEOUT)
486  			to->to_initval = NFS_MAX_UDP_TIMEOUT;
487  		to->to_maxval = NFS_MAX_UDP_TIMEOUT;
488  		to->to_exponential = 1;
489  		break;
490  #endif
491  	default:
492  		BUG();
493  	}
494  }
495  EXPORT_SYMBOL_GPL(nfs_init_timeout_values);
496  
497  /*
498   * Create an RPC client handle
499   */
500  int nfs_create_rpc_client(struct nfs_client *clp,
501  			  const struct nfs_client_initdata *cl_init,
502  			  rpc_authflavor_t flavor)
503  {
504  	struct rpc_clnt		*clnt = NULL;
505  	struct rpc_create_args args = {
506  		.net		= clp->cl_net,
507  		.protocol	= clp->cl_proto,
508  		.nconnect	= clp->cl_nconnect,
509  		.address	= (struct sockaddr *)&clp->cl_addr,
510  		.addrsize	= clp->cl_addrlen,
511  		.timeout	= cl_init->timeparms,
512  		.servername	= clp->cl_hostname,
513  		.nodename	= cl_init->nodename,
514  		.program	= &nfs_program,
515  		.version	= clp->rpc_ops->version,
516  		.authflavor	= flavor,
517  		.cred		= cl_init->cred,
518  	};
519  
520  	if (test_bit(NFS_CS_DISCRTRY, &clp->cl_flags))
521  		args.flags |= RPC_CLNT_CREATE_DISCRTRY;
522  	if (test_bit(NFS_CS_NO_RETRANS_TIMEOUT, &clp->cl_flags))
523  		args.flags |= RPC_CLNT_CREATE_NO_RETRANS_TIMEOUT;
524  	if (test_bit(NFS_CS_NORESVPORT, &clp->cl_flags))
525  		args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
526  	if (test_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags))
527  		args.flags |= RPC_CLNT_CREATE_INFINITE_SLOTS;
528  	if (test_bit(NFS_CS_NOPING, &clp->cl_flags))
529  		args.flags |= RPC_CLNT_CREATE_NOPING;
530  	if (test_bit(NFS_CS_REUSEPORT, &clp->cl_flags))
531  		args.flags |= RPC_CLNT_CREATE_REUSEPORT;
532  
533  	if (!IS_ERR(clp->cl_rpcclient))
534  		return 0;
535  
536  	clnt = rpc_create(&args);
537  	if (IS_ERR(clnt)) {
538  		dprintk("%s: cannot create RPC client. Error = %ld\n",
539  				__func__, PTR_ERR(clnt));
540  		return PTR_ERR(clnt);
541  	}
542  
543  	clnt->cl_principal = clp->cl_principal;
544  	clp->cl_rpcclient = clnt;
545  	return 0;
546  }
547  EXPORT_SYMBOL_GPL(nfs_create_rpc_client);
548  
549  /*
550   * Version 2 or 3 client destruction
551   */
552  static void nfs_destroy_server(struct nfs_server *server)
553  {
554  	if (server->nlm_host)
555  		nlmclnt_done(server->nlm_host);
556  }
557  
558  /*
559   * Version 2 or 3 lockd setup
560   */
561  static int nfs_start_lockd(struct nfs_server *server)
562  {
563  	struct nlm_host *host;
564  	struct nfs_client *clp = server->nfs_client;
565  	struct nlmclnt_initdata nlm_init = {
566  		.hostname	= clp->cl_hostname,
567  		.address	= (struct sockaddr *)&clp->cl_addr,
568  		.addrlen	= clp->cl_addrlen,
569  		.nfs_version	= clp->rpc_ops->version,
570  		.noresvport	= server->flags & NFS_MOUNT_NORESVPORT ?
571  					1 : 0,
572  		.net		= clp->cl_net,
573  		.nlmclnt_ops 	= clp->cl_nfs_mod->rpc_ops->nlmclnt_ops,
574  		.cred		= current_cred(),
575  	};
576  
577  	if (nlm_init.nfs_version > 3)
578  		return 0;
579  	if ((server->flags & NFS_MOUNT_LOCAL_FLOCK) &&
580  			(server->flags & NFS_MOUNT_LOCAL_FCNTL))
581  		return 0;
582  
583  	switch (clp->cl_proto) {
584  		default:
585  			nlm_init.protocol = IPPROTO_TCP;
586  			break;
587  #ifndef CONFIG_NFS_DISABLE_UDP_SUPPORT
588  		case XPRT_TRANSPORT_UDP:
589  			nlm_init.protocol = IPPROTO_UDP;
590  #endif
591  	}
592  
593  	host = nlmclnt_init(&nlm_init);
594  	if (IS_ERR(host))
595  		return PTR_ERR(host);
596  
597  	server->nlm_host = host;
598  	server->destroy = nfs_destroy_server;
599  	return 0;
600  }
601  
602  /*
603   * Create a general RPC client
604   */
605  int nfs_init_server_rpcclient(struct nfs_server *server,
606  		const struct rpc_timeout *timeo,
607  		rpc_authflavor_t pseudoflavour)
608  {
609  	struct nfs_client *clp = server->nfs_client;
610  
611  	server->client = rpc_clone_client_set_auth(clp->cl_rpcclient,
612  							pseudoflavour);
613  	if (IS_ERR(server->client)) {
614  		dprintk("%s: couldn't create rpc_client!\n", __func__);
615  		return PTR_ERR(server->client);
616  	}
617  
618  	memcpy(&server->client->cl_timeout_default,
619  			timeo,
620  			sizeof(server->client->cl_timeout_default));
621  	server->client->cl_timeout = &server->client->cl_timeout_default;
622  	server->client->cl_softrtry = 0;
623  	if (server->flags & NFS_MOUNT_SOFTERR)
624  		server->client->cl_softerr = 1;
625  	if (server->flags & NFS_MOUNT_SOFT)
626  		server->client->cl_softrtry = 1;
627  
628  	return 0;
629  }
630  EXPORT_SYMBOL_GPL(nfs_init_server_rpcclient);
631  
632  /**
633   * nfs_init_client - Initialise an NFS2 or NFS3 client
634   *
635   * @clp: nfs_client to initialise
636   * @cl_init: Initialisation parameters
637   *
638   * Returns pointer to an NFS client, or an ERR_PTR value.
639   */
640  struct nfs_client *nfs_init_client(struct nfs_client *clp,
641  				   const struct nfs_client_initdata *cl_init)
642  {
643  	int error;
644  
645  	/* the client is already initialised */
646  	if (clp->cl_cons_state == NFS_CS_READY)
647  		return clp;
648  
649  	/*
650  	 * Create a client RPC handle for doing FSSTAT with UNIX auth only
651  	 * - RFC 2623, sec 2.3.2
652  	 */
653  	error = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_UNIX);
654  	nfs_mark_client_ready(clp, error == 0 ? NFS_CS_READY : error);
655  	if (error < 0) {
656  		nfs_put_client(clp);
657  		clp = ERR_PTR(error);
658  	}
659  	return clp;
660  }
661  EXPORT_SYMBOL_GPL(nfs_init_client);
662  
663  /*
664   * Create a version 2 or 3 client
665   */
666  static int nfs_init_server(struct nfs_server *server,
667  			   const struct fs_context *fc)
668  {
669  	const struct nfs_fs_context *ctx = nfs_fc2context(fc);
670  	struct rpc_timeout timeparms;
671  	struct nfs_client_initdata cl_init = {
672  		.hostname = ctx->nfs_server.hostname,
673  		.addr = (const struct sockaddr *)&ctx->nfs_server.address,
674  		.addrlen = ctx->nfs_server.addrlen,
675  		.nfs_mod = ctx->nfs_mod,
676  		.proto = ctx->nfs_server.protocol,
677  		.net = fc->net_ns,
678  		.timeparms = &timeparms,
679  		.cred = server->cred,
680  		.nconnect = ctx->nfs_server.nconnect,
681  		.init_flags = (1UL << NFS_CS_REUSEPORT),
682  	};
683  	struct nfs_client *clp;
684  	int error;
685  
686  	nfs_init_timeout_values(&timeparms, ctx->nfs_server.protocol,
687  				ctx->timeo, ctx->retrans);
688  	if (ctx->flags & NFS_MOUNT_NORESVPORT)
689  		set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
690  
691  	/* Allocate or find a client reference we can use */
692  	clp = nfs_get_client(&cl_init);
693  	if (IS_ERR(clp))
694  		return PTR_ERR(clp);
695  
696  	server->nfs_client = clp;
697  
698  	/* Initialise the client representation from the mount data */
699  	server->flags = ctx->flags;
700  	server->options = ctx->options;
701  	server->caps |= NFS_CAP_HARDLINKS|NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
702  		NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|NFS_CAP_OWNER_GROUP|
703  		NFS_CAP_ATIME|NFS_CAP_CTIME|NFS_CAP_MTIME;
704  
705  	if (ctx->rsize)
706  		server->rsize = nfs_block_size(ctx->rsize, NULL);
707  	if (ctx->wsize)
708  		server->wsize = nfs_block_size(ctx->wsize, NULL);
709  
710  	server->acregmin = ctx->acregmin * HZ;
711  	server->acregmax = ctx->acregmax * HZ;
712  	server->acdirmin = ctx->acdirmin * HZ;
713  	server->acdirmax = ctx->acdirmax * HZ;
714  
715  	/* Start lockd here, before we might error out */
716  	error = nfs_start_lockd(server);
717  	if (error < 0)
718  		goto error;
719  
720  	server->port = ctx->nfs_server.port;
721  	server->auth_info = ctx->auth_info;
722  
723  	error = nfs_init_server_rpcclient(server, &timeparms,
724  					  ctx->selected_flavor);
725  	if (error < 0)
726  		goto error;
727  
728  	/* Preserve the values of mount_server-related mount options */
729  	if (ctx->mount_server.addrlen) {
730  		memcpy(&server->mountd_address, &ctx->mount_server.address,
731  			ctx->mount_server.addrlen);
732  		server->mountd_addrlen = ctx->mount_server.addrlen;
733  	}
734  	server->mountd_version = ctx->mount_server.version;
735  	server->mountd_port = ctx->mount_server.port;
736  	server->mountd_protocol = ctx->mount_server.protocol;
737  
738  	server->namelen  = ctx->namlen;
739  	return 0;
740  
741  error:
742  	server->nfs_client = NULL;
743  	nfs_put_client(clp);
744  	return error;
745  }
746  
747  /*
748   * Load up the server record from information gained in an fsinfo record
749   */
750  static void nfs_server_set_fsinfo(struct nfs_server *server,
751  				  struct nfs_fsinfo *fsinfo)
752  {
753  	unsigned long max_rpc_payload, raw_max_rpc_payload;
754  
755  	/* Work out a lot of parameters */
756  	if (server->rsize == 0)
757  		server->rsize = nfs_block_size(fsinfo->rtpref, NULL);
758  	if (server->wsize == 0)
759  		server->wsize = nfs_block_size(fsinfo->wtpref, NULL);
760  
761  	if (fsinfo->rtmax >= 512 && server->rsize > fsinfo->rtmax)
762  		server->rsize = nfs_block_size(fsinfo->rtmax, NULL);
763  	if (fsinfo->wtmax >= 512 && server->wsize > fsinfo->wtmax)
764  		server->wsize = nfs_block_size(fsinfo->wtmax, NULL);
765  
766  	raw_max_rpc_payload = rpc_max_payload(server->client);
767  	max_rpc_payload = nfs_block_size(raw_max_rpc_payload, NULL);
768  
769  	if (server->rsize > max_rpc_payload)
770  		server->rsize = max_rpc_payload;
771  	if (server->rsize > NFS_MAX_FILE_IO_SIZE)
772  		server->rsize = NFS_MAX_FILE_IO_SIZE;
773  	server->rpages = (server->rsize + PAGE_SIZE - 1) >> PAGE_SHIFT;
774  
775  	if (server->wsize > max_rpc_payload)
776  		server->wsize = max_rpc_payload;
777  	if (server->wsize > NFS_MAX_FILE_IO_SIZE)
778  		server->wsize = NFS_MAX_FILE_IO_SIZE;
779  	server->wpages = (server->wsize + PAGE_SIZE - 1) >> PAGE_SHIFT;
780  
781  	server->wtmult = nfs_block_bits(fsinfo->wtmult, NULL);
782  
783  	server->dtsize = nfs_block_size(fsinfo->dtpref, NULL);
784  	if (server->dtsize > PAGE_SIZE * NFS_MAX_READDIR_PAGES)
785  		server->dtsize = PAGE_SIZE * NFS_MAX_READDIR_PAGES;
786  	if (server->dtsize > server->rsize)
787  		server->dtsize = server->rsize;
788  
789  	if (server->flags & NFS_MOUNT_NOAC) {
790  		server->acregmin = server->acregmax = 0;
791  		server->acdirmin = server->acdirmax = 0;
792  	}
793  
794  	server->maxfilesize = fsinfo->maxfilesize;
795  
796  	server->time_delta = fsinfo->time_delta;
797  
798  	server->clone_blksize = fsinfo->clone_blksize;
799  	/* We're airborne Set socket buffersize */
800  	rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);
801  
802  #ifdef CONFIG_NFS_V4_2
803  	/*
804  	 * Defaults until limited by the session parameters.
805  	 */
806  	server->gxasize = min_t(unsigned int, raw_max_rpc_payload,
807  				XATTR_SIZE_MAX);
808  	server->sxasize = min_t(unsigned int, raw_max_rpc_payload,
809  				XATTR_SIZE_MAX);
810  	server->lxasize = min_t(unsigned int, raw_max_rpc_payload,
811  				nfs42_listxattr_xdrsize(XATTR_LIST_MAX));
812  
813  	if (fsinfo->xattr_support)
814  		server->caps |= NFS_CAP_XATTR;
815  #endif
816  }
817  
818  /*
819   * Probe filesystem information, including the FSID on v2/v3
820   */
821  int nfs_probe_fsinfo(struct nfs_server *server, struct nfs_fh *mntfh, struct nfs_fattr *fattr)
822  {
823  	struct nfs_fsinfo fsinfo;
824  	struct nfs_client *clp = server->nfs_client;
825  	int error;
826  
827  	if (clp->rpc_ops->set_capabilities != NULL) {
828  		error = clp->rpc_ops->set_capabilities(server, mntfh);
829  		if (error < 0)
830  			return error;
831  	}
832  
833  	fsinfo.fattr = fattr;
834  	fsinfo.nlayouttypes = 0;
835  	memset(fsinfo.layouttype, 0, sizeof(fsinfo.layouttype));
836  	error = clp->rpc_ops->fsinfo(server, mntfh, &fsinfo);
837  	if (error < 0)
838  		return error;
839  
840  	nfs_server_set_fsinfo(server, &fsinfo);
841  
842  	/* Get some general file system info */
843  	if (server->namelen == 0) {
844  		struct nfs_pathconf pathinfo;
845  
846  		pathinfo.fattr = fattr;
847  		nfs_fattr_init(fattr);
848  
849  		if (clp->rpc_ops->pathconf(server, mntfh, &pathinfo) >= 0)
850  			server->namelen = pathinfo.max_namelen;
851  	}
852  
853  	return 0;
854  }
855  EXPORT_SYMBOL_GPL(nfs_probe_fsinfo);
856  
857  /*
858   * Copy useful information when duplicating a server record
859   */
860  void nfs_server_copy_userdata(struct nfs_server *target, struct nfs_server *source)
861  {
862  	target->flags = source->flags;
863  	target->rsize = source->rsize;
864  	target->wsize = source->wsize;
865  	target->acregmin = source->acregmin;
866  	target->acregmax = source->acregmax;
867  	target->acdirmin = source->acdirmin;
868  	target->acdirmax = source->acdirmax;
869  	target->caps = source->caps;
870  	target->options = source->options;
871  	target->auth_info = source->auth_info;
872  	target->port = source->port;
873  }
874  EXPORT_SYMBOL_GPL(nfs_server_copy_userdata);
875  
876  void nfs_server_insert_lists(struct nfs_server *server)
877  {
878  	struct nfs_client *clp = server->nfs_client;
879  	struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
880  
881  	spin_lock(&nn->nfs_client_lock);
882  	list_add_tail_rcu(&server->client_link, &clp->cl_superblocks);
883  	list_add_tail(&server->master_link, &nn->nfs_volume_list);
884  	clear_bit(NFS_CS_STOP_RENEW, &clp->cl_res_state);
885  	spin_unlock(&nn->nfs_client_lock);
886  
887  }
888  EXPORT_SYMBOL_GPL(nfs_server_insert_lists);
889  
890  void nfs_server_remove_lists(struct nfs_server *server)
891  {
892  	struct nfs_client *clp = server->nfs_client;
893  	struct nfs_net *nn;
894  
895  	if (clp == NULL)
896  		return;
897  	nn = net_generic(clp->cl_net, nfs_net_id);
898  	spin_lock(&nn->nfs_client_lock);
899  	list_del_rcu(&server->client_link);
900  	if (list_empty(&clp->cl_superblocks))
901  		set_bit(NFS_CS_STOP_RENEW, &clp->cl_res_state);
902  	list_del(&server->master_link);
903  	spin_unlock(&nn->nfs_client_lock);
904  
905  	synchronize_rcu();
906  }
907  EXPORT_SYMBOL_GPL(nfs_server_remove_lists);
908  
909  /*
910   * Allocate and initialise a server record
911   */
912  struct nfs_server *nfs_alloc_server(void)
913  {
914  	struct nfs_server *server;
915  
916  	server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
917  	if (!server)
918  		return NULL;
919  
920  	server->client = server->client_acl = ERR_PTR(-EINVAL);
921  
922  	/* Zero out the NFS state stuff */
923  	INIT_LIST_HEAD(&server->client_link);
924  	INIT_LIST_HEAD(&server->master_link);
925  	INIT_LIST_HEAD(&server->delegations);
926  	INIT_LIST_HEAD(&server->layouts);
927  	INIT_LIST_HEAD(&server->state_owners_lru);
928  	INIT_LIST_HEAD(&server->ss_copies);
929  
930  	atomic_set(&server->active, 0);
931  
932  	server->io_stats = nfs_alloc_iostats();
933  	if (!server->io_stats) {
934  		kfree(server);
935  		return NULL;
936  	}
937  
938  	ida_init(&server->openowner_id);
939  	ida_init(&server->lockowner_id);
940  	pnfs_init_server(server);
941  	rpc_init_wait_queue(&server->uoc_rpcwaitq, "NFS UOC");
942  
943  	return server;
944  }
945  EXPORT_SYMBOL_GPL(nfs_alloc_server);
946  
947  /*
948   * Free up a server record
949   */
950  void nfs_free_server(struct nfs_server *server)
951  {
952  	nfs_server_remove_lists(server);
953  
954  	if (server->destroy != NULL)
955  		server->destroy(server);
956  
957  	if (!IS_ERR(server->client_acl))
958  		rpc_shutdown_client(server->client_acl);
959  	if (!IS_ERR(server->client))
960  		rpc_shutdown_client(server->client);
961  
962  	nfs_put_client(server->nfs_client);
963  
964  	ida_destroy(&server->lockowner_id);
965  	ida_destroy(&server->openowner_id);
966  	nfs_free_iostats(server->io_stats);
967  	put_cred(server->cred);
968  	kfree(server);
969  	nfs_release_automount_timer();
970  }
971  EXPORT_SYMBOL_GPL(nfs_free_server);
972  
973  /*
974   * Create a version 2 or 3 volume record
975   * - keyed on server and FSID
976   */
977  struct nfs_server *nfs_create_server(struct fs_context *fc)
978  {
979  	struct nfs_fs_context *ctx = nfs_fc2context(fc);
980  	struct nfs_server *server;
981  	struct nfs_fattr *fattr;
982  	int error;
983  
984  	server = nfs_alloc_server();
985  	if (!server)
986  		return ERR_PTR(-ENOMEM);
987  
988  	server->cred = get_cred(current_cred());
989  
990  	error = -ENOMEM;
991  	fattr = nfs_alloc_fattr();
992  	if (fattr == NULL)
993  		goto error;
994  
995  	/* Get a client representation */
996  	error = nfs_init_server(server, fc);
997  	if (error < 0)
998  		goto error;
999  
1000  	/* Probe the root fh to retrieve its FSID */
1001  	error = nfs_probe_fsinfo(server, ctx->mntfh, fattr);
1002  	if (error < 0)
1003  		goto error;
1004  	if (server->nfs_client->rpc_ops->version == 3) {
1005  		if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
1006  			server->namelen = NFS3_MAXNAMLEN;
1007  		if (!(ctx->flags & NFS_MOUNT_NORDIRPLUS))
1008  			server->caps |= NFS_CAP_READDIRPLUS;
1009  	} else {
1010  		if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
1011  			server->namelen = NFS2_MAXNAMLEN;
1012  	}
1013  
1014  	if (!(fattr->valid & NFS_ATTR_FATTR)) {
1015  		error = ctx->nfs_mod->rpc_ops->getattr(server, ctx->mntfh,
1016  						       fattr, NULL, NULL);
1017  		if (error < 0) {
1018  			dprintk("nfs_create_server: getattr error = %d\n", -error);
1019  			goto error;
1020  		}
1021  	}
1022  	memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
1023  
1024  	dprintk("Server FSID: %llx:%llx\n",
1025  		(unsigned long long) server->fsid.major,
1026  		(unsigned long long) server->fsid.minor);
1027  
1028  	nfs_server_insert_lists(server);
1029  	server->mount_time = jiffies;
1030  	nfs_free_fattr(fattr);
1031  	return server;
1032  
1033  error:
1034  	nfs_free_fattr(fattr);
1035  	nfs_free_server(server);
1036  	return ERR_PTR(error);
1037  }
1038  EXPORT_SYMBOL_GPL(nfs_create_server);
1039  
1040  /*
1041   * Clone an NFS2, NFS3 or NFS4 server record
1042   */
1043  struct nfs_server *nfs_clone_server(struct nfs_server *source,
1044  				    struct nfs_fh *fh,
1045  				    struct nfs_fattr *fattr,
1046  				    rpc_authflavor_t flavor)
1047  {
1048  	struct nfs_server *server;
1049  	struct nfs_fattr *fattr_fsinfo;
1050  	int error;
1051  
1052  	server = nfs_alloc_server();
1053  	if (!server)
1054  		return ERR_PTR(-ENOMEM);
1055  
1056  	server->cred = get_cred(source->cred);
1057  
1058  	error = -ENOMEM;
1059  	fattr_fsinfo = nfs_alloc_fattr();
1060  	if (fattr_fsinfo == NULL)
1061  		goto out_free_server;
1062  
1063  	/* Copy data from the source */
1064  	server->nfs_client = source->nfs_client;
1065  	server->destroy = source->destroy;
1066  	refcount_inc(&server->nfs_client->cl_count);
1067  	nfs_server_copy_userdata(server, source);
1068  
1069  	server->fsid = fattr->fsid;
1070  
1071  	error = nfs_init_server_rpcclient(server,
1072  			source->client->cl_timeout,
1073  			flavor);
1074  	if (error < 0)
1075  		goto out_free_server;
1076  
1077  	/* probe the filesystem info for this server filesystem */
1078  	error = nfs_probe_fsinfo(server, fh, fattr_fsinfo);
1079  	if (error < 0)
1080  		goto out_free_server;
1081  
1082  	if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
1083  		server->namelen = NFS4_MAXNAMLEN;
1084  
1085  	error = nfs_start_lockd(server);
1086  	if (error < 0)
1087  		goto out_free_server;
1088  
1089  	nfs_server_insert_lists(server);
1090  	server->mount_time = jiffies;
1091  
1092  	nfs_free_fattr(fattr_fsinfo);
1093  	return server;
1094  
1095  out_free_server:
1096  	nfs_free_fattr(fattr_fsinfo);
1097  	nfs_free_server(server);
1098  	return ERR_PTR(error);
1099  }
1100  EXPORT_SYMBOL_GPL(nfs_clone_server);
1101  
1102  void nfs_clients_init(struct net *net)
1103  {
1104  	struct nfs_net *nn = net_generic(net, nfs_net_id);
1105  
1106  	INIT_LIST_HEAD(&nn->nfs_client_list);
1107  	INIT_LIST_HEAD(&nn->nfs_volume_list);
1108  #if IS_ENABLED(CONFIG_NFS_V4)
1109  	idr_init(&nn->cb_ident_idr);
1110  #endif
1111  	spin_lock_init(&nn->nfs_client_lock);
1112  	nn->boot_time = ktime_get_real();
1113  
1114  	nfs_netns_sysfs_setup(nn, net);
1115  }
1116  
1117  void nfs_clients_exit(struct net *net)
1118  {
1119  	struct nfs_net *nn = net_generic(net, nfs_net_id);
1120  
1121  	nfs_netns_sysfs_destroy(nn);
1122  	nfs_cleanup_cb_ident_idr(net);
1123  	WARN_ON_ONCE(!list_empty(&nn->nfs_client_list));
1124  	WARN_ON_ONCE(!list_empty(&nn->nfs_volume_list));
1125  }
1126  
1127  #ifdef CONFIG_PROC_FS
1128  static void *nfs_server_list_start(struct seq_file *p, loff_t *pos);
1129  static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos);
1130  static void nfs_server_list_stop(struct seq_file *p, void *v);
1131  static int nfs_server_list_show(struct seq_file *m, void *v);
1132  
1133  static const struct seq_operations nfs_server_list_ops = {
1134  	.start	= nfs_server_list_start,
1135  	.next	= nfs_server_list_next,
1136  	.stop	= nfs_server_list_stop,
1137  	.show	= nfs_server_list_show,
1138  };
1139  
1140  static void *nfs_volume_list_start(struct seq_file *p, loff_t *pos);
1141  static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos);
1142  static void nfs_volume_list_stop(struct seq_file *p, void *v);
1143  static int nfs_volume_list_show(struct seq_file *m, void *v);
1144  
1145  static const struct seq_operations nfs_volume_list_ops = {
1146  	.start	= nfs_volume_list_start,
1147  	.next	= nfs_volume_list_next,
1148  	.stop	= nfs_volume_list_stop,
1149  	.show	= nfs_volume_list_show,
1150  };
1151  
1152  /*
1153   * set up the iterator to start reading from the server list and return the first item
1154   */
1155  static void *nfs_server_list_start(struct seq_file *m, loff_t *_pos)
1156  				__acquires(&nn->nfs_client_lock)
1157  {
1158  	struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
1159  
1160  	/* lock the list against modification */
1161  	spin_lock(&nn->nfs_client_lock);
1162  	return seq_list_start_head(&nn->nfs_client_list, *_pos);
1163  }
1164  
1165  /*
1166   * move to next server
1167   */
1168  static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos)
1169  {
1170  	struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
1171  
1172  	return seq_list_next(v, &nn->nfs_client_list, pos);
1173  }
1174  
1175  /*
1176   * clean up after reading from the transports list
1177   */
1178  static void nfs_server_list_stop(struct seq_file *p, void *v)
1179  				__releases(&nn->nfs_client_lock)
1180  {
1181  	struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
1182  
1183  	spin_unlock(&nn->nfs_client_lock);
1184  }
1185  
1186  /*
1187   * display a header line followed by a load of call lines
1188   */
1189  static int nfs_server_list_show(struct seq_file *m, void *v)
1190  {
1191  	struct nfs_client *clp;
1192  	struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
1193  
1194  	/* display header on line 1 */
1195  	if (v == &nn->nfs_client_list) {
1196  		seq_puts(m, "NV SERVER   PORT USE HOSTNAME\n");
1197  		return 0;
1198  	}
1199  
1200  	/* display one transport per line on subsequent lines */
1201  	clp = list_entry(v, struct nfs_client, cl_share_link);
1202  
1203  	/* Check if the client is initialized */
1204  	if (clp->cl_cons_state != NFS_CS_READY)
1205  		return 0;
1206  
1207  	rcu_read_lock();
1208  	seq_printf(m, "v%u %s %s %3d %s\n",
1209  		   clp->rpc_ops->version,
1210  		   rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR),
1211  		   rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT),
1212  		   refcount_read(&clp->cl_count),
1213  		   clp->cl_hostname);
1214  	rcu_read_unlock();
1215  
1216  	return 0;
1217  }
1218  
1219  /*
1220   * set up the iterator to start reading from the volume list and return the first item
1221   */
1222  static void *nfs_volume_list_start(struct seq_file *m, loff_t *_pos)
1223  				__acquires(&nn->nfs_client_lock)
1224  {
1225  	struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
1226  
1227  	/* lock the list against modification */
1228  	spin_lock(&nn->nfs_client_lock);
1229  	return seq_list_start_head(&nn->nfs_volume_list, *_pos);
1230  }
1231  
1232  /*
1233   * move to next volume
1234   */
1235  static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos)
1236  {
1237  	struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
1238  
1239  	return seq_list_next(v, &nn->nfs_volume_list, pos);
1240  }
1241  
1242  /*
1243   * clean up after reading from the transports list
1244   */
1245  static void nfs_volume_list_stop(struct seq_file *p, void *v)
1246  				__releases(&nn->nfs_client_lock)
1247  {
1248  	struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
1249  
1250  	spin_unlock(&nn->nfs_client_lock);
1251  }
1252  
1253  /*
1254   * display a header line followed by a load of call lines
1255   */
1256  static int nfs_volume_list_show(struct seq_file *m, void *v)
1257  {
1258  	struct nfs_server *server;
1259  	struct nfs_client *clp;
1260  	char dev[13];	// 8 for 2^24, 1 for ':', 3 for 2^8, 1 for '\0'
1261  	char fsid[34];	// 2 * 16 for %llx, 1 for ':', 1 for '\0'
1262  	struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
1263  
1264  	/* display header on line 1 */
1265  	if (v == &nn->nfs_volume_list) {
1266  		seq_puts(m, "NV SERVER   PORT DEV          FSID"
1267  			    "                              FSC\n");
1268  		return 0;
1269  	}
1270  	/* display one transport per line on subsequent lines */
1271  	server = list_entry(v, struct nfs_server, master_link);
1272  	clp = server->nfs_client;
1273  
1274  	snprintf(dev, sizeof(dev), "%u:%u",
1275  		 MAJOR(server->s_dev), MINOR(server->s_dev));
1276  
1277  	snprintf(fsid, sizeof(fsid), "%llx:%llx",
1278  		 (unsigned long long) server->fsid.major,
1279  		 (unsigned long long) server->fsid.minor);
1280  
1281  	rcu_read_lock();
1282  	seq_printf(m, "v%u %s %s %-12s %-33s %s\n",
1283  		   clp->rpc_ops->version,
1284  		   rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR),
1285  		   rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT),
1286  		   dev,
1287  		   fsid,
1288  		   nfs_server_fscache_state(server));
1289  	rcu_read_unlock();
1290  
1291  	return 0;
1292  }
1293  
1294  int nfs_fs_proc_net_init(struct net *net)
1295  {
1296  	struct nfs_net *nn = net_generic(net, nfs_net_id);
1297  	struct proc_dir_entry *p;
1298  
1299  	nn->proc_nfsfs = proc_net_mkdir(net, "nfsfs", net->proc_net);
1300  	if (!nn->proc_nfsfs)
1301  		goto error_0;
1302  
1303  	/* a file of servers with which we're dealing */
1304  	p = proc_create_net("servers", S_IFREG|S_IRUGO, nn->proc_nfsfs,
1305  			&nfs_server_list_ops, sizeof(struct seq_net_private));
1306  	if (!p)
1307  		goto error_1;
1308  
1309  	/* a file of volumes that we have mounted */
1310  	p = proc_create_net("volumes", S_IFREG|S_IRUGO, nn->proc_nfsfs,
1311  			&nfs_volume_list_ops, sizeof(struct seq_net_private));
1312  	if (!p)
1313  		goto error_1;
1314  	return 0;
1315  
1316  error_1:
1317  	remove_proc_subtree("nfsfs", net->proc_net);
1318  error_0:
1319  	return -ENOMEM;
1320  }
1321  
1322  void nfs_fs_proc_net_exit(struct net *net)
1323  {
1324  	remove_proc_subtree("nfsfs", net->proc_net);
1325  }
1326  
1327  /*
1328   * initialise the /proc/fs/nfsfs/ directory
1329   */
1330  int __init nfs_fs_proc_init(void)
1331  {
1332  	if (!proc_mkdir("fs/nfsfs", NULL))
1333  		goto error_0;
1334  
1335  	/* a file of servers with which we're dealing */
1336  	if (!proc_symlink("fs/nfsfs/servers", NULL, "../../net/nfsfs/servers"))
1337  		goto error_1;
1338  
1339  	/* a file of volumes that we have mounted */
1340  	if (!proc_symlink("fs/nfsfs/volumes", NULL, "../../net/nfsfs/volumes"))
1341  		goto error_1;
1342  
1343  	return 0;
1344  error_1:
1345  	remove_proc_subtree("fs/nfsfs", NULL);
1346  error_0:
1347  	return -ENOMEM;
1348  }
1349  
1350  /*
1351   * clean up the /proc/fs/nfsfs/ directory
1352   */
1353  void nfs_fs_proc_exit(void)
1354  {
1355  	remove_proc_subtree("fs/nfsfs", NULL);
1356  }
1357  
1358  #endif /* CONFIG_PROC_FS */
1359