client.c 37.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/* client.c: NFS client sharing and management code
 *
 * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */


#include <linux/module.h>
#include <linux/init.h>
A
Alexey Dobriyan 已提交
15
#include <linux/sched.h>
16 17 18 19 20 21 22 23 24 25
#include <linux/time.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/stat.h>
#include <linux/errno.h>
#include <linux/unistd.h>
#include <linux/sunrpc/clnt.h>
#include <linux/sunrpc/stats.h>
#include <linux/sunrpc/metrics.h>
26
#include <linux/sunrpc/xprtsock.h>
\
\"Talpey, Thomas\ 已提交
27
#include <linux/sunrpc/xprtrdma.h>
28 29 30 31 32 33 34 35 36
#include <linux/nfs_fs.h>
#include <linux/nfs_mount.h>
#include <linux/nfs4_mount.h>
#include <linux/lockd/bind.h>
#include <linux/seq_file.h>
#include <linux/mount.h>
#include <linux/nfs_idmap.h>
#include <linux/vfs.h>
#include <linux/inet.h>
37
#include <linux/in6.h>
38
#include <linux/slab.h>
A
Al Viro 已提交
39
#include <linux/idr.h>
40
#include <net/ipv6.h>
41
#include <linux/nfs_xdr.h>
A
Andy Adamson 已提交
42
#include <linux/sunrpc/bc_xprt.h>
43 44
#include <linux/nsproxy.h>
#include <linux/pid_namespace.h>
45 46 47 48 49 50 51


#include "nfs4_fs.h"
#include "callback.h"
#include "delegation.h"
#include "iostat.h"
#include "internal.h"
52
#include "fscache.h"
R
Ricardo Labiaga 已提交
53
#include "pnfs.h"
54
#include "nfs.h"
55
#include "netns.h"
56 57 58 59

#define NFSDBG_FACILITY		NFSDBG_CLIENT

static DECLARE_WAIT_QUEUE_HEAD(nfs_client_active_wq);
60 61 62
static DEFINE_SPINLOCK(nfs_version_lock);
static DEFINE_MUTEX(nfs_version_mutex);
static LIST_HEAD(nfs_versions);
63

64 65 66
/*
 * RPC cruft for NFS
 */
67
static const struct rpc_version *nfs_version[5] = {
68 69 70
	[2] = NULL,
	[3] = NULL,
	[4] = NULL,
71 72
};

73
const struct rpc_program nfs_program = {
74 75 76 77 78
	.name			= "nfs",
	.number			= NFS_PROGRAM,
	.nrvers			= ARRAY_SIZE(nfs_version),
	.version		= nfs_version,
	.stats			= &nfs_rpcstat,
J
Jim Rees 已提交
79
	.pipe_dir_name		= NFS_PIPE_DIRNAME,
80 81 82 83 84 85
};

struct rpc_stat nfs_rpcstat = {
	.program		= &nfs_program
};

86 87 88 89 90 91 92 93 94 95
static struct nfs_subversion *find_nfs_version(unsigned int version)
{
	struct nfs_subversion *nfs;
	spin_lock(&nfs_version_lock);

	list_for_each_entry(nfs, &nfs_versions, list) {
		if (nfs->rpc_ops->version == version) {
			spin_unlock(&nfs_version_lock);
			return nfs;
		}
96
	}
97 98

	spin_unlock(&nfs_version_lock);
99
	return ERR_PTR(-EPROTONOSUPPORT);
100 101 102 103 104 105 106 107
}

struct nfs_subversion *get_nfs_version(unsigned int version)
{
	struct nfs_subversion *nfs = find_nfs_version(version);

	if (IS_ERR(nfs)) {
		mutex_lock(&nfs_version_mutex);
108
		request_module("nfsv%d", version);
109 110 111 112
		nfs = find_nfs_version(version);
		mutex_unlock(&nfs_version_mutex);
	}

113 114
	if (!IS_ERR(nfs) && !try_module_get(nfs->owner))
		return ERR_PTR(-EAGAIN);
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
	return nfs;
}

void put_nfs_version(struct nfs_subversion *nfs)
{
	module_put(nfs->owner);
}

void register_nfs_version(struct nfs_subversion *nfs)
{
	spin_lock(&nfs_version_lock);

	list_add(&nfs->list, &nfs_versions);
	nfs_version[nfs->rpc_ops->version] = nfs->rpc_vers;

	spin_unlock(&nfs_version_lock);
}
EXPORT_SYMBOL_GPL(register_nfs_version);

void unregister_nfs_version(struct nfs_subversion *nfs)
{
	spin_lock(&nfs_version_lock);

	nfs_version[nfs->rpc_ops->version] = NULL;
	list_del(&nfs->list);

	spin_unlock(&nfs_version_lock);
}
EXPORT_SYMBOL_GPL(unregister_nfs_version);

145 146 147 148 149 150
/*
 * Allocate a shared client record
 *
 * Since these are allocated/deallocated very rarely, we don't
 * bother putting them in a slab cache...
 */
151
struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *cl_init)
152 153
{
	struct nfs_client *clp;
154
	struct rpc_cred *cred;
155
	int err = -ENOMEM;
156 157 158 159

	if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)
		goto error_0;

160
	clp->cl_nfs_mod = cl_init->nfs_mod;
161 162
	if (!try_module_get(clp->cl_nfs_mod->owner))
		goto error_dealloc;
163 164

	clp->rpc_ops = clp->cl_nfs_mod->rpc_ops;
165

166 167 168
	atomic_set(&clp->cl_count, 1);
	clp->cl_cons_state = NFS_CS_INITING;

169 170
	memcpy(&clp->cl_addr, cl_init->addr, cl_init->addrlen);
	clp->cl_addrlen = cl_init->addrlen;
171

172
	if (cl_init->hostname) {
173
		err = -ENOMEM;
174
		clp->cl_hostname = kstrdup(cl_init->hostname, GFP_KERNEL);
175
		if (!clp->cl_hostname)
176
			goto error_cleanup;
177 178 179 180 181
	}

	INIT_LIST_HEAD(&clp->cl_superblocks);
	clp->cl_rpcclient = ERR_PTR(-EINVAL);

182
	clp->cl_proto = cl_init->proto;
183
	clp->cl_net = get_net(cl_init->net);
184

185
	cred = rpc_lookup_machine_cred("*");
186 187
	if (!IS_ERR(cred))
		clp->cl_machine_cred = cred;
188 189
	nfs_fscache_get_client_cookie(clp);

190 191
	return clp;

192
error_cleanup:
193
	put_nfs_version(clp->cl_nfs_mod);
194
error_dealloc:
195 196
	kfree(clp);
error_0:
197
	return ERR_PTR(err);
198
}
B
Bryan Schumaker 已提交
199
EXPORT_SYMBOL_GPL(nfs_alloc_client);
200

B
Bryan Schumaker 已提交
201
#if IS_ENABLED(CONFIG_NFS_V4)
202
void nfs_cleanup_cb_ident_idr(struct net *net)
A
Andy Adamson 已提交
203
{
204 205 206
	struct nfs_net *nn = net_generic(net, nfs_net_id);

	idr_destroy(&nn->cb_ident_idr);
A
Andy Adamson 已提交
207 208 209 210 211
}

