super.c 63.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 *  linux/fs/nfs/super.c
 *
 *  Copyright (C) 1992  Rick Sladkey
 *
 *  nfs superblock handling functions
 *
 *  Modularised by Alan Cox <Alan.Cox@linux.org>, while hacking some
 *  experimental NFS changes. Modularisation taken straight from SYS5 fs.
 *
 *  Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
 *  J.S.Peatfield@damtp.cam.ac.uk
 *
 *  Split from inode.c by David Howells <dhowells@redhat.com>
 *
16 17 18 19 20
 * - superblocks are indexed on server only - all inodes, dentries, etc. associated with a
 *   particular server are held in the same superblock
 * - NFS superblocks can have several effective roots to the dentry tree
 * - directory type roots are spliced into the tree when a path from one root reaches the root
 *   of another (see nfs_lookup())
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
 */

#include <linux/module.h>
#include <linux/init.h>

#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>
36
#include <linux/sunrpc/xprtsock.h>
37
#include <linux/sunrpc/xprtrdma.h>
38 39 40 41 42 43 44 45 46 47
#include <linux/nfs_fs.h>
#include <linux/nfs_mount.h>
#include <linux/nfs4_mount.h>
#include <linux/lockd/bind.h>
#include <linux/smp_lock.h>
#include <linux/seq_file.h>
#include <linux/mount.h>
#include <linux/nfs_idmap.h>
#include <linux/vfs.h>
#include <linux/inet.h>
48 49
#include <linux/in6.h>
#include <net/ipv6.h>
50
#include <linux/netdevice.h>
51
#include <linux/nfs_xdr.h>
52
#include <linux/magic.h>
53
#include <linux/parser.h>
54 55 56 57 58 59 60 61 62 63 64 65

#include <asm/system.h>
#include <asm/uaccess.h>

#include "nfs4_fs.h"
#include "callback.h"
#include "delegation.h"
#include "iostat.h"
#include "internal.h"

#define NFSDBG_FACILITY		NFSDBG_VFS

66 67 68 69 70 71 72 73
enum {
	/* Mount options that take no arguments */
	Opt_soft, Opt_hard,
	Opt_posix, Opt_noposix,
	Opt_cto, Opt_nocto,
	Opt_ac, Opt_noac,
	Opt_lock, Opt_nolock,
	Opt_v2, Opt_v3,
74
	Opt_udp, Opt_tcp, Opt_rdma,
75 76
	Opt_acl, Opt_noacl,
	Opt_rdirplus, Opt_nordirplus,
77
	Opt_sharecache, Opt_nosharecache,
78 79 80 81 82 83 84 85 86 87

	/* Mount options that take integer arguments */
	Opt_port,
	Opt_rsize, Opt_wsize, Opt_bsize,
	Opt_timeo, Opt_retrans,
	Opt_acregmin, Opt_acregmax,
	Opt_acdirmin, Opt_acdirmax,
	Opt_actimeo,
	Opt_namelen,
	Opt_mountport,
88
	Opt_mountvers,
89
	Opt_nfsvers,
90 91

	/* Mount options that take string arguments */
92
	Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost,
93
	Opt_addr, Opt_mountaddr, Opt_clientaddr,
94

95 96
	/* Special mount options */
	Opt_userspace, Opt_deprecated, Opt_sloppy,
97 98 99 100

	Opt_err
};

101
static const match_table_t nfs_mount_option_tokens = {
102 103
	{ Opt_userspace, "bg" },
	{ Opt_userspace, "fg" },
104 105
	{ Opt_userspace, "retry=%s" },

106 107
	{ Opt_sloppy, "sloppy" },

108 109
	{ Opt_soft, "soft" },
	{ Opt_hard, "hard" },
110 111
	{ Opt_deprecated, "intr" },
	{ Opt_deprecated, "nointr" },
112 113 114 115 116 117 118 119 120 121 122 123
	{ Opt_posix, "posix" },
	{ Opt_noposix, "noposix" },
	{ Opt_cto, "cto" },
	{ Opt_nocto, "nocto" },
	{ Opt_ac, "ac" },
	{ Opt_noac, "noac" },
	{ Opt_lock, "lock" },
	{ Opt_nolock, "nolock" },
	{ Opt_v2, "v2" },
	{ Opt_v3, "v3" },
	{ Opt_udp, "udp" },
	{ Opt_tcp, "tcp" },
124
	{ Opt_rdma, "rdma" },
125 126 127 128
	{ Opt_acl, "acl" },
	{ Opt_noacl, "noacl" },
	{ Opt_rdirplus, "rdirplus" },
	{ Opt_nordirplus, "nordirplus" },
129 130
	{ Opt_sharecache, "sharecache" },
	{ Opt_nosharecache, "nosharecache" },
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153

	{ Opt_port, "port=%u" },
	{ Opt_rsize, "rsize=%u" },
	{ Opt_wsize, "wsize=%u" },
	{ Opt_bsize, "bsize=%u" },
	{ Opt_timeo, "timeo=%u" },
	{ Opt_retrans, "retrans=%u" },
	{ Opt_acregmin, "acregmin=%u" },
	{ Opt_acregmax, "acregmax=%u" },
	{ Opt_acdirmin, "acdirmin=%u" },
	{ Opt_acdirmax, "acdirmax=%u" },
	{ Opt_actimeo, "actimeo=%u" },
	{ Opt_namelen, "namlen=%u" },
	{ Opt_mountport, "mountport=%u" },
	{ Opt_mountvers, "mountvers=%u" },
	{ Opt_nfsvers, "nfsvers=%u" },
	{ Opt_nfsvers, "vers=%u" },

	{ Opt_sec, "sec=%s" },
	{ Opt_proto, "proto=%s" },
	{ Opt_mountproto, "mountproto=%s" },
	{ Opt_addr, "addr=%s" },
	{ Opt_clientaddr, "clientaddr=%s" },
154
	{ Opt_mounthost, "mounthost=%s" },
155
	{ Opt_mountaddr, "mountaddr=%s" },
156 157 158 159 160

	{ Opt_err, NULL }
};

enum {
161
	Opt_xprt_udp, Opt_xprt_tcp, Opt_xprt_rdma,
162 163 164 165

	Opt_xprt_err
};

166
static const match_table_t nfs_xprt_protocol_tokens = {
167 168
	{ Opt_xprt_udp, "udp" },
	{ Opt_xprt_tcp, "tcp" },
169
	{ Opt_xprt_rdma, "rdma" },
170 171 172 173 174 175 176 177 178 179 180 181 182

	{ Opt_xprt_err, NULL }
};

enum {
	Opt_sec_none, Opt_sec_sys,
	Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
	Opt_sec_lkey, Opt_sec_lkeyi, Opt_sec_lkeyp,
	Opt_sec_spkm, Opt_sec_spkmi, Opt_sec_spkmp,

	Opt_sec_err
};

183
static const match_table_t nfs_secflavor_tokens = {
184 185 186 187 188 189 190 191 192 193 194 195
	{ Opt_sec_none, "none" },
	{ Opt_sec_none, "null" },
	{ Opt_sec_sys, "sys" },

	{ Opt_sec_krb5, "krb5" },
	{ Opt_sec_krb5i, "krb5i" },
	{ Opt_sec_krb5p, "krb5p" },

	{ Opt_sec_lkey, "lkey" },
	{ Opt_sec_lkeyi, "lkeyi" },
	{ Opt_sec_lkeyp, "lkeyp" },

196 197 198 199
	{ Opt_sec_spkm, "spkm3" },
	{ Opt_sec_spkmi, "spkm3i" },
	{ Opt_sec_spkmp, "spkm3p" },

200 201 202 203
	{ Opt_sec_err, NULL }
};


