1/*
   2 *  linux/fs/nfs/super.c
   3 *
   4 *  Copyright (C) 1992  Rick Sladkey
   5 *
   6 *  nfs superblock handling functions
   7 *
   8 *  Modularised by Alan Cox <alan@lxorguk.ukuu.org.uk>, while hacking some
   9 *  experimental NFS changes. Modularisation taken straight from SYS5 fs.
  10 *
  11 *  Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
  12 *  J.S.Peatfield@damtp.cam.ac.uk
  13 *
  14 *  Split from inode.c by David Howells <dhowells@redhat.com>
  15 *
  16 * - superblocks are indexed on server only - all inodes, dentries, etc. associated with a
  17 *   particular server are held in the same superblock
  18 * - NFS superblocks can have several effective roots to the dentry tree
  19 * - directory type roots are spliced into the tree when a path from one root reaches the root
  20 *   of another (see nfs_lookup())
  21 */
  22
  23#include <linux/module.h>
  24#include <linux/init.h>
  25
  26#include <linux/time.h>
  27#include <linux/kernel.h>
  28#include <linux/mm.h>
  29#include <linux/string.h>
  30#include <linux/stat.h>
  31#include <linux/errno.h>
  32#include <linux/unistd.h>
  33#include <linux/sunrpc/clnt.h>
  34#include <linux/sunrpc/addr.h>
  35#include <linux/sunrpc/stats.h>
  36#include <linux/sunrpc/metrics.h>
  37#include <linux/sunrpc/xprtsock.h>
  38#include <linux/sunrpc/xprtrdma.h>
  39#include <linux/nfs_fs.h>
  40#include <linux/nfs_mount.h>
  41#include <linux/nfs4_mount.h>
  42#include <linux/lockd/bind.h>
  43#include <linux/seq_file.h>
  44#include <linux/mount.h>
  45#include <linux/namei.h>
  46#include <linux/vfs.h>
  47#include <linux/inet.h>
  48#include <linux/in6.h>
  49#include <linux/slab.h>
  50#include <net/ipv6.h>
  51#include <linux/netdevice.h>
  52#include <linux/nfs_xdr.h>
  53#include <linux/magic.h>
  54#include <linux/parser.h>
  55#include <linux/nsproxy.h>
  56#include <linux/rcupdate.h>
  57
  58#include <linux/uaccess.h>
  59
  60#include "nfs4_fs.h"
  61#include "callback.h"
  62#include "delegation.h"
  63#include "iostat.h"
  64#include "internal.h"
  65#include "fscache.h"
  66#include "nfs4session.h"
  67#include "pnfs.h"
  68#include "nfs.h"
  69
  70#define NFSDBG_FACILITY		NFSDBG_VFS
  71#define NFS_TEXT_DATA		1
  72
  73#if IS_ENABLED(CONFIG_NFS_V3)
  74#define NFS_DEFAULT_VERSION 3
  75#else
  76#define NFS_DEFAULT_VERSION 2
  77#endif
  78
  79enum {
  80	/* Mount options that take no arguments */
  81	Opt_soft, Opt_hard,
  82	Opt_posix, Opt_noposix,
  83	Opt_cto, Opt_nocto,
  84	Opt_ac, Opt_noac,
  85	Opt_lock, Opt_nolock,
  86	Opt_udp, Opt_tcp, Opt_rdma,
  87	Opt_acl, Opt_noacl,
  88	Opt_rdirplus, Opt_nordirplus,
  89	Opt_sharecache, Opt_nosharecache,
  90	Opt_resvport, Opt_noresvport,
  91	Opt_fscache, Opt_nofscache,
  92	Opt_migration, Opt_nomigration,
  93
  94	/* Mount options that take integer arguments */
  95	Opt_port,
  96	Opt_rsize, Opt_wsize, Opt_bsize,
  97	Opt_timeo, Opt_retrans,
  98	Opt_acregmin, Opt_acregmax,
  99	Opt_acdirmin, Opt_acdirmax,
 100	Opt_actimeo,
 101	Opt_namelen,
 102	Opt_mountport,
 103	Opt_mountvers,
 104	Opt_minorversion,
 105
 106	/* Mount options that take string arguments */
 107	Opt_nfsvers,
 108	Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost,
 109	Opt_addr, Opt_mountaddr, Opt_clientaddr,
 110	Opt_lookupcache,
 111	Opt_fscache_uniq,
 112	Opt_local_lock,
 113
 114	/* Special mount options */
 115	Opt_userspace, Opt_deprecated, Opt_sloppy,
 116
 117	Opt_err
 118};
 119
 120static const match_table_t nfs_mount_option_tokens = {
 121	{ Opt_userspace, "bg" },
 122	{ Opt_userspace, "fg" },
 123	{ Opt_userspace, "retry=%s" },
 124
 125	{ Opt_sloppy, "sloppy" },
 126
 127	{ Opt_soft, "soft" },
 128	{ Opt_hard, "hard" },
 129	{ Opt_deprecated, "intr" },
 130	{ Opt_deprecated, "nointr" },
 131	{ Opt_posix, "posix" },
 132	{ Opt_noposix, "noposix" },
 133	{ Opt_cto, "cto" },
 134	{ Opt_nocto, "nocto" },
 135	{ Opt_ac, "ac" },
 136	{ Opt_noac, "noac" },
 137	{ Opt_lock, "lock" },
 138	{ Opt_nolock, "nolock" },
 139	{ Opt_udp, "udp" },
 140	{ Opt_tcp, "tcp" },
 141	{ Opt_rdma, "rdma" },
 142	{ Opt_acl, "acl" },
 143	{ Opt_noacl, "noacl" },
 144	{ Opt_rdirplus, "rdirplus" },
 145	{ Opt_nordirplus, "nordirplus" },
 146	{ Opt_sharecache, "sharecache" },
 147	{ Opt_nosharecache, "nosharecache" },
 148	{ Opt_resvport, "resvport" },
 149	{ Opt_noresvport, "noresvport" },
 150	{ Opt_fscache, "fsc" },
 151	{ Opt_nofscache, "nofsc" },
 152	{ Opt_migration, "migration" },
 153	{ Opt_nomigration, "nomigration" },
 154
 155	{ Opt_port, "port=%s" },
 156	{ Opt_rsize, "rsize=%s" },
 157	{ Opt_wsize, "wsize=%s" },
 158	{ Opt_bsize, "bsize=%s" },
 159	{ Opt_timeo, "timeo=%s" },
 160	{ Opt_retrans, "retrans=%s" },
 161	{ Opt_acregmin, "acregmin=%s" },
 162	{ Opt_acregmax, "acregmax=%s" },
 163	{ Opt_acdirmin, "acdirmin=%s" },
 164	{ Opt_acdirmax, "acdirmax=%s" },
 165	{ Opt_actimeo, "actimeo=%s" },
 166	{ Opt_namelen, "namlen=%s" },
 167	{ Opt_mountport, "mountport=%s" },
 168	{ Opt_mountvers, "mountvers=%s" },
 169	{ Opt_minorversion, "minorversion=%s" },
 170
 171	{ Opt_nfsvers, "nfsvers=%s" },
 172	{ Opt_nfsvers, "vers=%s" },
 173
 174	{ Opt_sec, "sec=%s" },
 175	{ Opt_proto, "proto=%s" },
 176	{ Opt_mountproto, "mountproto=%s" },
 177	{ Opt_addr, "addr=%s" },
 178	{ Opt_clientaddr, "clientaddr=%s" },
 179	{ Opt_mounthost, "mounthost=%s" },
 180	{ Opt_mountaddr, "mountaddr=%s" },
 181
 182	{ Opt_lookupcache, "lookupcache=%s" },
 183	{ Opt_fscache_uniq, "fsc=%s" },
 184	{ Opt_local_lock, "local_lock=%s" },
 185
 186	/* The following needs to be listed after all other options */
 187	{ Opt_nfsvers, "v%s" },
 188
 189	{ Opt_err, NULL }
 190};
 191
 192enum {
 193	Opt_xprt_udp, Opt_xprt_udp6, Opt_xprt_tcp, Opt_xprt_tcp6, Opt_xprt_rdma,
 194	Opt_xprt_rdma6,
 195
 196	Opt_xprt_err
 197};
 198
 199static 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" },
 204	{ Opt_xprt_rdma, "rdma" },
 205	{ Opt_xprt_rdma6, "rdma6" },
 206
 207	{ Opt_xprt_err, NULL }
 208};
 209
 210enum {
 211	Opt_sec_none, Opt_sec_sys,
 212	Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
 213	Opt_sec_lkey, Opt_sec_lkeyi, Opt_sec_lkeyp,
 214	Opt_sec_spkm, Opt_sec_spkmi, Opt_sec_spkmp,
 215
 216	Opt_sec_err
 217};
 218
 219static const match_table_t nfs_secflavor_tokens = {
 220	{ Opt_sec_none, "none" },
 221	{ Opt_sec_none, "null" },
 222	{ Opt_sec_sys, "sys" },
 223
 224	{ Opt_sec_krb5, "krb5" },
 225	{ Opt_sec_krb5i, "krb5i" },
 226	{ Opt_sec_krb5p, "krb5p" },
 227
 228	{ Opt_sec_lkey, "lkey" },
 229	{ Opt_sec_lkeyi, "lkeyi" },
 230	{ Opt_sec_lkeyp, "lkeyp" },
 231
 232	{ Opt_sec_spkm, "spkm3" },
 233	{ Opt_sec_spkmi, "spkm3i" },
 234	{ Opt_sec_spkmp, "spkm3p" },
 235
 236	{ Opt_sec_err, NULL }
 237};
 238
 239enum {
 240	Opt_lookupcache_all, Opt_lookupcache_positive,
 241	Opt_lookupcache_none,
 242
 243	Opt_lookupcache_err
 244};
 245
 246static match_table_t nfs_lookupcache_tokens = {
 247	{ Opt_lookupcache_all, "all" },
 248	{ Opt_lookupcache_positive, "pos" },
 249	{ Opt_lookupcache_positive, "positive" },
 250	{ Opt_lookupcache_none, "none" },
 251
 252	{ Opt_lookupcache_err, NULL }
 253};
 254
 255enum {
 256	Opt_local_lock_all, Opt_local_lock_flock, Opt_local_lock_posix,
 257	Opt_local_lock_none,
 258
 259	Opt_local_lock_err
 260};
 261
 262static match_table_t nfs_local_lock_tokens = {
 263	{ Opt_local_lock_all, "all" },
 264	{ Opt_local_lock_flock, "flock" },
 265	{ Opt_local_lock_posix, "posix" },
 266	{ Opt_local_lock_none, "none" },
 267
 268	{ Opt_local_lock_err, NULL }
 269};
 270
 271enum {
 272	Opt_vers_2, Opt_vers_3, Opt_vers_4, Opt_vers_4_0,
 273	Opt_vers_4_1, Opt_vers_4_2,
 274
 275	Opt_vers_err
 276};
 277
 278static match_table_t nfs_vers_tokens = {
 279	{ Opt_vers_2, "2" },
 280	{ Opt_vers_3, "3" },
 281	{ Opt_vers_4, "4" },
 282	{ Opt_vers_4_0, "4.0" },
 283	{ Opt_vers_4_1, "4.1" },
 284	{ Opt_vers_4_2, "4.2" },
 285
 286	{ Opt_vers_err, NULL }
 287};
 288
 289static struct dentry *nfs_xdev_mount(struct file_system_type *fs_type,
 290		int flags, const char *dev_name, void *raw_data);
 291
 292struct file_system_type nfs_fs_type = {
 293	.owner		= THIS_MODULE,
 294	.name		= "nfs",
 295	.mount		= nfs_fs_mount,
 296	.kill_sb	= nfs_kill_super,
 297	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
 298};
 299MODULE_ALIAS_FS("nfs");
 300EXPORT_SYMBOL_GPL(nfs_fs_type);
 301
 302struct file_system_type nfs_xdev_fs_type = {
 303	.owner		= THIS_MODULE,
 304	.name		= "nfs",
 305	.mount		= nfs_xdev_mount,
 306	.kill_sb	= nfs_kill_super,
 307	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
 308};
 309
 310const struct super_operations nfs_sops = {
 311	.alloc_inode	= nfs_alloc_inode,
 312	.destroy_inode	= nfs_destroy_inode,
 313	.write_inode	= nfs_write_inode,
 314	.drop_inode	= nfs_drop_inode,
 315	.statfs		= nfs_statfs,
 316	.evict_inode	= nfs_evict_inode,
 317	.umount_begin	= nfs_umount_begin,
 318	.show_options	= nfs_show_options,
 319	.show_devname	= nfs_show_devname,
 320	.show_path	= nfs_show_path,
 321	.show_stats	= nfs_show_stats,
 322	.remount_fs	= nfs_remount,
 323};
 324EXPORT_SYMBOL_GPL(nfs_sops);
 325
 326#if IS_ENABLED(CONFIG_NFS_V4)
 327static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *);
 328static int nfs4_validate_mount_data(void *options,
 329	struct nfs_parsed_mount_data *args, const char *dev_name);
 330
 331struct file_system_type nfs4_fs_type = {
 332	.owner		= THIS_MODULE,
 333	.name		= "nfs4",
 334	.mount		= nfs_fs_mount,
 335	.kill_sb	= nfs_kill_super,
 336	.fs_flags	= FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
 337};
 338MODULE_ALIAS_FS("nfs4");
 339MODULE_ALIAS("nfs4");
 340EXPORT_SYMBOL_GPL(nfs4_fs_type);
 341
 342static int __init register_nfs4_fs(void)
 343{
 344	return register_filesystem(&nfs4_fs_type);
 345}
 346
 347static void unregister_nfs4_fs(void)
 348{
 349	unregister_filesystem(&nfs4_fs_type);
 350}
 351#else
 352static int __init register_nfs4_fs(void)
 353{
 354	return 0;
 355}
 356
 357static void unregister_nfs4_fs(void)
 358{
 359}
 360#endif
 361
 362static struct shrinker acl_shrinker = {
 363	.count_objects	= nfs_access_cache_count,
 364	.scan_objects	= nfs_access_cache_scan,
 365	.seeks		= DEFAULT_SEEKS,
 366};
 367
 368/*
 369 * Register the NFS filesystems
 370 */
 371int __init register_nfs_fs(void)
 372{
 373	int ret;
 374
 375        ret = register_filesystem(&nfs_fs_type);
 376	if (ret < 0)
 377		goto error_0;
 378
 379	ret = register_nfs4_fs();
 380	if (ret < 0)
 381		goto error_1;
 382
 383	ret = nfs_register_sysctl();
 384	if (ret < 0)
 385		goto error_2;
 386	ret = register_shrinker(&acl_shrinker);
 387	if (ret < 0)
 388		goto error_3;
 389	return 0;
 390error_3:
 391	nfs_unregister_sysctl();
 392error_2:
 393	unregister_nfs4_fs();
 394error_1:
 395	unregister_filesystem(&nfs_fs_type);
 396error_0:
 397	return ret;
 398}
 399
 400/*
 401 * Unregister the NFS filesystems
 402 */
 403void __exit unregister_nfs_fs(void)
 404{
 405	unregister_shrinker(&acl_shrinker);
 406	nfs_unregister_sysctl();
 407	unregister_nfs4_fs();
 408	unregister_filesystem(&nfs_fs_type);
 409}
 410
 411bool nfs_sb_active(struct super_block *sb)
 412{
 413	struct nfs_server *server = NFS_SB(sb);
 414
 415	if (!atomic_inc_not_zero(&sb->s_active))
 416		return false;
 417	if (atomic_inc_return(&server->active) != 1)
 418		atomic_dec(&sb->s_active);
 419	return true;
 420}
 421EXPORT_SYMBOL_GPL(nfs_sb_active);
 422
 423void nfs_sb_deactive(struct super_block *sb)
 424{
 425	struct nfs_server *server = NFS_SB(sb);
 426
 427	if (atomic_dec_and_test(&server->active))
 428		deactivate_super(sb);
 429}
 430EXPORT_SYMBOL_GPL(nfs_sb_deactive);
 431
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 432/*
 433 * Deliver file system statistics to userspace
 434 */
 435int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 436{
 437	struct nfs_server *server = NFS_SB(dentry->d_sb);
 438	unsigned char blockbits;
 439	unsigned long blockres;
 440	struct nfs_fh *fh = NFS_FH(d_inode(dentry));
 441	struct nfs_fsstat res;
 442	int error = -ENOMEM;
 443
 444	res.fattr = nfs_alloc_fattr();
 445	if (res.fattr == NULL)
 446		goto out_err;
 447
 448	error = server->nfs_client->rpc_ops->statfs(server, fh, &res);
 449	if (unlikely(error == -ESTALE)) {
 450		struct dentry *pd_dentry;
 451
 452		pd_dentry = dget_parent(dentry);
 453		if (pd_dentry != NULL) {
 454			nfs_zap_caches(d_inode(pd_dentry));
 455			dput(pd_dentry);
 456		}
 457	}
 458	nfs_free_fattr(res.fattr);
 459	if (error < 0)
 460		goto out_err;
 461
 462	buf->f_type = NFS_SUPER_MAGIC;
 463
 464	/*
 465	 * Current versions of glibc do not correctly handle the
 466	 * case where f_frsize != f_bsize.  Eventually we want to
 467	 * report the value of wtmult in this field.
 468	 */
 469	buf->f_frsize = dentry->d_sb->s_blocksize;
 470
 471	/*
 472	 * On most *nix systems, f_blocks, f_bfree, and f_bavail
 473	 * are reported in units of f_frsize.  Linux hasn't had
 474	 * an f_frsize field in its statfs struct until recently,
 475	 * thus historically Linux's sys_statfs reports these
 476	 * fields in units of f_bsize.
 477	 */
 478	buf->f_bsize = dentry->d_sb->s_blocksize;
 479	blockbits = dentry->d_sb->s_blocksize_bits;
 480	blockres = (1 << blockbits) - 1;
 481	buf->f_blocks = (res.tbytes + blockres) >> blockbits;
 482	buf->f_bfree = (res.fbytes + blockres) >> blockbits;
 483	buf->f_bavail = (res.abytes + blockres) >> blockbits;
 484
 485	buf->f_files = res.tfiles;
 486	buf->f_ffree = res.afiles;
 487
 488	buf->f_namelen = server->namelen;
 489
 490	return 0;
 491
 492 out_err:
 493	dprintk("%s: statfs error = %d\n", __func__, -error);
 494	return error;
 495}
 496EXPORT_SYMBOL_GPL(nfs_statfs);
 497
 498/*
 499 * Map the security flavour number to a name
 500 */
 501static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour)
 502{
 503	static const struct {
 504		rpc_authflavor_t flavour;
 505		const char *str;
 506	} sec_flavours[NFS_AUTH_INFO_MAX_FLAVORS] = {
 507		/* update NFS_AUTH_INFO_MAX_FLAVORS when this list changes! */
 508		{ RPC_AUTH_NULL, "null" },
 509		{ RPC_AUTH_UNIX, "sys" },
 510		{ RPC_AUTH_GSS_KRB5, "krb5" },
 511		{ RPC_AUTH_GSS_KRB5I, "krb5i" },
 512		{ RPC_AUTH_GSS_KRB5P, "krb5p" },
 513		{ RPC_AUTH_GSS_LKEY, "lkey" },
 514		{ RPC_AUTH_GSS_LKEYI, "lkeyi" },
 515		{ RPC_AUTH_GSS_LKEYP, "lkeyp" },
 516		{ RPC_AUTH_GSS_SPKM, "spkm" },
 517		{ RPC_AUTH_GSS_SPKMI, "spkmi" },
 518		{ RPC_AUTH_GSS_SPKMP, "spkmp" },
 519		{ UINT_MAX, "unknown" }
 520	};
 521	int i;
 522
 523	for (i = 0; sec_flavours[i].flavour != UINT_MAX; i++) {
 524		if (sec_flavours[i].flavour == flavour)
 525			break;
 526	}
 527	return sec_flavours[i].str;
 528}
 529
 530static void nfs_show_mountd_netid(struct seq_file *m, struct nfs_server *nfss,
 531				  int showdefaults)
 532{
 533	struct sockaddr *sap = (struct sockaddr *) &nfss->mountd_address;
 534	char *proto = NULL;
 535
 536	switch (sap->sa_family) {
 537	case AF_INET:
 538		switch (nfss->mountd_protocol) {
 539		case IPPROTO_UDP:
 540			proto = RPCBIND_NETID_UDP;
 541			break;
 542		case IPPROTO_TCP:
 543			proto = RPCBIND_NETID_TCP;
 544			break;
 545		}
 546		break;
 547	case AF_INET6:
 548		switch (nfss->mountd_protocol) {
 549		case IPPROTO_UDP:
 550			proto = RPCBIND_NETID_UDP6;
 551			break;
 552		case IPPROTO_TCP:
 553			proto = RPCBIND_NETID_TCP6;
 554			break;
 555		}
 556		break;
 557	}
 558	if (proto || showdefaults)
 559		seq_printf(m, ",mountproto=%s", proto ?: "auto");
 560}
 561
 562static void nfs_show_mountd_options(struct seq_file *m, struct nfs_server *nfss,
 563				    int showdefaults)
 564{
 565	struct sockaddr *sap = (struct sockaddr *)&nfss->mountd_address;
 566
 567	if (nfss->flags & NFS_MOUNT_LEGACY_INTERFACE)
 568		return;
 569
 570	switch (sap->sa_family) {
 571	case AF_INET: {
 572		struct sockaddr_in *sin = (struct sockaddr_in *)sap;
 573		seq_printf(m, ",mountaddr=%pI4", &sin->sin_addr.s_addr);
 574		break;
 575	}
 576	case AF_INET6: {
 577		struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
 578		seq_printf(m, ",mountaddr=%pI6c", &sin6->sin6_addr);
 579		break;
 580	}
 581	default:
 582		if (showdefaults)
 583			seq_printf(m, ",mountaddr=unspecified");
 584	}
 585
 586	if (nfss->mountd_version || showdefaults)
 587		seq_printf(m, ",mountvers=%u", nfss->mountd_version);
 588	if ((nfss->mountd_port &&
 589		nfss->mountd_port != (unsigned short)NFS_UNSPEC_PORT) ||
 590		showdefaults)
 591		seq_printf(m, ",mountport=%u", nfss->mountd_port);
 592
 593	nfs_show_mountd_netid(m, nfss, showdefaults);
 594}
 595
 596#if IS_ENABLED(CONFIG_NFS_V4)
 597static void nfs_show_nfsv4_options(struct seq_file *m, struct nfs_server *nfss,
 598				    int showdefaults)
 599{
 600	struct nfs_client *clp = nfss->nfs_client;
 601
 602	seq_printf(m, ",clientaddr=%s", clp->cl_ipaddr);
 603}
 604#else
 605static void nfs_show_nfsv4_options(struct seq_file *m, struct nfs_server *nfss,
 606				    int showdefaults)
 607{
 608}
 609#endif
 610
 611static void nfs_show_nfs_version(struct seq_file *m,
 612		unsigned int version,
 613		unsigned int minorversion)
 614{
 615	seq_printf(m, ",vers=%u", version);
 616	if (version == 4)
 617		seq_printf(m, ".%u", minorversion);
 618}
 619
 620/*
 621 * Describe the mount options in force on this server representation
 622 */
 623static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss,
 624				   int showdefaults)
 625{
 626	static const struct proc_nfs_info {
 627		int flag;
 628		const char *str;
 629		const char *nostr;
 630	} nfs_info[] = {
 631		{ NFS_MOUNT_SOFT, ",soft", ",hard" },
 
 
 632		{ NFS_MOUNT_POSIX, ",posix", "" },
 633		{ NFS_MOUNT_NOCTO, ",nocto", "" },
 634		{ NFS_MOUNT_NOAC, ",noac", "" },
 635		{ NFS_MOUNT_NONLM, ",nolock", "" },
 636		{ NFS_MOUNT_NOACL, ",noacl", "" },
 637		{ NFS_MOUNT_NORDIRPLUS, ",nordirplus", "" },
 638		{ NFS_MOUNT_UNSHARED, ",nosharecache", "" },
 639		{ NFS_MOUNT_NORESVPORT, ",noresvport", "" },
 640		{ 0, NULL, NULL }
 641	};
 642	const struct proc_nfs_info *nfs_infop;
 643	struct nfs_client *clp = nfss->nfs_client;
 644	u32 version = clp->rpc_ops->version;
 645	int local_flock, local_fcntl;
 646
 647	nfs_show_nfs_version(m, version, clp->cl_minorversion);
 648	seq_printf(m, ",rsize=%u", nfss->rsize);
 649	seq_printf(m, ",wsize=%u", nfss->wsize);
 650	if (nfss->bsize != 0)
 651		seq_printf(m, ",bsize=%u", nfss->bsize);
 652	seq_printf(m, ",namlen=%u", nfss->namelen);
 653	if (nfss->acregmin != NFS_DEF_ACREGMIN*HZ || showdefaults)
 654		seq_printf(m, ",acregmin=%u", nfss->acregmin/HZ);
 655	if (nfss->acregmax != NFS_DEF_ACREGMAX*HZ || showdefaults)
 656		seq_printf(m, ",acregmax=%u", nfss->acregmax/HZ);
 657	if (nfss->acdirmin != NFS_DEF_ACDIRMIN*HZ || showdefaults)
 658		seq_printf(m, ",acdirmin=%u", nfss->acdirmin/HZ);
 659	if (nfss->acdirmax != NFS_DEF_ACDIRMAX*HZ || showdefaults)
 660		seq_printf(m, ",acdirmax=%u", nfss->acdirmax/HZ);
 
 
 661	for (nfs_infop = nfs_info; nfs_infop->flag; nfs_infop++) {
 662		if (nfss->flags & nfs_infop->flag)
 663			seq_puts(m, nfs_infop->str);
 664		else
 665			seq_puts(m, nfs_infop->nostr);
 666	}
 667	rcu_read_lock();
 668	seq_printf(m, ",proto=%s",
 669		   rpc_peeraddr2str(nfss->client, RPC_DISPLAY_NETID));
 670	rcu_read_unlock();
 
 
 671	if (version == 4) {
 672		if (nfss->port != NFS_PORT)
 673			seq_printf(m, ",port=%u", nfss->port);
 674	} else
 675		if (nfss->port)
 676			seq_printf(m, ",port=%u", nfss->port);
 677
 678	seq_printf(m, ",timeo=%lu", 10U * nfss->client->cl_timeout->to_initval / HZ);
 679	seq_printf(m, ",retrans=%u", nfss->client->cl_timeout->to_retries);
 680	seq_printf(m, ",sec=%s", nfs_pseudoflavour_to_name(nfss->client->cl_auth->au_flavor));
 681
 682	if (version != 4)
 683		nfs_show_mountd_options(m, nfss, showdefaults);
 684	else
 685		nfs_show_nfsv4_options(m, nfss, showdefaults);
 686
 687	if (nfss->options & NFS_OPTION_FSCACHE)
 688		seq_printf(m, ",fsc");
 689
 690	if (nfss->options & NFS_OPTION_MIGRATION)
 691		seq_printf(m, ",migration");
 692
 693	if (nfss->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG) {
 694		if (nfss->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
 695			seq_printf(m, ",lookupcache=none");
 696		else
 697			seq_printf(m, ",lookupcache=pos");
 698	}
 699
 700	local_flock = nfss->flags & NFS_MOUNT_LOCAL_FLOCK;
 701	local_fcntl = nfss->flags & NFS_MOUNT_LOCAL_FCNTL;
 702
 703	if (!local_flock && !local_fcntl)
 704		seq_printf(m, ",local_lock=none");
 705	else if (local_flock && local_fcntl)
 706		seq_printf(m, ",local_lock=all");
 707	else if (local_flock)
 708		seq_printf(m, ",local_lock=flock");
 709	else
 710		seq_printf(m, ",local_lock=posix");
 711}
 712
 713/*
 714 * Describe the mount options on this VFS mountpoint
 715 */
 716int nfs_show_options(struct seq_file *m, struct dentry *root)
 717{
 718	struct nfs_server *nfss = NFS_SB(root->d_sb);
 719
 720	nfs_show_mount_options(m, nfss, 0);
 721
 722	rcu_read_lock();
 723	seq_printf(m, ",addr=%s",
 724			rpc_peeraddr2str(nfss->nfs_client->cl_rpcclient,
 725							RPC_DISPLAY_ADDR));
 726	rcu_read_unlock();
 727
 728	return 0;
 729}
 730EXPORT_SYMBOL_GPL(nfs_show_options);
 731
 732#if IS_ENABLED(CONFIG_NFS_V4)
 
 
 
 
 
 
 
 
 
 
 733#ifdef CONFIG_NFS_V4_1
 734static void show_sessions(struct seq_file *m, struct nfs_server *server)
 735{
 736	if (nfs4_has_session(server->nfs_client))
 737		seq_printf(m, ",sessions");
 738}
 739#else
 740static void show_sessions(struct seq_file *m, struct nfs_server *server) {}
 741#endif
 742#endif
 743
 744#ifdef CONFIG_NFS_V4_1
 745static void show_pnfs(struct seq_file *m, struct nfs_server *server)
 746{
 747	seq_printf(m, ",pnfs=");
 748	if (server->pnfs_curr_ld)
 749		seq_printf(m, "%s", server->pnfs_curr_ld->name);
 750	else
 751		seq_printf(m, "not configured");
 752}
 753
 754static void show_implementation_id(struct seq_file *m, struct nfs_server *nfss)
 755{
 756	if (nfss->nfs_client && nfss->nfs_client->cl_implid) {
 757		struct nfs41_impl_id *impl_id = nfss->nfs_client->cl_implid;
 758		seq_printf(m, "\n\timpl_id:\tname='%s',domain='%s',"
 759			   "date='%llu,%u'",
 760			   impl_id->name, impl_id->domain,
 761			   impl_id->date.seconds, impl_id->date.nseconds);
 762	}
 763}
 764#else
 765#if IS_ENABLED(CONFIG_NFS_V4)
 766static void show_pnfs(struct seq_file *m, struct nfs_server *server)
 767{
 768}
 769#endif
 770static void show_implementation_id(struct seq_file *m, struct nfs_server *nfss)
 771{
 772}
 773#endif
 774
 775int nfs_show_devname(struct seq_file *m, struct dentry *root)
 776{
 777	char *page = (char *) __get_free_page(GFP_KERNEL);
 778	char *devname, *dummy;
 779	int err = 0;
 780	if (!page)
 781		return -ENOMEM;
 782	devname = nfs_path(&dummy, root, page, PAGE_SIZE, 0);
 783	if (IS_ERR(devname))
 784		err = PTR_ERR(devname);
 785	else
 786		seq_escape(m, devname, " \t\n\\");
 787	free_page((unsigned long)page);
 788	return err;
 789}
 790EXPORT_SYMBOL_GPL(nfs_show_devname);
 791
 792int nfs_show_path(struct seq_file *m, struct dentry *dentry)
 793{
 794	seq_puts(m, "/");
 795	return 0;
 796}
 797EXPORT_SYMBOL_GPL(nfs_show_path);
 798
 799/*
 800 * Present statistical information for this VFS mountpoint
 801 */
 802int nfs_show_stats(struct seq_file *m, struct dentry *root)
 803{
 804	int i, cpu;
 805	struct nfs_server *nfss = NFS_SB(root->d_sb);
 806	struct rpc_auth *auth = nfss->client->cl_auth;
 807	struct nfs_iostats totals = { };
 808
 809	seq_printf(m, "statvers=%s", NFS_IOSTAT_VERS);
 810
 811	/*
 812	 * Display all mount option settings
 813	 */
 814	seq_printf(m, "\n\topts:\t");
 815	seq_puts(m, sb_rdonly(root->d_sb) ? "ro" : "rw");
 816	seq_puts(m, root->d_sb->s_flags & SB_SYNCHRONOUS ? ",sync" : "");
 817	seq_puts(m, root->d_sb->s_flags & SB_NOATIME ? ",noatime" : "");
 818	seq_puts(m, root->d_sb->s_flags & SB_NODIRATIME ? ",nodiratime" : "");
 819	nfs_show_mount_options(m, nfss, 1);
 820
 821	seq_printf(m, "\n\tage:\t%lu", (jiffies - nfss->mount_time) / HZ);
 822
 823	show_implementation_id(m, nfss);
 824
 825	seq_printf(m, "\n\tcaps:\t");
 826	seq_printf(m, "caps=0x%x", nfss->caps);
 827	seq_printf(m, ",wtmult=%u", nfss->wtmult);
 828	seq_printf(m, ",dtsize=%u", nfss->dtsize);
 829	seq_printf(m, ",bsize=%u", nfss->bsize);
 830	seq_printf(m, ",namlen=%u", nfss->namelen);
 831
 832#if IS_ENABLED(CONFIG_NFS_V4)
 833	if (nfss->nfs_client->rpc_ops->version == 4) {
 834		seq_printf(m, "\n\tnfsv4:\t");
 835		seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]);
 836		seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]);
 837		seq_printf(m, ",bm2=0x%x", nfss->attr_bitmask[2]);
 838		seq_printf(m, ",acl=0x%x", nfss->acl_bitmask);
 839		show_sessions(m, nfss);
 840		show_pnfs(m, nfss);
 
 841	}
 842#endif
 843
 844	/*
 845	 * Display security flavor in effect for this mount
 846	 */
 847	seq_printf(m, "\n\tsec:\tflavor=%u", auth->au_ops->au_flavor);
 848	if (auth->au_flavor)
 849		seq_printf(m, ",pseudoflavor=%u", auth->au_flavor);
 850
 851	/*
 852	 * Display superblock I/O counters
 853	 */
 854	for_each_possible_cpu(cpu) {
 855		struct nfs_iostats *stats;
 856
 857		preempt_disable();
 858		stats = per_cpu_ptr(nfss->io_stats, cpu);
 859
 860		for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
 861			totals.events[i] += stats->events[i];
 862		for (i = 0; i < __NFSIOS_BYTESMAX; i++)
 863			totals.bytes[i] += stats->bytes[i];
 864#ifdef CONFIG_NFS_FSCACHE
 865		for (i = 0; i < __NFSIOS_FSCACHEMAX; i++)
 866			totals.fscache[i] += stats->fscache[i];
 867#endif
 868
 869		preempt_enable();
 870	}
 871
 872	seq_printf(m, "\n\tevents:\t");
 873	for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
 874		seq_printf(m, "%lu ", totals.events[i]);
 875	seq_printf(m, "\n\tbytes:\t");
 876	for (i = 0; i < __NFSIOS_BYTESMAX; i++)
 877		seq_printf(m, "%Lu ", totals.bytes[i]);
 878#ifdef CONFIG_NFS_FSCACHE
 879	if (nfss->options & NFS_OPTION_FSCACHE) {
 880		seq_printf(m, "\n\tfsc:\t");
 881		for (i = 0; i < __NFSIOS_FSCACHEMAX; i++)
 882			seq_printf(m, "%Lu ", totals.fscache[i]);
 883	}
 884#endif
 885	seq_printf(m, "\n");
 886
 887	rpc_print_iostats(m, nfss->client);
 888
 889	return 0;
 890}
 891EXPORT_SYMBOL_GPL(nfs_show_stats);
 892
 893/*
 894 * Begin unmount by attempting to remove all automounted mountpoints we added
 895 * in response to xdev traversals and referrals
 896 */
 897void nfs_umount_begin(struct super_block *sb)
 898{
 899	struct nfs_server *server;
 900	struct rpc_clnt *rpc;
 901
 902	server = NFS_SB(sb);
 903	/* -EIO all pending I/O */
 904	rpc = server->client_acl;
 905	if (!IS_ERR(rpc))
 906		rpc_killall_tasks(rpc);
 907	rpc = server->client;
 908	if (!IS_ERR(rpc))
 909		rpc_killall_tasks(rpc);
 910}
 911EXPORT_SYMBOL_GPL(nfs_umount_begin);
 912
 913static struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(void)
 914{
 915	struct nfs_parsed_mount_data *data;
 916
 917	data = kzalloc(sizeof(*data), GFP_KERNEL);
 918	if (data) {
 919		data->timeo		= NFS_UNSPEC_TIMEO;
 920		data->retrans		= NFS_UNSPEC_RETRANS;
 921		data->acregmin		= NFS_DEF_ACREGMIN;
 922		data->acregmax		= NFS_DEF_ACREGMAX;
 923		data->acdirmin		= NFS_DEF_ACDIRMIN;
 924		data->acdirmax		= NFS_DEF_ACDIRMAX;
 925		data->mount_server.port	= NFS_UNSPEC_PORT;
 926		data->nfs_server.port	= NFS_UNSPEC_PORT;
 927		data->nfs_server.protocol = XPRT_TRANSPORT_TCP;
 928		data->selected_flavor	= RPC_AUTH_MAXFLAVOR;
 929		data->minorversion	= 0;
 930		data->need_mount	= true;
 931		data->net		= current->nsproxy->net_ns;
 932		security_init_mnt_opts(&data->lsm_opts);
 933	}
 934	return data;
 935}
 936
 937static void nfs_free_parsed_mount_data(struct nfs_parsed_mount_data *data)
 938{
 939	if (data) {
 940		kfree(data->client_address);
 941		kfree(data->mount_server.hostname);
 942		kfree(data->nfs_server.export_path);
 943		kfree(data->nfs_server.hostname);
 944		kfree(data->fscache_uniq);
 945		security_free_mnt_opts(&data->lsm_opts);
 946		kfree(data);
 947	}
 948}
 949
 950/*
 951 * Sanity-check a server address provided by the mount command.
 952 *
 953 * Address family must be initialized, and address must not be
 954 * the ANY address for that family.
 955 */
 956static int nfs_verify_server_address(struct sockaddr *addr)
 957{
 958	switch (addr->sa_family) {
 959	case AF_INET: {
 960		struct sockaddr_in *sa = (struct sockaddr_in *)addr;
 961		return sa->sin_addr.s_addr != htonl(INADDR_ANY);
 962	}
 963	case AF_INET6: {
 964		struct in6_addr *sa = &((struct sockaddr_in6 *)addr)->sin6_addr;
 965		return !ipv6_addr_any(sa);
 966	}
 967	}
 968
 969	dfprintk(MOUNT, "NFS: Invalid IP address specified\n");
 970	return 0;
 971}
 972
 973/*
 974 * Select between a default port value and a user-specified port value.
 975 * If a zero value is set, then autobind will be used.
 976 */
 977static void nfs_set_port(struct sockaddr *sap, int *port,
 978				 const unsigned short default_port)
 979{
 980	if (*port == NFS_UNSPEC_PORT)
 981		*port = default_port;
 982
 983	rpc_set_port(sap, *port);
 984}
 985
 986/*
 987 * Sanity check the NFS transport protocol.
 988 *
 989 */
 990static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data *mnt)
 991{
 992	switch (mnt->nfs_server.protocol) {
 993	case XPRT_TRANSPORT_UDP:
 994	case XPRT_TRANSPORT_TCP:
 995	case XPRT_TRANSPORT_RDMA:
 996		break;
 997	default:
 998		mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
 999	}
1000}
1001
1002/*
1003 * For text based NFSv2/v3 mounts, the mount protocol transport default
1004 * settings should depend upon the specified NFS transport.
1005 */
1006static void nfs_set_mount_transport_protocol(struct nfs_parsed_mount_data *mnt)
1007{
1008	nfs_validate_transport_protocol(mnt);
1009
1010	if (mnt->mount_server.protocol == XPRT_TRANSPORT_UDP ||
1011	    mnt->mount_server.protocol == XPRT_TRANSPORT_TCP)
1012			return;
1013	switch (mnt->nfs_server.protocol) {
1014	case XPRT_TRANSPORT_UDP:
1015		mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
1016		break;
1017	case XPRT_TRANSPORT_TCP:
1018	case XPRT_TRANSPORT_RDMA:
1019		mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
1020	}
1021}
1022
1023/*
1024 * Add 'flavor' to 'auth_info' if not already present.
1025 * Returns true if 'flavor' ends up in the list, false otherwise
1026 */
1027static bool nfs_auth_info_add(struct nfs_auth_info *auth_info,
1028			      rpc_authflavor_t flavor)
1029{
1030	unsigned int i;
1031	unsigned int max_flavor_len = ARRAY_SIZE(auth_info->flavors);
1032
1033	/* make sure this flavor isn't already in the list */
1034	for (i = 0; i < auth_info->flavor_len; i++) {
1035		if (flavor == auth_info->flavors[i])
1036			return true;
1037	}
1038
1039	if (auth_info->flavor_len + 1 >= max_flavor_len) {
1040		dfprintk(MOUNT, "NFS: too many sec= flavors\n");
1041		return false;
1042	}
1043
1044	auth_info->flavors[auth_info->flavor_len++] = flavor;
1045	return true;
1046}
1047
1048/*
1049 * Return true if 'match' is in auth_info or auth_info is empty.
1050 * Return false otherwise.
1051 */
1052bool nfs_auth_info_match(const struct nfs_auth_info *auth_info,
1053			 rpc_authflavor_t match)
1054{
1055	int i;
1056
1057	if (!auth_info->flavor_len)
1058		return true;
1059
1060	for (i = 0; i < auth_info->flavor_len; i++) {
1061		if (auth_info->flavors[i] == match)
1062			return true;
1063	}
1064	return false;
1065}
1066EXPORT_SYMBOL_GPL(nfs_auth_info_match);
1067
1068/*
1069 * Parse the value of the 'sec=' option.
1070 */
1071static int nfs_parse_security_flavors(char *value,
1072				      struct nfs_parsed_mount_data *mnt)
1073{
1074	substring_t args[MAX_OPT_ARGS];
1075	rpc_authflavor_t pseudoflavor;
1076	char *p;
1077
1078	dfprintk(MOUNT, "NFS: parsing sec=%s option\n", value);
1079
1080	while ((p = strsep(&value, ":")) != NULL) {
1081		switch (match_token(p, nfs_secflavor_tokens, args)) {
1082		case Opt_sec_none:
1083			pseudoflavor = RPC_AUTH_NULL;
1084			break;
1085		case Opt_sec_sys:
1086			pseudoflavor = RPC_AUTH_UNIX;
1087			break;
1088		case Opt_sec_krb5:
1089			pseudoflavor = RPC_AUTH_GSS_KRB5;
1090			break;
1091		case Opt_sec_krb5i:
1092			pseudoflavor = RPC_AUTH_GSS_KRB5I;
1093			break;
1094		case Opt_sec_krb5p:
1095			pseudoflavor = RPC_AUTH_GSS_KRB5P;
1096			break;
1097		case Opt_sec_lkey:
1098			pseudoflavor = RPC_AUTH_GSS_LKEY;
1099			break;
1100		case Opt_sec_lkeyi:
1101			pseudoflavor = RPC_AUTH_GSS_LKEYI;
1102			break;
1103		case Opt_sec_lkeyp:
1104			pseudoflavor = RPC_AUTH_GSS_LKEYP;
1105			break;
1106		case Opt_sec_spkm:
1107			pseudoflavor = RPC_AUTH_GSS_SPKM;
1108			break;
1109		case Opt_sec_spkmi:
1110			pseudoflavor = RPC_AUTH_GSS_SPKMI;
1111			break;
1112		case Opt_sec_spkmp:
1113			pseudoflavor = RPC_AUTH_GSS_SPKMP;
1114			break;
1115		default:
1116			dfprintk(MOUNT,
1117				 "NFS: sec= option '%s' not recognized\n", p);
1118			return 0;
1119		}
1120
1121		if (!nfs_auth_info_add(&mnt->auth_info, pseudoflavor))
1122			return 0;
1123	}
1124
1125	return 1;
1126}
1127
1128static int nfs_parse_version_string(char *string,
1129		struct nfs_parsed_mount_data *mnt,
1130		substring_t *args)
1131{
1132	mnt->flags &= ~NFS_MOUNT_VER3;
1133	switch (match_token(string, nfs_vers_tokens, args)) {
1134	case Opt_vers_2:
1135		mnt->version = 2;
1136		break;
1137	case Opt_vers_3:
1138		mnt->flags |= NFS_MOUNT_VER3;
1139		mnt->version = 3;
1140		break;
1141	case Opt_vers_4:
1142		/* Backward compatibility option. In future,
1143		 * the mount program should always supply
1144		 * a NFSv4 minor version number.
1145		 */
1146		mnt->version = 4;
1147		break;
1148	case Opt_vers_4_0:
1149		mnt->version = 4;
1150		mnt->minorversion = 0;
1151		break;
1152	case Opt_vers_4_1:
1153		mnt->version = 4;
1154		mnt->minorversion = 1;
1155		break;
1156	case Opt_vers_4_2:
1157		mnt->version = 4;
1158		mnt->minorversion = 2;
1159		break;
1160	default:
1161		return 0;
1162	}
1163	return 1;
1164}
1165
1166static int nfs_get_option_str(substring_t args[], char **option)
1167{
1168	kfree(*option);
1169	*option = match_strdup(args);
1170	return !*option;
1171}
1172
1173static int nfs_get_option_ul(substring_t args[], unsigned long *option)
1174{
1175	int rc;
1176	char *string;
1177
1178	string = match_strdup(args);
1179	if (string == NULL)
1180		return -ENOMEM;
1181	rc = kstrtoul(string, 10, option);
1182	kfree(string);
1183
1184	return rc;
1185}
1186
1187static int nfs_get_option_ul_bound(substring_t args[], unsigned long *option,
1188		unsigned long l_bound, unsigned long u_bound)
1189{
1190	int ret;
1191
1192	ret = nfs_get_option_ul(args, option);
1193	if (ret != 0)
1194		return ret;
1195	if (*option < l_bound || *option > u_bound)
1196		return -ERANGE;
1197	return 0;
1198}
1199
1200/*
1201 * Error-check and convert a string of mount options from user space into
1202 * a data structure.  The whole mount string is processed; bad options are
1203 * skipped as they are encountered.  If there were no errors, return 1;
1204 * otherwise return 0 (zero).
1205 */
1206static int nfs_parse_mount_options(char *raw,
1207				   struct nfs_parsed_mount_data *mnt)
1208{
1209	char *p, *string, *secdata;
1210	int rc, sloppy = 0, invalid_option = 0;
1211	unsigned short protofamily = AF_UNSPEC;
1212	unsigned short mountfamily = AF_UNSPEC;
1213
1214	if (!raw) {
1215		dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
1216		return 1;
1217	}
1218	dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
1219
1220	secdata = alloc_secdata();
1221	if (!secdata)
1222		goto out_nomem;
1223
1224	rc = security_sb_copy_data(raw, secdata);
1225	if (rc)
1226		goto out_security_failure;
1227
1228	rc = security_sb_parse_opts_str(secdata, &mnt->lsm_opts);
1229	if (rc)
1230		goto out_security_failure;
1231
1232	free_secdata(secdata);
1233
1234	while ((p = strsep(&raw, ",")) != NULL) {
1235		substring_t args[MAX_OPT_ARGS];
1236		unsigned long option;
1237		int token;
1238
1239		if (!*p)
1240			continue;
1241
1242		dfprintk(MOUNT, "NFS:   parsing nfs mount option '%s'\n", p);
1243
1244		token = match_token(p, nfs_mount_option_tokens, args);
1245		switch (token) {
1246
1247		/*
1248		 * boolean options:  foo/nofoo
1249		 */
1250		case Opt_soft:
1251			mnt->flags |= NFS_MOUNT_SOFT;
1252			break;
1253		case Opt_hard:
1254			mnt->flags &= ~NFS_MOUNT_SOFT;
1255			break;
1256		case Opt_posix:
1257			mnt->flags |= NFS_MOUNT_POSIX;
1258			break;
1259		case Opt_noposix:
1260			mnt->flags &= ~NFS_MOUNT_POSIX;
1261			break;
1262		case Opt_cto:
1263			mnt->flags &= ~NFS_MOUNT_NOCTO;
1264			break;
1265		case Opt_nocto:
1266			mnt->flags |= NFS_MOUNT_NOCTO;
1267			break;
1268		case Opt_ac:
1269			mnt->flags &= ~NFS_MOUNT_NOAC;
1270			break;
1271		case Opt_noac:
1272			mnt->flags |= NFS_MOUNT_NOAC;
1273			break;
1274		case Opt_lock:
1275			mnt->flags &= ~NFS_MOUNT_NONLM;
1276			mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
1277					NFS_MOUNT_LOCAL_FCNTL);
1278			break;
1279		case Opt_nolock:
1280			mnt->flags |= NFS_MOUNT_NONLM;
1281			mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
1282				       NFS_MOUNT_LOCAL_FCNTL);
1283			break;
1284		case Opt_udp:
1285			mnt->flags &= ~NFS_MOUNT_TCP;
1286			mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1287			break;
1288		case Opt_tcp:
1289			mnt->flags |= NFS_MOUNT_TCP;
1290			mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1291			break;
1292		case Opt_rdma:
1293			mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */
1294			mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
1295			xprt_load_transport(p);
1296			break;
1297		case Opt_acl:
1298			mnt->flags &= ~NFS_MOUNT_NOACL;
1299			break;
1300		case Opt_noacl:
1301			mnt->flags |= NFS_MOUNT_NOACL;
1302			break;
1303		case Opt_rdirplus:
1304			mnt->flags &= ~NFS_MOUNT_NORDIRPLUS;
1305			break;
1306		case Opt_nordirplus:
1307			mnt->flags |= NFS_MOUNT_NORDIRPLUS;
1308			break;
1309		case Opt_sharecache:
1310			mnt->flags &= ~NFS_MOUNT_UNSHARED;
1311			break;
1312		case Opt_nosharecache:
1313			mnt->flags |= NFS_MOUNT_UNSHARED;
1314			break;
1315		case Opt_resvport:
1316			mnt->flags &= ~NFS_MOUNT_NORESVPORT;
1317			break;
1318		case Opt_noresvport:
1319			mnt->flags |= NFS_MOUNT_NORESVPORT;
1320			break;
1321		case Opt_fscache:
1322			mnt->options |= NFS_OPTION_FSCACHE;
1323			kfree(mnt->fscache_uniq);
1324			mnt->fscache_uniq = NULL;
1325			break;
1326		case Opt_nofscache:
1327			mnt->options &= ~NFS_OPTION_FSCACHE;
1328			kfree(mnt->fscache_uniq);
1329			mnt->fscache_uniq = NULL;
1330			break;
1331		case Opt_migration:
1332			mnt->options |= NFS_OPTION_MIGRATION;
1333			break;
1334		case Opt_nomigration:
1335			mnt->options &= ~NFS_OPTION_MIGRATION;
1336			break;
1337
1338		/*
1339		 * options that take numeric values
1340		 */
1341		case Opt_port:
1342			if (nfs_get_option_ul(args, &option) ||
1343			    option > USHRT_MAX)
1344				goto out_invalid_value;
1345			mnt->nfs_server.port = option;
1346			break;
1347		case Opt_rsize:
1348			if (nfs_get_option_ul(args, &option))
1349				goto out_invalid_value;
1350			mnt->rsize = option;
1351			break;
1352		case Opt_wsize:
1353			if (nfs_get_option_ul(args, &option))
1354				goto out_invalid_value;
1355			mnt->wsize = option;
1356			break;
1357		case Opt_bsize:
1358			if (nfs_get_option_ul(args, &option))
1359				goto out_invalid_value;
1360			mnt->bsize = option;
1361			break;
1362		case Opt_timeo:
1363			if (nfs_get_option_ul_bound(args, &option, 1, INT_MAX))
1364				goto out_invalid_value;
1365			mnt->timeo = option;
1366			break;
1367		case Opt_retrans:
1368			if (nfs_get_option_ul_bound(args, &option, 0, INT_MAX))
1369				goto out_invalid_value;
1370			mnt->retrans = option;
1371			break;
1372		case Opt_acregmin:
1373			if (nfs_get_option_ul(args, &option))
1374				goto out_invalid_value;
1375			mnt->acregmin = option;
1376			break;
1377		case Opt_acregmax:
1378			if (nfs_get_option_ul(args, &option))
1379				goto out_invalid_value;
1380			mnt->acregmax = option;
1381			break;
1382		case Opt_acdirmin:
1383			if (nfs_get_option_ul(args, &option))
1384				goto out_invalid_value;
1385			mnt->acdirmin = option;
1386			break;
1387		case Opt_acdirmax:
1388			if (nfs_get_option_ul(args, &option))
1389				goto out_invalid_value;
1390			mnt->acdirmax = option;
1391			break;
1392		case Opt_actimeo:
1393			if (nfs_get_option_ul(args, &option))
1394				goto out_invalid_value;
1395			mnt->acregmin = mnt->acregmax =
1396			mnt->acdirmin = mnt->acdirmax = option;
1397			break;
1398		case Opt_namelen:
1399			if (nfs_get_option_ul(args, &option))
1400				goto out_invalid_value;
1401			mnt->namlen = option;
1402			break;
1403		case Opt_mountport:
1404			if (nfs_get_option_ul(args, &option) ||
1405			    option > USHRT_MAX)
1406				goto out_invalid_value;
1407			mnt->mount_server.port = option;
1408			break;
1409		case Opt_mountvers:
1410			if (nfs_get_option_ul(args, &option) ||
1411			    option < NFS_MNT_VERSION ||
1412			    option > NFS_MNT3_VERSION)
1413				goto out_invalid_value;
1414			mnt->mount_server.version = option;
1415			break;
1416		case Opt_minorversion:
1417			if (nfs_get_option_ul(args, &option))
1418				goto out_invalid_value;
1419			if (option > NFS4_MAX_MINOR_VERSION)
1420				goto out_invalid_value;
1421			mnt->minorversion = option;
1422			break;
1423
1424		/*
1425		 * options that take text values
1426		 */
1427		case Opt_nfsvers:
1428			string = match_strdup(args);
1429			if (string == NULL)
1430				goto out_nomem;
1431			rc = nfs_parse_version_string(string, mnt, args);
1432			kfree(string);
1433			if (!rc)
1434				goto out_invalid_value;
1435			break;
1436		case Opt_sec:
1437			string = match_strdup(args);
1438			if (string == NULL)
1439				goto out_nomem;
1440			rc = nfs_parse_security_flavors(string, mnt);
1441			kfree(string);
1442			if (!rc) {
1443				dfprintk(MOUNT, "NFS:   unrecognized "
1444						"security flavor\n");
1445				return 0;
1446			}
1447			break;
1448		case Opt_proto:
1449			string = match_strdup(args);
1450			if (string == NULL)
1451				goto out_nomem;
1452			token = match_token(string,
1453					    nfs_xprt_protocol_tokens, args);
1454
1455			protofamily = AF_INET;
1456			switch (token) {
1457			case Opt_xprt_udp6:
1458				protofamily = AF_INET6;
1459				/* fall through */
1460			case Opt_xprt_udp:
1461				mnt->flags &= ~NFS_MOUNT_TCP;
1462				mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1463				break;
1464			case Opt_xprt_tcp6:
1465				protofamily = AF_INET6;
1466				/* fall through */
1467			case Opt_xprt_tcp:
1468				mnt->flags |= NFS_MOUNT_TCP;
1469				mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1470				break;
1471			case Opt_xprt_rdma6:
1472				protofamily = AF_INET6;
1473				/* fall through */
1474			case Opt_xprt_rdma:
1475				/* vector side protocols to TCP */
1476				mnt->flags |= NFS_MOUNT_TCP;
1477				mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
1478				xprt_load_transport(string);
1479				break;
1480			default:
1481				dfprintk(MOUNT, "NFS:   unrecognized "
1482						"transport protocol\n");
1483				kfree(string);
1484				return 0;
1485			}
1486			kfree(string);
1487			break;
1488		case Opt_mountproto:
1489			string = match_strdup(args);
1490			if (string == NULL)
1491				goto out_nomem;
1492			token = match_token(string,
1493					    nfs_xprt_protocol_tokens, args);
1494			kfree(string);
1495
1496			mountfamily = AF_INET;
1497			switch (token) {
1498			case Opt_xprt_udp6:
1499				mountfamily = AF_INET6;
1500				/* fall through */
1501			case Opt_xprt_udp:
1502				mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
1503				break;
1504			case Opt_xprt_tcp6:
1505				mountfamily = AF_INET6;
1506				/* fall through */
1507			case Opt_xprt_tcp:
1508				mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
1509				break;
1510			case Opt_xprt_rdma: /* not used for side protocols */
1511			default:
1512				dfprintk(MOUNT, "NFS:   unrecognized "
1513						"transport protocol\n");
1514				return 0;
1515			}
1516			break;
1517		case Opt_addr:
1518			string = match_strdup(args);
1519			if (string == NULL)
1520				goto out_nomem;
1521			mnt->nfs_server.addrlen =
1522				rpc_pton(mnt->net, string, strlen(string),
1523					(struct sockaddr *)
1524					&mnt->nfs_server.address,
1525					sizeof(mnt->nfs_server.address));
1526			kfree(string);
1527			if (mnt->nfs_server.addrlen == 0)
1528				goto out_invalid_address;
1529			break;
1530		case Opt_clientaddr:
1531			if (nfs_get_option_str(args, &mnt->client_address))
1532				goto out_nomem;
1533			break;
1534		case Opt_mounthost:
1535			if (nfs_get_option_str(args,
1536					       &mnt->mount_server.hostname))
1537				goto out_nomem;
1538			break;
1539		case Opt_mountaddr:
1540			string = match_strdup(args);
1541			if (string == NULL)
1542				goto out_nomem;
1543			mnt->mount_server.addrlen =
1544				rpc_pton(mnt->net, string, strlen(string),
1545					(struct sockaddr *)
1546					&mnt->mount_server.address,
1547					sizeof(mnt->mount_server.address));
1548			kfree(string);
1549			if (mnt->mount_server.addrlen == 0)
1550				goto out_invalid_address;
1551			break;
1552		case Opt_lookupcache:
1553			string = match_strdup(args);
1554			if (string == NULL)
1555				goto out_nomem;
1556			token = match_token(string,
1557					nfs_lookupcache_tokens, args);
1558			kfree(string);
1559			switch (token) {
1560				case Opt_lookupcache_all:
1561					mnt->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE);
1562					break;
1563				case Opt_lookupcache_positive:
1564					mnt->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE;
1565					mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG;
1566					break;
1567				case Opt_lookupcache_none:
1568					mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
1569					break;
1570				default:
1571					dfprintk(MOUNT, "NFS:   invalid "
1572							"lookupcache argument\n");
1573					return 0;
1574			};
1575			break;
1576		case Opt_fscache_uniq:
1577			if (nfs_get_option_str(args, &mnt->fscache_uniq))
1578				goto out_nomem;
1579			mnt->options |= NFS_OPTION_FSCACHE;
1580			break;
1581		case Opt_local_lock:
1582			string = match_strdup(args);
1583			if (string == NULL)
1584				goto out_nomem;
1585			token = match_token(string, nfs_local_lock_tokens,
1586					args);
1587			kfree(string);
1588			switch (token) {
1589			case Opt_local_lock_all:
1590				mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
1591					       NFS_MOUNT_LOCAL_FCNTL);
1592				break;
1593			case Opt_local_lock_flock:
1594				mnt->flags |= NFS_MOUNT_LOCAL_FLOCK;
1595				break;
1596			case Opt_local_lock_posix:
1597				mnt->flags |= NFS_MOUNT_LOCAL_FCNTL;
1598				break;
1599			case Opt_local_lock_none:
1600				mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
1601						NFS_MOUNT_LOCAL_FCNTL);
1602				break;
1603			default:
1604				dfprintk(MOUNT, "NFS:	invalid	"
1605						"local_lock argument\n");
1606				return 0;
1607			};
1608			break;
1609
1610		/*
1611		 * Special options
1612		 */
1613		case Opt_sloppy:
1614			sloppy = 1;
1615			dfprintk(MOUNT, "NFS:   relaxing parsing rules\n");
1616			break;
1617		case Opt_userspace:
1618		case Opt_deprecated:
1619			dfprintk(MOUNT, "NFS:   ignoring mount option "
1620					"'%s'\n", p);
1621			break;
1622
1623		default:
1624			invalid_option = 1;
1625			dfprintk(MOUNT, "NFS:   unrecognized mount option "
1626					"'%s'\n", p);
1627		}
1628	}
1629
1630	if (!sloppy && invalid_option)
1631		return 0;
1632
1633	if (mnt->minorversion && mnt->version != 4)
1634		goto out_minorversion_mismatch;
1635
1636	if (mnt->options & NFS_OPTION_MIGRATION &&
1637	    (mnt->version != 4 || mnt->minorversion != 0))
1638		goto out_migration_misuse;
1639
1640	/*
1641	 * verify that any proto=/mountproto= options match the address
1642	 * families in the addr=/mountaddr= options.
1643	 */
1644	if (protofamily != AF_UNSPEC &&
1645	    protofamily != mnt->nfs_server.address.ss_family)
1646		goto out_proto_mismatch;
1647
1648	if (mountfamily != AF_UNSPEC) {
1649		if (mnt->mount_server.addrlen) {
1650			if (mountfamily != mnt->mount_server.address.ss_family)
1651				goto out_mountproto_mismatch;
1652		} else {
1653			if (mountfamily != mnt->nfs_server.address.ss_family)
1654				goto out_mountproto_mismatch;
1655		}
1656	}
1657
1658	return 1;
1659
1660out_mountproto_mismatch:
1661	printk(KERN_INFO "NFS: mount server address does not match mountproto= "
1662			 "option\n");
1663	return 0;
1664out_proto_mismatch:
1665	printk(KERN_INFO "NFS: server address does not match proto= option\n");
1666	return 0;
1667out_invalid_address:
1668	printk(KERN_INFO "NFS: bad IP address specified: %s\n", p);
1669	return 0;
1670out_invalid_value:
1671	printk(KERN_INFO "NFS: bad mount option value specified: %s\n", p);
1672	return 0;
1673out_minorversion_mismatch:
1674	printk(KERN_INFO "NFS: mount option vers=%u does not support "
1675			 "minorversion=%u\n", mnt->version, mnt->minorversion);
1676	return 0;
1677out_migration_misuse:
1678	printk(KERN_INFO
1679		"NFS: 'migration' not supported for this NFS version\n");
1680	return 0;
1681out_nomem:
1682	printk(KERN_INFO "NFS: not enough memory to parse option\n");
1683	return 0;
1684out_security_failure:
1685	free_secdata(secdata);
1686	printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
1687	return 0;
1688}
1689
1690/*
1691 * Ensure that a specified authtype in args->auth_info is supported by
1692 * the server. Returns 0 and sets args->selected_flavor if it's ok, and
1693 * -EACCES if not.
1694 */
1695static int nfs_verify_authflavors(struct nfs_parsed_mount_data *args,
1696			rpc_authflavor_t *server_authlist, unsigned int count)
 