/* nfs_client_lock held */
static void nfs_cb_idr_remove_locked(struct nfs_client *clp)
{
212
	struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
213

A
Andy Adamson 已提交
214
	if (clp->cl_cb_ident)
215
		idr_remove(&nn->cb_ident_idr, clp->cl_cb_ident);
A
Andy Adamson 已提交
216 217
}

F
Fred Isaman 已提交
218 219 220 221 222
static void pnfs_init_server(struct nfs_server *server)
{
	rpc_init_wait_queue(&server->roc_rpcwaitq, "pNFS ROC");
}

223
#else
224
void nfs_cleanup_cb_ident_idr(struct net *net)
A
Andy Adamson 已提交
225 226 227 228 229 230
{
}

static void nfs_cb_idr_remove_locked(struct nfs_client *clp)
{
}
F
Fred Isaman 已提交
231 232 233 234 235

static void pnfs_init_server(struct nfs_server *server)
{
}

236
#endif /* CONFIG_NFS_V4 */
237

238 239 240
/*
 * Destroy a shared client record
 */
241
void nfs_free_client(struct nfs_client *clp)
242
{
243
	dprintk("--> nfs_free_client(%u)\n", clp->rpc_ops->version);
244

245 246
	nfs_fscache_release_client_cookie(clp);

247 248 249 250
	/* -EIO all pending I/O */
	if (!IS_ERR(clp->cl_rpcclient))
		rpc_shutdown_client(clp->cl_rpcclient);

251 252 253
	if (clp->cl_machine_cred != NULL)
		put_rpccred(clp->cl_machine_cred);

254
	put_net(clp->cl_net);
255
	put_nfs_version(clp->cl_nfs_mod);
256
	kfree(clp->cl_hostname);
257
	kfree(clp->cl_acceptor);
258 259 260 261
	kfree(clp);

	dprintk("<-- nfs_free_client()\n");
}
B
Bryan Schumaker 已提交
262
EXPORT_SYMBOL_GPL(nfs_free_client);
263 264 265 266 267 268

/*
 * Release a reference to a shared client record
 */
void nfs_put_client(struct nfs_client *clp)
{
269 270
	struct nfs_net *nn;

D
David Howells 已提交
271 272 273
	if (!clp)
		return;

274
	dprintk("--> nfs_put_client({%d})\n", atomic_read(&clp->cl_count));
275
	nn = net_generic(clp->cl_net, nfs_net_id);
276

277
	if (atomic_dec_and_lock(&clp->cl_count, &nn->nfs_client_lock)) {
278
		list_del(&clp->cl_share_link);
A
Andy Adamson 已提交
279
		nfs_cb_idr_remove_locked(clp);
280
		spin_unlock(&nn->nfs_client_lock);
281

282
		WARN_ON_ONCE(!list_empty(&clp->cl_superblocks));
283

284
		clp->rpc_ops->free_client(clp);
285 286
	}
}
287
EXPORT_SYMBOL_GPL(nfs_put_client);
288

289
#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
290 291 292 293 294 295 296 297 298 299 300
/*
 * Test if two ip6 socket addresses refer to the same socket by
 * comparing relevant fields. The padding bytes specifically, are not
 * compared. sin6_flowinfo is not compared because it only affects QoS
 * and sin6_scope_id is only compared if the address is "link local"
 * because "link local" addresses need only be unique to a specific
 * link. Conversely, ordinary unicast addresses might have different
 * sin6_scope_id.
 *
 * The caller should ensure both socket addresses are AF_INET6.
 */
301 302
static int nfs_sockaddr_match_ipaddr6(const struct sockaddr *sa1,
				      const struct sockaddr *sa2)
303
{
304 305
	const struct sockaddr_in6 *sin1 = (const struct sockaddr_in6 *)sa1;
	const struct sockaddr_in6 *sin2 = (const struct sockaddr_in6 *)sa2;
306

307
	if (!ipv6_addr_equal(&sin1->sin6_addr, &sin2->sin6_addr))
308
		return 0;
309 310
	else if (ipv6_addr_type(&sin1->sin6_addr) & IPV6_ADDR_LINKLOCAL)
		return sin1->sin6_scope_id == sin2->sin6_scope_id;
311

312
	return 1;
313
}
314 315 316
#else	/* !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE) */
static int nfs_sockaddr_match_ipaddr6(const struct sockaddr *sa1,
				      const struct sockaddr *sa2)
317 318 319
{
	return 0;
}
320
#endif
321

I
Ian Dall 已提交
322 323 324 325 326 327 328
/*
 * Test if two ip4 socket addresses refer to the same socket, by
 * comparing relevant fields. The padding bytes specifically, are
 * not compared.
 *
 * The caller should ensure both socket addresses are AF_INET.
 */
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
static int nfs_sockaddr_match_ipaddr4(const struct sockaddr *sa1,
				      const struct sockaddr *sa2)
{
	const struct sockaddr_in *sin1 = (const struct sockaddr_in *)sa1;
	const struct sockaddr_in *sin2 = (const struct sockaddr_in *)sa2;

	return sin1->sin_addr.s_addr == sin2->sin_addr.s_addr;
}

static int nfs_sockaddr_cmp_ip6(const struct sockaddr *sa1,
				const struct sockaddr *sa2)
{
	const struct sockaddr_in6 *sin1 = (const struct sockaddr_in6 *)sa1;
	const struct sockaddr_in6 *sin2 = (const struct sockaddr_in6 *)sa2;

	return nfs_sockaddr_match_ipaddr6(sa1, sa2) &&
		(sin1->sin6_port == sin2->sin6_port);
}

348 349
static int nfs_sockaddr_cmp_ip4(const struct sockaddr *sa1,
				const struct sockaddr *sa2)
I
Ian Dall 已提交
350
{
351 352
	const struct sockaddr_in *sin1 = (const struct sockaddr_in *)sa1;
	const struct sockaddr_in *sin2 = (const struct sockaddr_in *)sa2;
353

354 355 356 357
	return nfs_sockaddr_match_ipaddr4(sa1, sa2) &&
		(sin1->sin_port == sin2->sin_port);
}

358
#if defined(CONFIG_NFS_V4_1)
359 360 361 362
/*
 * Test if two socket addresses represent the same actual socket,
 * by comparing (only) relevant fields, excluding the port number.
 */
363 364
int nfs_sockaddr_match_ipaddr(const struct sockaddr *sa1,
			      const struct sockaddr *sa2)
365 366
{
	if (sa1->sa_family != sa2->sa_family)
I
Ian Dall 已提交
367
		return 0;
368 369 370 371 372 373 374 375

	switch (sa1->sa_family) {
	case AF_INET:
		return nfs_sockaddr_match_ipaddr4(sa1, sa2);
	case AF_INET6:
		return nfs_sockaddr_match_ipaddr6(sa1, sa2);
	}
	return 0;
I
Ian Dall 已提交
376
}
B
Bryan Schumaker 已提交
377
EXPORT_SYMBOL_GPL(nfs_sockaddr_match_ipaddr);
378
#endif /* CONFIG_NFS_V4_1 */
I
Ian Dall 已提交
379 380 381