204
static void nfs_umount_begin(struct super_block *);
205
static int  nfs_statfs(struct dentry *, struct kstatfs *);
206 207
static int  nfs_show_options(struct seq_file *, struct vfsmount *);
static int  nfs_show_stats(struct seq_file *, struct vfsmount *);
208
static int nfs_get_sb(struct file_system_type *, int, const char *, void *, struct vfsmount *);
209
static int nfs_xdev_get_sb(struct file_system_type *fs_type,
210
		int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
211
static void nfs_kill_super(struct super_block *);
212
static void nfs_put_super(struct super_block *);
213
static int nfs_remount(struct super_block *sb, int *flags, char *raw_data);
214 215 216 217 218 219

static struct file_system_type nfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "nfs",
	.get_sb		= nfs_get_sb,
	.kill_sb	= nfs_kill_super,
220
	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
221 222
};

223
struct file_system_type nfs_xdev_fs_type = {
224 225
	.owner		= THIS_MODULE,
	.name		= "nfs",
226
	.get_sb		= nfs_xdev_get_sb,
227
	.kill_sb	= nfs_kill_super,
228
	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
229 230
};

231
static const struct super_operations nfs_sops = {
232 233 234
	.alloc_inode	= nfs_alloc_inode,
	.destroy_inode	= nfs_destroy_inode,
	.write_inode	= nfs_write_inode,
235
	.put_super	= nfs_put_super,
236 237 238 239 240
	.statfs		= nfs_statfs,
	.clear_inode	= nfs_clear_inode,
	.umount_begin	= nfs_umount_begin,
	.show_options	= nfs_show_options,
	.show_stats	= nfs_show_stats,
241
	.remount_fs	= nfs_remount,
242 243 244
};

#ifdef CONFIG_NFS_V4
245 246
static int nfs4_get_sb(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
247 248 249 250
static int nfs4_xdev_get_sb(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
static int nfs4_referral_get_sb(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
251 252 253 254 255 256 257
static void nfs4_kill_super(struct super_block *sb);

static struct file_system_type nfs4_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "nfs4",
	.get_sb		= nfs4_get_sb,
	.kill_sb	= nfs4_kill_super,
258
	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
259 260
};

261
struct file_system_type nfs4_xdev_fs_type = {
262 263
	.owner		= THIS_MODULE,
	.name		= "nfs4",
264
	.get_sb		= nfs4_xdev_get_sb,
265
	.kill_sb	= nfs4_kill_super,
266
	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
267 268
};

269
struct file_system_type nfs4_referral_fs_type = {
270 271
	.owner		= THIS_MODULE,
	.name		= "nfs4",
272
	.get_sb		= nfs4_referral_get_sb,
273
	.kill_sb	= nfs4_kill_super,
274
	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
275 276
};

277
static const struct super_operations nfs4_sops = {
278 279 280 281 282 283 284 285
	.alloc_inode	= nfs_alloc_inode,
	.destroy_inode	= nfs_destroy_inode,
	.write_inode	= nfs_write_inode,
	.statfs		= nfs_statfs,
	.clear_inode	= nfs4_clear_inode,
	.umount_begin	= nfs_umount_begin,
	.show_options	= nfs_show_options,
	.show_stats	= nfs_show_stats,
286
	.remount_fs	= nfs_remount,
287 288 289
};
#endif

290 291 292 293
static struct shrinker acl_shrinker = {
	.shrink		= nfs_access_cache_shrinker,
	.seeks		= DEFAULT_SEEKS,
};
294

295 296 297 298 299 300 301 302 303 304 305 306 307 308
/*
 * Register the NFS filesystems
 */
int __init register_nfs_fs(void)
{
	int ret;

        ret = register_filesystem(&nfs_fs_type);
	if (ret < 0)
		goto error_0;

	ret = nfs_register_sysctl();
	if (ret < 0)
		goto error_1;
309
#ifdef CONFIG_NFS_V4
310 311 312 313
	ret = register_filesystem(&nfs4_fs_type);
	if (ret < 0)
		goto error_2;
#endif
314
	register_shrinker(&acl_shrinker);
315 316 317 318 319
	return 0;

#ifdef CONFIG_NFS_V4
error_2:
	nfs_unregister_sysctl();
320
#endif
321 322 323 324 325 326 327 328 329 330 331
error_1:
	unregister_filesystem(&nfs_fs_type);
error_0:
	return ret;
}

/*
 * Unregister the NFS filesystems
 */
void __exit unregister_nfs_fs(void)
{
332
	unregister_shrinker(&acl_shrinker);
333 334 335
#ifdef CONFIG_NFS_V4
	unregister_filesystem(&nfs4_fs_type);
#endif
336
	nfs_unregister_sysctl();
337 338 339
	unregister_filesystem(&nfs_fs_type);
}

340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
void nfs_sb_active(struct nfs_server *server)
{
	atomic_inc(&server->active);
}

void nfs_sb_deactive(struct nfs_server *server)
{
	if (atomic_dec_and_test(&server->active))
		wake_up(&server->active_wq);
}

static void nfs_put_super(struct super_block *sb)
{
	struct nfs_server *server = NFS_SB(sb);
	/*
	 * Make sure there are no outstanding ops to this server.
	 * If so, wait for them to finish before allowing the
	 * unmount to continue.
	 */
	wait_event(server->active_wq, atomic_read(&server->active) == 0);
}

362 363 364
/*
 * Deliver file system statistics to userspace
 */
365
static int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
366
{
367
	struct nfs_server *server = NFS_SB(dentry->d_sb);
368 369
	unsigned char blockbits;
	unsigned long blockres;
370
	struct nfs_fh *fh = NFS_FH(dentry->d_inode);
371 372 373 374 375 376
	struct nfs_fattr fattr;
	struct nfs_fsstat res = {
			.fattr = &fattr,
	};
	int error;

377
	error = server->nfs_client->rpc_ops->statfs(server, fh, &res);
378 379
	if (error < 0)
		goto out_err;
380
	buf->f_type = NFS_SUPER_MAGIC;
381 382 383 384 385 386

	/*
	 * Current versions of glibc do not correctly handle the
	 * case where f_frsize != f_bsize.  Eventually we want to
	 * report the value of wtmult in this field.
	 */
387
	buf->f_frsize = dentry->d_sb->s_blocksize;
388 389 390 391 392 393 394 395

	/*
	 * On most *nix systems, f_blocks, f_bfree, and f_bavail
	 * are reported in units of f_frsize.  Linux hasn't had
	 * an f_frsize field in its statfs struct until recently,
	 * thus historically Linux's sys_statfs reports these
	 * fields in units of f_bsize.
	 */
396 397
	buf->f_bsize = dentry->d_sb->s_blocksize;
	blockbits = dentry->d_sb->s_blocksize_bits;
398 399 400 401 402 403 404 405 406
	blockres = (1 << blockbits) - 1;
	buf->f_blocks = (res.tbytes + blockres) >> blockbits;
	buf->f_bfree = (res.fbytes + blockres) >> blockbits;
	buf->f_bavail = (res.abytes + blockres) >> blockbits;

	buf->f_files = res.tfiles;
	buf->f_ffree = res.afiles;

	buf->f_namelen = server->namelen;
407

408 409 410
	return 0;

 out_err:
411
	dprintk("%s: statfs error = %d\n", __func__, -error);
412
	return error;
413 414
}

415 416 417
/*
 * Map the security flavour number to a name
 */
418 419
static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour)
{
420
	static const struct {
421 422 423 424 425 426 427 428 429 430 431 432 433 434
		rpc_authflavor_t flavour;
		const char *str;
	} sec_flavours[] = {
		{ RPC_AUTH_NULL, "null" },
		{ RPC_AUTH_UNIX, "sys" },
		{ RPC_AUTH_GSS_KRB5, "krb5" },
		{ RPC_AUTH_GSS_KRB5I, "krb5i" },
		{ RPC_AUTH_GSS_KRB5P, "krb5p" },
		{ RPC_AUTH_GSS_LKEY, "lkey" },
		{ RPC_AUTH_GSS_LKEYI, "lkeyi" },
		{ RPC_AUTH_GSS_LKEYP, "lkeyp" },
		{ RPC_AUTH_GSS_SPKM, "spkm" },
		{ RPC_AUTH_GSS_SPKMI, "spkmi" },
		{ RPC_AUTH_GSS_SPKMP, "spkmp" },
435
		{ UINT_MAX, "unknown" }
436 437 438
	};
	int i;

439
	for (i = 0; sec_flavours[i].flavour != UINT_MAX; i++) {
440 441 442 443 444 445
		if (sec_flavours[i].flavour == flavour)
			break;
	}
	return sec_flavours[i].str;
}

446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
static void nfs_show_mountd_options(struct seq_file *m, struct nfs_server *nfss,
				    int showdefaults)
{
	struct sockaddr *sap = (struct sockaddr *)&nfss->mountd_address;

	switch (sap->sa_family) {
	case AF_INET: {
		struct sockaddr_in *sin = (struct sockaddr_in *)sap;
		seq_printf(m, ",mountaddr=" NIPQUAD_FMT,
				NIPQUAD(sin->sin_addr.s_addr));
		break;
	}
	case AF_INET6: {
		struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
		seq_printf(m, ",mountaddr=" NIP6_FMT,
				NIP6(sin6->sin6_addr));
		break;
	}
	default:
		if (showdefaults)
			seq_printf(m, ",mountaddr=unspecified");
	}

	if (nfss->mountd_version || showdefaults)
		seq_printf(m, ",mountvers=%u", nfss->mountd_version);
	if (nfss->mountd_port || showdefaults)
		seq_printf(m, ",mountport=%u", nfss->mountd_port);

	switch (nfss->mountd_protocol) {
	case IPPROTO_UDP:
		seq_printf(m, ",mountproto=udp");
		break;
	case IPPROTO_TCP:
		seq_printf(m, ",mountproto=tcp");
		break;
	default:
		if (showdefaults)
			seq_printf(m, ",mountproto=auto");
	}
}

487 488 489
/*
 * Describe the mount options in force on this server representation
 */
490 491
static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss,
				   int showdefaults)
