super.c 72.0 KB
Newer Older
D
David Howells 已提交
1 2 3 4 5 6 7
/*
 *  linux/fs/nfs/super.c
 *
 *  Copyright (C) 1992  Rick Sladkey
 *
 *  nfs superblock handling functions
 *
A
Alan Cox 已提交
8
 *  Modularised by Alan Cox <alan@lxorguk.ukuu.org.uk>, while hacking some
D
David Howells 已提交
9 10 11 12 13 14 15
 *  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())
D
David Howells 已提交
21 22 23 24 25 26 27 28 29 30 31 32 33
 */

#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>
34
#include <linux/sunrpc/addr.h>
D
David Howells 已提交
35 36
#include <linux/sunrpc/stats.h>
#include <linux/sunrpc/metrics.h>
37
#include <linux/sunrpc/xprtsock.h>
\
\"Talpey, Thomas\ 已提交
38
#include <linux/sunrpc/xprtrdma.h>
D
David Howells 已提交
39 40 41 42 43 44
#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>
45
#include <linux/namei.h>
D
David Howells 已提交
46 47 48
#include <linux/nfs_idmap.h>
#include <linux/vfs.h>
#include <linux/inet.h>
49
#include <linux/in6.h>
50
#include <linux/slab.h>
51
#include <net/ipv6.h>
52
#include <linux/netdevice.h>
D
David Howells 已提交
53
#include <linux/nfs_xdr.h>
54
#include <linux/magic.h>
55
#include <linux/parser.h>
56
#include <linux/nsproxy.h>
57
#include <linux/rcupdate.h>
D
David Howells 已提交
58 59 60 61 62 63 64 65

#include <asm/uaccess.h>

#include "nfs4_fs.h"
#include "callback.h"
#include "delegation.h"
#include "iostat.h"
#include "internal.h"
66
#include "fscache.h"
67
#include "nfs4session.h"
J
J. Bruce Fields 已提交
68
#include "pnfs.h"
69
#include "nfs.h"
D
David Howells 已提交
70 71

#define NFSDBG_FACILITY		NFSDBG_VFS
72
#define NFS_TEXT_DATA		1
D
David Howells 已提交
73

B
Bryan Schumaker 已提交
74
#if IS_ENABLED(CONFIG_NFS_V3)
75 76 77 78 79
#define NFS_DEFAULT_VERSION 3
#else
#define NFS_DEFAULT_VERSION 2
#endif

80 81 82 83 84 85 86
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,
\
\"Talpey, Thomas\ 已提交
87
	Opt_udp, Opt_tcp, Opt_rdma,
88 89
	Opt_acl, Opt_noacl,
	Opt_rdirplus, Opt_nordirplus,
90
	Opt_sharecache, Opt_nosharecache,
C
Chuck Lever 已提交
91
	Opt_resvport, Opt_noresvport,
92
	Opt_fscache, Opt_nofscache,
93
	Opt_migration, Opt_nomigration,
94 95 96 97 98 99 100 101 102 103

	/* 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,
104
	Opt_mountvers,
105
	Opt_minorversion,
106 107

	/* Mount options that take string arguments */
108
	Opt_nfsvers,
109
	Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost,
110
	Opt_addr, Opt_mountaddr, Opt_clientaddr,
111
	Opt_lookupcache,
112
	Opt_fscache_uniq,
113
	Opt_local_lock,
114

115 116
	/* Special mount options */
	Opt_userspace, Opt_deprecated, Opt_sloppy,
117 118 119 120

	Opt_err
};

121
static const match_table_t nfs_mount_option_tokens = {
122 123
	{ Opt_userspace, "bg" },
	{ Opt_userspace, "fg" },
124 125
	{ Opt_userspace, "retry=%s" },

126 127
	{ Opt_sloppy, "sloppy" },

128 129
	{ Opt_soft, "soft" },
	{ Opt_hard, "hard" },
130 131
	{ Opt_deprecated, "intr" },
	{ Opt_deprecated, "nointr" },
132 133 134 135 136 137 138 139 140 141
	{ 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_udp, "udp" },
	{ Opt_tcp, "tcp" },
\
\"Talpey, Thomas\ 已提交
142
	{ Opt_rdma, "rdma" },
143 144 145 146
	{ Opt_acl, "acl" },
	{ Opt_noacl, "noacl" },
	{ Opt_rdirplus, "rdirplus" },
	{ Opt_nordirplus, "nordirplus" },
147 148
	{ Opt_sharecache, "sharecache" },
	{ Opt_nosharecache, "nosharecache" },
C
Chuck Lever 已提交
149 150
	{ Opt_resvport, "resvport" },
	{ Opt_noresvport, "noresvport" },
151 152
	{ Opt_fscache, "fsc" },
	{ Opt_nofscache, "nofsc" },
153 154
	{ Opt_migration, "migration" },
	{ Opt_nomigration, "nomigration" },
155

156 157 158 159 160 161 162 163 164 165 166 167 168 169
	{ Opt_port, "port=%s" },
	{ Opt_rsize, "rsize=%s" },
	{ Opt_wsize, "wsize=%s" },
	{ Opt_bsize, "bsize=%s" },
	{ Opt_timeo, "timeo=%s" },
	{ Opt_retrans, "retrans=%s" },
	{ Opt_acregmin, "acregmin=%s" },
	{ Opt_acregmax, "acregmax=%s" },
	{ Opt_acdirmin, "acdirmin=%s" },
	{ Opt_acdirmax, "acdirmax=%s" },
	{ Opt_actimeo, "actimeo=%s" },
	{ Opt_namelen, "namlen=%s" },
	{ Opt_mountport, "mountport=%s" },
	{ Opt_mountvers, "mountvers=%s" },
170 171
	{ Opt_minorversion, "minorversion=%s" },

172 173
	{ Opt_nfsvers, "nfsvers=%s" },
	{ Opt_nfsvers, "vers=%s" },
174 175 176 177 178 179

	{ Opt_sec, "sec=%s" },
	{ Opt_proto, "proto=%s" },
	{ Opt_mountproto, "mountproto=%s" },
	{ Opt_addr, "addr=%s" },
	{ Opt_clientaddr, "clientaddr=%s" },
180
	{ Opt_mounthost, "mounthost=%s" },
181
	{ Opt_mountaddr, "mountaddr=%s" },
182

183
	{ Opt_lookupcache, "lookupcache=%s" },
184
	{ Opt_fscache_uniq, "fsc=%s" },
185
	{ Opt_local_lock, "local_lock=%s" },
186

187 188 189
	/* The following needs to be listed after all other options */
	{ Opt_nfsvers, "v%s" },

190 191 192 193
	{ Opt_err, NULL }
};

enum {
194
	Opt_xprt_udp, Opt_xprt_udp6, Opt_xprt_tcp, Opt_xprt_tcp6, Opt_xprt_rdma,
195 196 197 198

	Opt_xprt_err
};

199
static const match_table_t nfs_xprt_protocol_tokens = {
200
	{ Opt_xprt_udp, "udp" },
201
	{ Opt_xprt_udp6, "udp6" },
202
	{ Opt_xprt_tcp, "tcp" },
203
	{ Opt_xprt_tcp6, "tcp6" },
\
\"Talpey, Thomas\ 已提交
204
	{ Opt_xprt_rdma, "rdma" },
205 206 207 208 209 210 211 212 213 214 215 216 217

	{ 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
};

218
static const match_table_t nfs_secflavor_tokens = {
219 220 221 222 223 224 225 226 227 228 229 230
	{ 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" },

231 232 233 234
	{ Opt_sec_spkm, "spkm3" },
	{ Opt_sec_spkmi, "spkm3i" },
	{ Opt_sec_spkmp, "spkm3p" },

235 236 237
	{ Opt_sec_err, NULL }
};

238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253
enum {
	Opt_lookupcache_all, Opt_lookupcache_positive,
	Opt_lookupcache_none,

	Opt_lookupcache_err
};

static match_table_t nfs_lookupcache_tokens = {
	{ Opt_lookupcache_all, "all" },
	{ Opt_lookupcache_positive, "pos" },
	{ Opt_lookupcache_positive, "positive" },
	{ Opt_lookupcache_none, "none" },

	{ Opt_lookupcache_err, NULL }
};

254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
enum {
	Opt_local_lock_all, Opt_local_lock_flock, Opt_local_lock_posix,
	Opt_local_lock_none,

	Opt_local_lock_err
};

static match_table_t nfs_local_lock_tokens = {
	{ Opt_local_lock_all, "all" },
	{ Opt_local_lock_flock, "flock" },
	{ Opt_local_lock_posix, "posix" },
	{ Opt_local_lock_none, "none" },

	{ Opt_local_lock_err, NULL }
};

270 271
enum {
	Opt_vers_2, Opt_vers_3, Opt_vers_4, Opt_vers_4_0,
272
	Opt_vers_4_1, Opt_vers_4_2,
273 274 275 276 277 278 279 280 281 282

	Opt_vers_err
};

static match_table_t nfs_vers_tokens = {
	{ Opt_vers_2, "2" },
	{ Opt_vers_3, "3" },
	{ Opt_vers_4, "4" },
	{ Opt_vers_4_0, "4.0" },
	{ Opt_vers_4_1, "4.1" },
283
	{ Opt_vers_4_2, "4.2" },
284 285 286

	{ Opt_vers_err, NULL }
};
287

288 289
static struct dentry *nfs_xdev_mount(struct file_system_type *fs_type,
		int flags, const char *dev_name, void *raw_data);
D
David Howells 已提交
290

291
struct file_system_type nfs_fs_type = {
D
David Howells 已提交
292 293
	.owner		= THIS_MODULE,
	.name		= "nfs",
294
	.mount		= nfs_fs_mount,
D
David Howells 已提交
295
	.kill_sb	= nfs_kill_super,
296
	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
D
David Howells 已提交
297
};
298
MODULE_ALIAS_FS("nfs");
B
Bryan Schumaker 已提交
299
EXPORT_SYMBOL_GPL(nfs_fs_type);
D
David Howells 已提交
300

301
struct file_system_type nfs_xdev_fs_type = {
D
David Howells 已提交
302 303
	.owner		= THIS_MODULE,
	.name		= "nfs",
304
	.mount		= nfs_xdev_mount,
D
David Howells 已提交
305
	.kill_sb	= nfs_kill_super,
306
	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
D
David Howells 已提交
307 308
};

309
const struct super_operations nfs_sops = {
D
David Howells 已提交
310 311 312
	.alloc_inode	= nfs_alloc_inode,
	.destroy_inode	= nfs_destroy_inode,
	.write_inode	= nfs_write_inode,
313
	.drop_inode	= nfs_drop_inode,
T
Trond Myklebust 已提交
314
	.put_super	= nfs_put_super,
D
David Howells 已提交
315
	.statfs		= nfs_statfs,
316
	.evict_inode	= nfs_evict_inode,
D
David Howells 已提交
317 318
	.umount_begin	= nfs_umount_begin,
	.show_options	= nfs_show_options,
319 320
	.show_devname	= nfs_show_devname,
	.show_path	= nfs_show_path,
D
David Howells 已提交
321
	.show_stats	= nfs_show_stats,
322
	.remount_fs	= nfs_remount,
D
David Howells 已提交
323
};
B
Bryan Schumaker 已提交
324
EXPORT_SYMBOL_GPL(nfs_sops);
D
David Howells 已提交
325

B
Bryan Schumaker 已提交
326
#if IS_ENABLED(CONFIG_NFS_V4)
327
static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *);
328 329
static int nfs4_validate_mount_data(void *options,
	struct nfs_parsed_mount_data *args, const char *dev_name);
330 331 332 333 334 335

struct file_system_type nfs4_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "nfs4",
	.mount		= nfs_fs_mount,
	.kill_sb	= nfs_kill_super,
336
	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
337
};
338
MODULE_ALIAS_FS("nfs4");
339
MODULE_ALIAS("nfs4");
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
EXPORT_SYMBOL_GPL(nfs4_fs_type);

static int __init register_nfs4_fs(void)
{
	return register_filesystem(&nfs4_fs_type);
}

static void unregister_nfs4_fs(void)
{
	unregister_filesystem(&nfs4_fs_type);
}
#else
static int __init register_nfs4_fs(void)
{
	return 0;
}