/*
 * Test if two socket addresses represent the same actual socket,
382
 * by comparing (only) relevant fields, including the port number.
I
Ian Dall 已提交
383 384 385 386 387 388 389 390 391
 */
static int nfs_sockaddr_cmp(const struct sockaddr *sa1,
			    const struct sockaddr *sa2)
{
	if (sa1->sa_family != sa2->sa_family)
		return 0;

	switch (sa1->sa_family) {
	case AF_INET:
392
		return nfs_sockaddr_cmp_ip4(sa1, sa2);
I
Ian Dall 已提交
393
	case AF_INET6:
394
		return nfs_sockaddr_cmp_ip6(sa1, sa2);
I
Ian Dall 已提交
395 396 397 398
	}
	return 0;
}

399
/*
400 401
 * Find an nfs_client on the list that matches the initialisation data
 * that is supplied.
402
 */
403
static struct nfs_client *nfs_match_client(const struct nfs_client_initdata *data)
404 405
{
	struct nfs_client *clp;
I
Ian Dall 已提交
406
	const struct sockaddr *sap = data->addr;
407
	struct nfs_net *nn = net_generic(data->net, nfs_net_id);
408

409
	list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) {
I
Ian Dall 已提交
410
	        const struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;
411 412 413 414 415
		/* Don't match clients that failed to initialise properly */
		if (clp->cl_cons_state < 0)
			continue;

		/* Different NFS versions cannot share the same nfs_client */
416
		if (clp->rpc_ops != data->nfs_mod->rpc_ops)
417 418
			continue;

419 420
		if (clp->cl_proto != data->proto)
			continue;
421 422 423
		/* Match nfsv4 minorversion */
		if (clp->cl_minorversion != data->minorversion)
			continue;
424
		/* Match the full socket address */
I
Ian Dall 已提交
425
		if (!nfs_sockaddr_cmp(sap, clap))
426 427 428 429
			continue;

		atomic_inc(&clp->cl_count);
		return clp;
430
	}
431
	return NULL;
432 433
}

434 435 436 437 438 439 440 441 442 443
static bool nfs_client_init_is_complete(const struct nfs_client *clp)
{
	return clp->cl_cons_state != NFS_CS_INITING;
}

int nfs_wait_client_init_complete(const struct nfs_client *clp)
{
	return wait_event_killable(nfs_client_active_wq,
			nfs_client_init_is_complete(clp));
}
B
Bryan Schumaker 已提交
444
EXPORT_SYMBOL_GPL(nfs_wait_client_init_complete);
445

446 447 448 449 450 451 452 453 454
/*
 * Found an existing client.  Make sure it's ready before returning.
 */
static struct nfs_client *
nfs_found_client(const struct nfs_client_initdata *cl_init,
		 struct nfs_client *clp)
{
	int error;

455
	error = nfs_wait_client_init_complete(clp);
456 457 458 459 460 461 462 463 464 465 466
	if (error < 0) {
		nfs_put_client(clp);
		return ERR_PTR(-ERESTARTSYS);
	}

	if (clp->cl_cons_state < NFS_CS_READY) {
		error = clp->cl_cons_state;
		nfs_put_client(clp);
		return ERR_PTR(error);
	}

467 468
	smp_rmb();

469 470 471 472 473
	dprintk("<-- %s found nfs_client %p for %s\n",
		__func__, clp, cl_init->hostname ?: "");
	return clp;
}

474 475 476 477
/*
 * Look up a client by IP address and protocol version
 * - creates a new record if one doesn't yet exist
 */
478
struct nfs_client *
479 480 481
nfs_get_client(const struct nfs_client_initdata *cl_init,
	       const struct rpc_timeout *timeparms,
	       const char *ip_addr,
C
Chuck Lever 已提交
482
	       rpc_authflavor_t authflavour)
483 484
{
	struct nfs_client *clp, *new = NULL;
485
	struct nfs_net *nn = net_generic(cl_init->net, nfs_net_id);
486
	const struct nfs_rpc_ops *rpc_ops = cl_init->nfs_mod->rpc_ops;
487

P
Peng Tao 已提交
488 489 490 491 492
	if (cl_init->hostname == NULL) {
		WARN_ON(1);
		return NULL;
	}

493
	dprintk("--> nfs_get_client(%s,v%u)\n",
P
Peng Tao 已提交
494
		cl_init->hostname, rpc_ops->version);
495 496 497

	/* see if the client already exists */
	do {
498
		spin_lock(&nn->nfs_client_lock);
499

500
		clp = nfs_match_client(cl_init);
501 502 503
		if (clp) {
			spin_unlock(&nn->nfs_client_lock);
			if (new)
504
				new->rpc_ops->free_client(new);
505 506
			return nfs_found_client(cl_init, clp);
		}
507
		if (new) {
508 509
			list_add_tail(&new->cl_share_link,
					&nn->nfs_client_list);
510
			spin_unlock(&nn->nfs_client_lock);
C
Chuck Lever 已提交
511
			new->cl_flags = cl_init->init_flags;
512
			return rpc_ops->init_client(new, timeparms, ip_addr);
513
		}
514

515
		spin_unlock(&nn->nfs_client_lock);
516

517
		new = rpc_ops->alloc_client(cl_init);
518
	} while (!IS_ERR(new));
519

520
	dprintk("<-- nfs_get_client() Failed to find %s (%ld)\n",
P
Peng Tao 已提交
521
		cl_init->hostname, PTR_ERR(new));
522
	return new;
523
}
B
Bryan Schumaker 已提交
524
EXPORT_SYMBOL_GPL(nfs_get_client);
525 526 527 528

/*
 * Mark a server as ready or failed
 */
529
void nfs_mark_client_ready(struct nfs_client *clp, int state)
530
{
531
	smp_wmb();
532 533 534
	clp->cl_cons_state = state;
	wake_up_all(&nfs_client_active_wq);
}
B
Bryan Schumaker 已提交
535
EXPORT_SYMBOL_GPL(nfs_mark_client_ready);
536 537 538 539

/*
 * Initialise the timeout values for a connection
 */