492
{
493
	static const struct proc_nfs_info {
494
		int flag;
495 496
		const char *str;
		const char *nostr;
497 498
	} nfs_info[] = {
		{ NFS_MOUNT_SOFT, ",soft", ",hard" },
499 500
		{ NFS_MOUNT_INTR, ",intr", ",nointr" },
		{ NFS_MOUNT_POSIX, ",posix", "" },
501 502 503 504
		{ NFS_MOUNT_NOCTO, ",nocto", "" },
		{ NFS_MOUNT_NOAC, ",noac", "" },
		{ NFS_MOUNT_NONLM, ",nolock", "" },
		{ NFS_MOUNT_NOACL, ",noacl", "" },
505
		{ NFS_MOUNT_NORDIRPLUS, ",nordirplus", "" },
506
		{ NFS_MOUNT_UNSHARED, ",nosharecache", ""},
507 508
		{ 0, NULL, NULL }
	};
509
	const struct proc_nfs_info *nfs_infop;
510
	struct nfs_client *clp = nfss->nfs_client;
511
	u32 version = clp->rpc_ops->version;
512

513
	seq_printf(m, ",vers=%u", version);
514 515
	seq_printf(m, ",rsize=%u", nfss->rsize);
	seq_printf(m, ",wsize=%u", nfss->wsize);
516 517 518
	if (nfss->bsize != 0)
		seq_printf(m, ",bsize=%u", nfss->bsize);
	seq_printf(m, ",namlen=%u", nfss->namelen);
519
	if (nfss->acregmin != NFS_DEF_ACREGMIN*HZ || showdefaults)
520
		seq_printf(m, ",acregmin=%u", nfss->acregmin/HZ);
521
	if (nfss->acregmax != NFS_DEF_ACREGMAX*HZ || showdefaults)
522
		seq_printf(m, ",acregmax=%u", nfss->acregmax/HZ);
523
	if (nfss->acdirmin != NFS_DEF_ACDIRMIN*HZ || showdefaults)
524
		seq_printf(m, ",acdirmin=%u", nfss->acdirmin/HZ);
525
	if (nfss->acdirmax != NFS_DEF_ACDIRMAX*HZ || showdefaults)
526
		seq_printf(m, ",acdirmax=%u", nfss->acdirmax/HZ);
527 528 529 530 531 532
	for (nfs_infop = nfs_info; nfs_infop->flag; nfs_infop++) {
		if (nfss->flags & nfs_infop->flag)
			seq_puts(m, nfs_infop->str);
		else
			seq_puts(m, nfs_infop->nostr);
	}
533 534
	seq_printf(m, ",proto=%s",
		   rpc_peeraddr2str(nfss->client, RPC_DISPLAY_PROTO));
535 536 537 538 539 540 541
	if (version == 4) {
		if (nfss->port != NFS_PORT)
			seq_printf(m, ",port=%u", nfss->port);
	} else
		if (nfss->port)
			seq_printf(m, ",port=%u", nfss->port);

542 543
	seq_printf(m, ",timeo=%lu", 10U * nfss->client->cl_timeout->to_initval / HZ);
	seq_printf(m, ",retrans=%u", nfss->client->cl_timeout->to_retries);
544
	seq_printf(m, ",sec=%s", nfs_pseudoflavour_to_name(nfss->client->cl_auth->au_flavor));
545 546 547 548 549 550 551 552

	if (version != 4)
		nfs_show_mountd_options(m, nfss, showdefaults);

#ifdef CONFIG_NFS_V4
	if (clp->rpc_ops->version == 4)
		seq_printf(m, ",clientaddr=%s", clp->cl_ipaddr);
#endif
553 554 555 556 557 558 559 560 561 562 563
}

/*
 * Describe the mount options on this VFS mountpoint
 */
static int nfs_show_options(struct seq_file *m, struct vfsmount *mnt)
{
	struct nfs_server *nfss = NFS_SB(mnt->mnt_sb);

	nfs_show_mount_options(m, nfss, 0);

564 565 566
	seq_printf(m, ",addr=%s",
			rpc_peeraddr2str(nfss->nfs_client->cl_rpcclient,
							RPC_DISPLAY_ADDR));
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596

	return 0;
}

/*
 * Present statistical information for this VFS mountpoint
 */