static void unregister_nfs4_fs(void)
{
}
D
David Howells 已提交
360 361
#endif

362 363 364 365
static struct shrinker acl_shrinker = {
	.shrink		= nfs_access_cache_shrinker,
	.seeks		= DEFAULT_SEEKS,
};
366

D
David Howells 已提交
367 368 369 370 371 372 373 374 375 376 377
/*
 * Register the NFS filesystems
 */
int __init register_nfs_fs(void)
{
	int ret;

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

378
	ret = register_nfs4_fs();
D
David Howells 已提交
379 380
	if (ret < 0)
		goto error_1;
381 382 383 384

	ret = nfs_register_sysctl();
	if (ret < 0)
		goto error_2;
385
	register_shrinker(&acl_shrinker);
D
David Howells 已提交
386 387
	return 0;

388 389
error_2:
	unregister_nfs4_fs();
D
David Howells 已提交
390 391 392 393 394 395 396 397 398 399 400
error_1:
	unregister_filesystem(&nfs_fs_type);
error_0:
	return ret;
}

/*
 * Unregister the NFS filesystems
 */
void __exit unregister_nfs_fs(void)
{
401
	unregister_shrinker(&acl_shrinker);
402
	nfs_unregister_sysctl();
403
	unregister_nfs4_fs();
D
David Howells 已提交
404 405 406
	unregister_filesystem(&nfs_fs_type);
}

407
void nfs_sb_active(struct super_block *sb)
408
{
409
	struct nfs_server *server = NFS_SB(sb);
410

411 412
	if (atomic_inc_return(&server->active) == 1)
		atomic_inc(&sb->s_active);
413
}
B
Bryan Schumaker 已提交
414
EXPORT_SYMBOL_GPL(nfs_sb_active);
415

416
void nfs_sb_deactive(struct super_block *sb)
417 418
{
	struct nfs_server *server = NFS_SB(sb);
419 420 421

	if (atomic_dec_and_test(&server->active))
		deactivate_super(sb);
422
}
B
Bryan Schumaker 已提交
423
EXPORT_SYMBOL_GPL(nfs_sb_deactive);
424

D
David Howells 已提交
425 426 427
/*
 * Deliver file system statistics to userspace
 */
428
int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
D
David Howells 已提交
429
{
430
	struct nfs_server *server = NFS_SB(dentry->d_sb);
D
David Howells 已提交
431 432
	unsigned char blockbits;
	unsigned long blockres;
433
	struct nfs_fh *fh = NFS_FH(dentry->d_inode);
434 435 436 437 438 439
	struct nfs_fsstat res;
	int error = -ENOMEM;

	res.fattr = nfs_alloc_fattr();
	if (res.fattr == NULL)
		goto out_err;
D
David Howells 已提交
440

441
	error = server->nfs_client->rpc_ops->statfs(server, fh, &res);
M
Menyhart Zoltan 已提交
442 443 444 445 446 447 448 449 450
	if (unlikely(error == -ESTALE)) {
		struct dentry *pd_dentry;

		pd_dentry = dget_parent(dentry);
		if (pd_dentry != NULL) {
			nfs_zap_caches(pd_dentry->d_inode);
			dput(pd_dentry);
		}
	}
451
	nfs_free_fattr(res.fattr);
D
David Howells 已提交
452 453
	if (error < 0)
		goto out_err;
454

A
Amnon Aaronsohn 已提交
455
	buf->f_type = NFS_SUPER_MAGIC;
D
David Howells 已提交
456 457 458 459 460 461

	/*
	 * 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.
	 */
462
	buf->f_frsize = dentry->d_sb->s_blocksize;
D
David Howells 已提交
463 464 465 466 467 468 469 470

	/*
	 * 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.
	 */
471 472
	buf->f_bsize = dentry->d_sb->s_blocksize;
	blockbits = dentry->d_sb->s_blocksize_bits;
D
David Howells 已提交
473 474 475 476 477 478 479 480 481
	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;
A
Amnon Aaronsohn 已提交
482

D
David Howells 已提交
483 484 485
	return 0;

 out_err:
486
	dprintk("%s: statfs error = %d\n", __func__, -error);
A
Amnon Aaronsohn 已提交
487
	return error;
D
David Howells 已提交
488
}
B
Bryan Schumaker 已提交
489
EXPORT_SYMBOL_GPL(nfs_statfs);
D
David Howells 已提交
490

491 492 493
/*
 * Map the security flavour number to a name
 */
494 495
static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour)
{
496
	static const struct {
497 498 499 500 501 502 503 504 505 506 507 508 509 510
		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" },
511
		{ UINT_MAX, "unknown" }
512 513 514
	};
	int i;

515
	for (i = 0; sec_flavours[i].flavour != UINT_MAX; i++) {
516 517 518 519 520 521
		if (sec_flavours[i].flavour == flavour)
			break;
	}
	return sec_flavours[i].str;
}

522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560
static void nfs_show_mountd_netid(struct seq_file *m, struct nfs_server *nfss,
				  int showdefaults)
{
	struct sockaddr *sap = (struct sockaddr *) &nfss->mountd_address;

	seq_printf(m, ",mountproto=");
	switch (sap->sa_family) {
	case AF_INET:
		switch (nfss->mountd_protocol) {
		case IPPROTO_UDP:
			seq_printf(m, RPCBIND_NETID_UDP);
			break;
		case IPPROTO_TCP:
			seq_printf(m, RPCBIND_NETID_TCP);
			break;
		default:
			if (showdefaults)
				seq_printf(m, "auto");
		}
		break;
	case AF_INET6:
		switch (nfss->mountd_protocol) {
		case IPPROTO_UDP:
			seq_printf(m, RPCBIND_NETID_UDP6);
			break;
		case IPPROTO_TCP:
			seq_printf(m, RPCBIND_NETID_TCP6);
			break;
		default:
			if (showdefaults)
				seq_printf(m, "auto");
		}
		break;
	default:
		if (showdefaults)
			seq_printf(m, "auto");
	}
}

561 562 563 564 565
static void nfs_show_mountd_options(struct seq_file *m, struct nfs_server *nfss,
				    int showdefaults)
{
	struct sockaddr *sap = (struct sockaddr *)&nfss->mountd_address;

566 567 568
	if (nfss->flags & NFS_MOUNT_LEGACY_INTERFACE)
		return;

569 570 571
	switch (sap->sa_family) {
	case AF_INET: {
		struct sockaddr_in *sin = (struct sockaddr_in *)sap;
H
Harvey Harrison 已提交
572
		seq_printf(m, ",mountaddr=%pI4", &sin->sin_addr.s_addr);
573 574 575 576
		break;
	}
	case AF_INET6: {
		struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
577
		seq_printf(m, ",mountaddr=%pI6c", &sin6->sin6_addr);
578 579 580 581 582 583 584 585 586
		break;
	}
	default:
		if (showdefaults)
			seq_printf(m, ",mountaddr=unspecified");
	}

	if (nfss->mountd_version || showdefaults)
		seq_printf(m, ",mountvers=%u", nfss->mountd_version);
587 588 589
	if ((nfss->mountd_port &&
		nfss->mountd_port != (unsigned short)NFS_UNSPEC_PORT) ||
		showdefaults)
590 591
		seq_printf(m, ",mountport=%u", nfss->mountd_port);

592
	nfs_show_mountd_netid(m, nfss, showdefaults);
593 594
}

B
Bryan Schumaker 已提交
595
#if IS_ENABLED(CONFIG_NFS_V4)
596 597 598 599 600 601 602 603 604 605 606 607 608 609
static void nfs_show_nfsv4_options(struct seq_file *m, struct nfs_server *nfss,
				    int showdefaults)
{
	struct nfs_client *clp = nfss->nfs_client;

	seq_printf(m, ",clientaddr=%s", clp->cl_ipaddr);
}
#else
static void nfs_show_nfsv4_options(struct seq_file *m, struct nfs_server *nfss,
				    int showdefaults)
{
}
#endif

610 611 612 613 614 615 616 617 618
static void nfs_show_nfs_version(struct seq_file *m,
		unsigned int version,
		unsigned int minorversion)
{
	seq_printf(m, ",vers=%u", version);
	if (version == 4)
		seq_printf(m, ".%u", minorversion);
}

D
David Howells 已提交
619 620 621
/*
 * Describe the mount options in force on this server representation
 */
622 623
static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss,
				   int showdefaults)
D
David Howells 已提交
624
{
D
David Howells 已提交
625
	static const struct proc_nfs_info {
D
David Howells 已提交
626
		int flag;
D
David Howells 已提交
627 628
		const char *str;
		const char *nostr;
D
David Howells 已提交
629 630
	} nfs_info[] = {
		{ NFS_MOUNT_SOFT, ",soft", ",hard" },
631
		{ NFS_MOUNT_POSIX, ",posix", "" },
D
David Howells 已提交
632 633 634 635
		{ NFS_MOUNT_NOCTO, ",nocto", "" },
		{ NFS_MOUNT_NOAC, ",noac", "" },
		{ NFS_MOUNT_NONLM, ",nolock", "" },
		{ NFS_MOUNT_NOACL, ",noacl", "" },
636
		{ NFS_MOUNT_NORDIRPLUS, ",nordirplus", "" },
C
Chuck Lever 已提交
637 638
		{ NFS_MOUNT_UNSHARED, ",nosharecache", "" },
		{ NFS_MOUNT_NORESVPORT, ",noresvport", "" },
D
David Howells 已提交
639 640
		{ 0, NULL, NULL }
	};
D
David Howells 已提交
641
	const struct proc_nfs_info *nfs_infop;
642
	struct nfs_client *clp = nfss->nfs_client;
643
	u32 version = clp->rpc_ops->version;
644
	int local_flock, local_fcntl;
D
David Howells 已提交
645

646
	nfs_show_nfs_version(m, version, clp->cl_minorversion);
647 648
	seq_printf(m, ",rsize=%u", nfss->rsize);
	seq_printf(m, ",wsize=%u", nfss->wsize);
649 650 651
	if (nfss->bsize != 0)
		seq_printf(m, ",bsize=%u", nfss->bsize);
	seq_printf(m, ",namlen=%u", nfss->namelen);
652
	if (nfss->acregmin != NFS_DEF_ACREGMIN*HZ || showdefaults)
653
		seq_printf(m, ",acregmin=%u", nfss->acregmin/HZ);
654
	if (nfss->acregmax != NFS_DEF_ACREGMAX*HZ || showdefaults)
655
		seq_printf(m, ",acregmax=%u", nfss->acregmax/HZ);
656
	if (nfss->acdirmin != NFS_DEF_ACDIRMIN*HZ || showdefaults)
657
		seq_printf(m, ",acdirmin=%u", nfss->acdirmin/HZ);
658
	if (nfss->acdirmax != NFS_DEF_ACDIRMAX*HZ || showdefaults)
659
		seq_printf(m, ",acdirmax=%u", nfss->acdirmax/HZ);
D
David Howells 已提交
660 661 662 663 664 665
	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);
	}
666
	rcu_read_lock();
667
	seq_printf(m, ",proto=%s",
668
		   rpc_peeraddr2str(nfss->client, RPC_DISPLAY_NETID));
669
	rcu_read_unlock();
670 671 672 673 674 675 676
	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);

677 678
	seq_printf(m, ",timeo=%lu", 10U * nfss->client->cl_timeout->to_initval / HZ);
	seq_printf(m, ",retrans=%u", nfss->client->cl_timeout->to_retries);
679
	seq_printf(m, ",sec=%s", nfs_pseudoflavour_to_name(nfss->client->cl_auth->au_flavor));
680 681 682

	if (version != 4)
		nfs_show_mountd_options(m, nfss, showdefaults);
683 684
	else
		nfs_show_nfsv4_options(m, nfss, showdefaults);
685

686 687
	if (nfss->options & NFS_OPTION_FSCACHE)
		seq_printf(m, ",fsc");
688

689 690 691
	if (nfss->options & NFS_OPTION_MIGRATION)
		seq_printf(m, ",migration");