540
void nfs_init_timeout_values(struct rpc_timeout *to, int proto,
541 542 543 544 545 546
				    unsigned int timeo, unsigned int retrans)
{
	to->to_initval = timeo * HZ / 10;
	to->to_retries = retrans;

	switch (proto) {
547
	case XPRT_TRANSPORT_TCP:
\
\"Talpey, Thomas\ 已提交
548
	case XPRT_TRANSPORT_RDMA:
549 550
		if (to->to_retries == 0)
			to->to_retries = NFS_DEF_TCP_RETRANS;
551
		if (to->to_initval == 0)
552
			to->to_initval = NFS_DEF_TCP_TIMEO * HZ / 10;
553 554 555 556
		if (to->to_initval > NFS_MAX_TCP_TIMEOUT)
			to->to_initval = NFS_MAX_TCP_TIMEOUT;
		to->to_increment = to->to_initval;
		to->to_maxval = to->to_initval + (to->to_increment * to->to_retries);
557 558 559 560
		if (to->to_maxval > NFS_MAX_TCP_TIMEOUT)
			to->to_maxval = NFS_MAX_TCP_TIMEOUT;
		if (to->to_maxval < to->to_initval)
			to->to_maxval = to->to_initval;
561 562
		to->to_exponential = 0;
		break;
563
	case XPRT_TRANSPORT_UDP:
564 565
		if (to->to_retries == 0)
			to->to_retries = NFS_DEF_UDP_RETRANS;
566
		if (!to->to_initval)
567
			to->to_initval = NFS_DEF_UDP_TIMEO * HZ / 10;
568 569 570 571 572
		if (to->to_initval > NFS_MAX_UDP_TIMEOUT)
			to->to_initval = NFS_MAX_UDP_TIMEOUT;
		to->to_maxval = NFS_MAX_UDP_TIMEOUT;
		to->to_exponential = 1;
		break;
573 574
	default:
		BUG();
575 576
	}
}
B
Bryan Schumaker 已提交
577
EXPORT_SYMBOL_GPL(nfs_init_timeout_values);
578 579 580 581

/*
 * Create an RPC client handle
 */
582 583 584
int nfs_create_rpc_client(struct nfs_client *clp,
			  const struct rpc_timeout *timeparms,
			  rpc_authflavor_t flavor)
585 586
{
	struct rpc_clnt		*clnt = NULL;
587
	struct rpc_create_args args = {
588
		.net		= clp->cl_net,
589
		.protocol	= clp->cl_proto,
590
		.address	= (struct sockaddr *)&clp->cl_addr,
591
		.addrsize	= clp->cl_addrlen,
592
		.timeout	= timeparms,
593 594 595 596 597
		.servername	= clp->cl_hostname,
		.program	= &nfs_program,
		.version	= clp->rpc_ops->version,
		.authflavor	= flavor,
	};
598

C
Chuck Lever 已提交
599
	if (test_bit(NFS_CS_DISCRTRY, &clp->cl_flags))
600
		args.flags |= RPC_CLNT_CREATE_DISCRTRY;
601 602
	if (test_bit(NFS_CS_NO_RETRANS_TIMEOUT, &clp->cl_flags))
		args.flags |= RPC_CLNT_CREATE_NO_RETRANS_TIMEOUT;
C
Chuck Lever 已提交
603
	if (test_bit(NFS_CS_NORESVPORT, &clp->cl_flags))
604
		args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
605 606
	if (test_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags))
		args.flags |= RPC_CLNT_CREATE_INFINITE_SLOTS;
607

608 609 610
	if (!IS_ERR(clp->cl_rpcclient))
		return 0;

611
	clnt = rpc_create(&args);
612 613
	if (IS_ERR(clnt)) {
		dprintk("%s: cannot create RPC client. Error = %ld\n",
614
				__func__, PTR_ERR(clnt));
615 616 617 618 619 620
		return PTR_ERR(clnt);
	}

	clp->cl_rpcclient = clnt;
	return 0;
}
B
Bryan Schumaker 已提交
621
EXPORT_SYMBOL_GPL(nfs_create_rpc_client);
622 623 624 625 626 627

/*
 * Version 2 or 3 client destruction
 */
static void nfs_destroy_server(struct nfs_server *server)
{
628
	if (server->nlm_host)
629
		nlmclnt_done(server->nlm_host);
630 631 632 633 634 635 636
}

/*
 * Version 2 or 3 lockd setup
 */
static int nfs_start_lockd(struct nfs_server *server)
{
637 638
	struct nlm_host *host;
	struct nfs_client *clp = server->nfs_client;
639 640 641 642 643
	struct nlmclnt_initdata nlm_init = {
		.hostname	= clp->cl_hostname,
		.address	= (struct sockaddr *)&clp->cl_addr,
		.addrlen	= clp->cl_addrlen,
		.nfs_version	= clp->rpc_ops->version,
644 645
		.noresvport	= server->flags & NFS_MOUNT_NORESVPORT ?
					1 : 0,
646
		.net		= clp->cl_net,
647
	};
648

649
	if (nlm_init.nfs_version > 3)
650
		return 0;
651 652
	if ((server->flags & NFS_MOUNT_LOCAL_FLOCK) &&
			(server->flags & NFS_MOUNT_LOCAL_FCNTL))
653 654
		return 0;

655 656 657 658 659 660 661 662
	switch (clp->cl_proto) {
		default:
			nlm_init.protocol = IPPROTO_TCP;
			break;
		case XPRT_TRANSPORT_UDP:
			nlm_init.protocol = IPPROTO_UDP;
	}

663
	host = nlmclnt_init(&nlm_init);
664 665 666 667 668 669
	if (IS_ERR(host))
		return PTR_ERR(host);

	server->nlm_host = host;
	server->destroy = nfs_destroy_server;
	return 0;
670 671 672 673 674
}

/*
 * Create a general RPC client
 */
675
int nfs_init_server_rpcclient(struct nfs_server *server,
676 677
		const struct rpc_timeout *timeo,
		rpc_authflavor_t pseudoflavour)
678 679 680
{
	struct nfs_client *clp = server->nfs_client;

681 682
	server->client = rpc_clone_client_set_auth(clp->cl_rpcclient,
							pseudoflavour);
683
	if (IS_ERR(server->client)) {
684
		dprintk("%s: couldn't create rpc_client!\n", __func__);
685 686 687
		return PTR_ERR(server->client);
	}

688 689 690 691
	memcpy(&server->client->cl_timeout_default,
			timeo,
			sizeof(server->client->cl_timeout_default));
	server->client->cl_timeout = &server->client->cl_timeout_default;
692 693 694 695 696 697
	server->client->cl_softrtry = 0;
	if (server->flags & NFS_MOUNT_SOFT)
		server->client->cl_softrtry = 1;

	return 0;
}
B
Bryan Schumaker 已提交
698
EXPORT_SYMBOL_GPL(nfs_init_server_rpcclient);
699

700 701 702 703 704 705 706 707
/**
 * nfs_init_client - Initialise an NFS2 or NFS3 client
 *
 * @clp: nfs_client to initialise
 * @timeparms: timeout parameters for underlying RPC transport
 * @ip_addr: IP presentation address (not used)
 *
 * Returns pointer to an NFS client, or an ERR_PTR value.
708
 */
709 710
struct nfs_client *nfs_init_client(struct nfs_client *clp,
		    const struct rpc_timeout *timeparms,
711
		    const char *ip_addr)
712 713 714 715 716 717
{
	int error;

	if (clp->cl_cons_state == NFS_CS_READY) {
		/* the client is already initialised */
		dprintk("<-- nfs_init_client() = 0 [already %p]\n", clp);
718
		return clp;
719 720 721 722 723 724
	}

	/*
	 * Create a client RPC handle for doing FSSTAT with UNIX auth only
	 * - RFC 2623, sec 2.3.2
	 */
C
Chuck Lever 已提交
725
	error = nfs_create_rpc_client(clp, timeparms, RPC_AUTH_UNIX);
726 727 728
	if (error < 0)
		goto error;
	nfs_mark_client_ready(clp, NFS_CS_READY);
729
	return clp;
730 731 732

error:
	nfs_mark_client_ready(clp, error);
733
	nfs_put_client(clp);
734
	dprintk("<-- nfs_init_client() = xerror %d\n", error);
735
	return ERR_PTR(error);
736
}
B
Bryan Schumaker 已提交
737
EXPORT_SYMBOL_GPL(nfs_init_client);
738 739 740 741