static int nfs_show_stats(struct seq_file *m, struct vfsmount *mnt)
{
	int i, cpu;
	struct nfs_server *nfss = NFS_SB(mnt->mnt_sb);
	struct rpc_auth *auth = nfss->client->cl_auth;
	struct nfs_iostats totals = { };

	seq_printf(m, "statvers=%s", NFS_IOSTAT_VERS);

	/*
	 * Display all mount option settings
	 */
	seq_printf(m, "\n\topts:\t");
	seq_puts(m, mnt->mnt_sb->s_flags & MS_RDONLY ? "ro" : "rw");
	seq_puts(m, mnt->mnt_sb->s_flags & MS_SYNCHRONOUS ? ",sync" : "");
	seq_puts(m, mnt->mnt_sb->s_flags & MS_NOATIME ? ",noatime" : "");
	seq_puts(m, mnt->mnt_sb->s_flags & MS_NODIRATIME ? ",nodiratime" : "");
	nfs_show_mount_options(m, nfss, 1);

	seq_printf(m, "\n\tage:\t%lu", (jiffies - nfss->mount_time) / HZ);

	seq_printf(m, "\n\tcaps:\t");
	seq_printf(m, "caps=0x%x", nfss->caps);
597 598 599 600
	seq_printf(m, ",wtmult=%u", nfss->wtmult);
	seq_printf(m, ",dtsize=%u", nfss->dtsize);
	seq_printf(m, ",bsize=%u", nfss->bsize);
	seq_printf(m, ",namlen=%u", nfss->namelen);
601 602

#ifdef CONFIG_NFS_V4
603
	if (nfss->nfs_client->rpc_ops->version == 4) {
604 605 606 607 608 609 610 611 612 613
		seq_printf(m, "\n\tnfsv4:\t");
		seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]);
		seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]);
		seq_printf(m, ",acl=0x%x", nfss->acl_bitmask);
	}
#endif

	/*
	 * Display security flavor in effect for this mount
	 */
614
	seq_printf(m, "\n\tsec:\tflavor=%u", auth->au_ops->au_flavor);
615
	if (auth->au_flavor)
616
		seq_printf(m, ",pseudoflavor=%u", auth->au_flavor);
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649

	/*
	 * Display superblock I/O counters
	 */
	for_each_possible_cpu(cpu) {
		struct nfs_iostats *stats;

		preempt_disable();
		stats = per_cpu_ptr(nfss->io_stats, cpu);

		for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
			totals.events[i] += stats->events[i];
		for (i = 0; i < __NFSIOS_BYTESMAX; i++)
			totals.bytes[i] += stats->bytes[i];

		preempt_enable();
	}

	seq_printf(m, "\n\tevents:\t");
	for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
		seq_printf(m, "%lu ", totals.events[i]);
	seq_printf(m, "\n\tbytes:\t");
	for (i = 0; i < __NFSIOS_BYTESMAX; i++)
		seq_printf(m, "%Lu ", totals.bytes[i]);
	seq_printf(m, "\n");

	rpc_print_iostats(m, nfss->client);

	return 0;
}

/*
 * Begin unmount by attempting to remove all automounted mountpoints we added
650
 * in response to xdev traversals and referrals
651
 */
652
static void nfs_umount_begin(struct super_block *sb)
653
{
654
	struct nfs_server *server = NFS_SB(sb);
655 656 657 658 659 660 661 662 663
	struct rpc_clnt *rpc;

	/* -EIO all pending I/O */
	rpc = server->client_acl;
	if (!IS_ERR(rpc))
		rpc_killall_tasks(rpc);
	rpc = server->client;
	if (!IS_ERR(rpc))
		rpc_killall_tasks(rpc);
664 665
}

666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684
/*
 * Set the port number in an address.  Be agnostic about the address family.
 */
static void nfs_set_port(struct sockaddr *sap, unsigned short port)
{
	switch (sap->sa_family) {
	case AF_INET: {
		struct sockaddr_in *ap = (struct sockaddr_in *)sap;
		ap->sin_port = htons(port);
		break;
	}
	case AF_INET6: {
		struct sockaddr_in6 *ap = (struct sockaddr_in6 *)sap;
		ap->sin6_port = htons(port);
		break;
	}
	}
}

685
/*
686 687 688 689
 * Sanity-check a server address provided by the mount command.
 *
 * Address family must be initialized, and address must not be
 * the ANY address for that family.
690 691 692 693 694
 */
static int nfs_verify_server_address(struct sockaddr *addr)
{
	switch (addr->sa_family) {
	case AF_INET: {
695
		struct sockaddr_in *sa = (struct sockaddr_in *)addr;
696
		return sa->sin_addr.s_addr != htonl(INADDR_ANY);
697 698 699 700
	}
	case AF_INET6: {
		struct in6_addr *sa = &((struct sockaddr_in6 *)addr)->sin6_addr;
		return !ipv6_addr_any(sa);
701 702 703 704 705 706
	}
	}

	return 0;
}

707 708
static void nfs_parse_ipv4_address(char *string, size_t str_len,
				   struct sockaddr *sap, size_t *addr_len)
709
{
710 711
	struct sockaddr_in *sin = (struct sockaddr_in *)sap;
	u8 *addr = (u8 *)&sin->sin_addr.s_addr;
712

713 714 715 716 717 718 719
	if (str_len <= INET_ADDRSTRLEN) {
		dfprintk(MOUNT, "NFS: parsing IPv4 address %*s\n",
				(int)str_len, string);

		sin->sin_family = AF_INET;
		*addr_len = sizeof(*sin);
		if (in4_pton(string, str_len, addr, '\0', NULL))
720
			return;
721 722 723 724 725 726
	}

	sap->sa_family = AF_UNSPEC;
	*addr_len = 0;
}

727 728
#define IPV6_SCOPE_DELIMITER	'%'

729
#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
static void nfs_parse_ipv6_scope_id(const char *string, const size_t str_len,
				    const char *delim,
				    struct sockaddr_in6 *sin6)
{
	char *p;
	size_t len;

	if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL))
		return ;
	if (*delim != IPV6_SCOPE_DELIMITER)
		return;

	len = (string + str_len) - delim - 1;
	p = kstrndup(delim + 1, len, GFP_KERNEL);
	if (p) {
		unsigned long scope_id = 0;
		struct net_device *dev;

		dev = dev_get_by_name(&init_net, p);
		if (dev != NULL) {
			scope_id = dev->ifindex;
			dev_put(dev);
		} else {
			/* scope_id is set to zero on error */
			strict_strtoul(p, 10, &scope_id);
		}

		kfree(p);
		sin6->sin6_scope_id = scope_id;
		dfprintk(MOUNT, "NFS: IPv6 scope ID = %lu\n", scope_id);
	}
}

763 764 765 766 767
static void nfs_parse_ipv6_address(char *string, size_t str_len,
				   struct sockaddr *sap, size_t *addr_len)
{
	struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
	u8 *addr = (u8 *)&sin6->sin6_addr.in6_u;
768
	const char *delim;
769 770 771 772

	if (str_len <= INET6_ADDRSTRLEN) {
		dfprintk(MOUNT, "NFS: parsing IPv6 address %*s\n",
				(int)str_len, string);
773

774 775
		sin6->sin6_family = AF_INET6;
		*addr_len = sizeof(*sin6);
776 777
		if (in6_pton(string, str_len, addr, IPV6_SCOPE_DELIMITER, &delim)) {
			nfs_parse_ipv6_scope_id(string, str_len, delim, sin6);
778
			return;
779
		}
780
	}
781 782