692 693 694 695 696 697
	if (nfss->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG) {
		if (nfss->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
			seq_printf(m, ",lookupcache=none");
		else
			seq_printf(m, ",lookupcache=pos");
	}
698 699 700 701 702 703 704 705 706 707 708 709

	local_flock = nfss->flags & NFS_MOUNT_LOCAL_FLOCK;
	local_fcntl = nfss->flags & NFS_MOUNT_LOCAL_FCNTL;

	if (!local_flock && !local_fcntl)
		seq_printf(m, ",local_lock=none");
	else if (local_flock && local_fcntl)
		seq_printf(m, ",local_lock=all");
	else if (local_flock)
		seq_printf(m, ",local_lock=flock");
	else
		seq_printf(m, ",local_lock=posix");
D
David Howells 已提交
710 711 712 713 714
}

/*
 * Describe the mount options on this VFS mountpoint
 */
715
int nfs_show_options(struct seq_file *m, struct dentry *root)
D
David Howells 已提交
716
{
717
	struct nfs_server *nfss = NFS_SB(root->d_sb);
D
David Howells 已提交
718 719 720

	nfs_show_mount_options(m, nfss, 0);

721
	rcu_read_lock();
722 723 724
	seq_printf(m, ",addr=%s",
			rpc_peeraddr2str(nfss->nfs_client->cl_rpcclient,
							RPC_DISPLAY_ADDR));
725
	rcu_read_unlock();
D
David Howells 已提交
726 727 728

	return 0;
}
B
Bryan Schumaker 已提交
729
EXPORT_SYMBOL_GPL(nfs_show_options);
730

B
Bryan Schumaker 已提交
731
#if IS_ENABLED(CONFIG_NFS_V4)
J
J. Bruce Fields 已提交
732
#ifdef CONFIG_NFS_V4_1
733
static void show_sessions(struct seq_file *m, struct nfs_server *server)
J
J. Bruce Fields 已提交
734 735 736 737 738
{
	if (nfs4_has_session(server->nfs_client))
		seq_printf(m, ",sessions");
}
#else
739 740
static void show_sessions(struct seq_file *m, struct nfs_server *server) {}
#endif
J
J. Bruce Fields 已提交
741 742 743
#endif

#ifdef CONFIG_NFS_V4_1
744
static void show_pnfs(struct seq_file *m, struct nfs_server *server)
J
J. Bruce Fields 已提交
745 746 747 748 749 750 751
{
	seq_printf(m, ",pnfs=");
	if (server->pnfs_curr_ld)
		seq_printf(m, "%s", server->pnfs_curr_ld->name);
	else
		seq_printf(m, "not configured");
}
752 753 754

static void show_implementation_id(struct seq_file *m, struct nfs_server *nfss)
{
755 756
	if (nfss->nfs_client && nfss->nfs_client->cl_implid) {
		struct nfs41_impl_id *impl_id = nfss->nfs_client->cl_implid;
757 758 759 760 761 762
		seq_printf(m, "\n\timpl_id:\tname='%s',domain='%s',"
			   "date='%llu,%u'",
			   impl_id->name, impl_id->domain,
			   impl_id->date.seconds, impl_id->date.nseconds);
	}
}
763
#else
B
Bryan Schumaker 已提交
764
#if IS_ENABLED(CONFIG_NFS_V4)
765 766 767
static void show_pnfs(struct seq_file *m, struct nfs_server *server)
{
}
768
#endif
769 770 771
static void show_implementation_id(struct seq_file *m, struct nfs_server *nfss)
{
}
772
#endif
D
David Howells 已提交
773

774
int nfs_show_devname(struct seq_file *m, struct dentry *root)
775 776 777 778 779 780
{
	char *page = (char *) __get_free_page(GFP_KERNEL);
	char *devname, *dummy;
	int err = 0;
	if (!page)
		return -ENOMEM;
781
	devname = nfs_path(&dummy, root, page, PAGE_SIZE, 0);
782 783 784 785 786 787 788
	if (IS_ERR(devname))
		err = PTR_ERR(devname);
	else
		seq_escape(m, devname, " \t\n\\");
	free_page((unsigned long)page);
	return err;
}
B
Bryan Schumaker 已提交
789
EXPORT_SYMBOL_GPL(nfs_show_devname);
790

791
int nfs_show_path(struct seq_file *m, struct dentry *dentry)
792 793 794 795
{
	seq_puts(m, "/");
	return 0;
}
B
Bryan Schumaker 已提交
796
EXPORT_SYMBOL_GPL(nfs_show_path);
797

D
David Howells 已提交
798 799 800
/*
 * Present statistical information for this VFS mountpoint
 */
801
int nfs_show_stats(struct seq_file *m, struct dentry *root)
D
David Howells 已提交
802 803
{
	int i, cpu;
804
	struct nfs_server *nfss = NFS_SB(root->d_sb);
D
David Howells 已提交
805 806 807 808 809 810 811 812 813
	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");
814 815 816 817
	seq_puts(m, root->d_sb->s_flags & MS_RDONLY ? "ro" : "rw");
	seq_puts(m, root->d_sb->s_flags & MS_SYNCHRONOUS ? ",sync" : "");
	seq_puts(m, root->d_sb->s_flags & MS_NOATIME ? ",noatime" : "");
	seq_puts(m, root->d_sb->s_flags & MS_NODIRATIME ? ",nodiratime" : "");
D
David Howells 已提交
818 819 820 821
	nfs_show_mount_options(m, nfss, 1);

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

822
	show_implementation_id(m, nfss);
823

D
David Howells 已提交
824 825
	seq_printf(m, "\n\tcaps:\t");
	seq_printf(m, "caps=0x%x", nfss->caps);
826 827 828 829
	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);
D
David Howells 已提交
830

B
Bryan Schumaker 已提交
831
#if IS_ENABLED(CONFIG_NFS_V4)
832
	if (nfss->nfs_client->rpc_ops->version == 4) {
D
David Howells 已提交
833 834 835
		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]);
836
		seq_printf(m, ",bm2=0x%x", nfss->attr_bitmask[2]);
D
David Howells 已提交
837
		seq_printf(m, ",acl=0x%x", nfss->acl_bitmask);
J
J. Bruce Fields 已提交
838 839
		show_sessions(m, nfss);
		show_pnfs(m, nfss);
D
David Howells 已提交
840 841 842 843 844 845
	}
#endif

	/*
	 * Display security flavor in effect for this mount
	 */
846
	seq_printf(m, "\n\tsec:\tflavor=%u", auth->au_ops->au_flavor);
D
David Howells 已提交
847
	if (auth->au_flavor)
848
		seq_printf(m, ",pseudoflavor=%u", auth->au_flavor);
D
David Howells 已提交
849 850 851 852 853 854 855 856 857 858 859 860 861 862

	/*
	 * 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];
863 864 865 866
#ifdef CONFIG_NFS_FSCACHE
		for (i = 0; i < __NFSIOS_FSCACHEMAX; i++)
			totals.fscache[i] += stats->fscache[i];
#endif
D
David Howells 已提交
867 868 869 870 871 872 873 874 875 876

		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]);
877 878 879 880 881 882 883
#ifdef CONFIG_NFS_FSCACHE
	if (nfss->options & NFS_OPTION_FSCACHE) {
		seq_printf(m, "\n\tfsc:\t");
		for (i = 0; i < __NFSIOS_FSCACHEMAX; i++)
			seq_printf(m, "%Lu ", totals.bytes[i]);
	}
#endif
D
David Howells 已提交
884 885 886 887 888 889
	seq_printf(m, "\n");

	rpc_print_iostats(m, nfss->client);

	return 0;
}
B
Bryan Schumaker 已提交
890
EXPORT_SYMBOL_GPL(nfs_show_stats);
D
David Howells 已提交
891 892 893

/*
 * Begin unmount by attempting to remove all automounted mountpoints we added
894
 * in response to xdev traversals and referrals
D
David Howells 已提交
895
 */
896
void nfs_umount_begin(struct super_block *sb)
D
David Howells 已提交
897
{
898
	struct nfs_server *server;
T
Trond Myklebust 已提交
899 900
	struct rpc_clnt *rpc;

901
	server = NFS_SB(sb);
T
Trond Myklebust 已提交
902 903 904 905 906 907 908
	/* -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);
D
David Howells 已提交
909
}
B
Bryan Schumaker 已提交
910
EXPORT_SYMBOL_GPL(nfs_umount_begin);
D
David Howells 已提交
911

912
static struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(void)
913 914 915 916 917 918 919 920 921
{
	struct nfs_parsed_mount_data *data;

	data = kzalloc(sizeof(*data), GFP_KERNEL);
	if (data) {
		data->acregmin		= NFS_DEF_ACREGMIN;
		data->acregmax		= NFS_DEF_ACREGMAX;
		data->acdirmin		= NFS_DEF_ACDIRMIN;
		data->acdirmax		= NFS_DEF_ACDIRMAX;
922
		data->mount_server.port	= NFS_UNSPEC_PORT;
923
		data->nfs_server.port	= NFS_UNSPEC_PORT;
924
		data->nfs_server.protocol = XPRT_TRANSPORT_TCP;
925
		data->auth_flavors[0]	= RPC_AUTH_MAXFLAVOR;
926 927
		data->auth_flavor_len	= 1;
		data->minorversion	= 0;
928
		data->need_mount	= true;
929
		data->net		= current->nsproxy->net_ns;
930
		security_init_mnt_opts(&data->lsm_opts);
931 932 933 934
	}
	return data;
}

935 936 937 938 939 940 941 942 943 944 945 946 947
static void nfs_free_parsed_mount_data(struct nfs_parsed_mount_data *data)
{
	if (data) {
		kfree(data->client_address);
		kfree(data->mount_server.hostname);
		kfree(data->nfs_server.export_path);
		kfree(data->nfs_server.hostname);
		kfree(data->fscache_uniq);
		security_free_mnt_opts(&data->lsm_opts);
		kfree(data);
	}
}

948
/*
949 950 951 952
 * 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.
953 954 955 956 957
 */
static int nfs_verify_server_address(struct sockaddr *addr)
{
	switch (addr->sa_family) {
	case AF_INET: {
958
		struct sockaddr_in *sa = (struct sockaddr_in *)addr;
A
Al Viro 已提交
959
		return sa->sin_addr.s_addr != htonl(INADDR_ANY);
960 961 962 963
	}
	case AF_INET6: {
		struct in6_addr *sa = &((struct sockaddr_in6 *)addr)->sin6_addr;
		return !ipv6_addr_any(sa);
964 965 966
	}
	}

967
	dfprintk(MOUNT, "NFS: Invalid IP address specified\n");
968 969 970
	return 0;
}

971 972 973 974
/*
 * Select between a default port value and a user-specified port value.
 * If a zero value is set, then autobind will be used.
 */
975
static void nfs_set_port(struct sockaddr *sap, int *port,
976 977
				 const unsigned short default_port)
{
978 979
	if (*port == NFS_UNSPEC_PORT)
		*port = default_port;
980

981
	rpc_set_port(sap, *port);
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 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020
/*
 * 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;
	}
}

1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
/*
 * Parse the value of the 'sec=' option.
 */
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_flavors[0] = RPC_AUTH_NULL;
		break;
	case Opt_sec_sys:
		mnt->auth_flavors[0] = RPC_AUTH_UNIX;
		break;
	case Opt_sec_krb5:
		mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5;
		break;
	case Opt_sec_krb5i:
		mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5I;
		break;
	case Opt_sec_krb5p:
		mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5P;
		break;
	case Opt_sec_lkey:
		mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEY;
		break;
	case Opt_sec_lkeyi:
		mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYI;
		break;
	case Opt_sec_lkeyp:
		mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYP;
		break;
	case Opt_sec_spkm:
		mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKM;
		break;
	case Opt_sec_spkmi:
		mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMI;
		break;
	case Opt_sec_spkmp:
		mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMP;
		break;
	default:
		return 0;
	}

1069
	mnt->flags |= NFS_MOUNT_SECFLAVOUR;
1070
	mnt->auth_flavor_len = 1;
1071 1072 1073
	return 1;
}