1697{
1698	rpc_authflavor_t flavor = RPC_AUTH_MAXFLAVOR;
1699	bool found_auth_null = false;
1700	unsigned int i;
1701
1702	/*
1703	 * If the sec= mount option is used, the specified flavor or AUTH_NULL
1704	 * must be in the list returned by the server.
1705	 *
1706	 * AUTH_NULL has a special meaning when it's in the server list - it
1707	 * means that the server will ignore the rpc creds, so any flavor
1708	 * can be used but still use the sec= that was specified.
1709	 *
1710	 * Note also that the MNT procedure in MNTv1 does not return a list
1711	 * of supported security flavors. In this case, nfs_mount() fabricates
1712	 * a security flavor list containing just AUTH_NULL.
1713	 */
1714	for (i = 0; i < count; i++) {
1715		flavor = server_authlist[i];
1716
1717		if (nfs_auth_info_match(&args->auth_info, flavor))
1718			goto out;
1719
1720		if (flavor == RPC_AUTH_NULL)
1721			found_auth_null = true;
1722	}
1723
1724	if (found_auth_null) {
1725		flavor = args->auth_info.flavors[0];
1726		goto out;
1727	}
1728
1729	dfprintk(MOUNT,
1730		 "NFS: specified auth flavors not supported by server\n");
1731	return -EACCES;
1732
1733out:
1734	args->selected_flavor = flavor;
1735	dfprintk(MOUNT, "NFS: using auth flavor %u\n", args->selected_flavor);
1736	return 0;
1737}
1738
1739/*
1740 * Use the remote server's MOUNT service to request the NFS file handle
1741 * corresponding to the provided path.
1742 */
1743static int nfs_request_mount(struct nfs_parsed_mount_data *args,
1744			     struct nfs_fh *root_fh,
1745			     rpc_authflavor_t *server_authlist,
1746			     unsigned int *server_authlist_len)
1747{
 
1748	struct nfs_mount_request request = {
1749		.sap		= (struct sockaddr *)
1750						&args->mount_server.address,
1751		.dirpath	= args->nfs_server.export_path,
1752		.protocol	= args->mount_server.protocol,
1753		.fh		= root_fh,
1754		.noresvport	= args->flags & NFS_MOUNT_NORESVPORT,
1755		.auth_flav_len	= server_authlist_len,
1756		.auth_flavs	= server_authlist,
1757		.net		= args->net,
1758	};
1759	int status;
1760
1761	if (args->mount_server.version == 0) {
1762		switch (args->version) {
1763			default:
1764				args->mount_server.version = NFS_MNT3_VERSION;
1765				break;
1766			case 2:
1767				args->mount_server.version = NFS_MNT_VERSION;
1768		}
1769	}
1770	request.version = args->mount_server.version;
1771
1772	if (args->mount_server.hostname)
1773		request.hostname = args->mount_server.hostname;
1774	else
1775		request.hostname = args->nfs_server.hostname;
1776
1777	/*
1778	 * Construct the mount server's address.
1779	 */
1780	if (args->mount_server.address.ss_family == AF_UNSPEC) {
1781		memcpy(request.sap, &args->nfs_server.address,
1782		       args->nfs_server.addrlen);
1783		args->mount_server.addrlen = args->nfs_server.addrlen;
1784	}
1785	request.salen = args->mount_server.addrlen;
1786	nfs_set_port(request.sap, &args->mount_server.port, 0);
1787
1788	/*
1789	 * Now ask the mount server to map our export path
1790	 * to a file handle.
1791	 */
1792	status = nfs_mount(&request);
1793	if (status != 0) {
1794		dfprintk(MOUNT, "NFS: unable to mount server %s, error %d\n",
1795				request.hostname, status);
1796		return status;
1797	}
1798
1799	return 0;
1800}
1801
1802static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_info,
1803					struct nfs_subversion *nfs_mod)
1804{
 
1805	int status;
1806	unsigned int i;
1807	bool tried_auth_unix = false;
1808	bool auth_null_in_list = false;
1809	struct nfs_server *server = ERR_PTR(-EACCES);
1810	struct nfs_parsed_mount_data *args = mount_info->parsed;
1811	rpc_authflavor_t authlist[NFS_MAX_SECFLAVORS];
1812	unsigned int authlist_len = ARRAY_SIZE(authlist);
1813
1814	status = nfs_request_mount(args, mount_info->mntfh, authlist,
1815					&authlist_len);
1816	if (status)
1817		return ERR_PTR(status);
1818
1819	/*
1820	 * Was a sec= authflavor specified in the options? First, verify
1821	 * whether the server supports it, and then just try to use it if so.
1822	 */
1823	if (args->auth_info.flavor_len > 0) {
1824		status = nfs_verify_authflavors(args, authlist, authlist_len);
1825		dfprintk(MOUNT, "NFS: using auth flavor %u\n",
1826			 args->selected_flavor);
1827		if (status)
1828			return ERR_PTR(status);
1829		return nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
1830	}
1831
1832	/*
1833	 * No sec= option was provided. RFC 2623, section 2.7 suggests we
1834	 * SHOULD prefer the flavor listed first. However, some servers list
1835	 * AUTH_NULL first. Avoid ever choosing AUTH_NULL.
1836	 */
1837	for (i = 0; i < authlist_len; ++i) {
1838		rpc_authflavor_t flavor;
1839		struct rpcsec_gss_info info;
1840
1841		flavor = authlist[i];
1842		switch (flavor) {
1843		case RPC_AUTH_UNIX:
1844			tried_auth_unix = true;
1845			break;
1846		case RPC_AUTH_NULL:
1847			auth_null_in_list = true;
1848			continue;
1849		default:
1850			if (rpcauth_get_gssinfo(flavor, &info) != 0)
1851				continue;
1852			/* Fallthrough */
1853		}
1854		dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", flavor);
1855		args->selected_flavor = flavor;
1856		server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
1857		if (!IS_ERR(server))
1858			return server;
1859	}
1860
1861	/*
1862	 * Nothing we tried so far worked. At this point, give up if we've
1863	 * already tried AUTH_UNIX or if the server's list doesn't contain
1864	 * AUTH_NULL
1865	 */
1866	if (tried_auth_unix || !auth_null_in_list)
1867		return server;
1868
1869	/* Last chance! Try AUTH_UNIX */
1870	dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", RPC_AUTH_UNIX);
1871	args->selected_flavor = RPC_AUTH_UNIX;
1872	return nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
1873}
1874
1875struct dentry *nfs_try_mount(int flags, const char *dev_name,
1876			     struct nfs_mount_info *mount_info,
1877			     struct nfs_subversion *nfs_mod)
1878{
1879	struct nfs_server *server;
1880
1881	if (mount_info->parsed->need_mount)
1882		server = nfs_try_mount_request(mount_info, nfs_mod);
1883	else
1884		server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
1885
1886	if (IS_ERR(server))
1887		return ERR_CAST(server);
1888
1889	return nfs_fs_mount_common(server, flags, dev_name, mount_info, nfs_mod);
1890}
1891EXPORT_SYMBOL_GPL(nfs_try_mount);
1892
1893/*
1894 * Split "dev_name" into "hostname:export_path".
1895 *
1896 * The leftmost colon demarks the split between the server's hostname
1897 * and the export path.  If the hostname starts with a left square
1898 * bracket, then it may contain colons.
1899 *
1900 * Note: caller frees hostname and export path, even on error.
1901 */
1902static int nfs_parse_devname(const char *dev_name,
1903			     char **hostname, size_t maxnamlen,
1904			     char **export_path, size_t maxpathlen)
1905{
1906	size_t len;
1907	char *end;
1908
1909	/* Is the host name protected with square brakcets? */
1910	if (*dev_name == '[') {
1911		end = strchr(++dev_name, ']');
1912		if (end == NULL || end[1] != ':')
1913			goto out_bad_devname;
1914
1915		len = end - dev_name;
1916		end++;
1917	} else {
1918		char *comma;
1919
1920		end = strchr(dev_name, ':');
1921		if (end == NULL)
1922			goto out_bad_devname;
1923		len = end - dev_name;
1924
1925		/* kill possible hostname list: not supported */
1926		comma = strchr(dev_name, ',');
1927		if (comma != NULL && comma < end)
1928			*comma = 0;
1929	}
1930
1931	if (len > maxnamlen)
1932		goto out_hostname;
1933
1934	/* N.B. caller will free nfs_server.hostname in all cases */
1935	*hostname = kstrndup(dev_name, len, GFP_KERNEL);
1936	if (*hostname == NULL)
1937		goto out_nomem;
1938	len = strlen(++end);
1939	if (len > maxpathlen)
1940		goto out_path;
1941	*export_path = kstrndup(end, len, GFP_KERNEL);
1942	if (!*export_path)
1943		goto out_nomem;
1944
1945	dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", *export_path);
1946	return 0;
1947
1948out_bad_devname:
1949	dfprintk(MOUNT, "NFS: device name not in host:path format\n");
1950	return -EINVAL;
1951
1952out_nomem:
1953	dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
1954	return -ENOMEM;
1955
1956out_hostname:
1957	dfprintk(MOUNT, "NFS: server hostname too long\n");
1958	return -ENAMETOOLONG;
1959
1960out_path:
1961	dfprintk(MOUNT, "NFS: export pathname too long\n");
1962	return -ENAMETOOLONG;
1963}
1964
1965/*
1966 * Validate the NFS2/NFS3 mount data
1967 * - fills in the mount root filehandle
1968 *
1969 * For option strings, user space handles the following behaviors:
1970 *
1971 * + DNS: mapping server host name to IP address ("addr=" option)
1972 *
1973 * + failure mode: how to behave if a mount request can't be handled
1974 *   immediately ("fg/bg" option)
1975 *
1976 * + retry: how often to retry a mount request ("retry=" option)
1977 *
1978 * + breaking back: trying proto=udp after proto=tcp, v2 after v3,
1979 *   mountproto=tcp after mountproto=udp, and so on
1980 */
1981static int nfs23_validate_mount_data(void *options,
1982				     struct nfs_parsed_mount_data *args,
1983				     struct nfs_fh *mntfh,
1984				     const char *dev_name)
1985{
1986	struct nfs_mount_data *data = (struct nfs_mount_data *)options;
1987	struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
1988	int extra_flags = NFS_MOUNT_LEGACY_INTERFACE;
1989
1990	if (data == NULL)
1991		goto out_no_data;
1992
1993	args->version = NFS_DEFAULT_VERSION;
1994	switch (data->version) {
1995	case 1:
1996		data->namlen = 0; /* fall through */
1997	case 2:
1998		data->bsize = 0; /* fall through */
1999	case 3:
2000		if (data->flags & NFS_MOUNT_VER3)
2001			goto out_no_v3;
2002		data->root.size = NFS2_FHSIZE;
2003		memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
2004		/* Turn off security negotiation */
2005		extra_flags |= NFS_MOUNT_SECFLAVOUR;
2006		/* fall through */
2007	case 4:
2008		if (data->flags & NFS_MOUNT_SECFLAVOUR)
2009			goto out_no_sec;
2010		/* fall through */
2011	case 5:
2012		memset(data->context, 0, sizeof(data->context));
2013		/* fall through */
2014	case 6:
2015		if (data->flags & NFS_MOUNT_VER3) {
2016			if (data->root.size > NFS3_FHSIZE || data->root.size == 0)
2017				goto out_invalid_fh;
2018			mntfh->size = data->root.size;
2019			args->version = 3;
2020		} else {
2021			mntfh->size = NFS2_FHSIZE;
2022			args->version = 2;
2023		}
2024
2025
2026		memcpy(mntfh->data, data->root.data, mntfh->size);
2027		if (mntfh->size < sizeof(mntfh->data))
2028			memset(mntfh->data + mntfh->size, 0,
2029			       sizeof(mntfh->data) - mntfh->size);
2030
2031		/*
2032		 * Translate to nfs_parsed_mount_data, which nfs_fill_super
2033		 * can deal with.
2034		 */
2035		args->flags		= data->flags & NFS_MOUNT_FLAGMASK;
2036		args->flags		|= extra_flags;
2037		args->rsize		= data->rsize;
2038		args->wsize		= data->wsize;
2039		args->timeo		= data->timeo;
2040		args->retrans		= data->retrans;
2041		args->acregmin		= data->acregmin;
2042		args->acregmax		= data->acregmax;
2043		args->acdirmin		= data->acdirmin;
2044		args->acdirmax		= data->acdirmax;
2045		args->need_mount	= false;
2046
2047		memcpy(sap, &data->addr, sizeof(data->addr));
2048		args->nfs_server.addrlen = sizeof(data->addr);
2049		args->nfs_server.port = ntohs(data->addr.sin_port);
2050		if (!nfs_verify_server_address(sap))
2051			goto out_no_address;
2052
2053		if (!(data->flags & NFS_MOUNT_TCP))
2054			args->nfs_server.protocol = XPRT_TRANSPORT_UDP;
2055		/* N.B. caller will free nfs_server.hostname in all cases */
2056		args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
2057		args->namlen		= data->namlen;
2058		args->bsize		= data->bsize;
2059
2060		if (data->flags & NFS_MOUNT_SECFLAVOUR)
2061			args->selected_flavor = data->pseudoflavor;
2062		else
2063			args->selected_flavor = RPC_AUTH_UNIX;
2064		if (!args->nfs_server.hostname)
2065			goto out_nomem;
2066
2067		if (!(data->flags & NFS_MOUNT_NONLM))
2068			args->flags &= ~(NFS_MOUNT_LOCAL_FLOCK|
2069					 NFS_MOUNT_LOCAL_FCNTL);
2070		else
2071			args->flags |= (NFS_MOUNT_LOCAL_FLOCK|
2072					NFS_MOUNT_LOCAL_FCNTL);
2073		/*
2074		 * The legacy version 6 binary mount data from userspace has a
2075		 * field used only to transport selinux information into the
2076		 * the kernel.  To continue to support that functionality we
2077		 * have a touch of selinux knowledge here in the NFS code. The
2078		 * userspace code converted context=blah to just blah so we are
2079		 * converting back to the full string selinux understands.
2080		 */
2081		if (data->context[0]){
2082#ifdef CONFIG_SECURITY_SELINUX
2083			int rc;
2084			char *opts_str = kmalloc(sizeof(data->context) + 8, GFP_KERNEL);
2085			if (!opts_str)
2086				return -ENOMEM;
2087			strcpy(opts_str, "context=");
2088			data->context[NFS_MAX_CONTEXT_LEN] = '\0';
2089			strcat(opts_str, &data->context[0]);
2090			rc = security_sb_parse_opts_str(opts_str, &args->lsm_opts);
2091			kfree(opts_str);
2092			if (rc)
2093				return rc;
2094#else
2095			return -EINVAL;
2096#endif
2097		}
2098
2099		break;
2100	default:
2101		return NFS_TEXT_DATA;
2102	}
2103
2104	return 0;
2105
2106out_no_data:
2107	dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n");
2108	return -EINVAL;
2109
2110out_no_v3:
2111	dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n",
2112		 data->version);
2113	return -EINVAL;
2114
2115out_no_sec:
2116	dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n");
2117	return -EINVAL;
2118
2119out_nomem:
2120	dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n");
2121	return -ENOMEM;
2122
2123out_no_address:
2124	dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
2125	return -EINVAL;
2126
2127out_invalid_fh:
2128	dfprintk(MOUNT, "NFS: invalid root filehandle\n");
2129	return -EINVAL;
2130}
2131
2132#if IS_ENABLED(CONFIG_NFS_V4)
2133static int nfs_validate_mount_data(struct file_system_type *fs_type,
2134				   void *options,
2135				   struct nfs_parsed_mount_data *args,
2136				   struct nfs_fh *mntfh,
2137				   const char *dev_name)
2138{
2139	if (fs_type == &nfs_fs_type)
2140		return nfs23_validate_mount_data(options, args, mntfh, dev_name);
2141	return nfs4_validate_mount_data(options, args, dev_name);
2142}
2143#else
2144static int nfs_validate_mount_data(struct file_system_type *fs_type,
2145				   void *options,
2146				   struct nfs_parsed_mount_data *args,
2147				   struct nfs_fh *mntfh,
2148				   const char *dev_name)
2149{
2150	return nfs23_validate_mount_data(options, args, mntfh, dev_name);
2151}
2152#endif
2153
2154static int nfs_validate_text_mount_data(void *options,
2155					struct nfs_parsed_mount_data *args,
2156					const char *dev_name)
2157{
2158	int port = 0;
2159	int max_namelen = PAGE_SIZE;
2160	int max_pathlen = NFS_MAXPATHLEN;
2161	struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
2162
2163	if (nfs_parse_mount_options((char *)options, args) == 0)
2164		return -EINVAL;
2165
2166	if (!nfs_verify_server_address(sap))
2167		goto out_no_address;
2168
2169	if (args->version == 4) {
2170#if IS_ENABLED(CONFIG_NFS_V4)
2171		port = NFS_PORT;
2172		max_namelen = NFS4_MAXNAMLEN;
2173		max_pathlen = NFS4_MAXPATHLEN;
2174		nfs_validate_transport_protocol(args);
2175		if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP)
2176			goto out_invalid_transport_udp;
2177		nfs4_validate_mount_flags(args);
2178#else
2179		goto out_v4_not_compiled;
2180#endif /* CONFIG_NFS_V4 */
2181	} else
2182		nfs_set_mount_transport_protocol(args);
2183
2184	nfs_set_port(sap, &args->nfs_server.port, port);
2185
2186	return nfs_parse_devname(dev_name,
2187				   &args->nfs_server.hostname,
2188				   max_namelen,
2189				   &args->nfs_server.export_path,
2190				   max_pathlen);
2191
2192#if !IS_ENABLED(CONFIG_NFS_V4)
2193out_v4_not_compiled:
2194	dfprintk(MOUNT, "NFS: NFSv4 is not compiled into kernel\n");
2195	return -EPROTONOSUPPORT;
2196#else
2197out_invalid_transport_udp:
2198	dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
2199	return -EINVAL;
2200#endif /* !CONFIG_NFS_V4 */
2201
2202out_no_address:
2203	dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
2204	return -EINVAL;
2205}
2206
2207#define NFS_REMOUNT_CMP_FLAGMASK ~(NFS_MOUNT_INTR \
2208		| NFS_MOUNT_SECURE \
2209		| NFS_MOUNT_TCP \
2210		| NFS_MOUNT_VER3 \
2211		| NFS_MOUNT_KERBEROS \
2212		| NFS_MOUNT_NONLM \
2213		| NFS_MOUNT_BROKEN_SUID \
2214		| NFS_MOUNT_STRICTLOCK \
2215		| NFS_MOUNT_LEGACY_INTERFACE)
2216
2217#define NFS_MOUNT_CMP_FLAGMASK (NFS_REMOUNT_CMP_FLAGMASK & \
2218		~(NFS_MOUNT_UNSHARED | NFS_MOUNT_NORESVPORT))
2219
2220static int
2221nfs_compare_remount_data(struct nfs_server *nfss,
2222			 struct nfs_parsed_mount_data *data)
2223{
2224	if ((data->flags ^ nfss->flags) & NFS_REMOUNT_CMP_FLAGMASK ||
2225	    data->rsize != nfss->rsize ||
2226	    data->wsize != nfss->wsize ||
2227	    data->version != nfss->nfs_client->rpc_ops->version ||
2228	    data->minorversion != nfss->nfs_client->cl_minorversion ||
2229	    data->retrans != nfss->client->cl_timeout->to_retries ||
2230	    !nfs_auth_info_match(&data->auth_info, nfss->client->cl_auth->au_flavor) ||
2231	    data->acregmin != nfss->acregmin / HZ ||
2232	    data->acregmax != nfss->acregmax / HZ ||
2233	    data->acdirmin != nfss->acdirmin / HZ ||
2234	    data->acdirmax != nfss->acdirmax / HZ ||
2235	    data->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) ||
2236	    data->nfs_server.port != nfss->port ||
2237	    data->nfs_server.addrlen != nfss->nfs_client->cl_addrlen ||
2238	    !rpc_cmp_addr((struct sockaddr *)&data->nfs_server.address,
 
2239			  (struct sockaddr *)&nfss->nfs_client->cl_addr))
2240		return -EINVAL;
2241
2242	return 0;
2243}
2244
2245int
2246nfs_remount(struct super_block *sb, int *flags, char *raw_data)
2247{
2248	int error;
 
2249	struct nfs_server *nfss = sb->s_fs_info;
2250	struct nfs_parsed_mount_data *data;
2251	struct nfs_mount_data *options = (struct nfs_mount_data *)raw_data;
2252	struct nfs4_mount_data *options4 = (struct nfs4_mount_data *)raw_data;
2253	u32 nfsvers = nfss->nfs_client->rpc_ops->version;
2254
2255	sync_filesystem(sb);
2256
2257	/*
2258	 * Userspace mount programs that send binary options generally send
2259	 * them populated with default values. We have no way to know which
2260	 * ones were explicitly specified. Fall back to legacy behavior and
2261	 * just return success.
2262	 */
2263	if ((nfsvers == 4 && (!options4 || options4->version == 1)) ||
2264	    (nfsvers <= 3 && (!options || (options->version >= 1 &&
2265					   options->version <= 6))))
2266		return 0;
2267
2268	data = kzalloc(sizeof(*data), GFP_KERNEL);
2269	if (data == NULL)
2270		return -ENOMEM;
2271
2272	/* fill out struct with values from existing mount */
2273	data->flags = nfss->flags;
2274	data->rsize = nfss->rsize;
2275	data->wsize = nfss->wsize;
2276	data->retrans = nfss->client->cl_timeout->to_retries;
2277	data->selected_flavor = nfss->client->cl_auth->au_flavor;
2278	data->acregmin = nfss->acregmin / HZ;
2279	data->acregmax = nfss->acregmax / HZ;
2280	data->acdirmin = nfss->acdirmin / HZ;
2281	data->acdirmax = nfss->acdirmax / HZ;
2282	data->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ;
2283	data->nfs_server.port = nfss->port;
2284	data->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
2285	data->version = nfsvers;
2286	data->minorversion = nfss->nfs_client->cl_minorversion;
2287	data->net = current->nsproxy->net_ns;
2288	memcpy(&data->nfs_server.address, &nfss->nfs_client->cl_addr,
2289		data->nfs_server.addrlen);
2290
2291	/* overwrite those values with any that were specified */
2292	error = -EINVAL;
2293	if (!nfs_parse_mount_options((char *)options, data))
2294		goto out;
2295
2296	/*
2297	 * noac is a special case. It implies -o sync, but that's not
2298	 * necessarily reflected in the mtab options. do_remount_sb
2299	 * will clear SB_SYNCHRONOUS if -o sync wasn't specified in the
2300	 * remount options, so we have to explicitly reset it.
2301	 */
2302	if (data->flags & NFS_MOUNT_NOAC)
2303		*flags |= SB_SYNCHRONOUS;
 
 
2304
2305	/* compare new mount options with old ones */
2306	error = nfs_compare_remount_data(nfss, data);
2307out:
2308	kfree(data);
2309	return error;
2310}
2311EXPORT_SYMBOL_GPL(nfs_remount);
2312
2313/*
2314 * Initialise the common bits of the superblock
2315 */
2316static void nfs_initialise_sb(struct super_block *sb)
2317{
2318	struct nfs_server *server = NFS_SB(sb);
2319
2320	sb->s_magic = NFS_SUPER_MAGIC;
2321
2322	/* We probably want something more informative here */
2323	snprintf(sb->s_id, sizeof(sb->s_id),
2324		 "%u:%u", MAJOR(sb->s_dev), MINOR(sb->s_dev));
2325
2326	if (sb->s_blocksize == 0)
2327		sb->s_blocksize = nfs_block_bits(server->wsize,
2328						 &sb->s_blocksize_bits);
2329
2330	nfs_super_set_maxbytes(sb, server->maxfilesize);
2331}
2332
2333/*
2334 * Finish setting up an NFS2/3 superblock
2335 */
2336void nfs_fill_super(struct super_block *sb, struct nfs_mount_info *mount_info)
2337{
2338	struct nfs_parsed_mount_data *data = mount_info->parsed;
2339	struct nfs_server *server = NFS_SB(sb);
2340
2341	sb->s_blocksize_bits = 0;
2342	sb->s_blocksize = 0;
2343	sb->s_xattr = server->nfs_client->cl_nfs_mod->xattr;
2344	sb->s_op = server->nfs_client->cl_nfs_mod->sops;
2345	if (data && data->bsize)
2346		sb->s_blocksize = nfs_block_size(data->bsize, &sb->s_blocksize_bits);
2347
2348	if (server->nfs_client->rpc_ops->version != 2) {
2349		/* The VFS shouldn't apply the umask to mode bits. We will do
2350		 * so ourselves when necessary.
2351		 */
2352		sb->s_flags |= SB_POSIXACL;
2353		sb->s_time_gran = 1;
2354		sb->s_export_op = &nfs_export_ops;
2355	}
 
2356
2357 	nfs_initialise_sb(sb);
2358}
2359EXPORT_SYMBOL_GPL(nfs_fill_super);
 
 
 
 
2360
2361/*
2362 * Finish setting up a cloned NFS2/3/4 superblock
2363 */
2364static void nfs_clone_super(struct super_block *sb,
2365			    struct nfs_mount_info *mount_info)
2366{
2367	const struct super_block *old_sb = mount_info->cloned->sb;
2368	struct nfs_server *server = NFS_SB(sb);
2369
2370	sb->s_blocksize_bits = old_sb->s_blocksize_bits;
2371	sb->s_blocksize = old_sb->s_blocksize;
2372	sb->s_maxbytes = old_sb->s_maxbytes;
2373	sb->s_xattr = old_sb->s_xattr;
2374	sb->s_op = old_sb->s_op;
2375	sb->s_time_gran = 1;
2376	sb->s_export_op = old_sb->s_export_op;
2377
2378	if (server->nfs_client->rpc_ops->version != 2) {
2379		/* The VFS shouldn't apply the umask to mode bits. We will do
2380		 * so ourselves when necessary.
2381		 */
2382		sb->s_flags |= SB_POSIXACL;
2383	}
2384
2385 	nfs_initialise_sb(sb);
2386}
2387
2388static int nfs_compare_mount_options(const struct super_block *s, const struct nfs_server *b, int flags)
 