	sap->sa_family = AF_UNSPEC;
783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
	*addr_len = 0;
}
#else
static void nfs_parse_ipv6_address(char *string, size_t str_len,
				   struct sockaddr *sap, size_t *addr_len)
{
	sap->sa_family = AF_UNSPEC;
	*addr_len = 0;
}
#endif

/*
 * Construct a sockaddr based on the contents of a string that contains
 * an IP address in presentation format.
 *
 * If there is a problem constructing the new sockaddr, set the address
 * family to AF_UNSPEC.
 */
static void nfs_parse_ip_address(char *string, size_t str_len,
				 struct sockaddr *sap, size_t *addr_len)
{
	unsigned int i, colons;

	colons = 0;
	for (i = 0; i < str_len; i++)
		if (string[i] == ':')
			colons++;

	if (colons >= 2)
		nfs_parse_ipv6_address(string, str_len, sap, addr_len);
	else
		nfs_parse_ipv4_address(string, str_len, sap, addr_len);
815 816
}

817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853
/*
 * Sanity check the NFS transport protocol.
 *
 */
static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data *mnt)
{
	switch (mnt->nfs_server.protocol) {
	case XPRT_TRANSPORT_UDP:
	case XPRT_TRANSPORT_TCP:
	case XPRT_TRANSPORT_RDMA:
		break;
	default:
		mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
	}
}

/*
 * For text based NFSv2/v3 mounts, the mount protocol transport default
 * settings should depend upon the specified NFS transport.
 */
static void nfs_set_mount_transport_protocol(struct nfs_parsed_mount_data *mnt)
{
	nfs_validate_transport_protocol(mnt);

	if (mnt->mount_server.protocol == XPRT_TRANSPORT_UDP ||
	    mnt->mount_server.protocol == XPRT_TRANSPORT_TCP)
			return;
	switch (mnt->nfs_server.protocol) {
	case XPRT_TRANSPORT_UDP:
		mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
		break;
	case XPRT_TRANSPORT_TCP:
	case XPRT_TRANSPORT_RDMA:
		mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
	}
}

854 855 856
/*
 * Parse the value of the 'sec=' option.
 *
857
 * The flavor_len setting is for v4 mounts.
858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917
 */
static int nfs_parse_security_flavors(char *value,
				      struct nfs_parsed_mount_data *mnt)
{
	substring_t args[MAX_OPT_ARGS];

	dfprintk(MOUNT, "NFS: parsing sec=%s option\n", value);

	switch (match_token(value, nfs_secflavor_tokens, args)) {
	case Opt_sec_none:
		mnt->auth_flavor_len = 0;
		mnt->auth_flavors[0] = RPC_AUTH_NULL;
		break;
	case Opt_sec_sys:
		mnt->auth_flavor_len = 0;
		mnt->auth_flavors[0] = RPC_AUTH_UNIX;
		break;
	case Opt_sec_krb5:
		mnt->auth_flavor_len = 1;
		mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5;
		break;
	case Opt_sec_krb5i:
		mnt->auth_flavor_len = 1;
		mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5I;
		break;
	case Opt_sec_krb5p:
		mnt->auth_flavor_len = 1;
		mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5P;
		break;
	case Opt_sec_lkey:
		mnt->auth_flavor_len = 1;
		mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEY;
		break;
	case Opt_sec_lkeyi:
		mnt->auth_flavor_len = 1;
		mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYI;
		break;
	case Opt_sec_lkeyp:
		mnt->auth_flavor_len = 1;
		mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYP;
		break;
	case Opt_sec_spkm:
		mnt->auth_flavor_len = 1;
		mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKM;
		break;
	case Opt_sec_spkmi:
		mnt->auth_flavor_len = 1;
		mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMI;
		break;
	case Opt_sec_spkmp:
		mnt->auth_flavor_len = 1;
		mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMP;
		break;
	default:
		return 0;
	}

	return 1;
}

918 919 920 921 922
static void nfs_parse_invalid_value(const char *option)
{
	dfprintk(MOUNT, "NFS:   bad value specified for %s option\n", option);
}

923 924
/*
 * Error-check and convert a string of mount options from user space into
925 926 927
 * a data structure.  The whole mount string is processed; bad options are
 * skipped as they are encountered.  If there were no errors, return 1;
 * otherwise return 0 (zero).
928 929 930 931
 */
static int nfs_parse_mount_options(char *raw,
				   struct nfs_parsed_mount_data *mnt)
{
932
	char *p, *string, *secdata;
933
	int rc, sloppy = 0, errors = 0;
934 935 936 937 938 939 940

	if (!raw) {
		dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
		return 1;
	}
	dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);

941 942 943 944 945 946 947 948 949 950 951 952 953 954
	secdata = alloc_secdata();
	if (!secdata)
		goto out_nomem;

	rc = security_sb_copy_data(raw, secdata);
	if (rc)
		goto out_security_failure;

	rc = security_sb_parse_opts_str(secdata, &mnt->lsm_opts);
	if (rc)
		goto out_security_failure;

	free_secdata(secdata);