1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
static int nfs_parse_version_string(char *string,
		struct nfs_parsed_mount_data *mnt,
		substring_t *args)
{
	mnt->flags &= ~NFS_MOUNT_VER3;
	switch (match_token(string, nfs_vers_tokens, args)) {
	case Opt_vers_2:
		mnt->version = 2;
		break;
	case Opt_vers_3:
		mnt->flags |= NFS_MOUNT_VER3;
		mnt->version = 3;
		break;
	case Opt_vers_4:
		/* Backward compatibility option. In future,
		 * the mount program should always supply
		 * a NFSv4 minor version number.
		 */
		mnt->version = 4;
		break;
	case Opt_vers_4_0:
		mnt->version = 4;
		mnt->minorversion = 0;
		break;
	case Opt_vers_4_1:
		mnt->version = 4;
		mnt->minorversion = 1;
		break;
1102 1103 1104 1105
	case Opt_vers_4_2:
		mnt->version = 4;
		mnt->minorversion = 2;
		break;
1106 1107 1108 1109 1110 1111
	default:
		return 0;
	}
	return 1;
}

1112 1113 1114 1115
static int nfs_get_option_str(substring_t args[], char **option)
{
	kfree(*option);
	*option = match_strdup(args);
1116
	return !*option;
1117 1118 1119 1120 1121 1122 1123 1124 1125 1126
}

static int nfs_get_option_ul(substring_t args[], unsigned long *option)
{
	int rc;
	char *string;

	string = match_strdup(args);
	if (string == NULL)
		return -ENOMEM;
1127
	rc = kstrtoul(string, 10, option);
1128 1129 1130 1131 1132
	kfree(string);

	return rc;
}

1133 1134
/*
 * Error-check and convert a string of mount options from user space into
1135 1136 1137
 * 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).
1138 1139 1140 1141
 */
static int nfs_parse_mount_options(char *raw,
				   struct nfs_parsed_mount_data *mnt)
{
1142
	char *p, *string, *secdata;
1143
	int rc, sloppy = 0, invalid_option = 0;
1144 1145
	unsigned short protofamily = AF_UNSPEC;
	unsigned short mountfamily = AF_UNSPEC;
1146 1147 1148 1149 1150 1151 1152

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

1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166
	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);

1167 1168
	while ((p = strsep(&raw, ",")) != NULL) {
		substring_t args[MAX_OPT_ARGS];
1169 1170
		unsigned long option;
		int token;
1171 1172 1173 1174 1175 1176 1177 1178

		if (!*p)
			continue;

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

		token = match_token(p, nfs_mount_option_tokens, args);
		switch (token) {
1179 1180 1181 1182

		/*
		 * boolean options:  foo/nofoo
		 */
1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208
		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;
1209 1210
			mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
					NFS_MOUNT_LOCAL_FCNTL);
1211 1212 1213
			break;
		case Opt_nolock:
			mnt->flags |= NFS_MOUNT_NONLM;
1214 1215
			mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
				       NFS_MOUNT_LOCAL_FCNTL);
1216 1217 1218
			break;
		case Opt_udp:
			mnt->flags &= ~NFS_MOUNT_TCP;
1219
			mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1220 1221 1222
			break;
		case Opt_tcp:
			mnt->flags |= NFS_MOUNT_TCP;
1223
			mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1224
			break;
\
\"Talpey, Thomas\ 已提交
1225 1226 1227
		case Opt_rdma:
			mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */
			mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
1228
			xprt_load_transport(p);
\
\"Talpey, Thomas\ 已提交
1229
			break;
1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241
		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;
1242 1243 1244 1245 1246 1247
		case Opt_sharecache:
			mnt->flags &= ~NFS_MOUNT_UNSHARED;
			break;
		case Opt_nosharecache:
			mnt->flags |= NFS_MOUNT_UNSHARED;
			break;
C
Chuck Lever 已提交
1248 1249 1250 1251 1252 1253
		case Opt_resvport:
			mnt->flags &= ~NFS_MOUNT_NORESVPORT;
			break;
		case Opt_noresvport:
			mnt->flags |= NFS_MOUNT_NORESVPORT;
			break;
1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
		case Opt_fscache:
			mnt->options |= NFS_OPTION_FSCACHE;
			kfree(mnt->fscache_uniq);
			mnt->fscache_uniq = NULL;
			break;
		case Opt_nofscache:
			mnt->options &= ~NFS_OPTION_FSCACHE;
			kfree(mnt->fscache_uniq);
			mnt->fscache_uniq = NULL;
			break;
1264 1265 1266 1267 1268 1269
		case Opt_migration:
			mnt->options |= NFS_OPTION_MIGRATION;
			break;
		case Opt_nomigration:
			mnt->options &= NFS_OPTION_MIGRATION;
			break;
1270

1271 1272 1273
		/*
		 * options that take numeric values
		 */
1274
		case Opt_port:
1275 1276
			if (nfs_get_option_ul(args, &option) ||
			    option > USHRT_MAX)
1277 1278
				goto out_invalid_value;
			mnt->nfs_server.port = option;
1279 1280
			break;
		case Opt_rsize:
1281
			if (nfs_get_option_ul(args, &option))
1282 1283
				goto out_invalid_value;
			mnt->rsize = option;
1284 1285
			break;
		case Opt_wsize:
1286
			if (nfs_get_option_ul(args, &option))
1287 1288
				goto out_invalid_value;
			mnt->wsize = option;
1289 1290
			break;
		case Opt_bsize:
1291
			if (nfs_get_option_ul(args, &option))
1292 1293
				goto out_invalid_value;
			mnt->bsize = option;
1294 1295
			break;
		case Opt_timeo:
1296
			if (nfs_get_option_ul(args, &option) || option == 0)
1297 1298
				goto out_invalid_value;
			mnt->timeo = option;
1299 1300
			break;
		case Opt_retrans:
1301
			if (nfs_get_option_ul(args, &option) || option == 0)
1302 1303
				goto out_invalid_value;
			mnt->retrans = option;
1304 1305
			break;
		case Opt_acregmin:
1306
			if (nfs_get_option_ul(args, &option))
1307 1308
				goto out_invalid_value;
			mnt->acregmin = option;
1309 1310
			break;
		case Opt_acregmax:
1311
			if (nfs_get_option_ul(args, &option))
1312 1313
				goto out_invalid_value;
			mnt->acregmax = option;
1314 1315
			break;
		case Opt_acdirmin:
1316
			if (nfs_get_option_ul(args, &option))
1317 1318
				goto out_invalid_value;
			mnt->acdirmin = option;
1319 1320
			break;
		case Opt_acdirmax:
1321
			if (nfs_get_option_ul(args, &option))
1322 1323
				goto out_invalid_value;
			mnt->acdirmax = option;
1324 1325
			break;
		case Opt_actimeo:
1326
			if (nfs_get_option_ul(args, &option))
1327 1328 1329
				goto out_invalid_value;
			mnt->acregmin = mnt->acregmax =
			mnt->acdirmin = mnt->acdirmax = option;
1330 1331
			break;
		case Opt_namelen:
1332
			if (nfs_get_option_ul(args, &option))
1333 1334
				goto out_invalid_value;
			mnt->namlen = option;
1335 1336
			break;
		case Opt_mountport:
1337 1338
			if (nfs_get_option_ul(args, &option) ||
			    option > USHRT_MAX)
1339 1340
				goto out_invalid_value;
			mnt->mount_server.port = option;
1341 1342
			break;
		case Opt_mountvers:
1343
			if (nfs_get_option_ul(args, &option) ||
1344
			    option < NFS_MNT_VERSION ||
1345 1346 1347
			    option > NFS_MNT3_VERSION)
				goto out_invalid_value;
			mnt->mount_server.version = option;
1348
			break;
1349
		case Opt_minorversion:
1350
			if (nfs_get_option_ul(args, &option))
1351 1352 1353 1354
				goto out_invalid_value;
			if (option > NFS4_MAX_MINOR_VERSION)
				goto out_invalid_value;
			mnt->minorversion = option;
1355
			break;
1356

1357 1358 1359
		/*
		 * options that take text values
		 */
1360 1361 1362 1363 1364 1365 1366 1367 1368
		case Opt_nfsvers:
			string = match_strdup(args);
			if (string == NULL)
				goto out_nomem;
			rc = nfs_parse_version_string(string, mnt, args);
			kfree(string);
			if (!rc)
				goto out_invalid_value;
			break;
1369 1370 1371 1372
		case Opt_sec:
			string = match_strdup(args);
			if (string == NULL)
				goto out_nomem;
1373
			rc = nfs_parse_security_flavors(string, mnt);
1374
			kfree(string);
1375 1376 1377
			if (!rc) {
				dfprintk(MOUNT, "NFS:   unrecognized "
						"security flavor\n");
1378
				return 0;
1379
			}
1380 1381 1382 1383 1384 1385 1386 1387
			break;
		case Opt_proto:
			string = match_strdup(args);
			if (string == NULL)
				goto out_nomem;
			token = match_token(string,
					    nfs_xprt_protocol_tokens, args);

1388
			protofamily = AF_INET;
1389
			switch (token) {
1390 1391
			case Opt_xprt_udp6:
				protofamily = AF_INET6;
1392
			case Opt_xprt_udp:
1393
				mnt->flags &= ~NFS_MOUNT_TCP;
1394
				mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1395
				break;
1396 1397
			case Opt_xprt_tcp6:
				protofamily = AF_INET6;
1398
			case Opt_xprt_tcp:
1399
				mnt->flags |= NFS_MOUNT_TCP;
1400
				mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1401
				break;
\
\"Talpey, Thomas\ 已提交
1402 1403 1404 1405
			case Opt_xprt_rdma:
				/* vector side protocols to TCP */
				mnt->flags |= NFS_MOUNT_TCP;
				mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
1406
				xprt_load_transport(string);
\
\"Talpey, Thomas\ 已提交
1407
				break;
1408
			default:
1409 1410
				dfprintk(MOUNT, "NFS:   unrecognized "
						"transport protocol\n");
1411
				kfree(string);
1412
				return 0;
1413
			}
1414
			kfree(string);
1415 1416 1417 1418 1419 1420 1421
			break;
		case Opt_mountproto:
			string = match_strdup(args);
			if (string == NULL)
				goto out_nomem;
			token = match_token(string,
					    nfs_xprt_protocol_tokens, args);
1422
			kfree(string);
1423

1424
			mountfamily = AF_INET;
1425
			switch (token) {
1426 1427
			case Opt_xprt_udp6:
				mountfamily = AF_INET6;
1428
			case Opt_xprt_udp:
1429
				mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
1430
				break;
1431 1432
			case Opt_xprt_tcp6:
				mountfamily = AF_INET6;
1433
			case Opt_xprt_tcp:
1434
				mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
1435
				break;
\
\"Talpey, Thomas\ 已提交
1436
			case Opt_xprt_rdma: /* not used for side protocols */
1437
			default:
1438 1439
				dfprintk(MOUNT, "NFS:   unrecognized "
						"transport protocol\n");
1440
				return 0;
1441 1442 1443 1444 1445 1446
			}
			break;
		case Opt_addr:
			string = match_strdup(args);
			if (string == NULL)
				goto out_nomem;
1447
			mnt->nfs_server.addrlen =
1448
				rpc_pton(mnt->net, string, strlen(string),
1449 1450 1451
					(struct sockaddr *)
					&mnt->nfs_server.address,
					sizeof(mnt->nfs_server.address));
1452
			kfree(string);
1453 1454
			if (mnt->nfs_server.addrlen == 0)
				goto out_invalid_address;
1455 1456
			break;
		case Opt_clientaddr:
1457
			if (nfs_get_option_str(args, &mnt->client_address))
1458 1459
				goto out_nomem;
			break;
1460
		case Opt_mounthost:
1461 1462
			if (nfs_get_option_str(args,
					       &mnt->mount_server.hostname))
1463 1464
				goto out_nomem;
			break;
1465
		case Opt_mountaddr:
1466 1467 1468
			string = match_strdup(args);
			if (string == NULL)
				goto out_nomem;
1469
			mnt->mount_server.addrlen =
1470
				rpc_pton(mnt->net, string, strlen(string),
1471 1472 1473
					(struct sockaddr *)
					&mnt->mount_server.address,
					sizeof(mnt->mount_server.address));
1474
			kfree(string);
1475 1476
			if (mnt->mount_server.addrlen == 0)
				goto out_invalid_address;
1477
			break;