/*
 * Create a version 2 or 3 client
 */
742
static int nfs_init_server(struct nfs_server *server,
743 744
			   const struct nfs_parsed_mount_data *data,
			   struct nfs_subversion *nfs_mod)
745
{
746 747
	struct nfs_client_initdata cl_init = {
		.hostname = data->nfs_server.hostname,
748
		.addr = (const struct sockaddr *)&data->nfs_server.address,
749
		.addrlen = data->nfs_server.addrlen,
750
		.nfs_mod = nfs_mod,
751
		.proto = data->nfs_server.protocol,
752
		.net = data->net,
753
	};
754
	struct rpc_timeout timeparms;
755
	struct nfs_client *clp;
756
	int error;
757 758 759

	dprintk("--> nfs_init_server()\n");

760 761
	nfs_init_timeout_values(&timeparms, data->nfs_server.protocol,
			data->timeo, data->retrans);
C
Chuck Lever 已提交
762 763
	if (data->flags & NFS_MOUNT_NORESVPORT)
		set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
764

765
	/* Allocate or find a client reference we can use */
C
Chuck Lever 已提交
766
	clp = nfs_get_client(&cl_init, &timeparms, NULL, RPC_AUTH_UNIX);
767 768 769 770 771 772 773 774
	if (IS_ERR(clp)) {
		dprintk("<-- nfs_init_server() = error %ld\n", PTR_ERR(clp));
		return PTR_ERR(clp);
	}

	server->nfs_client = clp;

	/* Initialise the client representation from the mount data */
775
	server->flags = data->flags;
776
	server->options = data->options;
777 778
	server->caps |= NFS_CAP_HARDLINKS|NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
		NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|NFS_CAP_OWNER_GROUP|
779
		NFS_CAP_ATIME|NFS_CAP_CTIME|NFS_CAP_MTIME|NFS_CAP_CHANGE_ATTR;
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795

	if (data->rsize)
		server->rsize = nfs_block_size(data->rsize, NULL);
	if (data->wsize)
		server->wsize = nfs_block_size(data->wsize, NULL);

	server->acregmin = data->acregmin * HZ;
	server->acregmax = data->acregmax * HZ;
	server->acdirmin = data->acdirmin * HZ;
	server->acdirmax = data->acdirmax * HZ;

	/* Start lockd here, before we might error out */
	error = nfs_start_lockd(server);
	if (error < 0)
		goto error;

796
	server->port = data->nfs_server.port;
797
	server->auth_info = data->auth_info;
798

799 800
	error = nfs_init_server_rpcclient(server, &timeparms,
					  data->selected_flavor);
801 802 803
	if (error < 0)
		goto error;

804 805 806 807 808 809 810 811 812 813
	/* Preserve the values of mount_server-related mount options */
	if (data->mount_server.addrlen) {
		memcpy(&server->mountd_address, &data->mount_server.address,
			data->mount_server.addrlen);
		server->mountd_addrlen = data->mount_server.addrlen;
	}
	server->mountd_version = data->mount_server.version;
	server->mountd_port = data->mount_server.port;
	server->mountd_protocol = data->mount_server.protocol;

814 815 816 817 818 819 820 821 822 823 824 825 826 827
	server->namelen  = data->namlen;
	dprintk("<-- nfs_init_server() = 0 [new %p]\n", clp);
	return 0;

error:
	server->nfs_client = NULL;
	nfs_put_client(clp);
	dprintk("<-- nfs_init_server() = xerror %d\n", error);
	return error;
}

/*
 * Load up the server record from information gained in an fsinfo record
 */
828 829 830
static void nfs_server_set_fsinfo(struct nfs_server *server,
				  struct nfs_fh *mntfh,
				  struct nfs_fsinfo *fsinfo)