955 956 957 958 959 960 961 962 963 964 965
	while ((p = strsep(&raw, ",")) != NULL) {
		substring_t args[MAX_OPT_ARGS];
		int option, token;

		if (!*p)
			continue;

		dfprintk(MOUNT, "NFS:   parsing nfs mount option '%s'\n", p);

		token = match_token(p, nfs_mount_option_tokens, args);
		switch (token) {
966 967 968 969

		/*
		 * boolean options:  foo/nofoo
		 */
970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
		case Opt_soft:
			mnt->flags |= NFS_MOUNT_SOFT;
			break;
		case Opt_hard:
			mnt->flags &= ~NFS_MOUNT_SOFT;
			break;
		case Opt_posix:
			mnt->flags |= NFS_MOUNT_POSIX;
			break;
		case Opt_noposix:
			mnt->flags &= ~NFS_MOUNT_POSIX;
			break;
		case Opt_cto:
			mnt->flags &= ~NFS_MOUNT_NOCTO;
			break;
		case Opt_nocto:
			mnt->flags |= NFS_MOUNT_NOCTO;
			break;
		case Opt_ac:
			mnt->flags &= ~NFS_MOUNT_NOAC;
			break;
		case Opt_noac:
			mnt->flags |= NFS_MOUNT_NOAC;
			break;
		case Opt_lock:
			mnt->flags &= ~NFS_MOUNT_NONLM;
			break;
		case Opt_nolock:
			mnt->flags |= NFS_MOUNT_NONLM;
			break;
		case Opt_v2:
			mnt->flags &= ~NFS_MOUNT_VER3;
			break;
		case Opt_v3:
			mnt->flags |= NFS_MOUNT_VER3;
			break;
		case Opt_udp:
			mnt->flags &= ~NFS_MOUNT_TCP;
1008
			mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1009 1010 1011
			break;
		case Opt_tcp:
			mnt->flags |= NFS_MOUNT_TCP;
1012
			mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1013
			break;
1014 1015 1016 1017
		case Opt_rdma:
			mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */
			mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
			break;
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
		case Opt_acl:
			mnt->flags &= ~NFS_MOUNT_NOACL;
			break;
		case Opt_noacl:
			mnt->flags |= NFS_MOUNT_NOACL;
			break;
		case Opt_rdirplus:
			mnt->flags &= ~NFS_MOUNT_NORDIRPLUS;
			break;
		case Opt_nordirplus:
			mnt->flags |= NFS_MOUNT_NORDIRPLUS;
			break;
1030 1031 1032 1033 1034 1035
		case Opt_sharecache:
			mnt->flags &= ~NFS_MOUNT_UNSHARED;
			break;
		case Opt_nosharecache:
			mnt->flags |= NFS_MOUNT_UNSHARED;
			break;
1036

1037 1038 1039
		/*
		 * options that take numeric values
		 */
1040
		case Opt_port:
1041 1042 1043 1044 1045 1046
			if (match_int(args, &option) ||
			    option < 0 || option > USHORT_MAX) {
				errors++;
				nfs_parse_invalid_value("port");
			} else
				mnt->nfs_server.port = option;
1047 1048
			break;
		case Opt_rsize:
1049 1050 1051 1052 1053
			if (match_int(args, &option) || option < 0) {
				errors++;
				nfs_parse_invalid_value("rsize");
			} else
				mnt->rsize = option;
1054 1055
			break;
		case Opt_wsize:
1056 1057 1058 1059 1060
			if (match_int(args, &option) || option < 0) {
				errors++;
				nfs_parse_invalid_value("wsize");
			} else
				mnt->wsize = option;
1061 1062
			break;
		case Opt_bsize:
1063 1064 1065 1066 1067
			if (match_int(args, &option) || option < 0) {
				errors++;
				nfs_parse_invalid_value("bsize");
			} else
				mnt->bsize = option;
1068 1069
			break;
		case Opt_timeo:
1070 1071 1072 1073 1074
			if (match_int(args, &option) || option <= 0) {
				errors++;
				nfs_parse_invalid_value("timeo");
			} else
				mnt->timeo = option;
1075 1076
			break;
		case Opt_retrans:
1077 1078 1079 1080 1081
			if (match_int(args, &option) || option <= 0) {
				errors++;
				nfs_parse_invalid_value("retrans");
			} else
				mnt->retrans = option;
1082 1083
			break;
		case Opt_acregmin:
1084 1085 1086 1087 1088
			if (match_int(args, &option) || option < 0) {
				errors++;
				nfs_parse_invalid_value("acregmin");
			} else
				mnt->acregmin = option;
1089 1090
			break;
		case Opt_acregmax:
1091 1092 1093 1094 1095
			if (match_int(args, &option) || option < 0) {
				errors++;
				nfs_parse_invalid_value("acregmax");
			} else
				mnt->acregmax = option;
1096 1097
			break;
		case Opt_acdirmin:
1098 1099 1100 1101 1102
			if (match_int(args, &option) || option < 0) {
				errors++;
				nfs_parse_invalid_value("acdirmin");
			} else
				mnt->acdirmin = option;
1103 1104
			break;
		case Opt_acdirmax:
1105 1106 1107 1108 1109
			if (match_int(args, &option) || option < 0) {
				errors++;
				nfs_parse_invalid_value("acdirmax");
			} else
				mnt->acdirmax = option;
1110 1111
			break;
		case Opt_actimeo:
1112 1113 1114 1115 1116 1117
			if (match_int(args, &option) || option < 0) {
				errors++;
				nfs_parse_invalid_value("actimeo");
			} else
				mnt->acregmin = mnt->acregmax =
				mnt->acdirmin = mnt->acdirmax = option;
1118 1119
			break;
		case Opt_namelen:
1120 1121 1122 1123 1124
			if (match_int(args, &option) || option < 0) {
				errors++;
				nfs_parse_invalid_value("namlen");
			} else
				mnt->namlen = option;
1125 1126
			break;
		case Opt_mountport:
1127 1128 1129 1130 1131 1132
			if (match_int(args, &option) ||
			    option < 0 || option > USHORT_MAX) {
				errors++;
				nfs_parse_invalid_value("mountport");
			} else
				mnt->mount_server.port = option;
1133 1134
			break;
		case Opt_mountvers:
1135 1136 1137 1138 1139 1140 1141
			if (match_int(args, &option) ||
			    option < NFS_MNT_VERSION ||
			    option > NFS_MNT3_VERSION) {
				errors++;
				nfs_parse_invalid_value("mountvers");
			} else
				mnt->mount_server.version = option;
1142 1143
			break;
		case Opt_nfsvers:
1144 1145 1146 1147 1148
			if (match_int(args, &option)) {
				errors++;
				nfs_parse_invalid_value("nfsvers");
				break;
			}
1149
			switch (option) {
1150
			case NFS2_VERSION:
1151 1152
				mnt->flags &= ~NFS_MOUNT_VER3;
				break;
1153
			case NFS3_VERSION:
1154 1155 1156
				mnt->flags |= NFS_MOUNT_VER3;
				break;
			default:
1157 1158
				errors++;
				nfs_parse_invalid_value("nfsvers");
1159 1160 1161
			}
			break;

1162 1163 1164
		/*
		 * options that take text values
		 */
1165 1166 1167 1168
		case Opt_sec:
			string = match_strdup(args);
			if (string == NULL)
				goto out_nomem;
1169
			rc = nfs_parse_security_flavors(string, mnt);
1170
			kfree(string);
1171 1172 1173 1174 1175
			if (!rc) {
				errors++;
				dfprintk(MOUNT, "NFS:   unrecognized "
						"security flavor\n");
			}
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
			break;
		case Opt_proto:
			string = match_strdup(args);
			if (string == NULL)
				goto out_nomem;
			token = match_token(string,
					    nfs_xprt_protocol_tokens, args);
			kfree(string);

			switch (token) {
1186
			case Opt_xprt_udp:
1187
				mnt->flags &= ~NFS_MOUNT_TCP;
1188
				mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1189
				break;
1190
			case Opt_xprt_tcp:
1191
				mnt->flags |= NFS_MOUNT_TCP;
1192
				mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1193
				break;
1194 1195 1196 1197 1198
			case Opt_xprt_rdma:
				/* vector side protocols to TCP */
				mnt->flags |= NFS_MOUNT_TCP;
				mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
				break;
1199
			default:
1200 1201 1202
				errors++;
				dfprintk(MOUNT, "NFS:   unrecognized "
						"transport protocol\n");
1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213
			}
			break;
		case Opt_mountproto:
			string = match_strdup(args);
			if (string == NULL)
				goto out_nomem;
			token = match_token(string,
					    nfs_xprt_protocol_tokens, args);
			kfree(string);

			switch (token) {
1214
			case Opt_xprt_udp:
1215
				mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
1216
				break;
1217
			case Opt_xprt_tcp:
1218
				mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
1219
				break;
1220
			case Opt_xprt_rdma: /* not used for side protocols */
1221
			default:
1222 1223 1224
				errors++;
				dfprintk(MOUNT, "NFS:   unrecognized "
						"transport protocol\n");
1225 1226 1227 1228 1229 1230
			}
			break;
		case Opt_addr:
			string = match_strdup(args);
			if (string == NULL)
				goto out_nomem;
1231 1232 1233 1234
			nfs_parse_ip_address(string, strlen(string),
					     (struct sockaddr *)
						&mnt->nfs_server.address,
					     &mnt->nfs_server.addrlen);
1235 1236 1237 1238 1239 1240
			kfree(string);
			break;
		case Opt_clientaddr:
			string = match_strdup(args);
			if (string == NULL)
				goto out_nomem;
1241
			kfree(mnt->client_address);
1242 1243
			mnt->client_address = string;
			break;
1244 1245 1246 1247
		case Opt_mounthost:
			string = match_strdup(args);
			if (string == NULL)
				goto out_nomem;
1248
			kfree(mnt->mount_server.hostname);
1249 1250
			mnt->mount_server.hostname = string;
			break;
1251
		case Opt_mountaddr:
1252 1253 1254
			string = match_strdup(args);
			if (string == NULL)
				goto out_nomem;
1255 1256 1257 1258
			nfs_parse_ip_address(string, strlen(string),
					     (struct sockaddr *)
						&mnt->mount_server.address,
					     &mnt->mount_server.addrlen);
1259 1260 1261
			kfree(string);
			break;

1262 1263 1264 1265 1266 1267 1268
		/*
		 * Special options
		 */
		case Opt_sloppy:
			sloppy = 1;
			dfprintk(MOUNT, "NFS:   relaxing parsing rules\n");
			break;
1269 1270
		case Opt_userspace:
		case Opt_deprecated:
1271 1272
			dfprintk(MOUNT, "NFS:   ignoring mount option "
					"'%s'\n", p);
1273 1274 1275
			break;

		default:
1276 1277 1278
			errors++;
			dfprintk(MOUNT, "NFS:   unrecognized mount option "
					"'%s'\n", p);
1279 1280 1281
		}
	}