1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498
		case Opt_lookupcache:
			string = match_strdup(args);
			if (string == NULL)
				goto out_nomem;
			token = match_token(string,
					nfs_lookupcache_tokens, args);
			kfree(string);
			switch (token) {
				case Opt_lookupcache_all:
					mnt->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE);
					break;
				case Opt_lookupcache_positive:
					mnt->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE;
					mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG;
					break;
				case Opt_lookupcache_none:
					mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
					break;
				default:
					dfprintk(MOUNT, "NFS:   invalid "
							"lookupcache argument\n");
1499
					return 0;
1500 1501
			};
			break;
1502
		case Opt_fscache_uniq:
1503
			if (nfs_get_option_str(args, &mnt->fscache_uniq))
1504 1505 1506
				goto out_nomem;
			mnt->options |= NFS_OPTION_FSCACHE;
			break;
1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534
		case Opt_local_lock:
			string = match_strdup(args);
			if (string == NULL)
				goto out_nomem;
			token = match_token(string, nfs_local_lock_tokens,
					args);
			kfree(string);
			switch (token) {
			case Opt_local_lock_all:
				mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
					       NFS_MOUNT_LOCAL_FCNTL);
				break;
			case Opt_local_lock_flock:
				mnt->flags |= NFS_MOUNT_LOCAL_FLOCK;
				break;
			case Opt_local_lock_posix:
				mnt->flags |= NFS_MOUNT_LOCAL_FCNTL;
				break;
			case Opt_local_lock_none:
				mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
						NFS_MOUNT_LOCAL_FCNTL);
				break;
			default:
				dfprintk(MOUNT, "NFS:	invalid	"
						"local_lock argument\n");
				return 0;
			};
			break;
1535

1536 1537 1538 1539 1540 1541 1542
		/*
		 * Special options
		 */
		case Opt_sloppy:
			sloppy = 1;
			dfprintk(MOUNT, "NFS:   relaxing parsing rules\n");
			break;
1543 1544
		case Opt_userspace:
		case Opt_deprecated:
1545 1546
			dfprintk(MOUNT, "NFS:   ignoring mount option "
					"'%s'\n", p);
1547 1548 1549
			break;

		default:
1550
			invalid_option = 1;
1551 1552
			dfprintk(MOUNT, "NFS:   unrecognized mount option "
					"'%s'\n", p);
1553 1554 1555
		}
	}

1556 1557 1558
	if (!sloppy && invalid_option)
		return 0;

1559 1560 1561
	if (mnt->minorversion && mnt->version != 4)
		goto out_minorversion_mismatch;

1562 1563 1564 1565
	if (mnt->options & NFS_OPTION_MIGRATION &&
	    mnt->version != 4 && mnt->minorversion != 0)
		goto out_migration_misuse;

1566 1567
	/*
	 * verify that any proto=/mountproto= options match the address
P
Peter Meerwald 已提交
1568
	 * families in the addr=/mountaddr= options.
1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583
	 */
	if (protofamily != AF_UNSPEC &&
	    protofamily != mnt->nfs_server.address.ss_family)
		goto out_proto_mismatch;

	if (mountfamily != AF_UNSPEC) {
		if (mnt->mount_server.addrlen) {
			if (mountfamily != mnt->mount_server.address.ss_family)
				goto out_mountproto_mismatch;
		} else {
			if (mountfamily != mnt->nfs_server.address.ss_family)
				goto out_mountproto_mismatch;
		}
	}

1584 1585
	return 1;

1586 1587 1588 1589 1590 1591 1592
out_mountproto_mismatch:
	printk(KERN_INFO "NFS: mount server address does not match mountproto= "
			 "option\n");
	return 0;
out_proto_mismatch:
	printk(KERN_INFO "NFS: server address does not match proto= option\n");
	return 0;
1593 1594 1595
out_invalid_address:
	printk(KERN_INFO "NFS: bad IP address specified: %s\n", p);
	return 0;
1596
out_invalid_value:
1597
	printk(KERN_INFO "NFS: bad mount option value specified: %s\n", p);
1598
	return 0;
1599 1600 1601 1602
out_minorversion_mismatch:
	printk(KERN_INFO "NFS: mount option vers=%u does not support "
			 "minorversion=%u\n", mnt->version, mnt->minorversion);
	return 0;
1603 1604 1605 1606
out_migration_misuse:
	printk(KERN_INFO
		"NFS: 'migration' not supported for this NFS version\n");
	return 0;
1607 1608 1609
out_nomem:
	printk(KERN_INFO "NFS: not enough memory to parse option\n");
	return 0;
1610 1611 1612 1613
out_security_failure:
	free_secdata(secdata);
	printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
	return 0;
1614 1615
}

1616
/*
1617 1618
 * Ensure that the specified authtype in args->auth_flavors[0] is supported by
 * the server. Returns 0 if it's ok, and -EACCES if not.
1619
 */
1620 1621
static int nfs_verify_authflavor(struct nfs_parsed_mount_data *args,
			rpc_authflavor_t *server_authlist, unsigned int count)
1622
{
1623
	unsigned int i;
1624

1625 1626 1627 1628 1629 1630 1631 1632
	/*
	 * If the sec= mount option is used, the specified flavor or AUTH_NULL
	 * must be in the list returned by the server.
	 *
	 * AUTH_NULL has a special meaning when it's in the server list - it
	 * means that the server will ignore the rpc creds, so any flavor
	 * can be used.
	 */
1633
	for (i = 0; i < count; i++) {
1634 1635 1636
		if (args->auth_flavors[0] == server_authlist[i] ||
		    server_authlist[i] == RPC_AUTH_NULL)
			goto out;
1637
	}
1638

1639 1640 1641
	dfprintk(MOUNT, "NFS: auth flavor %u not supported by server\n",
		args->auth_flavors[0]);
	return -EACCES;
1642

1643
out:
1644
	dfprintk(MOUNT, "NFS: using auth flavor %u\n", args->auth_flavors[0]);
1645
	return 0;
1646 1647
}

1648 1649 1650 1651
/*
 * Use the remote server's MOUNT service to request the NFS file handle
 * corresponding to the provided path.
 */
1652
static int nfs_request_mount(struct nfs_parsed_mount_data *args,
1653 1654 1655
			     struct nfs_fh *root_fh,
			     rpc_authflavor_t *server_authlist,
			     unsigned int *server_authlist_len)
1656
{
1657 1658 1659 1660 1661 1662
	struct nfs_mount_request request = {
		.sap		= (struct sockaddr *)
						&args->mount_server.address,
		.dirpath	= args->nfs_server.export_path,
		.protocol	= args->mount_server.protocol,
		.fh		= root_fh,
1663
		.noresvport	= args->flags & NFS_MOUNT_NORESVPORT,
1664
		.auth_flav_len	= server_authlist_len,
1665
		.auth_flavs	= server_authlist,
1666
		.net		= args->net,
1667
	};
1668
	int status;
1669 1670

	if (args->mount_server.version == 0) {
1671 1672 1673 1674 1675 1676 1677
		switch (args->version) {
			default:
				args->mount_server.version = NFS_MNT3_VERSION;
				break;
			case 2:
				args->mount_server.version = NFS_MNT_VERSION;
		}
1678
	}
1679
	request.version = args->mount_server.version;
1680

1681
	if (args->mount_server.hostname)
1682
		request.hostname = args->mount_server.hostname;
1683
	else
1684
		request.hostname = args->nfs_server.hostname;
1685

1686 1687 1688
	/*
	 * Construct the mount server's address.
	 */
1689
	if (args->mount_server.address.ss_family == AF_UNSPEC) {
1690
		memcpy(request.sap, &args->nfs_server.address,
1691 1692 1693
		       args->nfs_server.addrlen);
		args->mount_server.addrlen = args->nfs_server.addrlen;
	}
1694
	request.salen = args->mount_server.addrlen;
1695
	nfs_set_port(request.sap, &args->mount_server.port, 0);
1696 1697 1698 1699 1700

	/*
	 * Now ask the mount server to map our export path
	 * to a file handle.
	 */
1701
	status = nfs_mount(&request);
1702 1703 1704 1705 1706
	if (status != 0) {
		dfprintk(MOUNT, "NFS: unable to mount server %s, error %d\n",
				request.hostname, status);
		return status;
	}
1707

1708
	return 0;
1709 1710
}

1711 1712 1713 1714
static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_info,
					struct nfs_subversion *nfs_mod)
{
	int status;
1715 1716 1717 1718
	unsigned int i;
	bool tried_auth_unix = false;
	bool auth_null_in_list = false;
	struct nfs_server *server = ERR_PTR(-EACCES);
1719 1720 1721
	struct nfs_parsed_mount_data *args = mount_info->parsed;
	rpc_authflavor_t authlist[NFS_MAX_SECFLAVORS];
	unsigned int authlist_len = ARRAY_SIZE(authlist);
1722

1723 1724
	status = nfs_request_mount(args, mount_info->mntfh, authlist,
					&authlist_len);
1725 1726 1727
	if (status)
		return ERR_PTR(status);

1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779
	/*
	 * Was a sec= authflavor specified in the options? First, verify
	 * whether the server supports it, and then just try to use it if so.
	 */
	if (args->auth_flavors[0] != RPC_AUTH_MAXFLAVOR) {
		status = nfs_verify_authflavor(args, authlist, authlist_len);
		dfprintk(MOUNT, "NFS: using auth flavor %u\n", args->auth_flavors[0]);
		if (status)
			return ERR_PTR(status);
		return nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
	}

	/*
	 * No sec= option was provided. RFC 2623, section 2.7 suggests we
	 * SHOULD prefer the flavor listed first. However, some servers list
	 * AUTH_NULL first. Avoid ever choosing AUTH_NULL.
	 */
	for (i = 0; i < authlist_len; ++i) {
		rpc_authflavor_t flavor;
		struct rpcsec_gss_info info;

		flavor = authlist[i];
		switch (flavor) {
		case RPC_AUTH_UNIX:
			tried_auth_unix = true;
			break;
		case RPC_AUTH_NULL:
			auth_null_in_list = true;
			continue;
		default:
			if (rpcauth_get_gssinfo(flavor, &info) != 0)
				continue;
			/* Fallthrough */
		}
		dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", flavor);
		args->auth_flavors[0] = flavor;
		server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
		if (!IS_ERR(server))
			return server;
	}

	/*
	 * Nothing we tried so far worked. At this point, give up if we've
	 * already tried AUTH_UNIX or if the server's list doesn't contain
	 * AUTH_NULL
	 */
	if (tried_auth_unix || !auth_null_in_list)
		return server;

	/* Last chance! Try AUTH_UNIX */
	dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", RPC_AUTH_UNIX);
	args->auth_flavors[0] = RPC_AUTH_UNIX;
1780 1781 1782
	return nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
}

B
Bryan Schumaker 已提交
1783 1784 1785
struct dentry *nfs_try_mount(int flags, const char *dev_name,
			     struct nfs_mount_info *mount_info,
			     struct nfs_subversion *nfs_mod)
1786 1787 1788
{
	struct nfs_server *server;

1789 1790 1791 1792
	if (mount_info->parsed->need_mount)
		server = nfs_try_mount_request(mount_info, nfs_mod);
	else
		server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
1793 1794 1795 1796

	if (IS_ERR(server))
		return ERR_CAST(server);

1797
	return nfs_fs_mount_common(server, flags, dev_name, mount_info, nfs_mod);
1798
}
B
Bryan Schumaker 已提交
1799
EXPORT_SYMBOL_GPL(nfs_try_mount);
1800

1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812
/*
 * 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)
1813 1814
{
	size_t len;
1815
	char *end;
1816

1817 1818 1819 1820
	/* Is the host name protected with square brakcets? */
	if (*dev_name == '[') {
		end = strchr(++dev_name, ']');
		if (end == NULL || end[1] != ':')
1821 1822
			goto out_bad_devname;

1823 1824 1825 1826
		len = end - dev_name;
		end++;
	} else {
		char *comma;
1827

1828 1829 1830 1831
		end = strchr(dev_name, ':');
		if (end == NULL)
			goto out_bad_devname;
		len = end - dev_name;
1832

1833 1834 1835 1836 1837
		/* kill possible hostname list: not supported */
		comma = strchr(dev_name, ',');
		if (comma != NULL && comma < end)
			*comma = 0;
	}
1838 1839 1840 1841 1842

	if (len > maxnamlen)
		goto out_hostname;

	/* N.B. caller will free nfs_server.hostname in all cases */