831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850
{
	unsigned long max_rpc_payload;

	/* Work out a lot of parameters */
	if (server->rsize == 0)
		server->rsize = nfs_block_size(fsinfo->rtpref, NULL);
	if (server->wsize == 0)
		server->wsize = nfs_block_size(fsinfo->wtpref, NULL);

	if (fsinfo->rtmax >= 512 && server->rsize > fsinfo->rtmax)
		server->rsize = nfs_block_size(fsinfo->rtmax, NULL);
	if (fsinfo->wtmax >= 512 && server->wsize > fsinfo->wtmax)
		server->wsize = nfs_block_size(fsinfo->wtmax, NULL);

	max_rpc_payload = nfs_block_size(rpc_max_payload(server->client), NULL);
	if (server->rsize > max_rpc_payload)
		server->rsize = max_rpc_payload;
	if (server->rsize > NFS_MAX_FILE_IO_SIZE)
		server->rsize = NFS_MAX_FILE_IO_SIZE;
	server->rpages = (server->rsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
P
Peter Zijlstra 已提交
851

852
	server->backing_dev_info.name = "nfs";
853 854 855 856 857 858 859
	server->backing_dev_info.ra_pages = server->rpages * NFS_MAX_READAHEAD;

	if (server->wsize > max_rpc_payload)
		server->wsize = max_rpc_payload;
	if (server->wsize > NFS_MAX_FILE_IO_SIZE)
		server->wsize = NFS_MAX_FILE_IO_SIZE;
	server->wpages = (server->wsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
R
Ricardo Labiaga 已提交
860

861 862 863
	server->wtmult = nfs_block_bits(fsinfo->wtmult, NULL);

	server->dtsize = nfs_block_size(fsinfo->dtpref, NULL);
B
Bryan Schumaker 已提交
864 865
	if (server->dtsize > PAGE_CACHE_SIZE * NFS_MAX_READDIR_PAGES)
		server->dtsize = PAGE_CACHE_SIZE * NFS_MAX_READDIR_PAGES;
866 867 868 869 870 871 872 873 874 875
	if (server->dtsize > server->rsize)
		server->dtsize = server->rsize;

	if (server->flags & NFS_MOUNT_NOAC) {
		server->acregmin = server->acregmax = 0;
		server->acdirmin = server->acdirmax = 0;
	}

	server->maxfilesize = fsinfo->maxfilesize;

R
Ricardo Labiaga 已提交
876 877
	server->time_delta = fsinfo->time_delta;

878 879 880 881 882 883 884
	/* We're airborne Set socket buffersize */
	rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);
}

/*
 * Probe filesystem information, including the FSID on v2/v3
 */
885
int nfs_probe_fsinfo(struct nfs_server *server, struct nfs_fh *mntfh, struct nfs_fattr *fattr)
886 887 888 889 890 891 892 893 894 895 896 897 898 899
{
	struct nfs_fsinfo fsinfo;
	struct nfs_client *clp = server->nfs_client;
	int error;

	dprintk("--> nfs_probe_fsinfo()\n");

	if (clp->rpc_ops->set_capabilities != NULL) {
		error = clp->rpc_ops->set_capabilities(server, mntfh);
		if (error < 0)
			goto out_error;
	}

	fsinfo.fattr = fattr;
R
Ricardo Labiaga 已提交
900
	fsinfo.layouttype = 0;
901 902 903 904
	error = clp->rpc_ops->fsinfo(server, mntfh, &fsinfo);
	if (error < 0)
		goto out_error;

905
	nfs_server_set_fsinfo(server, mntfh, &fsinfo);
906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924

	/* Get some general file system info */
	if (server->namelen == 0) {
		struct nfs_pathconf pathinfo;

		pathinfo.fattr = fattr;
		nfs_fattr_init(fattr);

		if (clp->rpc_ops->pathconf(server, mntfh, &pathinfo) >= 0)
			server->namelen = pathinfo.max_namelen;
	}

	dprintk("<-- nfs_probe_fsinfo() = 0\n");
	return 0;

out_error:
	dprintk("nfs_probe_fsinfo: error = %d\n", -error);
	return error;
}
B
Bryan Schumaker 已提交
925
EXPORT_SYMBOL_GPL(nfs_probe_fsinfo);
926 927 928 929

/*
 * Copy useful information when duplicating a server record
 */
930
void nfs_server_copy_userdata(struct nfs_server *target, struct nfs_server *source)
931 932
{
	target->flags = source->flags;
933 934
	target->rsize = source->rsize;
	target->wsize = source->wsize;
935 936 937 938 939
	target->acregmin = source->acregmin;
	target->acregmax = source->acregmax;
	target->acdirmin = source->acdirmin;
	target->acdirmax = source->acdirmax;
	target->caps = source->caps;
940
	target->options = source->options;
941
	target->auth_info = source->auth_info;
942
}
B
Bryan Schumaker 已提交
943
EXPORT_SYMBOL_GPL(nfs_server_copy_userdata);
944

945
void nfs_server_insert_lists(struct nfs_server *server)
946 947
{
	struct nfs_client *clp = server->nfs_client;
948
	struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
949

950
	spin_lock(&nn->nfs_client_lock);
951
	list_add_tail_rcu(&server->client_link, &clp->cl_superblocks);
952
	list_add_tail(&server->master_link, &nn->nfs_volume_list);
953
	clear_bit(NFS_CS_STOP_RENEW, &clp->cl_res_state);
954
	spin_unlock(&nn->nfs_client_lock);
955 956

}
B
Bryan Schumaker 已提交
957
EXPORT_SYMBOL_GPL(nfs_server_insert_lists);
958

C
Chuck Lever 已提交
959
void nfs_server_remove_lists(struct nfs_server *server)
960
{
961
	struct nfs_client *clp = server->nfs_client;
962
	struct nfs_net *nn;
963

964 965
	if (clp == NULL)
		return;
966
	nn = net_generic(clp->cl_net, nfs_net_id);
967
	spin_lock(&nn->nfs_client_lock);
968
	list_del_rcu(&server->client_link);
969
	if (list_empty(&clp->cl_superblocks))
970
		set_bit(NFS_CS_STOP_RENEW, &clp->cl_res_state);
971
	list_del(&server->master_link);
972
	spin_unlock(&nn->nfs_client_lock);
973 974 975

	synchronize_rcu();
}
C
Chuck Lever 已提交
976
EXPORT_SYMBOL_GPL(nfs_server_remove_lists);
977

978 979 980
/*
 * Allocate and initialise a server record
 */
981
struct nfs_server *nfs_alloc_server(void)
982 983 984 985 986 987 988 989 990 991 992 993
{
	struct nfs_server *server;

	server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
	if (!server)
		return NULL;

	server->client = server->client_acl = ERR_PTR(-EINVAL);

	/* Zero out the NFS state stuff */
	INIT_LIST_HEAD(&server->client_link);
	INIT_LIST_HEAD(&server->master_link);
994
	INIT_LIST_HEAD(&server->delegations);
995
	INIT_LIST_HEAD(&server->layouts);
996
	INIT_LIST_HEAD(&server->state_owners_lru);
997

998 999
	atomic_set(&server->active, 0);

1000 1001 1002 1003 1004 1005
	server->io_stats = nfs_alloc_iostats();
	if (!server->io_stats) {
		kfree(server);
		return NULL;
	}

1006 1007 1008 1009 1010 1011
	if (bdi_init(&server->backing_dev_info)) {
		nfs_free_iostats(server->io_stats);
		kfree(server);
		return NULL;
	}

1012
	ida_init(&server->openowner_id);
1013
	ida_init(&server->lockowner_id);
F
Fred Isaman 已提交
1014 1015
	pnfs_init_server(server);

1016 1017
	return server;
}
B
Bryan Schumaker 已提交
1018
EXPORT_SYMBOL_GPL(nfs_alloc_server);
1019 1020 1021 1022 1023 1024 1025 1026

/*
 * Free up a server record
 */
void nfs_free_server(struct nfs_server *server)
{
	dprintk("--> nfs_free_server()\n");

1027
	nfs_server_remove_lists(server);
1028 1029 1030

	if (server->destroy != NULL)
		server->destroy(server);
1031 1032 1033

	if (!IS_ERR(server->client_acl))
		rpc_shutdown_client(server->client_acl);
1034 1035 1036 1037 1038
	if (!IS_ERR(server->client))
		rpc_shutdown_client(server->client);

	nfs_put_client(server->nfs_client);

1039
	ida_destroy(&server->lockowner_id);
1040
	ida_destroy(&server->openowner_id);
1041
	nfs_free_iostats(server->io_stats);
P
Peter Zijlstra 已提交
1042
	bdi_destroy(&server->backing_dev_info);
1043 1044 1045 1046
	kfree(server);
	nfs_release_automount_timer();
	dprintk("<-- nfs_free_server()\n");
}
B
Bryan Schumaker 已提交
1047
EXPORT_SYMBOL_GPL(nfs_free_server);
1048 1049 1050 1051 1052

/*
 * Create a version 2 or 3 volume record
 * - keyed on server and FSID
 */
1053
struct nfs_server *nfs_create_server(struct nfs_mount_info *mount_info,
1054
				     struct nfs_subversion *nfs_mod)
1055 1056
{
	struct nfs_server *server;
1057
	struct nfs_fattr *fattr;
1058 1059 1060 1061 1062 1063
	int error;

	server = nfs_alloc_server();
	if (!server)
		return ERR_PTR(-ENOMEM);

1064 1065 1066 1067 1068
	error = -ENOMEM;
	fattr = nfs_alloc_fattr();
	if (fattr == NULL)
		goto error;

1069
	/* Get a client representation */
1070
	error = nfs_init_server(server, mount_info->parsed, nfs_mod);
1071 1072 1073 1074
	if (error < 0)
		goto error;

	/* Probe the root fh to retrieve its FSID */
1075
	error = nfs_probe_fsinfo(server, mount_info->mntfh, fattr);
1076 1077
	if (error < 0)
		goto error;
1078 1079 1080
	if (server->nfs_client->rpc_ops->version == 3) {
		if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
			server->namelen = NFS3_MAXNAMLEN;
1081
		if (!(mount_info->parsed->flags & NFS_MOUNT_NORDIRPLUS))
1082 1083 1084 1085 1086 1087
			server->caps |= NFS_CAP_READDIRPLUS;
	} else {
		if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
			server->namelen = NFS2_MAXNAMLEN;
	}

1088
	if (!(fattr->valid & NFS_ATTR_FATTR)) {
1089
		error = nfs_mod->rpc_ops->getattr(server, mount_info->mntfh, fattr, NULL);
1090 1091 1092 1093 1094
		if (error < 0) {
			dprintk("nfs_create_server: getattr error = %d\n", -error);
			goto error;
		}
	}
1095
	memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
1096

1097 1098 1099
	dprintk("Server FSID: %llx:%llx\n",
		(unsigned long long) server->fsid.major,
		(unsigned long long) server->fsid.minor);
1100

1101
	nfs_server_insert_lists(server);
1102
	server->mount_time = jiffies;
1103
	nfs_free_fattr(fattr);
1104 1105 1106
	return server;

error:
1107
	nfs_free_fattr(fattr);
1108 1109 1110
	nfs_free_server(server);
	return ERR_PTR(error);
}
B
Bryan Schumaker 已提交
1111
EXPORT_SYMBOL_GPL(nfs_create_server);
1112 1113 1114 1115 1116 1117

/*
 * Clone an NFS2, NFS3 or NFS4 server record
 */
struct nfs_server *nfs_clone_server(struct nfs_server *source,
				    struct nfs_fh *fh,
1118 1119
				    struct nfs_fattr *fattr,
				    rpc_authflavor_t flavor)
1120 1121
{
	struct nfs_server *server;
1122
	struct nfs_fattr *fattr_fsinfo;
1123 1124 1125
	int error;

	dprintk("--> nfs_clone_server(,%llx:%llx,)\n",
1126 1127
		(unsigned long long) fattr->fsid.major,
		(unsigned long long) fattr->fsid.minor);
1128 1129 1130 1131 1132

	server = nfs_alloc_server();
	if (!server)
		return ERR_PTR(-ENOMEM);

1133 1134 1135 1136 1137
	error = -ENOMEM;
	fattr_fsinfo = nfs_alloc_fattr();
	if (fattr_fsinfo == NULL)
		goto out_free_server;

1138 1139
	/* Copy data from the source */
	server->nfs_client = source->nfs_client;
1140
	server->destroy = source->destroy;
1141 1142 1143 1144 1145
	atomic_inc(&server->nfs_client->cl_count);
	nfs_server_copy_userdata(server, source);

	server->fsid = fattr->fsid;

1146 1147
	error = nfs_init_server_rpcclient(server,
			source->client->cl_timeout,
1148
			flavor);
1149 1150 1151 1152
	if (error < 0)
		goto out_free_server;

	/* probe the filesystem info for this server filesystem */
1153
	error = nfs_probe_fsinfo(server, fh, fattr_fsinfo);
1154 1155 1156
	if (error < 0)
		goto out_free_server;

1157 1158 1159
	if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
		server->namelen = NFS4_MAXNAMLEN;

1160
	dprintk("Cloned FSID: %llx:%llx\n",
1161 1162
		(unsigned long long) server->fsid.major,
		(unsigned long long) server->fsid.minor);
1163 1164 1165 1166 1167

	error = nfs_start_lockd(server);
	if (error < 0)
		goto out_free_server;

1168
	nfs_server_insert_lists(server);
1169 1170
	server->mount_time = jiffies;

1171
	nfs_free_fattr(fattr_fsinfo);
1172 1173 1174 1175
	dprintk("<-- nfs_clone_server() = %p\n", server);
	return server;

out_free_server:
1176
	nfs_free_fattr(fattr_fsinfo);
1177 1178 1179 1180
	nfs_free_server(server);
	dprintk("<-- nfs_clone_server() = error %d\n", error);
	return ERR_PTR(error);
}
B
Bryan Schumaker 已提交
1181
EXPORT_SYMBOL_GPL(nfs_clone_server);
1182

1183 1184 1185 1186 1187
void nfs_clients_init(struct net *net)
{
	struct nfs_net *nn = net_generic(net, nfs_net_id);

	INIT_LIST_HEAD(&nn->nfs_client_list);
1188
	INIT_LIST_HEAD(&nn->nfs_volume_list);
B
Bryan Schumaker 已提交
1189
#if IS_ENABLED(CONFIG_NFS_V4)
1190 1191
	idr_init(&nn->cb_ident_idr);
#endif
1192
	spin_lock_init(&nn->nfs_client_lock);
1193
	nn->boot_time = CURRENT_TIME;
1194 1195
}

1196 1197 1198 1199 1200 1201 1202 1203 1204
#ifdef CONFIG_PROC_FS
static struct proc_dir_entry *proc_fs_nfs;

static int nfs_server_list_open(struct inode *inode, struct file *file);
static void *nfs_server_list_start(struct seq_file *p, loff_t *pos);
static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos);
static void nfs_server_list_stop(struct seq_file *p, void *v);
static int nfs_server_list_show(struct seq_file *m, void *v);