1282 1283 1284 1285 1286 1287
	if (errors > 0) {
		dfprintk(MOUNT, "NFS: parsing encountered %d error%s\n",
				errors, (errors == 1 ? "" : "s"));
		if (!sloppy)
			return 0;
	}
1288 1289 1290 1291 1292
	return 1;

out_nomem:
	printk(KERN_INFO "NFS: not enough memory to parse option\n");
	return 0;
1293 1294 1295 1296
out_security_failure:
	free_secdata(secdata);
	printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
	return 0;
1297 1298
}

1299 1300 1301 1302 1303 1304 1305
/*
 * Use the remote server's MOUNT service to request the NFS file handle
 * corresponding to the provided path.
 */
static int nfs_try_mount(struct nfs_parsed_mount_data *args,
			 struct nfs_fh *root_fh)
{
1306
	struct sockaddr *sap = (struct sockaddr *)&args->mount_server.address;
1307
	char *hostname;
1308
	int status;
1309 1310 1311 1312 1313 1314 1315 1316

	if (args->mount_server.version == 0) {
		if (args->flags & NFS_MOUNT_VER3)
			args->mount_server.version = NFS_MNT3_VERSION;
		else
			args->mount_server.version = NFS_MNT_VERSION;
	}

1317 1318 1319 1320 1321
	if (args->mount_server.hostname)
		hostname = args->mount_server.hostname;
	else
		hostname = args->nfs_server.hostname;

1322 1323 1324
	/*
	 * Construct the mount server's address.
	 */
1325 1326 1327 1328 1329 1330
	if (args->mount_server.address.ss_family == AF_UNSPEC) {
		memcpy(sap, &args->nfs_server.address,
		       args->nfs_server.addrlen);
		args->mount_server.addrlen = args->nfs_server.addrlen;
	}

1331 1332 1333
	/*
	 * autobind will be used if mount_server.port == 0
	 */
1334
	nfs_set_port(sap, args->mount_server.port);
1335 1336 1337 1338 1339

	/*
	 * Now ask the mount server to map our export path
	 * to a file handle.
	 */
1340 1341
	status = nfs_mount(sap,
			   args->mount_server.addrlen,
1342
			   hostname,
1343 1344 1345 1346
			   args->nfs_server.export_path,
			   args->mount_server.version,
			   args->mount_server.protocol,
			   root_fh);
1347 1348
	if (status == 0)
		return 0;
1349

1350
	dfprintk(MOUNT, "NFS: unable to mount server %s, error %d\n",
1351
			hostname, status);
1352 1353 1354
	return status;
}

1355 1356 1357
static int nfs_parse_simple_hostname(const char *dev_name,
				     char **hostname, size_t maxnamlen,
				     char **export_path, size_t maxpathlen)
1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410
{
	size_t len;
	char *colon, *comma;

	colon = strchr(dev_name, ':');
	if (colon == NULL)
		goto out_bad_devname;

	len = colon - dev_name;
	if (len > maxnamlen)
		goto out_hostname;

	/* N.B. caller will free nfs_server.hostname in all cases */
	*hostname = kstrndup(dev_name, len, GFP_KERNEL);
	if (!*hostname)
		goto out_nomem;

	/* kill possible hostname list: not supported */
	comma = strchr(*hostname, ',');
	if (comma != NULL) {
		if (comma == *hostname)
			goto out_bad_devname;
		*comma = '\0';
	}

	colon++;
	len = strlen(colon);
	if (len > maxpathlen)
		goto out_path;
	*export_path = kstrndup(colon, len, GFP_KERNEL);
	if (!*export_path)
		goto out_nomem;

	dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", *export_path);
	return 0;

out_bad_devname:
	dfprintk(MOUNT, "NFS: device name not in host:path format\n");
	return -EINVAL;

out_nomem:
	dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
	return -ENOMEM;

out_hostname:
	dfprintk(MOUNT, "NFS: server hostname too long\n");
	return -ENAMETOOLONG;

out_path:
	dfprintk(MOUNT, "NFS: export pathname too long\n");
	return -ENAMETOOLONG;
}

1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489
/*
 * Hostname has square brackets around it because it contains one or
 * more colons.  We look for the first closing square bracket, and a
 * colon must follow it.
 */
static int nfs_parse_protected_hostname(const char *dev_name,
					char **hostname, size_t maxnamlen,
					char **export_path, size_t maxpathlen)
{
	size_t len;
	char *start, *end;

	start = (char *)(dev_name + 1);

	end = strchr(start, ']');
	if (end == NULL)
		goto out_bad_devname;
	if (*(end + 1) != ':')
		goto out_bad_devname;

	len = end - start;
	if (len > maxnamlen)
		goto out_hostname;

	/* N.B. caller will free nfs_server.hostname in all cases */
	*hostname = kstrndup(start, len, GFP_KERNEL);
	if (*hostname == NULL)
		goto out_nomem;

	end += 2;
	len = strlen(end);
	if (len > maxpathlen)
		goto out_path;
	*export_path = kstrndup(end, len, GFP_KERNEL);
	if (!*export_path)
		goto out_nomem;

	return 0;

out_bad_devname:
	dfprintk(MOUNT, "NFS: device name not in host:path format\n");
	return -EINVAL;

out_nomem:
	dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
	return -ENOMEM;

out_hostname:
	dfprintk(MOUNT, "NFS: server hostname too long\n");
	return -ENAMETOOLONG;

out_path:
	dfprintk(MOUNT, "NFS: export pathname too long\n");
	return -ENAMETOOLONG;
}

/*
 * Split "dev_name" into "hostname:export_path".
 *
 * The leftmost colon demarks the split between the server's hostname
 * and the export path.  If the hostname starts with a left square
 * bracket, then it may contain colons.
 *
 * Note: caller frees hostname and export path, even on error.
 */