1843
	*hostname = kstrndup(dev_name, len, GFP_KERNEL);
1844 1845
	if (*hostname == NULL)
		goto out_nomem;
1846
	len = strlen(++end);
1847 1848 1849 1850 1851 1852
	if (len > maxpathlen)
		goto out_path;
	*export_path = kstrndup(end, len, GFP_KERNEL);
	if (!*export_path)
		goto out_nomem;

1853
	dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", *export_path);
1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872
	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;
}

D
David Howells 已提交
1873
/*
1874 1875
 * Validate the NFS2/NFS3 mount data
 * - fills in the mount root filehandle
1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887
 *
 * 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
D
David Howells 已提交
1888
 */
1889 1890 1891 1892
static int nfs23_validate_mount_data(void *options,
				     struct nfs_parsed_mount_data *args,
				     struct nfs_fh *mntfh,
				     const char *dev_name)
D
David Howells 已提交
1893
{
1894
	struct nfs_mount_data *data = (struct nfs_mount_data *)options;
1895
	struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
1896

1897 1898
	if (data == NULL)
		goto out_no_data;
D
David Howells 已提交
1899

1900
	args->version = NFS_DEFAULT_VERSION;
1901
	switch (data->version) {
1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916
	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:
1917 1918 1919
		if (data->flags & NFS_MOUNT_VER3) {
			if (data->root.size > NFS3_FHSIZE || data->root.size == 0)
				goto out_invalid_fh;
1920
			mntfh->size = data->root.size;
1921 1922
			args->version = 3;
		} else {
1923
			mntfh->size = NFS2_FHSIZE;
1924 1925
			args->version = 2;
		}
1926 1927 1928 1929 1930 1931


		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);
1932

1933 1934 1935 1936
		/*
		 * Translate to nfs_parsed_mount_data, which nfs_fill_super
		 * can deal with.
		 */
1937
		args->flags		= data->flags & NFS_MOUNT_FLAGMASK;
1938
		args->flags		|= NFS_MOUNT_LEGACY_INTERFACE;
1939 1940 1941 1942 1943 1944 1945 1946
		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;
1947
		args->need_mount	= false;
1948

1949
		memcpy(sap, &data->addr, sizeof(data->addr));
1950
		args->nfs_server.addrlen = sizeof(data->addr);
1951
		args->nfs_server.port = ntohs(data->addr.sin_port);
1952
		if (!nfs_verify_server_address(sap))
1953 1954
			goto out_no_address;

1955
		if (!(data->flags & NFS_MOUNT_TCP))
1956
			args->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1957 1958 1959 1960
		/* 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;
1961

1962
		args->auth_flavors[0] = RPC_AUTH_UNIX;
1963 1964
		if (data->flags & NFS_MOUNT_SECFLAVOUR)
			args->auth_flavors[0] = data->pseudoflavor;
1965 1966
		if (!args->nfs_server.hostname)
			goto out_nomem;
1967

1968 1969 1970 1971 1972 1973
		if (!(data->flags & NFS_MOUNT_NONLM))
			args->flags &= ~(NFS_MOUNT_LOCAL_FLOCK|
					 NFS_MOUNT_LOCAL_FCNTL);
		else
			args->flags |= (NFS_MOUNT_LOCAL_FLOCK|
					NFS_MOUNT_LOCAL_FCNTL);
1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999
		/*
		 * 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
		}

2000
		break;
2001 2002
	default:
		return NFS_TEXT_DATA;
D
David Howells 已提交
2003
	}
2004

B
Bryan Schumaker 已提交
2005
#if !IS_ENABLED(CONFIG_NFS_V3)
2006
	if (args->version == 3)
2007 2008
		goto out_v3_not_compiled;
#endif /* !CONFIG_NFS_V3 */
D
David Howells 已提交
2009

2010
	return 0;
D
David Howells 已提交
2011

2012 2013 2014
out_no_data:
	dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n");
	return -EINVAL;
2015

2016 2017 2018 2019
out_no_v3:
	dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n",
		 data->version);
	return -EINVAL;
D
David Howells 已提交
2020

2021 2022 2023 2024
out_no_sec:
	dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n");
	return -EINVAL;

B
Bryan Schumaker 已提交
2025
#if !IS_ENABLED(CONFIG_NFS_V3)
2026 2027 2028 2029 2030
out_v3_not_compiled:
	dfprintk(MOUNT, "NFS: NFSv3 is not compiled into kernel\n");
	return -EPROTONOSUPPORT;
#endif /* !CONFIG_NFS_V3 */

2031 2032 2033 2034
out_nomem:
	dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n");
	return -ENOMEM;

2035 2036 2037 2038 2039 2040 2041
out_no_address:
	dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
	return -EINVAL;

out_invalid_fh:
	dfprintk(MOUNT, "NFS: invalid root filehandle\n");
	return -EINVAL;
D
David Howells 已提交
2042 2043
}

B
Bryan Schumaker 已提交
2044
#if IS_ENABLED(CONFIG_NFS_V4)
2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065
static int nfs_validate_mount_data(struct file_system_type *fs_type,
				   void *options,
				   struct nfs_parsed_mount_data *args,
				   struct nfs_fh *mntfh,
				   const char *dev_name)
{
	if (fs_type == &nfs_fs_type)
		return nfs23_validate_mount_data(options, args, mntfh, dev_name);
	return nfs4_validate_mount_data(options, args, dev_name);
}
#else
static int nfs_validate_mount_data(struct file_system_type *fs_type,
				   void *options,
				   struct nfs_parsed_mount_data *args,
				   struct nfs_fh *mntfh,
				   const char *dev_name)
{
	return nfs23_validate_mount_data(options, args, mntfh, dev_name);
}
#endif

2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081
static int nfs_validate_text_mount_data(void *options,
					struct nfs_parsed_mount_data *args,
					const char *dev_name)
{
	int port = 0;
	int max_namelen = PAGE_SIZE;
	int max_pathlen = NFS_MAXPATHLEN;
	struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;

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

	if (!nfs_verify_server_address(sap))
		goto out_no_address;

	if (args->version == 4) {
B
Bryan Schumaker 已提交
2082
#if IS_ENABLED(CONFIG_NFS_V4)
2083 2084 2085 2086
		port = NFS_PORT;
		max_namelen = NFS4_MAXNAMLEN;
		max_pathlen = NFS4_MAXPATHLEN;
		nfs_validate_transport_protocol(args);
2087 2088
		if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP)
			goto out_invalid_transport_udp;
2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106
		nfs4_validate_mount_flags(args);
#else
		goto out_v4_not_compiled;
#endif /* CONFIG_NFS_V4 */
	} else
		nfs_set_mount_transport_protocol(args);

	nfs_set_port(sap, &args->nfs_server.port, port);

	if (args->auth_flavor_len > 1)
		goto out_bad_auth;

	return nfs_parse_devname(dev_name,
				   &args->nfs_server.hostname,
				   max_namelen,
				   &args->nfs_server.export_path,
				   max_pathlen);

B
Bryan Schumaker 已提交
2107
#if !IS_ENABLED(CONFIG_NFS_V4)
2108 2109 2110
out_v4_not_compiled:
	dfprintk(MOUNT, "NFS: NFSv4 is not compiled into kernel\n");
	return -EPROTONOSUPPORT;
2111 2112 2113 2114
#else
out_invalid_transport_udp:
	dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
	return -EINVAL;
2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125
#endif /* !CONFIG_NFS_V4 */

out_no_address:
	dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
	return -EINVAL;

out_bad_auth:
	dfprintk(MOUNT, "NFS: Too many RPC auth flavours specified\n");
	return -EINVAL;
}

2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139
static int
nfs_compare_remount_data(struct nfs_server *nfss,
			 struct nfs_parsed_mount_data *data)
{
	if (data->flags != nfss->flags ||
	    data->rsize != nfss->rsize ||
	    data->wsize != nfss->wsize ||
	    data->retrans != nfss->client->cl_timeout->to_retries ||
	    data->auth_flavors[0] != nfss->client->cl_auth->au_flavor ||
	    data->acregmin != nfss->acregmin / HZ ||
	    data->acregmax != nfss->acregmax / HZ ||
	    data->acdirmin != nfss->acdirmin / HZ ||
	    data->acdirmax != nfss->acdirmax / HZ ||
	    data->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) ||
2140
	    data->nfs_server.port != nfss->port ||
2141
	    data->nfs_server.addrlen != nfss->nfs_client->cl_addrlen ||
S
Stefan Richter 已提交
2142 2143
	    !rpc_cmp_addr((struct sockaddr *)&data->nfs_server.address,
			  (struct sockaddr *)&nfss->nfs_client->cl_addr))
2144 2145 2146 2147 2148
		return -EINVAL;

	return 0;
}

2149
int
2150 2151 2152 2153 2154 2155 2156
nfs_remount(struct super_block *sb, int *flags, char *raw_data)
{
	int error;
	struct nfs_server *nfss = sb->s_fs_info;
	struct nfs_parsed_mount_data *data;
	struct nfs_mount_data *options = (struct nfs_mount_data *)raw_data;
	struct nfs4_mount_data *options4 = (struct nfs4_mount_data *)raw_data;
2157
	u32 nfsvers = nfss->nfs_client->rpc_ops->version;
2158 2159 2160 2161 2162 2163 2164

	/*
	 * Userspace mount programs that send binary options generally send
	 * them populated with default values. We have no way to know which
	 * ones were explicitly specified. Fall back to legacy behavior and
	 * just return success.
	 */
2165 2166 2167
	if ((nfsvers == 4 && (!options4 || options4->version == 1)) ||
	    (nfsvers <= 3 && (!options || (options->version >= 1 &&
					   options->version <= 6))))
2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184
		return 0;

	data = kzalloc(sizeof(*data), GFP_KERNEL);
	if (data == NULL)
		return -ENOMEM;

	/* fill out struct with values from existing mount */
	data->flags = nfss->flags;
	data->rsize = nfss->rsize;
	data->wsize = nfss->wsize;
	data->retrans = nfss->client->cl_timeout->to_retries;
	data->auth_flavors[0] = nfss->client->cl_auth->au_flavor;
	data->acregmin = nfss->acregmin / HZ;
	data->acregmax = nfss->acregmax / HZ;
	data->acdirmin = nfss->acdirmin / HZ;
	data->acdirmax = nfss->acdirmax / HZ;
	data->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ;
2185
	data->nfs_server.port = nfss->port;
2186 2187 2188 2189 2190 2191 2192 2193 2194
	data->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
	memcpy(&data->nfs_server.address, &nfss->nfs_client->cl_addr,
		data->nfs_server.addrlen);

	/* overwrite those values with any that were specified */
	error = nfs_parse_mount_options((char *)options, data);
	if (error < 0)
		goto out;

2195 2196 2197 2198 2199 2200 2201 2202 2203
	/*
	 * noac is a special case. It implies -o sync, but that's not
	 * necessarily reflected in the mtab options. do_remount_sb
	 * will clear MS_SYNCHRONOUS if -o sync wasn't specified in the
	 * remount options, so we have to explicitly reset it.
	 */
	if (data->flags & NFS_MOUNT_NOAC)
		*flags |= MS_SYNCHRONOUS;

2204 2205 2206 2207 2208 2209
	/* compare new mount options with old ones */
	error = nfs_compare_remount_data(nfss, data);
out:
	kfree(data);
	return error;
}
B
Bryan Schumaker 已提交
2210
EXPORT_SYMBOL_GPL(nfs_remount);
2211

D
David Howells 已提交
2212
/*
2213
 * Initialise the common bits of the superblock
D
David Howells 已提交
2214
 */
2215
inline void nfs_initialise_sb(struct super_block *sb)
D
David Howells 已提交
2216
{
2217
	struct nfs_server *server = NFS_SB(sb);
2218

2219
	sb->s_magic = NFS_SUPER_MAGIC;
D
David Howells 已提交
2220

2221 2222
	/* We probably want something more informative here */
	snprintf(sb->s_id, sizeof(sb->s_id),
2223
		 "%u:%u", MAJOR(sb->s_dev), MINOR(sb->s_dev));
2224

2225 2226 2227
	if (sb->s_blocksize == 0)
		sb->s_blocksize = nfs_block_bits(server->wsize,
						 &sb->s_blocksize_bits);
D
David Howells 已提交
2228

J
Jens Axboe 已提交
2229 2230
	sb->s_bdi = &server->backing_dev_info;

2231
	nfs_super_set_maxbytes(sb, server->maxfilesize);
D
David Howells 已提交
2232 2233 2234
}