J
James Morris 已提交
1205
static const struct seq_operations nfs_server_list_ops = {
1206 1207 1208 1209 1210 1211
	.start	= nfs_server_list_start,
	.next	= nfs_server_list_next,
	.stop	= nfs_server_list_stop,
	.show	= nfs_server_list_show,
};

1212
static const struct file_operations nfs_server_list_fops = {
1213 1214 1215
	.open		= nfs_server_list_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
1216
	.release	= seq_release_net,
1217
	.owner		= THIS_MODULE,
1218 1219 1220 1221 1222 1223 1224 1225
};

static int nfs_volume_list_open(struct inode *inode, struct file *file);
static void *nfs_volume_list_start(struct seq_file *p, loff_t *pos);
static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos);
static void nfs_volume_list_stop(struct seq_file *p, void *v);
static int nfs_volume_list_show(struct seq_file *m, void *v);

J
James Morris 已提交
1226
static const struct seq_operations nfs_volume_list_ops = {
1227 1228 1229 1230 1231 1232
	.start	= nfs_volume_list_start,
	.next	= nfs_volume_list_next,
	.stop	= nfs_volume_list_stop,
	.show	= nfs_volume_list_show,
};

1233
static const struct file_operations nfs_volume_list_fops = {
1234 1235 1236
	.open		= nfs_volume_list_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
1237
	.release	= seq_release_net,
1238
	.owner		= THIS_MODULE,
1239 1240 1241 1242 1243 1244 1245 1246
};

/*
 * open "/proc/fs/nfsfs/servers" which provides a summary of servers with which
 * we're dealing
 */
static int nfs_server_list_open(struct inode *inode, struct file *file)
{
1247 1248
	return seq_open_net(inode, file, &nfs_server_list_ops,
			   sizeof(struct seq_net_private));
1249 1250 1251 1252 1253 1254 1255
}

/*
 * set up the iterator to start reading from the server list and return the first item
 */