2389{
2390	const struct nfs_server *a = s->s_fs_info;
2391	const struct rpc_clnt *clnt_a = a->client;
2392	const struct rpc_clnt *clnt_b = b->client;
2393
2394	if ((s->s_flags & NFS_MS_MASK) != (flags & NFS_MS_MASK))
2395		goto Ebusy;
2396	if (a->nfs_client != b->nfs_client)
2397		goto Ebusy;
2398	if ((a->flags ^ b->flags) & NFS_MOUNT_CMP_FLAGMASK)
2399		goto Ebusy;
2400	if (a->wsize != b->wsize)
2401		goto Ebusy;
2402	if (a->rsize != b->rsize)
2403		goto Ebusy;
2404	if (a->acregmin != b->acregmin)
2405		goto Ebusy;
2406	if (a->acregmax != b->acregmax)
2407		goto Ebusy;
2408	if (a->acdirmin != b->acdirmin)
2409		goto Ebusy;
2410	if (a->acdirmax != b->acdirmax)
2411		goto Ebusy;
2412	if (b->auth_info.flavor_len > 0 &&
2413	   clnt_a->cl_auth->au_flavor != clnt_b->cl_auth->au_flavor)
2414		goto Ebusy;
2415	return 1;
2416Ebusy:
2417	return 0;
2418}
2419
2420struct nfs_sb_mountdata {
2421	struct nfs_server *server;
2422	int mntflags;
2423};
2424
2425static int nfs_set_super(struct super_block *s, void *data)
2426{
2427	struct nfs_sb_mountdata *sb_mntdata = data;
2428	struct nfs_server *server = sb_mntdata->server;
2429	int ret;
2430
2431	s->s_flags = sb_mntdata->mntflags;
2432	s->s_fs_info = server;
2433	s->s_d_op = server->nfs_client->rpc_ops->dentry_ops;
2434	ret = set_anon_super(s, server);
2435	if (ret == 0)
2436		server->s_dev = s->s_dev;
2437	return ret;
2438}
2439
2440static int nfs_compare_super_address(struct nfs_server *server1,
2441				     struct nfs_server *server2)
2442{
2443	struct sockaddr *sap1, *sap2;
2444	struct rpc_xprt *xprt1 = server1->client->cl_xprt;
2445	struct rpc_xprt *xprt2 = server2->client->cl_xprt;
2446
2447	if (!net_eq(xprt1->xprt_net, xprt2->xprt_net))
2448		return 0;
2449
2450	sap1 = (struct sockaddr *)&server1->nfs_client->cl_addr;
2451	sap2 = (struct sockaddr *)&server2->nfs_client->cl_addr;
2452
2453	if (sap1->sa_family != sap2->sa_family)
2454		return 0;
2455
2456	switch (sap1->sa_family) {
2457	case AF_INET: {
2458		struct sockaddr_in *sin1 = (struct sockaddr_in *)sap1;
2459		struct sockaddr_in *sin2 = (struct sockaddr_in *)sap2;
2460		if (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr)
2461			return 0;
2462		if (sin1->sin_port != sin2->sin_port)
2463			return 0;
2464		break;
2465	}
2466	case AF_INET6: {
2467		struct sockaddr_in6 *sin1 = (struct sockaddr_in6 *)sap1;
2468		struct sockaddr_in6 *sin2 = (struct sockaddr_in6 *)sap2;
2469		if (!ipv6_addr_equal(&sin1->sin6_addr, &sin2->sin6_addr))
2470			return 0;
2471		if (sin1->sin6_port != sin2->sin6_port)
2472			return 0;
2473		break;
2474	}
2475	default:
2476		return 0;
2477	}
2478
2479	return 1;
2480}
2481
2482static int nfs_compare_super(struct super_block *sb, void *data)
 