/*
2235
 * Finish setting up an NFS2/3 superblock
D
David Howells 已提交
2236
 */
2237
void nfs_fill_super(struct super_block *sb, struct nfs_mount_info *mount_info)
D
David Howells 已提交
2238
{
2239
	struct nfs_parsed_mount_data *data = mount_info->parsed;
D
David Howells 已提交
2240
	struct nfs_server *server = NFS_SB(sb);
2241

2242 2243
	sb->s_blocksize_bits = 0;
	sb->s_blocksize = 0;
2244 2245 2246
	sb->s_xattr = server->nfs_client->cl_nfs_mod->xattr;
	sb->s_op = server->nfs_client->cl_nfs_mod->sops;
	if (data && data->bsize)
2247
		sb->s_blocksize = nfs_block_size(data->bsize, &sb->s_blocksize_bits);
D
David Howells 已提交
2248

2249
	if (server->nfs_client->rpc_ops->version != 2) {
2250 2251 2252 2253 2254
		/* The VFS shouldn't apply the umask to mode bits. We will do
		 * so ourselves when necessary.
		 */
		sb->s_flags |= MS_POSIXACL;
		sb->s_time_gran = 1;
2255
	}
2256 2257

 	nfs_initialise_sb(sb);
D
David Howells 已提交
2258
}
B
Bryan Schumaker 已提交
2259
EXPORT_SYMBOL_GPL(nfs_fill_super);
D
David Howells 已提交
2260 2261

/*
2262
 * Finish setting up a cloned NFS2/3/4 superblock
D
David Howells 已提交
2263
 */
2264
void nfs_clone_super(struct super_block *sb, struct nfs_mount_info *mount_info)
D
David Howells 已提交
2265
{
2266
	const struct super_block *old_sb = mount_info->cloned->sb;
2267 2268 2269 2270 2271
	struct nfs_server *server = NFS_SB(sb);

	sb->s_blocksize_bits = old_sb->s_blocksize_bits;
	sb->s_blocksize = old_sb->s_blocksize;
	sb->s_maxbytes = old_sb->s_maxbytes;
2272 2273 2274
	sb->s_xattr = old_sb->s_xattr;
	sb->s_op = old_sb->s_op;
	sb->s_time_gran = 1;
D
David Howells 已提交
2275

2276
	if (server->nfs_client->rpc_ops->version != 2) {
2277 2278
		/* The VFS shouldn't apply the umask to mode bits. We will do
		 * so ourselves when necessary.
D
David Howells 已提交
2279 2280 2281 2282
		 */
		sb->s_flags |= MS_POSIXACL;
	}

2283
 	nfs_initialise_sb(sb);
D
David Howells 已提交
2284 2285
}

2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311
static int nfs_compare_mount_options(const struct super_block *s, const struct nfs_server *b, int flags)
{
	const struct nfs_server *a = s->s_fs_info;
	const struct rpc_clnt *clnt_a = a->client;
	const struct rpc_clnt *clnt_b = b->client;

	if ((s->s_flags & NFS_MS_MASK) != (flags & NFS_MS_MASK))
		goto Ebusy;
	if (a->nfs_client != b->nfs_client)
		goto Ebusy;
	if (a->flags != b->flags)
		goto Ebusy;
	if (a->wsize != b->wsize)
		goto Ebusy;
	if (a->rsize != b->rsize)
		goto Ebusy;
	if (a->acregmin != b->acregmin)
		goto Ebusy;
	if (a->acregmax != b->acregmax)
		goto Ebusy;
	if (a->acdirmin != b->acdirmin)
		goto Ebusy;
	if (a->acdirmax != b->acdirmax)
		goto Ebusy;
	if (clnt_a->cl_auth->au_flavor != clnt_b->cl_auth->au_flavor)
		goto Ebusy;
T
Trond Myklebust 已提交
2312
	return 1;
2313
Ebusy:
T
Trond Myklebust 已提交
2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329
	return 0;
}

struct nfs_sb_mountdata {
	struct nfs_server *server;
	int mntflags;
};

static int nfs_set_super(struct super_block *s, void *data)
{
	struct nfs_sb_mountdata *sb_mntdata = data;
	struct nfs_server *server = sb_mntdata->server;
	int ret;

	s->s_flags = sb_mntdata->mntflags;
	s->s_fs_info = server;
A
Al Viro 已提交
2330
	s->s_d_op = server->nfs_client->rpc_ops->dentry_ops;
T
Trond Myklebust 已提交
2331 2332 2333 2334 2335 2336
	ret = set_anon_super(s, server);
	if (ret == 0)
		server->s_dev = s->s_dev;
	return ret;
}

2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373
static int nfs_compare_super_address(struct nfs_server *server1,
				     struct nfs_server *server2)
{
	struct sockaddr *sap1, *sap2;

	sap1 = (struct sockaddr *)&server1->nfs_client->cl_addr;
	sap2 = (struct sockaddr *)&server2->nfs_client->cl_addr;

	if (sap1->sa_family != sap2->sa_family)
		return 0;

	switch (sap1->sa_family) {
	case AF_INET: {
		struct sockaddr_in *sin1 = (struct sockaddr_in *)sap1;
		struct sockaddr_in *sin2 = (struct sockaddr_in *)sap2;
		if (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr)
			return 0;
		if (sin1->sin_port != sin2->sin_port)
			return 0;
		break;
	}
	case AF_INET6: {
		struct sockaddr_in6 *sin1 = (struct sockaddr_in6 *)sap1;
		struct sockaddr_in6 *sin2 = (struct sockaddr_in6 *)sap2;
		if (!ipv6_addr_equal(&sin1->sin6_addr, &sin2->sin6_addr))
			return 0;
		if (sin1->sin6_port != sin2->sin6_port)
			return 0;
		break;
	}
	default:
		return 0;
	}

	return 1;
}

T
Trond Myklebust 已提交
2374 2375 2376 2377 2378 2379
static int nfs_compare_super(struct super_block *sb, void *data)
{
	struct nfs_sb_mountdata *sb_mntdata = data;
	struct nfs_server *server = sb_mntdata->server, *old = NFS_SB(sb);
	int mntflags = sb_mntdata->mntflags;

2380
	if (!nfs_compare_super_address(old, server))
T
Trond Myklebust 已提交
2381 2382 2383 2384 2385 2386 2387
		return 0;
	/* Note: NFS_MOUNT_UNSHARED == NFS4_MOUNT_UNSHARED */
	if (old->flags & NFS_MOUNT_UNSHARED)
		return 0;
	if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0)
		return 0;
	return nfs_compare_mount_options(sb, server, mntflags);
2388 2389
}

2390
#ifdef CONFIG_NFS_FSCACHE
2391 2392 2393 2394
static void nfs_get_cache_cookie(struct super_block *sb,
				 struct nfs_parsed_mount_data *parsed,
				 struct nfs_clone_mount *cloned)
{
2395
	struct nfs_server *nfss = NFS_SB(sb);
2396 2397 2398
	char *uniq = NULL;
	int ulen = 0;

2399 2400 2401 2402 2403 2404 2405 2406 2407 2408
	nfss->fscache_key = NULL;
	nfss->fscache = NULL;

	if (parsed) {
		if (!(parsed->options & NFS_OPTION_FSCACHE))
			return;
		if (parsed->fscache_uniq) {
			uniq = parsed->fscache_uniq;
			ulen = strlen(parsed->fscache_uniq);
		}
2409 2410
	} else if (cloned) {
		struct nfs_server *mnt_s = NFS_SB(cloned->sb);
2411 2412
		if (!(mnt_s->options & NFS_OPTION_FSCACHE))
			return;
2413 2414 2415 2416
		if (mnt_s->fscache_key) {
			uniq = mnt_s->fscache_key->key.uniquifier;
			ulen = mnt_s->fscache_key->key.uniq_len;
		};
2417 2418
	} else
		return;
2419 2420 2421

	nfs_fscache_get_super_cookie(sb, uniq, ulen);
}
2422 2423 2424 2425 2426 2427 2428
#else
static void nfs_get_cache_cookie(struct super_block *sb,
				 struct nfs_parsed_mount_data *parsed,
				 struct nfs_clone_mount *cloned)
{
}
#endif
2429

2430 2431 2432 2433 2434
static int nfs_bdi_register(struct nfs_server *server)
{
	return bdi_register_dev(&server->backing_dev_info, server->s_dev);
}

2435 2436
int nfs_set_sb_security(struct super_block *s, struct dentry *mntroot,
			struct nfs_mount_info *mount_info)
2437
{
2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452
	int error;
	unsigned long kflags = 0, kflags_out = 0;
	if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL)
		kflags |= SECURITY_LSM_NATIVE_LABELS;

	error = security_sb_set_mnt_opts(s, &mount_info->parsed->lsm_opts,
						kflags, &kflags_out);
	if (error)
		goto err;

	if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL &&
		!(kflags_out & SECURITY_LSM_NATIVE_LABELS))
		NFS_SB(s)->caps &= ~NFS_CAP_SECURITY_LABEL;
err:
	return error;
2453
}
B
Bryan Schumaker 已提交
2454
EXPORT_SYMBOL_GPL(nfs_set_sb_security);
2455

2456 2457
int nfs_clone_sb_security(struct super_block *s, struct dentry *mntroot,
			  struct nfs_mount_info *mount_info)
2458 2459 2460 2461
{
	/* clone any lsm security options from the parent to the new sb */
	if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops)
		return -ESTALE;
2462
	return security_sb_clone_mnt_opts(mount_info->cloned->sb, s);
2463
}
B
Bryan Schumaker 已提交
2464
EXPORT_SYMBOL_GPL(nfs_clone_sb_security);
2465

2466
struct dentry *nfs_fs_mount_common(struct nfs_server *server,
2467
				   int flags, const char *dev_name,
2468 2469
				   struct nfs_mount_info *mount_info,
				   struct nfs_subversion *nfs_mod)
D
David Howells 已提交
2470 2471
{
	struct super_block *s;
2472
	struct dentry *mntroot = ERR_PTR(-ENOMEM);
2473
	int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
T
Trond Myklebust 已提交
2474 2475
	struct nfs_sb_mountdata sb_mntdata = {
		.mntflags = flags,
2476
		.server = server,
T
Trond Myklebust 已提交
2477
	};
2478
	int error;
2479

2480 2481 2482
	if (server->flags & NFS_MOUNT_UNSHARED)
		compare_super = NULL;

2483 2484 2485 2486
	/* -o noac implies -o sync */
	if (server->flags & NFS_MOUNT_NOAC)
		sb_mntdata.mntflags |= MS_SYNCHRONOUS;

2487
	/* Get a superblock - note that we may end up sharing one that already exists */
2488
	s = sget(nfs_mod->nfs_fs, compare_super, nfs_set_super, flags, &sb_mntdata);
2489
	if (IS_ERR(s)) {
2490
		mntroot = ERR_CAST(s);
2491
		goto out_err_nosb;
2492 2493
	}

2494 2495 2496
	if (s->s_fs_info != server) {
		nfs_free_server(server);
		server = NULL;
2497 2498
	} else {
		error = nfs_bdi_register(server);
2499 2500
		if (error) {
			mntroot = ERR_PTR(error);
2501
			goto error_splat_bdi;
2502
		}
2503
	}
D
David Howells 已提交
2504

2505 2506
	if (!s->s_root) {
		/* initial superblock/root creation */
2507
		mount_info->fill_super(s, mount_info);
2508
		nfs_get_cache_cookie(s, mount_info->parsed, mount_info->cloned);
2509
	}
D
David Howells 已提交
2510

2511
	mntroot = nfs_get_root(s, mount_info->mntfh, dev_name);
2512
	if (IS_ERR(mntroot))
2513
		goto error_splat_super;
2514

2515
	error = mount_info->set_security(s, mntroot, mount_info);
2516 2517 2518
	if (error)
		goto error_splat_root;

2519
	s->s_flags |= MS_ACTIVE;
2520 2521

out:
2522
	return mntroot;
2523

2524 2525
out_err_nosb:
	nfs_free_server(server);
2526
	goto out;
2527

2528 2529
error_splat_root:
	dput(mntroot);
2530
	mntroot = ERR_PTR(error);
2531
error_splat_super:
2532 2533 2534
	if (server && !s->s_root)
		bdi_unregister(&server->backing_dev_info);
error_splat_bdi:
2535
	deactivate_locked_super(s);
2536
	goto out;
D
David Howells 已提交
2537
}
B
Bryan Schumaker 已提交
2538
EXPORT_SYMBOL_GPL(nfs_fs_mount_common);
D
David Howells 已提交
2539