static void *nfs_server_list_start(struct seq_file *m, loff_t *_pos)
{
1256
	struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
1257

1258
	/* lock the list against modification */
1259
	spin_lock(&nn->nfs_client_lock);
1260
	return seq_list_start_head(&nn->nfs_client_list, *_pos);
1261 1262 1263 1264 1265 1266 1267
}

/*
 * move to next server
 */
static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos)
{
1268
	struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
1269 1270

	return seq_list_next(v, &nn->nfs_client_list, pos);
1271 1272 1273 1274 1275 1276 1277
}

/*
 * clean up after reading from the transports list
 */
static void nfs_server_list_stop(struct seq_file *p, void *v)
{
1278
	struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
1279 1280

	spin_unlock(&nn->nfs_client_lock);
1281 1282 1283 1284 1285 1286 1287 1288
}

/*
 * display a header line followed by a load of call lines
 */
static int nfs_server_list_show(struct seq_file *m, void *v)
{
	struct nfs_client *clp;
1289
	struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
1290 1291

	/* display header on line 1 */
1292
	if (v == &nn->nfs_client_list) {
1293 1294 1295 1296 1297 1298 1299
		seq_puts(m, "NV SERVER   PORT USE HOSTNAME\n");
		return 0;
	}

	/* display one transport per line on subsequent lines */
	clp = list_entry(v, struct nfs_client, cl_share_link);

1300 1301 1302 1303
	/* Check if the client is initialized */
	if (clp->cl_cons_state != NFS_CS_READY)
		return 0;

1304
	rcu_read_lock();
1305
	seq_printf(m, "v%u %s %s %3d %s\n",
1306
		   clp->rpc_ops->version,
1307 1308
		   rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR),
		   rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT),
1309 1310
		   atomic_read(&clp->cl_count),
		   clp->cl_hostname);
1311
	rcu_read_unlock();
1312 1313 1314 1315 1316 1317 1318 1319 1320

	return 0;
}

/*
 * open "/proc/fs/nfsfs/volumes" which provides a summary of extant volumes
 */
static int nfs_volume_list_open(struct inode *inode, struct file *file)
{
1321 1322
	return seq_open_net(inode, file, &nfs_server_list_ops,
			   sizeof(struct seq_net_private));
1323 1324 1325 1326 1327 1328 1329
}

/*
 * set up the iterator to start reading from the volume list and return the first item
 */
static void *nfs_volume_list_start(struct seq_file *m, loff_t *_pos)
{
1330
	struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
1331

1332
	/* lock the list against modification */
1333
	spin_lock(&nn->nfs_client_lock);
1334
	return seq_list_start_head(&nn->nfs_volume_list, *_pos);
1335 1336 1337 1338 1339 1340 1341
}

/*
 * move to next volume
 */
static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos)
{
1342
	struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
1343 1344

	return seq_list_next(v, &nn->nfs_volume_list, pos);
1345 1346 1347 1348 1349 1350 1351
}

/*
 * clean up after reading from the transports list
 */
static void nfs_volume_list_stop(struct seq_file *p, void *v)
{
1352
	struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id);
1353 1354

	spin_unlock(&nn->nfs_client_lock);
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364
}

/*
 * display a header line followed by a load of call lines
 */
static int nfs_volume_list_show(struct seq_file *m, void *v)
{
	struct nfs_server *server;
	struct nfs_client *clp;
	char dev[8], fsid[17];
1365
	struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id);
1366 1367

	/* display header on line 1 */
1368
	if (v == &nn->nfs_volume_list) {
D
David Howells 已提交
1369
		seq_puts(m, "NV SERVER   PORT DEV     FSID              FSC\n");
1370 1371 1372 1373 1374 1375 1376 1377 1378 1379
		return 0;
	}
	/* display one transport per line on subsequent lines */
	server = list_entry(v, struct nfs_server, master_link);
	clp = server->nfs_client;

	snprintf(dev, 8, "%u:%u",
		 MAJOR(server->s_dev), MINOR(server->s_dev));

	snprintf(fsid, 17, "%llx:%llx",
1380 1381
		 (unsigned long long) server->fsid.major,
		 (unsigned long long) server->fsid.minor);
1382

1383
	rcu_read_lock();
D
David Howells 已提交
1384
	seq_printf(m, "v%u %s %s %-7s %-17s %s\n",
1385
		   clp->rpc_ops->version,
1386 1387
		   rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR),
		   rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT),
1388
		   dev,
D
David Howells 已提交
1389 1390
		   fsid,
		   nfs_server_fscache_state(server));
1391
	rcu_read_unlock();
1392 1393 1394 1395

	return 0;
}

1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414
int nfs_fs_proc_net_init(struct net *net)
{
	struct nfs_net *nn = net_generic(net, nfs_net_id);
	struct proc_dir_entry *p;

	nn->proc_nfsfs = proc_net_mkdir(net, "nfsfs", net->proc_net);
	if (!nn->proc_nfsfs)
		goto error_0;

	/* a file of servers with which we're dealing */
	p = proc_create("servers", S_IFREG|S_IRUGO,
			nn->proc_nfsfs, &nfs_server_list_fops);
	if (!p)
		goto error_1;

	/* a file of volumes that we have mounted */
	p = proc_create("volumes", S_IFREG|S_IRUGO,
			nn->proc_nfsfs, &nfs_volume_list_fops);
	if (!p)
1415
		goto error_1;
1416 1417 1418
	return 0;

error_1:
1419
	remove_proc_subtree("nfsfs", net->proc_net);
1420 1421 1422 1423 1424 1425
error_0:
	return -ENOMEM;
}

void nfs_fs_proc_net_exit(struct net *net)
{
1426
	remove_proc_subtree("nfsfs", net->proc_net);
1427 1428
}

1429 1430 1431 1432 1433 1434 1435
/*
 * initialise the /proc/fs/nfsfs/ directory
 */
int __init nfs_fs_proc_init(void)
{
	struct proc_dir_entry *p;

A
Alexey Dobriyan 已提交
1436
	proc_fs_nfs = proc_mkdir("fs/nfsfs", NULL);
1437 1438 1439 1440
	if (!proc_fs_nfs)
		goto error_0;

	/* a file of servers with which we're dealing */
1441
	p = proc_symlink("servers", proc_fs_nfs, "../../net/nfsfs/servers");
1442 1443 1444 1445
	if (!p)
		goto error_1;

	/* a file of volumes that we have mounted */
1446
	p = proc_symlink("volumes", proc_fs_nfs, "../../net/nfsfs/volumes");
1447 1448 1449 1450 1451 1452 1453
	if (!p)
		goto error_2;
	return 0;

error_2:
	remove_proc_entry("servers", proc_fs_nfs);
error_1:
A
Alexey Dobriyan 已提交
1454
	remove_proc_entry("fs/nfsfs", NULL);
1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465
error_0:
	return -ENOMEM;
}

/*
 * clean up the /proc/fs/nfsfs/ directory
 */
void nfs_fs_proc_exit(void)
{
	remove_proc_entry("volumes", proc_fs_nfs);
	remove_proc_entry("servers", proc_fs_nfs);
A
Alexey Dobriyan 已提交
1466
	remove_proc_entry("fs/nfsfs", NULL);
1467 1468 1469
}

#endif /* CONFIG_PROC_FS */