static int nfs_parse_devname(const char *dev_name,
			     char **hostname, size_t maxnamlen,
			     char **export_path, size_t maxpathlen)
{
	if (*dev_name == '[')
		return nfs_parse_protected_hostname(dev_name,
						    hostname, maxnamlen,
						    export_path, maxpathlen);

	return nfs_parse_simple_hostname(dev_name,
					 hostname, maxnamlen,
					 export_path, maxpathlen);
}

1490
/*
1491 1492
 * Validate the NFS2/NFS3 mount data
 * - fills in the mount root filehandle
1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504
 *
 * For option strings, user space handles the following behaviors:
 *
 * + DNS: mapping server host name to IP address ("addr=" option)
 *
 * + failure mode: how to behave if a mount request can't be handled
 *   immediately ("fg/bg" option)
 *
 * + retry: how often to retry a mount request ("retry=" option)
 *
 * + breaking back: trying proto=udp after proto=tcp, v2 after v3,
 *   mountproto=tcp after mountproto=udp, and so on
1505
 */
1506 1507
static int nfs_validate_mount_data(void *options,
				   struct nfs_parsed_mount_data *args,
1508 1509
				   struct nfs_fh *mntfh,
				   const char *dev_name)
1510
{
1511
	struct nfs_mount_data *data = (struct nfs_mount_data *)options;
1512

1513 1514
	if (data == NULL)
		goto out_no_data;
1515

1516 1517 1518
	args->flags		= (NFS_MOUNT_VER3 | NFS_MOUNT_TCP);
	args->rsize		= NFS_MAX_FILE_IO_SIZE;
	args->wsize		= NFS_MAX_FILE_IO_SIZE;
1519 1520 1521 1522
	args->acregmin		= NFS_DEF_ACREGMIN;
	args->acregmax		= NFS_DEF_ACREGMAX;
	args->acdirmin		= NFS_DEF_ACDIRMIN;
	args->acdirmax		= NFS_DEF_ACDIRMAX;
1523 1524
	args->mount_server.port	= 0;	/* autobind unless user sets port */
	args->nfs_server.port	= 0;	/* autobind unless user sets port */
1525
	args->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1526
	args->auth_flavors[0]	= RPC_AUTH_UNIX;
1527

1528
	switch (data->version) {
1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
	case 1:
		data->namlen = 0;
	case 2:
		data->bsize = 0;
	case 3:
		if (data->flags & NFS_MOUNT_VER3)
			goto out_no_v3;
		data->root.size = NFS2_FHSIZE;
		memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
	case 4:
		if (data->flags & NFS_MOUNT_SECFLAVOUR)
			goto out_no_sec;
	case 5:
		memset(data->context, 0, sizeof(data->context));
	case 6:
1544 1545 1546
		if (data->flags & NFS_MOUNT_VER3) {
			if (data->root.size > NFS3_FHSIZE || data->root.size == 0)
				goto out_invalid_fh;
1547
			mntfh->size = data->root.size;
1548
		} else
1549 1550 1551 1552 1553 1554 1555
			mntfh->size = NFS2_FHSIZE;


		memcpy(mntfh->data, data->root.data, mntfh->size);
		if (mntfh->size < sizeof(mntfh->data))
			memset(mntfh->data + mntfh->size, 0,
			       sizeof(mntfh->data) - mntfh->size);
1556

1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569
		/*
		 * Translate to nfs_parsed_mount_data, which nfs_fill_super
		 * can deal with.
		 */
		args->flags		= data->flags;
		args->rsize		= data->rsize;
		args->wsize		= data->wsize;
		args->timeo		= data->timeo;
		args->retrans		= data->retrans;
		args->acregmin		= data->acregmin;
		args->acregmax		= data->acregmax;
		args->acdirmin		= data->acdirmin;
		args->acdirmax		= data->acdirmax;
1570 1571 1572 1573 1574 1575 1576 1577

		memcpy(&args->nfs_server.address, &data->addr,
		       sizeof(data->addr));
		args->nfs_server.addrlen = sizeof(data->addr);
		if (!nfs_verify_server_address((struct sockaddr *)
						&args->nfs_server.address))
			goto out_no_address;

1578
		if (!(data->flags & NFS_MOUNT_TCP))
1579
			args->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1580 1581 1582 1583
		/* N.B. caller will free nfs_server.hostname in all cases */
		args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
		args->namlen		= data->namlen;
		args->bsize		= data->bsize;
1584 1585 1586

		if (data->flags & NFS_MOUNT_SECFLAVOUR)
			args->auth_flavors[0] = data->pseudoflavor;
1587 1588
		if (!args->nfs_server.hostname)
			goto out_nomem;
1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615

		/*
		 * The legacy version 6 binary mount data from userspace has a
		 * field used only to transport selinux information into the
		 * the kernel.  To continue to support that functionality we
		 * have a touch of selinux knowledge here in the NFS code. The
		 * userspace code converted context=blah to just blah so we are
		 * converting back to the full string selinux understands.
		 */
		if (data->context[0]){
#ifdef CONFIG_SECURITY_SELINUX
			int rc;
			char *opts_str = kmalloc(sizeof(data->context) + 8, GFP_KERNEL);
			if (!opts_str)
				return -ENOMEM;
			strcpy(opts_str, "context=");
			data->context[NFS_MAX_CONTEXT_LEN] = '\0';
			strcat(opts_str, &data->context[0]);
			rc = security_sb_parse_opts_str(opts_str, &args->lsm_opts);
			kfree(opts_str);
			if (rc)
				return rc;
#else
			return -EINVAL;
#endif
		}

1616
		break;
1617 1618 1619
	default: {
		int status;

1620 1621
		if (nfs_parse_mount_options((char *)options, args) == 0)
			return -EINVAL;
1622

1623 1624 1625 1626
		if (!nfs_verify_server_address((struct sockaddr *)
						&args->nfs_server.address))
			goto out_no_address;

1627 1628 1629
		nfs_set_port((struct sockaddr *)&args->nfs_server.address,
				args->nfs_server.port);

1630 1631
		nfs_set_mount_transport_protocol(args);

1632 1633 1634 1635 1636 1637 1638
		status = nfs_parse_devname(dev_name,
					   &args->nfs_server.hostname,
					   PAGE_SIZE,
					   &args->nfs_server.export_path,
					   NFS_MAXPATHLEN);
		if (!status)
			status = nfs_try_mount(args, mntfh);
1639

1640 1641
		kfree(args->nfs_server.export_path);
		args->nfs_server.export_path = NULL;
1642 1643

		if (status)
1644
			return status;
1645 1646 1647

		break;
		}
1648
	}
1649 1650

#ifndef CONFIG_NFS_V3
1651
	if (args->flags & NFS_MOUNT_VER3)
1652 1653
		goto out_v3_not_compiled;
#endif /* !CONFIG_NFS_V3 */
1654

1655
	return 0;
1656

1657 1658 1659
out_no_data:
	dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n");
	return -EINVAL;
1660

1661 1662 1663 1664
out_no_v3:
	dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n",
		 data->version);
	return -EINVAL;
1665

1666 1667 1668 1669 1670 1671 1672 1673 1674 1675
out_no_sec:
	dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n");
	return -EINVAL;

#ifndef CONFIG_NFS_V3
out_v3_not_compiled:
	dfprintk(MOUNT, "NFS: NFSv3 is not compiled into kernel\n");
	return -EPROTONOSUPPORT;
#endif /* !CONFIG_NFS_V3 */

1676 1677 1678 1679
out_nomem:
	dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n");
	return -ENOMEM;