2540
struct dentry *nfs_fs_mount(struct file_system_type *fs_type,
2541 2542 2543 2544
	int flags, const char *dev_name, void *raw_data)
{
	struct nfs_mount_info mount_info = {
		.fill_super = nfs_fill_super,
2545
		.set_security = nfs_set_sb_security,
2546 2547
	};
	struct dentry *mntroot = ERR_PTR(-ENOMEM);
2548
	struct nfs_subversion *nfs_mod;
2549 2550
	int error;

2551
	mount_info.parsed = nfs_alloc_parsed_mount_data();
2552 2553
	mount_info.mntfh = nfs_alloc_fhandle();
	if (mount_info.parsed == NULL || mount_info.mntfh == NULL)
2554 2555 2556
		goto out;

	/* Validate the mount data */
2557
	error = nfs_validate_mount_data(fs_type, raw_data, mount_info.parsed, mount_info.mntfh, dev_name);
2558
	if (error == NFS_TEXT_DATA)
2559
		error = nfs_validate_text_mount_data(raw_data, mount_info.parsed, dev_name);
2560 2561 2562 2563 2564
	if (error < 0) {
		mntroot = ERR_PTR(error);
		goto out;
	}

2565 2566 2567 2568 2569 2570
	nfs_mod = get_nfs_version(mount_info.parsed->version);
	if (IS_ERR(nfs_mod)) {
		mntroot = ERR_CAST(nfs_mod);
		goto out;
	}

B
Bryan Schumaker 已提交
2571
	mntroot = nfs_mod->rpc_ops->try_mount(flags, dev_name, &mount_info, nfs_mod);
2572 2573

	put_nfs_version(nfs_mod);
2574
out:
2575
	nfs_free_parsed_mount_data(mount_info.parsed);
2576
	nfs_free_fhandle(mount_info.mntfh);
2577 2578
	return mntroot;
}
B
Bryan Schumaker 已提交
2579
EXPORT_SYMBOL_GPL(nfs_fs_mount);
2580

T
Trond Myklebust 已提交
2581 2582 2583 2584
/*
 * Ensure that we unregister the bdi before kill_anon_super
 * releases the device name
 */
2585
void nfs_put_super(struct super_block *s)
T
Trond Myklebust 已提交
2586 2587 2588 2589 2590
{
	struct nfs_server *server = NFS_SB(s);

	bdi_unregister(&server->backing_dev_info);
}
B
Bryan Schumaker 已提交
2591
EXPORT_SYMBOL_GPL(nfs_put_super);
T
Trond Myklebust 已提交
2592

2593 2594 2595
/*
 * Destroy an NFS2/3 superblock
 */
2596
void nfs_kill_super(struct super_block *s)
D
David Howells 已提交
2597 2598 2599 2600
{
	struct nfs_server *server = NFS_SB(s);

	kill_anon_super(s);
2601
	nfs_fscache_release_super_cookie(s);
2602
	nfs_free_server(server);
D
David Howells 已提交
2603
}
B
Bryan Schumaker 已提交
2604
EXPORT_SYMBOL_GPL(nfs_kill_super);
D
David Howells 已提交
2605

2606
/*
2607
 * Clone an NFS2/3/4 server record on xdev traversal (FSID-change)
2608
 */
2609
static struct dentry *
2610 2611
nfs_xdev_mount(struct file_system_type *fs_type, int flags,
		const char *dev_name, void *raw_data)
D
David Howells 已提交
2612
{
2613 2614 2615 2616 2617 2618
	struct nfs_clone_mount *data = raw_data;
	struct nfs_mount_info mount_info = {
		.fill_super = nfs_clone_super,
		.set_security = nfs_clone_sb_security,
		.cloned = data,
	};
2619
	struct nfs_server *server;
2620
	struct dentry *mntroot = ERR_PTR(-ENOMEM);
2621
	struct nfs_subversion *nfs_mod = NFS_SB(data->sb)->nfs_client->cl_nfs_mod;
D
David Howells 已提交
2622

2623
	dprintk("--> nfs_xdev_mount()\n");
D
David Howells 已提交
2624

2625
	mount_info.mntfh = mount_info.cloned->fh;
2626

2627
	/* create a new volume representation */
2628
	server = nfs_mod->rpc_ops->clone_server(NFS_SB(data->sb), data->fh, data->fattr, data->authflavor);
D
David Howells 已提交
2629

2630 2631 2632 2633 2634
	if (IS_ERR(server))
		mntroot = ERR_CAST(server);
	else
		mntroot = nfs_fs_mount_common(server, flags,
				dev_name, &mount_info, nfs_mod);
2635

2636 2637 2638
	dprintk("<-- nfs_xdev_mount() = %ld\n",
			IS_ERR(mntroot) ? PTR_ERR(mntroot) : 0L);
	return mntroot;
D
David Howells 已提交
2639 2640
}

B
Bryan Schumaker 已提交
2641
#if IS_ENABLED(CONFIG_NFS_V4)
2642

2643 2644
static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args)
{
2645 2646
	args->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3|
			 NFS_MOUNT_LOCAL_FLOCK|NFS_MOUNT_LOCAL_FCNTL);
2647 2648
}

2649 2650 2651
/*
 * Validate NFSv4 mount options
 */
2652 2653 2654
static int nfs4_validate_mount_data(void *options,
				    struct nfs_parsed_mount_data *args,
				    const char *dev_name)
2655
{
2656
	struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
2657
	struct nfs4_mount_data *data = (struct nfs4_mount_data *)options;
2658 2659 2660 2661 2662
	char *c;

	if (data == NULL)
		goto out_no_data;

2663 2664
	args->version = 4;

2665 2666
	switch (data->version) {
	case 1:
2667 2668 2669
		if (data->host_addrlen > sizeof(args->nfs_server.address))
			goto out_no_address;
		if (data->host_addrlen == 0)
2670
			goto out_no_address;
2671
		args->nfs_server.addrlen = data->host_addrlen;
2672
		if (copy_from_user(sap, data->host_addr, data->host_addrlen))
2673
			return -EFAULT;
2674
		if (!nfs_verify_server_address(sap))
2675
			goto out_no_address;
2676
		args->nfs_server.port = ntohs(((struct sockaddr_in *)sap)->sin_port);
2677

2678
		args->auth_flavors[0] = RPC_AUTH_UNIX;
2679 2680 2681
		if (data->auth_flavourlen) {
			if (data->auth_flavourlen > 1)
				goto out_inval_auth;
2682
			if (copy_from_user(&args->auth_flavors[0],
2683
					   data->auth_flavours,
2684
					   sizeof(args->auth_flavors[0])))
2685 2686 2687 2688 2689 2690
				return -EFAULT;
		}

		c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
		if (IS_ERR(c))
			return PTR_ERR(c);
2691
		args->nfs_server.hostname = c;
2692 2693 2694 2695

		c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN);
		if (IS_ERR(c))
			return PTR_ERR(c);
2696 2697
		args->nfs_server.export_path = c;
		dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c);
2698 2699 2700 2701

		c = strndup_user(data->client_addr.data, 16);
		if (IS_ERR(c))
			return PTR_ERR(c);
2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718
		args->client_address = c;

		/*
		 * Translate to nfs_parsed_mount_data, which nfs4_fill_super
		 * can deal with.
		 */

		args->flags	= data->flags & NFS4_MOUNT_FLAGMASK;
		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;
		args->nfs_server.protocol = data->proto;
2719
		nfs_validate_transport_protocol(args);
2720 2721
		if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP)
			goto out_invalid_transport_udp;
2722 2723

		break;
2724
	default:
2725
		return NFS_TEXT_DATA;
2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741
	}

	return 0;

out_no_data:
	dfprintk(MOUNT, "NFS4: mount program didn't pass any mount data\n");
	return -EINVAL;

out_inval_auth:
	dfprintk(MOUNT, "NFS4: Invalid number of RPC auth flavours %d\n",
		 data->auth_flavourlen);
	return -EINVAL;

out_no_address:
	dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n");
	return -EINVAL;
2742 2743 2744 2745

out_invalid_transport_udp:
	dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
	return -EINVAL;
2746 2747
}

2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759
/*
 * NFS v4 module parameters need to stay in the
 * NFS client for backwards compatibility
 */
unsigned int nfs_callback_set_tcpport;
unsigned short nfs_callback_tcpport;
/* Default cache timeout is 10 minutes */
unsigned int nfs_idmap_cache_timeout = 600;
/* Turn off NFSv4 uid/gid mapping when using AUTH_SYS */
bool nfs4_disable_idmapping = true;
unsigned short max_session_slots = NFS4_DEF_SLOT_TABLE_SIZE;
unsigned short send_implementation_id = 1;
2760
char nfs4_client_id_uniquifier[NFS4_CLIENT_ID_UNIQ_LEN] = "";
2761
bool recover_lost_locks = false;
2762

B
Bryan Schumaker 已提交
2763 2764 2765 2766 2767 2768
EXPORT_SYMBOL_GPL(nfs_callback_set_tcpport);
EXPORT_SYMBOL_GPL(nfs_callback_tcpport);
EXPORT_SYMBOL_GPL(nfs_idmap_cache_timeout);
EXPORT_SYMBOL_GPL(nfs4_disable_idmapping);
EXPORT_SYMBOL_GPL(max_session_slots);
EXPORT_SYMBOL_GPL(send_implementation_id);
2769
EXPORT_SYMBOL_GPL(nfs4_client_id_uniquifier);
2770
EXPORT_SYMBOL_GPL(recover_lost_locks);
B
Bryan Schumaker 已提交
2771

2772 2773 2774 2775 2776 2777 2778 2779 2780
#define NFS_CALLBACK_MAXPORTNR (65535U)

static int param_set_portnr(const char *val, const struct kernel_param *kp)
{
	unsigned long num;
	int ret;

	if (!val)
		return -EINVAL;
2781
	ret = kstrtoul(val, 0, &num);
2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795
	if (ret == -EINVAL || num > NFS_CALLBACK_MAXPORTNR)
		return -EINVAL;
	*((unsigned int *)kp->arg) = num;
	return 0;
}
static struct kernel_param_ops param_ops_portnr = {
	.set = param_set_portnr,
	.get = param_get_uint,
};
#define param_check_portnr(name, p) __param_check(name, p, unsigned int);

module_param_named(callback_tcpport, nfs_callback_set_tcpport, portnr, 0644);
module_param(nfs_idmap_cache_timeout, int, 0644);
module_param(nfs4_disable_idmapping, bool, 0644);
2796 2797
module_param_string(nfs4_unique_id, nfs4_client_id_uniquifier,
			NFS4_CLIENT_ID_UNIQ_LEN, 0600);
2798 2799 2800 2801 2802 2803 2804 2805
MODULE_PARM_DESC(nfs4_disable_idmapping,
		"Turn off NFSv4 idmapping when using 'sec=sys'");
module_param(max_session_slots, ushort, 0644);
MODULE_PARM_DESC(max_session_slots, "Maximum number of outstanding NFSv4.1 "
		"requests the client will negotiate");
module_param(send_implementation_id, ushort, 0644);
MODULE_PARM_DESC(send_implementation_id,
		"Send implementation ID with NFSv4.1 exchange_id");
2806
MODULE_PARM_DESC(nfs4_unique_id, "nfs_client_id4 uniquifier string");
2807

2808 2809 2810 2811 2812 2813
module_param(recover_lost_locks, bool, 0644);
MODULE_PARM_DESC(recover_lost_locks,
		 "If the server reports that a lock might be lost, "
		 "try to recover it risking data corruption.");


2814
#endif /* CONFIG_NFS_V4 */