2483{
2484	struct nfs_sb_mountdata *sb_mntdata = data;
2485	struct nfs_server *server = sb_mntdata->server, *old = NFS_SB(sb);
2486	int mntflags = sb_mntdata->mntflags;
 
 
 
 
 
 
 
 
 
 
 
 
2487
2488	if (!nfs_compare_super_address(old, server))
2489		return 0;
2490	/* Note: NFS_MOUNT_UNSHARED == NFS4_MOUNT_UNSHARED */
2491	if (old->flags & NFS_MOUNT_UNSHARED)
2492		return 0;
2493	if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0)
2494		return 0;
2495	return nfs_compare_mount_options(sb, server, mntflags);
 
 
2496}
2497
2498#ifdef CONFIG_NFS_FSCACHE
2499static void nfs_get_cache_cookie(struct super_block *sb,
2500				 struct nfs_parsed_mount_data *parsed,
2501				 struct nfs_clone_mount *cloned)
2502{
2503	struct nfs_server *nfss = NFS_SB(sb);
2504	char *uniq = NULL;
2505	int ulen = 0;
2506
2507	nfss->fscache_key = NULL;
2508	nfss->fscache = NULL;
2509
2510	if (parsed) {
2511		if (!(parsed->options & NFS_OPTION_FSCACHE))
2512			return;
2513		if (parsed->fscache_uniq) {
2514			uniq = parsed->fscache_uniq;
2515			ulen = strlen(parsed->fscache_uniq);
2516		}
2517	} else if (cloned) {
2518		struct nfs_server *mnt_s = NFS_SB(cloned->sb);
2519		if (!(mnt_s->options & NFS_OPTION_FSCACHE))
2520			return;
2521		if (mnt_s->fscache_key) {
2522			uniq = mnt_s->fscache_key->key.uniquifier;
2523			ulen = mnt_s->fscache_key->key.uniq_len;
2524		};
2525	} else
2526		return;
 
 
 
 
 
 
2527
2528	nfs_fscache_get_super_cookie(sb, uniq, ulen);
2529}
2530#else
2531static void nfs_get_cache_cookie(struct super_block *sb,
2532				 struct nfs_parsed_mount_data *parsed,
2533				 struct nfs_clone_mount *cloned)
2534{
2535}
2536#endif
2537
2538int nfs_set_sb_security(struct super_block *s, struct dentry *mntroot,
2539			struct nfs_mount_info *mount_info)
2540{
2541	int error;
2542	unsigned long kflags = 0, kflags_out = 0;
2543	if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL)
2544		kflags |= SECURITY_LSM_NATIVE_LABELS;
2545
2546	error = security_sb_set_mnt_opts(s, &mount_info->parsed->lsm_opts,
2547						kflags, &kflags_out);
2548	if (error)
2549		goto err;
2550
2551	if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL &&
2552		!(kflags_out & SECURITY_LSM_NATIVE_LABELS))
2553		NFS_SB(s)->caps &= ~NFS_CAP_SECURITY_LABEL;
2554err:
2555	return error;
2556}
2557EXPORT_SYMBOL_GPL(nfs_set_sb_security);
2558
2559int nfs_clone_sb_security(struct super_block *s, struct dentry *mntroot,
2560			  struct nfs_mount_info *mount_info)
2561{
2562	int error;
2563	unsigned long kflags = 0, kflags_out = 0;
2564
2565	/* clone any lsm security options from the parent to the new sb */
2566	if (d_inode(mntroot)->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops)
2567		return -ESTALE;
2568
2569	if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL)
2570		kflags |= SECURITY_LSM_NATIVE_LABELS;
2571
2572	error = security_sb_clone_mnt_opts(mount_info->cloned->sb, s, kflags,
2573			&kflags_out);
2574	if (error)
2575		return error;
2576
2577	if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL &&
2578		!(kflags_out & SECURITY_LSM_NATIVE_LABELS))
2579		NFS_SB(s)->caps &= ~NFS_CAP_SECURITY_LABEL;
2580	return 0;
2581}
2582EXPORT_SYMBOL_GPL(nfs_clone_sb_security);
2583
2584struct dentry *nfs_fs_mount_common(struct nfs_server *server,
2585				   int flags, const char *dev_name,
2586				   struct nfs_mount_info *mount_info,
2587				   struct nfs_subversion *nfs_mod)
2588{
 
2589	struct super_block *s;
2590	struct dentry *mntroot = ERR_PTR(-ENOMEM);
2591	int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
2592	struct nfs_sb_mountdata sb_mntdata = {
2593		.mntflags = flags,
2594		.server = server,
2595	};
2596	int error;
2597
 
 
 
 
2598	if (server->flags & NFS_MOUNT_UNSHARED)
2599		compare_super = NULL;
2600
2601	/* -o noac implies -o sync */
2602	if (server->flags & NFS_MOUNT_NOAC)
2603		sb_mntdata.mntflags |= SB_SYNCHRONOUS;
2604
2605	if (mount_info->cloned != NULL && mount_info->cloned->sb != NULL)
2606		if (mount_info->cloned->sb->s_flags & SB_SYNCHRONOUS)
2607			sb_mntdata.mntflags |= SB_SYNCHRONOUS;
 
 
 
2608
2609	/* Get a superblock - note that we may end up sharing one that already exists */
2610	s = sget(nfs_mod->nfs_fs, compare_super, nfs_set_super, flags, &sb_mntdata);
 
 
2611	if (IS_ERR(s)) {
2612		mntroot = ERR_CAST(s);
 
2613		goto out_err_nosb;
2614	}
2615
2616	if (s->s_fs_info != server) {
2617		nfs_free_server(server);
2618		server = NULL;
2619	} else {
2620		error = super_setup_bdi_name(s, "%u:%u", MAJOR(server->s_dev),
2621					     MINOR(server->s_dev));
2622		if (error) {
2623			mntroot = ERR_PTR(error);
2624			goto error_splat_super;
2625		}
2626		s->s_bdi->ra_pages = server->rpages * NFS_MAX_READAHEAD;
2627		server->super = s;
2628	}
2629
2630	if (!s->s_root) {
 
2631		/* initial superblock/root creation */
2632		mount_info->fill_super(s, mount_info);
2633		nfs_get_cache_cookie(s, mount_info->parsed, mount_info->cloned);
2634		if (!(server->flags & NFS_MOUNT_UNSHARED))
2635			s->s_iflags |= SB_I_MULTIROOT;
 
 
2636	}
2637
2638	mntroot = nfs_get_root(s, mount_info->mntfh, dev_name);
2639	if (IS_ERR(mntroot))
 
2640		goto error_splat_super;
2641
2642	error = mount_info->set_security(s, mntroot, mount_info);
2643	if (error)
2644		goto error_splat_root;
2645
2646	s->s_flags |= SB_ACTIVE;
 
2647
2648out:
2649	return mntroot;
2650
2651out_err_nosb:
2652	nfs_free_server(server);
2653	goto out;
2654
2655error_splat_root:
2656	dput(mntroot);
2657	mntroot = ERR_PTR(error);
2658error_splat_super:
2659	deactivate_locked_super(s);
2660	goto out;
2661}
2662EXPORT_SYMBOL_GPL(nfs_fs_mount_common);
2663
2664struct dentry *nfs_fs_mount(struct file_system_type *fs_type,
2665	int flags, const char *dev_name, void *raw_data)
2666{
2667	struct nfs_mount_info mount_info = {
2668		.fill_super = nfs_fill_super,
2669		.set_security = nfs_set_sb_security,
2670	};
2671	struct dentry *mntroot = ERR_PTR(-ENOMEM);
2672	struct nfs_subversion *nfs_mod;
2673	int error;
2674
2675	mount_info.parsed = nfs_alloc_parsed_mount_data();
2676	mount_info.mntfh = nfs_alloc_fhandle();
2677	if (mount_info.parsed == NULL || mount_info.mntfh == NULL)
2678		goto out;
2679
2680	/* Validate the mount data */
2681	error = nfs_validate_mount_data(fs_type, raw_data, mount_info.parsed, mount_info.mntfh, dev_name);
2682	if (error == NFS_TEXT_DATA)
2683		error = nfs_validate_text_mount_data(raw_data, mount_info.parsed, dev_name);
2684	if (error < 0) {
2685		mntroot = ERR_PTR(error);
2686		goto out;
2687	}
2688
2689	nfs_mod = get_nfs_version(mount_info.parsed->version);
2690	if (IS_ERR(nfs_mod)) {
2691		mntroot = ERR_CAST(nfs_mod);
2692		goto out;
2693	}
2694
2695	mntroot = nfs_mod->rpc_ops->try_mount(flags, dev_name, &mount_info, nfs_mod);
2696
2697	put_nfs_version(nfs_mod);
2698out:
2699	nfs_free_parsed_mount_data(mount_info.parsed);
2700	nfs_free_fhandle(mount_info.mntfh);
2701	return mntroot;
2702}
2703EXPORT_SYMBOL_GPL(nfs_fs_mount);
2704
2705/*
2706 * Destroy an NFS2/3 superblock
2707 */
2708void nfs_kill_super(struct super_block *s)
2709{
2710	struct nfs_server *server = NFS_SB(s);
2711	dev_t dev = s->s_dev;
2712
2713	generic_shutdown_super(s);
2714
2715	nfs_fscache_release_super_cookie(s);
2716
2717	nfs_free_server(server);
2718	free_anon_bdev(dev);
2719}
2720EXPORT_SYMBOL_GPL(nfs_kill_super);
2721
2722/*
2723 * Clone an NFS2/3/4 server record on xdev traversal (FSID-change)
2724 */
2725static struct dentry *
2726nfs_xdev_mount(struct file_system_type *fs_type, int flags,
2727		const char *dev_name, void *raw_data)
2728{
2729	struct nfs_clone_mount *data = raw_data;
2730	struct nfs_mount_info mount_info = {
2731		.fill_super = nfs_clone_super,
2732		.set_security = nfs_clone_sb_security,
2733		.cloned = data,
2734	};
2735	struct nfs_server *server;
2736	struct dentry *mntroot = ERR_PTR(-ENOMEM);
2737	struct nfs_subversion *nfs_mod = NFS_SB(data->sb)->nfs_client->cl_nfs_mod;
2738
2739	dprintk("--> nfs_xdev_mount()\n");
2740
2741	mount_info.mntfh = mount_info.cloned->fh;
2742
2743	/* create a new volume representation */
2744	server = nfs_mod->rpc_ops->clone_server(NFS_SB(data->sb), data->fh, data->fattr, data->authflavor);
2745
2746	if (IS_ERR(server))
2747		mntroot = ERR_CAST(server);
2748	else
2749		mntroot = nfs_fs_mount_common(server, flags,
2750				dev_name, &mount_info, nfs_mod);
2751
2752	dprintk("<-- nfs_xdev_mount() = %ld\n",
2753			IS_ERR(mntroot) ? PTR_ERR(mntroot) : 0L);
2754	return mntroot;
2755}
2756
2757#if IS_ENABLED(CONFIG_NFS_V4)
2758
2759static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args)
2760{
2761	args->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3|
2762			 NFS_MOUNT_LOCAL_FLOCK|NFS_MOUNT_LOCAL_FCNTL);
2763}
2764
2765/*
2766 * Validate NFSv4 mount options
2767 */
2768static int nfs4_validate_mount_data(void *options,
2769				    struct nfs_parsed_mount_data *args,
2770				    const char *dev_name)
2771{
2772	struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
2773	struct nfs4_mount_data *data = (struct nfs4_mount_data *)options;
2774	char *c;
2775
2776	if (data == NULL)
2777		goto out_no_data;
2778
2779	args->version = 4;
2780
2781	switch (data->version) {
2782	case 1:
2783		if (data->host_addrlen > sizeof(args->nfs_server.address))
2784			goto out_no_address;
2785		if (data->host_addrlen == 0)
2786			goto out_no_address;
2787		args->nfs_server.addrlen = data->host_addrlen;
2788		if (copy_from_user(sap, data->host_addr, data->host_addrlen))
2789			return -EFAULT;
2790		if (!nfs_verify_server_address(sap))
2791			goto out_no_address;
2792		args->nfs_server.port = ntohs(((struct sockaddr_in *)sap)->sin_port);
2793
2794		if (data->auth_flavourlen) {
2795			rpc_authflavor_t pseudoflavor;
2796			if (data->auth_flavourlen > 1)
2797				goto out_inval_auth;
2798			if (copy_from_user(&pseudoflavor,
2799					   data->auth_flavours,
2800					   sizeof(pseudoflavor)))
2801				return -EFAULT;
2802			args->selected_flavor = pseudoflavor;
2803		} else
2804			args->selected_flavor = RPC_AUTH_UNIX;
2805
2806		c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
2807		if (IS_ERR(c))
2808			return PTR_ERR(c);
2809		args->nfs_server.hostname = c;
2810
2811		c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN);
2812		if (IS_ERR(c))
2813			return PTR_ERR(c);
2814		args->nfs_server.export_path = c;
2815		dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c);
2816
2817		c = strndup_user(data->client_addr.data, 16);
2818		if (IS_ERR(c))
2819			return PTR_ERR(c);
2820		args->client_address = c;
2821
2822		/*
2823		 * Translate to nfs_parsed_mount_data, which nfs4_fill_super
2824		 * can deal with.
2825		 */
2826
2827		args->flags	= data->flags & NFS4_MOUNT_FLAGMASK;
2828		args->rsize	= data->rsize;
2829		args->wsize	= data->wsize;
2830		args->timeo	= data->timeo;
2831		args->retrans	= data->retrans;
2832		args->acregmin	= data->acregmin;
2833		args->acregmax	= data->acregmax;
2834		args->acdirmin	= data->acdirmin;
2835		args->acdirmax	= data->acdirmax;
2836		args->nfs_server.protocol = data->proto;
2837		nfs_validate_transport_protocol(args);
2838		if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP)
2839			goto out_invalid_transport_udp;
2840
2841		break;
2842	default:
2843		return NFS_TEXT_DATA;
2844	}
2845
2846	return 0;
2847
2848out_no_data:
2849	dfprintk(MOUNT, "NFS4: mount program didn't pass any mount data\n");
2850	return -EINVAL;
2851
2852out_inval_auth:
2853	dfprintk(MOUNT, "NFS4: Invalid number of RPC auth flavours %d\n",
2854		 data->auth_flavourlen);
2855	return -EINVAL;
2856
2857out_no_address:
2858	dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n");
2859	return -EINVAL;
2860
2861out_invalid_transport_udp:
2862	dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
2863	return -EINVAL;
2864}
2865
2866/*
2867 * NFS v4 module parameters need to stay in the
2868 * NFS client for backwards compatibility
2869 */
2870unsigned int nfs_callback_set_tcpport;
2871unsigned short nfs_callback_nr_threads;
2872/* Default cache timeout is 10 minutes */
2873unsigned int nfs_idmap_cache_timeout = 600;
2874/* Turn off NFSv4 uid/gid mapping when using AUTH_SYS */
2875bool nfs4_disable_idmapping = true;
2876unsigned short max_session_slots = NFS4_DEF_SLOT_TABLE_SIZE;
2877unsigned short max_session_cb_slots = NFS4_DEF_CB_SLOT_TABLE_SIZE;
2878unsigned short send_implementation_id = 1;
2879char nfs4_client_id_uniquifier[NFS4_CLIENT_ID_UNIQ_LEN] = "";
2880bool recover_lost_locks = false;
2881
2882EXPORT_SYMBOL_GPL(nfs_callback_nr_threads);
2883EXPORT_SYMBOL_GPL(nfs_callback_set_tcpport);
2884EXPORT_SYMBOL_GPL(nfs_idmap_cache_timeout);
2885EXPORT_SYMBOL_GPL(nfs4_disable_idmapping);
2886EXPORT_SYMBOL_GPL(max_session_slots);
2887EXPORT_SYMBOL_GPL(max_session_cb_slots);
2888EXPORT_SYMBOL_GPL(send_implementation_id);
2889EXPORT_SYMBOL_GPL(nfs4_client_id_uniquifier);
2890EXPORT_SYMBOL_GPL(recover_lost_locks);
2891
2892#define NFS_CALLBACK_MAXPORTNR (65535U)
2893
2894static int param_set_portnr(const char *val, const struct kernel_param *kp)
2895{
2896	unsigned long num;
2897	int ret;
2898
2899	if (!val)
2900		return -EINVAL;
2901	ret = kstrtoul(val, 0, &num);
2902	if (ret == -EINVAL || num > NFS_CALLBACK_MAXPORTNR)
2903		return -EINVAL;
2904	*((unsigned int *)kp->arg) = num;
2905	return 0;
2906}
2907static const struct kernel_param_ops param_ops_portnr = {
2908	.set = param_set_portnr,
2909	.get = param_get_uint,
2910};
2911#define param_check_portnr(name, p) __param_check(name, p, unsigned int);
2912
2913module_param_named(callback_tcpport, nfs_callback_set_tcpport, portnr, 0644);
2914module_param_named(callback_nr_threads, nfs_callback_nr_threads, ushort, 0644);
2915MODULE_PARM_DESC(callback_nr_threads, "Number of threads that will be "
2916		"assigned to the NFSv4 callback channels.");
2917module_param(nfs_idmap_cache_timeout, int, 0644);
2918module_param(nfs4_disable_idmapping, bool, 0644);
2919module_param_string(nfs4_unique_id, nfs4_client_id_uniquifier,
2920			NFS4_CLIENT_ID_UNIQ_LEN, 0600);
2921MODULE_PARM_DESC(nfs4_disable_idmapping,
2922		"Turn off NFSv4 idmapping when using 'sec=sys'");
2923module_param(max_session_slots, ushort, 0644);
2924MODULE_PARM_DESC(max_session_slots, "Maximum number of outstanding NFSv4.1 "
2925		"requests the client will negotiate");
2926module_param(max_session_cb_slots, ushort, 0644);
2927MODULE_PARM_DESC(max_session_cb_slots, "Maximum number of parallel NFSv4.1 "
2928		"callbacks the client will process for a given server");
2929module_param(send_implementation_id, ushort, 0644);
2930MODULE_PARM_DESC(send_implementation_id,
2931		"Send implementation ID with NFSv4.1 exchange_id");
2932MODULE_PARM_DESC(nfs4_unique_id, "nfs_client_id4 uniquifier string");
2933
2934module_param(recover_lost_locks, bool, 0644);
2935MODULE_PARM_DESC(recover_lost_locks,
2936		 "If the server reports that a lock might be lost, "
2937		 "try to recover it risking data corruption.");
2938
2939
2940#endif /* CONFIG_NFS_V4 */