super.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 *  linux/fs/nfs/super.c
   4 *
   5 *  Copyright (C) 1992  Rick Sladkey
   6 *
   7 *  nfs superblock handling functions
   8 *
   9 *  Modularised by Alan Cox <alan@lxorguk.ukuu.org.uk>, while hacking some
  10 *  experimental NFS changes. Modularisation taken straight from SYS5 fs.
  11 *
  12 *  Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
  13 *  J.S.Peatfield@damtp.cam.ac.uk
  14 *
  15 *  Split from inode.c by David Howells <dhowells@redhat.com>
  16 *
  17 * - superblocks are indexed on server only - all inodes, dentries, etc. associated with a
  18 *   particular server are held in the same superblock
  19 * - NFS superblocks can have several effective roots to the dentry tree
  20 * - directory type roots are spliced into the tree when a path from one root reaches the root
  21 *   of another (see nfs_lookup())
  22 */
  23
  24#include <linux/module.h>
  25#include <linux/init.h>
  26
  27#include <linux/time.h>
  28#include <linux/kernel.h>
  29#include <linux/mm.h>
  30#include <linux/string.h>
  31#include <linux/stat.h>
  32#include <linux/errno.h>
  33#include <linux/unistd.h>
  34#include <linux/sunrpc/clnt.h>
  35#include <linux/sunrpc/addr.h>
  36#include <linux/sunrpc/stats.h>
  37#include <linux/sunrpc/metrics.h>
  38#include <linux/sunrpc/xprtsock.h>
  39#include <linux/sunrpc/xprtrdma.h>
  40#include <linux/nfs_fs.h>
  41#include <linux/nfs_mount.h>
  42#include <linux/nfs4_mount.h>
  43#include <linux/lockd/bind.h>
  44#include <linux/seq_file.h>
  45#include <linux/mount.h>
  46#include <linux/namei.h>
  47#include <linux/vfs.h>
  48#include <linux/inet.h>
  49#include <linux/in6.h>
  50#include <linux/sched.h>
  51#include <linux/slab.h>
  52#include <net/ipv6.h>
  53#include <linux/netdevice.h>
  54#include <linux/nfs_xdr.h>
  55#include <linux/magic.h>
  56#include <linux/parser.h>
  57#include <linux/nsproxy.h>
  58#include <linux/rcupdate.h>
  59
  60#include <linux/uaccess.h>
  61#include <linux/nfs_ssc.h>
  62
  63#include <uapi/linux/tls.h>
  64
  65#include "nfs4_fs.h"
  66#include "callback.h"
  67#include "delegation.h"
  68#include "iostat.h"
  69#include "internal.h"
  70#include "fscache.h"
  71#include "nfs4session.h"
  72#include "pnfs.h"
  73#include "nfs.h"
  74#include "netns.h"
  75#include "sysfs.h"
  76#include "nfs4idmap.h"
  77
  78#define NFSDBG_FACILITY		NFSDBG_VFS
  79
  80const struct super_operations nfs_sops = {
  81	.alloc_inode	= nfs_alloc_inode,
  82	.free_inode	= nfs_free_inode,
  83	.write_inode	= nfs_write_inode,
  84	.drop_inode	= nfs_drop_inode,
  85	.statfs		= nfs_statfs,
  86	.evict_inode	= nfs_evict_inode,
  87	.umount_begin	= nfs_umount_begin,
  88	.show_options	= nfs_show_options,
  89	.show_devname	= nfs_show_devname,
  90	.show_path	= nfs_show_path,
  91	.show_stats	= nfs_show_stats,
  92};
  93EXPORT_SYMBOL_GPL(nfs_sops);
  94
  95#ifdef CONFIG_NFS_V4_2
  96static const struct nfs_ssc_client_ops nfs_ssc_clnt_ops_tbl = {
  97	.sco_sb_deactive = nfs_sb_deactive,
  98};
  99#endif
 100
 101#if IS_ENABLED(CONFIG_NFS_V4)
 102static int __init register_nfs4_fs(void)
 103{
 104	return register_filesystem(&nfs4_fs_type);
 105}
 106
 107static void unregister_nfs4_fs(void)
 108{
 109	unregister_filesystem(&nfs4_fs_type);
 110}
 111#else
 112static int __init register_nfs4_fs(void)
 113{
 114	return 0;
 115}
 116
 117static void unregister_nfs4_fs(void)
 118{
 119}
 120#endif
 121
 122#ifdef CONFIG_NFS_V4_2
 123static void nfs_ssc_register_ops(void)
 124{
 125	nfs_ssc_register(&nfs_ssc_clnt_ops_tbl);
 126}
 127
 128static void nfs_ssc_unregister_ops(void)
 129{
 130	nfs_ssc_unregister(&nfs_ssc_clnt_ops_tbl);
 131}
 132#endif /* CONFIG_NFS_V4_2 */
 133
 134static struct shrinker *acl_shrinker;
 135
 136/*
 137 * Register the NFS filesystems
 138 */
 139int __init register_nfs_fs(void)
 140{
 141	int ret;
 142
 143        ret = register_filesystem(&nfs_fs_type);
 144	if (ret < 0)
 145		goto error_0;
 146
 147	ret = register_nfs4_fs();
 148	if (ret < 0)
 149		goto error_1;
 150
 151	ret = nfs_register_sysctl();
 152	if (ret < 0)
 153		goto error_2;
 154
 155	acl_shrinker = shrinker_alloc(0, "nfs-acl");
 156	if (!acl_shrinker) {
 157		ret = -ENOMEM;
 158		goto error_3;
 159	}
 160
 161	acl_shrinker->count_objects = nfs_access_cache_count;
 162	acl_shrinker->scan_objects = nfs_access_cache_scan;
 163
 164	shrinker_register(acl_shrinker);
 165
 166#ifdef CONFIG_NFS_V4_2
 167	nfs_ssc_register_ops();
 168#endif
 169	return 0;
 170error_3:
 171	nfs_unregister_sysctl();
 172error_2:
 173	unregister_nfs4_fs();
 174error_1:
 175	unregister_filesystem(&nfs_fs_type);
 176error_0:
 177	return ret;
 178}
 179
 180/*
 181 * Unregister the NFS filesystems
 182 */
 183void __exit unregister_nfs_fs(void)
 184{
 185	shrinker_free(acl_shrinker);
 186	nfs_unregister_sysctl();
 187	unregister_nfs4_fs();
 188#ifdef CONFIG_NFS_V4_2
 189	nfs_ssc_unregister_ops();
 190#endif
 191	unregister_filesystem(&nfs_fs_type);
 192}
 193
 194bool nfs_sb_active(struct super_block *sb)
 195{
 196	struct nfs_server *server = NFS_SB(sb);
 197
 198	if (!atomic_inc_not_zero(&sb->s_active))
 199		return false;
 200	if (atomic_inc_return(&server->active) != 1)
 201		atomic_dec(&sb->s_active);
 202	return true;
 203}
 204EXPORT_SYMBOL_GPL(nfs_sb_active);
 205
 206void nfs_sb_deactive(struct super_block *sb)
 207{
 208	struct nfs_server *server = NFS_SB(sb);
 209
 210	if (atomic_dec_and_test(&server->active))
 211		deactivate_super(sb);
 212}
 213EXPORT_SYMBOL_GPL(nfs_sb_deactive);
 214
 215static int __nfs_list_for_each_server(struct list_head *head,
 216		int (*fn)(struct nfs_server *, void *),
 217		void *data)
 218{
 219	struct nfs_server *server, *last = NULL;
 220	int ret = 0;
 221
 222	rcu_read_lock();
 223	list_for_each_entry_rcu(server, head, client_link) {
 224		if (!(server->super && nfs_sb_active(server->super)))
 225			continue;
 226		rcu_read_unlock();
 227		if (last)
 228			nfs_sb_deactive(last->super);
 229		last = server;
 230		ret = fn(server, data);
 231		if (ret)
 232			goto out;
 233		cond_resched();
 234		rcu_read_lock();
 235	}
 236	rcu_read_unlock();
 237out:
 238	if (last)
 239		nfs_sb_deactive(last->super);
 240	return ret;
 241}
 242
 243int nfs_client_for_each_server(struct nfs_client *clp,
 244		int (*fn)(struct nfs_server *, void *),
 245		void *data)
 246{
 247	return __nfs_list_for_each_server(&clp->cl_superblocks, fn, data);
 248}
 249EXPORT_SYMBOL_GPL(nfs_client_for_each_server);
 250
 251/*
 252 * Deliver file system statistics to userspace
 253 */
 254int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 255{
 256	struct nfs_server *server = NFS_SB(dentry->d_sb);
 257	unsigned char blockbits;
 258	unsigned long blockres;
 259	struct nfs_fh *fh = NFS_FH(d_inode(dentry));
 260	struct nfs_fsstat res;
 261	int error = -ENOMEM;
 262
 263	res.fattr = nfs_alloc_fattr();
 264	if (res.fattr == NULL)
 265		goto out_err;
 266
 267	error = server->nfs_client->rpc_ops->statfs(server, fh, &res);
 268	if (unlikely(error == -ESTALE)) {
 269		struct dentry *pd_dentry;
 270
 271		pd_dentry = dget_parent(dentry);
 272		nfs_zap_caches(d_inode(pd_dentry));
 273		dput(pd_dentry);
 274	}
 275	nfs_free_fattr(res.fattr);
 276	if (error < 0)
 277		goto out_err;
 278
 279	buf->f_type = NFS_SUPER_MAGIC;
 280
 281	/*
 282	 * Current versions of glibc do not correctly handle the
 283	 * case where f_frsize != f_bsize.  Eventually we want to
 284	 * report the value of wtmult in this field.
 285	 */
 286	buf->f_frsize = dentry->d_sb->s_blocksize;
 287
 288	/*
 289	 * On most *nix systems, f_blocks, f_bfree, and f_bavail
 290	 * are reported in units of f_frsize.  Linux hasn't had
 291	 * an f_frsize field in its statfs struct until recently,
 292	 * thus historically Linux's sys_statfs reports these
 293	 * fields in units of f_bsize.
 294	 */
 295	buf->f_bsize = dentry->d_sb->s_blocksize;
 296	blockbits = dentry->d_sb->s_blocksize_bits;
 297	blockres = (1 << blockbits) - 1;
 298	buf->f_blocks = (res.tbytes + blockres) >> blockbits;
 299	buf->f_bfree = (res.fbytes + blockres) >> blockbits;
 300	buf->f_bavail = (res.abytes + blockres) >> blockbits;
 301
 302	buf->f_files = res.tfiles;
 303	buf->f_ffree = res.afiles;
 304
 305	buf->f_namelen = server->namelen;
 306
 307	return 0;
 308
 309 out_err:
 310	dprintk("%s: statfs error = %d\n", __func__, -error);
 311	return error;
 312}
 313EXPORT_SYMBOL_GPL(nfs_statfs);
 314
 315/*
 316 * Map the security flavour number to a name
 317 */
 318static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour)
 319{
 320	static const struct {
 321		rpc_authflavor_t flavour;
 322		const char *str;
 323	} sec_flavours[NFS_AUTH_INFO_MAX_FLAVORS] = {
 324		/* update NFS_AUTH_INFO_MAX_FLAVORS when this list changes! */
 325		{ RPC_AUTH_NULL, "null" },
 326		{ RPC_AUTH_UNIX, "sys" },
 327		{ RPC_AUTH_GSS_KRB5, "krb5" },
 328		{ RPC_AUTH_GSS_KRB5I, "krb5i" },
 329		{ RPC_AUTH_GSS_KRB5P, "krb5p" },
 330		{ RPC_AUTH_GSS_LKEY, "lkey" },
 331		{ RPC_AUTH_GSS_LKEYI, "lkeyi" },
 332		{ RPC_AUTH_GSS_LKEYP, "lkeyp" },
 333		{ RPC_AUTH_GSS_SPKM, "spkm" },
 334		{ RPC_AUTH_GSS_SPKMI, "spkmi" },
 335		{ RPC_AUTH_GSS_SPKMP, "spkmp" },
 336		{ UINT_MAX, "unknown" }
 337	};
 338	int i;
 339
 340	for (i = 0; sec_flavours[i].flavour != UINT_MAX; i++) {
 341		if (sec_flavours[i].flavour == flavour)
 342			break;
 343	}
 344	return sec_flavours[i].str;
 345}
 346
 347static void nfs_show_mountd_netid(struct seq_file *m, struct nfs_server *nfss,
 348				  int showdefaults)
 349{
 350	struct sockaddr *sap = (struct sockaddr *) &nfss->mountd_address;
 351	char *proto = NULL;
 352
 353	switch (sap->sa_family) {
 354	case AF_INET:
 355		switch (nfss->mountd_protocol) {
 356		case IPPROTO_UDP:
 357			proto = RPCBIND_NETID_UDP;
 358			break;
 359		case IPPROTO_TCP:
 360			proto = RPCBIND_NETID_TCP;
 361			break;
 362		}
 363		break;
 364	case AF_INET6:
 365		switch (nfss->mountd_protocol) {
 366		case IPPROTO_UDP:
 367			proto = RPCBIND_NETID_UDP6;
 368			break;
 369		case IPPROTO_TCP:
 370			proto = RPCBIND_NETID_TCP6;
 371			break;
 372		}
 373		break;
 374	}
 375	if (proto || showdefaults)
 376		seq_printf(m, ",mountproto=%s", proto ?: "auto");
 377}
 378
 379static void nfs_show_mountd_options(struct seq_file *m, struct nfs_server *nfss,
 380				    int showdefaults)
 381{
 382	struct sockaddr *sap = (struct sockaddr *)&nfss->mountd_address;
 383
 384	if (nfss->flags & NFS_MOUNT_LEGACY_INTERFACE)
 385		return;
 386
 387	switch (sap->sa_family) {
 388	case AF_INET: {
 389		struct sockaddr_in *sin = (struct sockaddr_in *)sap;
 390		seq_printf(m, ",mountaddr=%pI4", &sin->sin_addr.s_addr);
 391		break;
 392	}
 393	case AF_INET6: {
 394		struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
 395		seq_printf(m, ",mountaddr=%pI6c", &sin6->sin6_addr);
 396		break;
 397	}
 398	default:
 399		if (showdefaults)
 400			seq_puts(m, ",mountaddr=unspecified");
 401	}
 402
 403	if (nfss->mountd_version || showdefaults)
 404		seq_printf(m, ",mountvers=%u", nfss->mountd_version);
 405	if ((nfss->mountd_port &&
 406		nfss->mountd_port != (unsigned short)NFS_UNSPEC_PORT) ||
 407		showdefaults)
 408		seq_printf(m, ",mountport=%u", nfss->mountd_port);
 409
 410	nfs_show_mountd_netid(m, nfss, showdefaults);
 411}
 412
 413#if IS_ENABLED(CONFIG_NFS_V4)
 414static void nfs_show_nfsv4_options(struct seq_file *m, struct nfs_server *nfss,
 415				    int showdefaults)
 416{
 417	struct nfs_client *clp = nfss->nfs_client;
 418
 419	seq_printf(m, ",clientaddr=%s", clp->cl_ipaddr);
 420}
 421#else
 422static void nfs_show_nfsv4_options(struct seq_file *m, struct nfs_server *nfss,
 423				    int showdefaults)
 424{
 425}
 426#endif
 427
 428static void nfs_show_nfs_version(struct seq_file *m,
 429		unsigned int version,
 430		unsigned int minorversion)
 431{
 432	seq_printf(m, ",vers=%u", version);
 433	if (version == 4)
 434		seq_printf(m, ".%u", minorversion);
 435}
 436
 437/*
 438 * Describe the mount options in force on this server representation
 439 */
 440static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss,
 441				   int showdefaults)
 442{
 443	static const struct proc_nfs_info {
 444		int flag;
 445		const char *str;
 446		const char *nostr;
 447	} nfs_info[] = {
 448		{ NFS_MOUNT_SOFT, ",soft", "" },
 449		{ NFS_MOUNT_SOFTERR, ",softerr", "" },
 450		{ NFS_MOUNT_SOFTREVAL, ",softreval", "" },
 451		{ NFS_MOUNT_POSIX, ",posix", "" },
 452		{ NFS_MOUNT_NOCTO, ",nocto", "" },
 453		{ NFS_MOUNT_NOAC, ",noac", "" },
 454		{ NFS_MOUNT_NONLM, ",nolock", "" },
 455		{ NFS_MOUNT_NOACL, ",noacl", "" },
 456		{ NFS_MOUNT_NORDIRPLUS, ",nordirplus", "" },
 457		{ NFS_MOUNT_FORCE_RDIRPLUS, ",rdirplus=force", "" },
 458		{ NFS_MOUNT_UNSHARED, ",nosharecache", "" },
 459		{ NFS_MOUNT_NORESVPORT, ",noresvport", "" },
 460		{ NFS_MOUNT_NETUNREACH_FATAL,
 461		  ",fatal_neterrors=ENETDOWN:ENETUNREACH",
 462		  ",fatal_neterrors=none" },
 463		{ 0, NULL, NULL }
 464	};
 465	const struct proc_nfs_info *nfs_infop;
 466	struct nfs_client *clp = nfss->nfs_client;
 467	u32 version = clp->rpc_ops->version;
 468	int local_flock, local_fcntl;
 469
 470	nfs_show_nfs_version(m, version, clp->cl_minorversion);
 471	seq_printf(m, ",rsize=%u", nfss->rsize);
 472	seq_printf(m, ",wsize=%u", nfss->wsize);
 473	if (nfss->bsize != 0)
 474		seq_printf(m, ",bsize=%u", nfss->bsize);
 475	seq_printf(m, ",namlen=%u", nfss->namelen);
 476	if (nfss->acregmin != NFS_DEF_ACREGMIN*HZ || showdefaults)
 477		seq_printf(m, ",acregmin=%u", nfss->acregmin/HZ);
 478	if (nfss->acregmax != NFS_DEF_ACREGMAX*HZ || showdefaults)
 479		seq_printf(m, ",acregmax=%u", nfss->acregmax/HZ);
 480	if (nfss->acdirmin != NFS_DEF_ACDIRMIN*HZ || showdefaults)
 481		seq_printf(m, ",acdirmin=%u", nfss->acdirmin/HZ);
 482	if (nfss->acdirmax != NFS_DEF_ACDIRMAX*HZ || showdefaults)
 483		seq_printf(m, ",acdirmax=%u", nfss->acdirmax/HZ);
 484	if (!(nfss->flags & (NFS_MOUNT_SOFT|NFS_MOUNT_SOFTERR)))
 485			seq_puts(m, ",hard");
 486	for (nfs_infop = nfs_info; nfs_infop->flag; nfs_infop++) {
 487		if (nfss->flags & nfs_infop->flag)
 488			seq_puts(m, nfs_infop->str);
 489		else
 490			seq_puts(m, nfs_infop->nostr);
 491	}
 492	rcu_read_lock();
 493	seq_printf(m, ",proto=%s",
 494		   rpc_peeraddr2str(nfss->client, RPC_DISPLAY_NETID));
 495	rcu_read_unlock();
 496	if (clp->cl_nconnect > 0)
 497		seq_printf(m, ",nconnect=%u", clp->cl_nconnect);
 498	if (version == 4) {
 499		if (clp->cl_max_connect > 1)
 500			seq_printf(m, ",max_connect=%u", clp->cl_max_connect);
 501		if (nfss->port != NFS_PORT)
 502			seq_printf(m, ",port=%u", nfss->port);
 503	} else
 504		if (nfss->port)
 505			seq_printf(m, ",port=%u", nfss->port);
 506
 507	seq_printf(m, ",timeo=%lu", 10U * nfss->client->cl_timeout->to_initval / HZ);
 508	seq_printf(m, ",retrans=%u", nfss->client->cl_timeout->to_retries);
 509	seq_printf(m, ",sec=%s", nfs_pseudoflavour_to_name(nfss->client->cl_auth->au_flavor));
 510	switch (clp->cl_xprtsec.policy) {
 511	case RPC_XPRTSEC_TLS_ANON:
 512		seq_puts(m, ",xprtsec=tls");
 513		break;
 514	case RPC_XPRTSEC_TLS_X509:
 515		seq_puts(m, ",xprtsec=mtls");
 516		break;
 517	default:
 518		break;
 519	}
 520
 521	if (version != 4)
 522		nfs_show_mountd_options(m, nfss, showdefaults);
 523	else
 524		nfs_show_nfsv4_options(m, nfss, showdefaults);
 525
 526	if (nfss->options & NFS_OPTION_FSCACHE) {
 527#ifdef CONFIG_NFS_FSCACHE
 528		if (nfss->fscache_uniq)
 529			seq_printf(m, ",fsc=%s", nfss->fscache_uniq);
 530		else
 531			seq_puts(m, ",fsc");
 532#else
 533		seq_puts(m, ",fsc");
 534#endif
 535	}
 536
 537	if (nfss->options & NFS_OPTION_MIGRATION)
 538		seq_puts(m, ",migration");
 539
 540	if (nfss->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG) {
 541		if (nfss->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
 542			seq_puts(m, ",lookupcache=none");
 543		else
 544			seq_puts(m, ",lookupcache=pos");
 545	}
 546
 547	local_flock = nfss->flags & NFS_MOUNT_LOCAL_FLOCK;
 548	local_fcntl = nfss->flags & NFS_MOUNT_LOCAL_FCNTL;
 549
 550	if (!local_flock && !local_fcntl)
 551		seq_puts(m, ",local_lock=none");
 552	else if (local_flock && local_fcntl)
 553		seq_puts(m, ",local_lock=all");
 554	else if (local_flock)
 555		seq_puts(m, ",local_lock=flock");
 556	else
 557		seq_puts(m, ",local_lock=posix");
 558
 559	if (nfss->flags & NFS_MOUNT_NO_ALIGNWRITE)
 560		seq_puts(m, ",noalignwrite");
 561
 562	if (nfss->flags & NFS_MOUNT_WRITE_EAGER) {
 563		if (nfss->flags & NFS_MOUNT_WRITE_WAIT)
 564			seq_puts(m, ",write=wait");
 565		else
 566			seq_puts(m, ",write=eager");
 567	}
 568}
 569
 570/*
 571 * Describe the mount options on this VFS mountpoint
 572 */
 573int nfs_show_options(struct seq_file *m, struct dentry *root)
 574{
 575	struct nfs_server *nfss = NFS_SB(root->d_sb);
 576
 577	nfs_show_mount_options(m, nfss, 0);
 578
 579	rcu_read_lock();
 580	seq_printf(m, ",addr=%s",
 581			rpc_peeraddr2str(nfss->nfs_client->cl_rpcclient,
 582							RPC_DISPLAY_ADDR));
 583	rcu_read_unlock();
 584
 585	return 0;
 586}
 587EXPORT_SYMBOL_GPL(nfs_show_options);
 588
 589#if IS_ENABLED(CONFIG_NFS_V4)
 590static void show_lease(struct seq_file *m, struct nfs_server *server)
 591{
 592	struct nfs_client *clp = server->nfs_client;
 593	unsigned long expire;
 594
 595	seq_printf(m, ",lease_time=%ld", clp->cl_lease_time / HZ);
 596	expire = clp->cl_last_renewal + clp->cl_lease_time;
 597	seq_printf(m, ",lease_expired=%ld",
 598		   time_after(expire, jiffies) ?  0 : (jiffies - expire) / HZ);
 599}
 600#ifdef CONFIG_NFS_V4_1
 601static void show_sessions(struct seq_file *m, struct nfs_server *server)
 602{
 603	if (nfs4_has_session(server->nfs_client))
 604		seq_puts(m, ",sessions");
 605}
 606#else
 607static void show_sessions(struct seq_file *m, struct nfs_server *server) {}
 608#endif
 609#endif
 610
 611#ifdef CONFIG_NFS_V4_1
 612static void show_pnfs(struct seq_file *m, struct nfs_server *server)
 613{
 614	seq_printf(m, ",pnfs=");
 615	if (server->pnfs_curr_ld)
 616		seq_printf(m, "%s", server->pnfs_curr_ld->name);
 617	else
 618		seq_printf(m, "not configured");
 619}
 620
 621static void show_implementation_id(struct seq_file *m, struct nfs_server *nfss)
 622{
 623	if (nfss->nfs_client && nfss->nfs_client->cl_implid) {
 624		struct nfs41_impl_id *impl_id = nfss->nfs_client->cl_implid;
 625		seq_printf(m, "\n\timpl_id:\tname='%s',domain='%s',"
 626			   "date='%llu,%u'",
 627			   impl_id->name, impl_id->domain,
 628			   impl_id->date.seconds, impl_id->date.nseconds);
 629	}
 630}
 631#else
 632#if IS_ENABLED(CONFIG_NFS_V4)
 633static void show_pnfs(struct seq_file *m, struct nfs_server *server)
 634{
 635}
 636#endif
 637static void show_implementation_id(struct seq_file *m, struct nfs_server *nfss)
 638{
 639}
 640#endif
 641
 642int nfs_show_devname(struct seq_file *m, struct dentry *root)
 643{
 644	char *page = (char *) __get_free_page(GFP_KERNEL);
 645	char *devname, *dummy;
 646	int err = 0;
 647	if (!page)
 648		return -ENOMEM;
 649	devname = nfs_path(&dummy, root, page, PAGE_SIZE, 0);
 650	if (IS_ERR(devname))
 651		err = PTR_ERR(devname);
 652	else
 653		seq_escape(m, devname, " \t\n\\");
 654	free_page((unsigned long)page);
 655	return err;
 656}
 657EXPORT_SYMBOL_GPL(nfs_show_devname);
 658
 659int nfs_show_path(struct seq_file *m, struct dentry *dentry)
 660{
 661	seq_puts(m, "/");
 662	return 0;
 663}
 664EXPORT_SYMBOL_GPL(nfs_show_path);
 665
 666/*
 667 * Present statistical information for this VFS mountpoint
 668 */
 669int nfs_show_stats(struct seq_file *m, struct dentry *root)
 670{
 671	int i, cpu;
 672	struct nfs_server *nfss = NFS_SB(root->d_sb);
 673	struct rpc_auth *auth = nfss->client->cl_auth;
 674	struct nfs_iostats totals = { };
 675
 676	seq_printf(m, "statvers=%s", NFS_IOSTAT_VERS);
 677
 678	/*
 679	 * Display all mount option settings
 680	 */
 681	seq_puts(m, "\n\topts:\t");
 682	seq_puts(m, sb_rdonly(root->d_sb) ? "ro" : "rw");
 683	seq_puts(m, root->d_sb->s_flags & SB_SYNCHRONOUS ? ",sync" : "");
 684	seq_puts(m, root->d_sb->s_flags & SB_NOATIME ? ",noatime" : "");
 685	seq_puts(m, root->d_sb->s_flags & SB_NODIRATIME ? ",nodiratime" : "");
 686	nfs_show_mount_options(m, nfss, 1);
 687
 688	seq_printf(m, "\n\tage:\t%lu", (jiffies - nfss->mount_time) / HZ);
 689
 690	show_implementation_id(m, nfss);
 691
 692	seq_puts(m, "\n\tcaps:\t");
 693	seq_printf(m, "caps=0x%x", nfss->caps);
 694	seq_printf(m, ",wtmult=%u", nfss->wtmult);
 695	seq_printf(m, ",dtsize=%u", nfss->dtsize);
 696	seq_printf(m, ",bsize=%u", nfss->bsize);
 697	seq_printf(m, ",namlen=%u", nfss->namelen);
 698
 699#if IS_ENABLED(CONFIG_NFS_V4)
 700	if (nfss->nfs_client->rpc_ops->version == 4) {
 701		seq_puts(m, "\n\tnfsv4:\t");
 702		seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]);
 703		seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]);
 704		seq_printf(m, ",bm2=0x%x", nfss->attr_bitmask[2]);
 705		seq_printf(m, ",acl=0x%x", nfss->acl_bitmask);
 706		show_sessions(m, nfss);
 707		show_pnfs(m, nfss);
 708		show_lease(m, nfss);
 709	}
 710#endif
 711
 712	/*
 713	 * Display security flavor in effect for this mount
 714	 */
 715	seq_printf(m, "\n\tsec:\tflavor=%u", auth->au_ops->au_flavor);
 716	if (auth->au_flavor)
 717		seq_printf(m, ",pseudoflavor=%u", auth->au_flavor);
 718
 719	/*
 720	 * Display superblock I/O counters
 721	 */
 722	for_each_possible_cpu(cpu) {
 723		struct nfs_iostats *stats;
 724
 725		preempt_disable();
 726		stats = per_cpu_ptr(nfss->io_stats, cpu);
 727
 728		for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
 729			totals.events[i] += stats->events[i];
 730		for (i = 0; i < __NFSIOS_BYTESMAX; i++)
 731			totals.bytes[i] += stats->bytes[i];
 732
 733		preempt_enable();
 734	}
 735
 736	seq_puts(m, "\n\tevents:\t");
 737	for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
 738		seq_printf(m, "%lu ", totals.events[i]);
 739	seq_puts(m, "\n\tbytes:\t");
 740	for (i = 0; i < __NFSIOS_BYTESMAX; i++)
 741		seq_printf(m, "%Lu ", totals.bytes[i]);
 742	seq_putc(m, '\n');
 743
 744	rpc_clnt_show_stats(m, nfss->client);
 745
 746	return 0;
 747}
 748EXPORT_SYMBOL_GPL(nfs_show_stats);
 749
 750/*
 751 * Begin unmount by attempting to remove all automounted mountpoints we added
 752 * in response to xdev traversals and referrals
 753 */
 754void nfs_umount_begin(struct super_block *sb)
 755{
 756	struct nfs_server *server;
 757	struct rpc_clnt *rpc;
 758
 759	server = NFS_SB(sb);
 760	/* -EIO all pending I/O */
 761	rpc = server->client_acl;
 762	if (!IS_ERR(rpc))
 763		rpc_killall_tasks(rpc);
 764	rpc = server->client;
 765	if (!IS_ERR(rpc))
 766		rpc_killall_tasks(rpc);
 767}
 768EXPORT_SYMBOL_GPL(nfs_umount_begin);
 769
 770/*
 771 * Return true if 'match' is in auth_info or auth_info is empty.
 772 * Return false otherwise.
 773 */
 774bool nfs_auth_info_match(const struct nfs_auth_info *auth_info,
 775			 rpc_authflavor_t match)
 776{
 777	int i;
 778
 779	if (!auth_info->flavor_len)
 780		return true;
 781
 782	for (i = 0; i < auth_info->flavor_len; i++) {
 783		if (auth_info->flavors[i] == match)
 784			return true;
 785	}
 786	return false;
 787}
 788EXPORT_SYMBOL_GPL(nfs_auth_info_match);
 789
 790/*
 791 * Ensure that a specified authtype in ctx->auth_info is supported by
 792 * the server. Returns 0 and sets ctx->selected_flavor if it's ok, and
 793 * -EACCES if not.
 794 */
 795static int nfs_verify_authflavors(struct nfs_fs_context *ctx,
 796				  rpc_authflavor_t *server_authlist,
 797				  unsigned int count)
 798{
 799	rpc_authflavor_t flavor = RPC_AUTH_MAXFLAVOR;
 800	bool found_auth_null = false;
 801	unsigned int i;
 802
 803	/*
 804	 * If the sec= mount option is used, the specified flavor or AUTH_NULL
 805	 * must be in the list returned by the server.
 806	 *
 807	 * AUTH_NULL has a special meaning when it's in the server list - it
 808	 * means that the server will ignore the rpc creds, so any flavor
 809	 * can be used but still use the sec= that was specified.
 810	 *
 811	 * Note also that the MNT procedure in MNTv1 does not return a list
 812	 * of supported security flavors. In this case, nfs_mount() fabricates
 813	 * a security flavor list containing just AUTH_NULL.
 814	 */
 815	for (i = 0; i < count; i++) {
 816		flavor = server_authlist[i];
 817
 818		if (nfs_auth_info_match(&ctx->auth_info, flavor))
 819			goto out;
 820
 821		if (flavor == RPC_AUTH_NULL)
 822			found_auth_null = true;
 823	}
 824
 825	if (found_auth_null) {
 826		flavor = ctx->auth_info.flavors[0];
 827		goto out;
 828	}
 829
 830	dfprintk(MOUNT,
 831		 "NFS: specified auth flavors not supported by server\n");
 832	return -EACCES;
 833
 834out:
 835	ctx->selected_flavor = flavor;
 836	dfprintk(MOUNT, "NFS: using auth flavor %u\n", ctx->selected_flavor);
 837	return 0;
 838}
 839
 840/*
 841 * Use the remote server's MOUNT service to request the NFS file handle
 842 * corresponding to the provided path.
 843 */
 844static int nfs_request_mount(struct fs_context *fc,
 845			     struct nfs_fh *root_fh,
 846			     rpc_authflavor_t *server_authlist,
 847			     unsigned int *server_authlist_len)
 848{
 849	struct nfs_fs_context *ctx = nfs_fc2context(fc);
 850	struct nfs_mount_request request = {
 851		.sap		= &ctx->mount_server._address,
 852		.dirpath	= ctx->nfs_server.export_path,
 853		.protocol	= ctx->mount_server.protocol,
 854		.fh		= root_fh,
 855		.noresvport	= ctx->flags & NFS_MOUNT_NORESVPORT,
 856		.auth_flav_len	= server_authlist_len,
 857		.auth_flavs	= server_authlist,
 858		.net		= fc->net_ns,
 859	};
 860	int status;
 861
 862	if (ctx->mount_server.version == 0) {
 863		switch (ctx->version) {
 864			default:
 865				ctx->mount_server.version = NFS_MNT3_VERSION;
 866				break;
 867			case 2:
 868				ctx->mount_server.version = NFS_MNT_VERSION;
 869		}
 870	}
 871	request.version = ctx->mount_server.version;
 872
 873	if (ctx->mount_server.hostname)
 874		request.hostname = ctx->mount_server.hostname;
 875	else
 876		request.hostname = ctx->nfs_server.hostname;
 877
 878	/*
 879	 * Construct the mount server's address.
 880	 */
 881	if (ctx->mount_server.address.sa_family == AF_UNSPEC) {
 882		memcpy(request.sap, &ctx->nfs_server._address,
 883		       ctx->nfs_server.addrlen);
 884		ctx->mount_server.addrlen = ctx->nfs_server.addrlen;
 885	}
 886	request.salen = ctx->mount_server.addrlen;
 887	nfs_set_port(request.sap, &ctx->mount_server.port, 0);
 888
 889	/*
 890	 * Now ask the mount server to map our export path
 891	 * to a file handle.
 892	 */
 893	if ((request.protocol == XPRT_TRANSPORT_UDP) ==
 894	    !(ctx->flags & NFS_MOUNT_TCP))
 895		/*
 896		 * NFS protocol and mount protocol are both UDP or neither UDP
 897		 * so timeouts are compatible.  Use NFS timeouts for MOUNT
 898		 */
 899		status = nfs_mount(&request, ctx->timeo, ctx->retrans);
 900	else
 901		status = nfs_mount(&request, NFS_UNSPEC_TIMEO, NFS_UNSPEC_RETRANS);
 902	if (status != 0) {
 903		dfprintk(MOUNT, "NFS: unable to mount server %s, error %d\n",
 904				request.hostname, status);
 905		return status;
 906	}
 907
 908	return 0;
 909}
 910
 911static struct nfs_server *nfs_try_mount_request(struct fs_context *fc)
 912{
 913	struct nfs_fs_context *ctx = nfs_fc2context(fc);
 914	int status;
 915	unsigned int i;
 916	bool tried_auth_unix = false;
 917	bool auth_null_in_list = false;
 918	struct nfs_server *server = ERR_PTR(-EACCES);
 919	rpc_authflavor_t authlist[NFS_MAX_SECFLAVORS];
 920	unsigned int authlist_len = ARRAY_SIZE(authlist);
 921
 922	/* make sure 'nolock'/'lock' override the 'local_lock' mount option */
 923	if (ctx->lock_status) {
 924		if (ctx->lock_status == NFS_LOCK_NOLOCK) {
 925			ctx->flags |= NFS_MOUNT_NONLM;
 926			ctx->flags |= (NFS_MOUNT_LOCAL_FLOCK | NFS_MOUNT_LOCAL_FCNTL);
 927		} else {
 928			ctx->flags &= ~NFS_MOUNT_NONLM;
 929			ctx->flags &= ~(NFS_MOUNT_LOCAL_FLOCK | NFS_MOUNT_LOCAL_FCNTL);
 930		}
 931	}
 932	status = nfs_request_mount(fc, ctx->mntfh, authlist, &authlist_len);
 933	if (status)
 934		return ERR_PTR(status);
 935
 936	/*
 937	 * Was a sec= authflavor specified in the options? First, verify
 938	 * whether the server supports it, and then just try to use it if so.
 939	 */
 940	if (ctx->auth_info.flavor_len > 0) {
 941		status = nfs_verify_authflavors(ctx, authlist, authlist_len);
 942		dfprintk(MOUNT, "NFS: using auth flavor %u\n",
 943			 ctx->selected_flavor);
 944		if (status)
 945			return ERR_PTR(status);
 946		return ctx->nfs_mod->rpc_ops->create_server(fc);
 947	}
 948
 949	/*
 950	 * No sec= option was provided. RFC 2623, section 2.7 suggests we
 951	 * SHOULD prefer the flavor listed first. However, some servers list
 952	 * AUTH_NULL first. Avoid ever choosing AUTH_NULL.
 953	 */
 954	for (i = 0; i < authlist_len; ++i) {
 955		rpc_authflavor_t flavor;
 956		struct rpcsec_gss_info info;
 957
 958		flavor = authlist[i];
 959		switch (flavor) {
 960		case RPC_AUTH_UNIX:
 961			tried_auth_unix = true;
 962			break;
 963		case RPC_AUTH_NULL:
 964			auth_null_in_list = true;
 965			continue;
 966		default:
 967			if (rpcauth_get_gssinfo(flavor, &info) != 0)
 968				continue;
 969			break;
 970		}
 971		dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", flavor);
 972		ctx->selected_flavor = flavor;
 973		server = ctx->nfs_mod->rpc_ops->create_server(fc);
 974		if (!IS_ERR(server))
 975			return server;
 976	}
 977
 978	/*
 979	 * Nothing we tried so far worked. At this point, give up if we've
 980	 * already tried AUTH_UNIX or if the server's list doesn't contain
 981	 * AUTH_NULL
 982	 */
 983	if (tried_auth_unix || !auth_null_in_list)
 984		return server;
 985
 986	/* Last chance! Try AUTH_UNIX */
 987	dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", RPC_AUTH_UNIX);
 988	ctx->selected_flavor = RPC_AUTH_UNIX;
 989	return ctx->nfs_mod->rpc_ops->create_server(fc);
 990}
 991
 992int nfs_try_get_tree(struct fs_context *fc)
 993{
 994	struct nfs_fs_context *ctx = nfs_fc2context(fc);
 995
 996	if (ctx->need_mount)
 997		ctx->server = nfs_try_mount_request(fc);
 998	else
 999		ctx->server = ctx->nfs_mod->rpc_ops->create_server(fc);
1000
1001	return nfs_get_tree_common(fc);
1002}
1003EXPORT_SYMBOL_GPL(nfs_try_get_tree);
1004
1005
1006#define NFS_REMOUNT_CMP_FLAGMASK ~(NFS_MOUNT_INTR \
1007		| NFS_MOUNT_SECURE \
1008		| NFS_MOUNT_TCP \
1009		| NFS_MOUNT_VER3 \
1010		| NFS_MOUNT_KERBEROS \
1011		| NFS_MOUNT_NONLM \
1012		| NFS_MOUNT_BROKEN_SUID \
1013		| NFS_MOUNT_STRICTLOCK \
1014		| NFS_MOUNT_LEGACY_INTERFACE)
1015
1016#define NFS_MOUNT_CMP_FLAGMASK (NFS_REMOUNT_CMP_FLAGMASK & \
1017		~(NFS_MOUNT_UNSHARED | NFS_MOUNT_NORESVPORT))
1018
1019static int
1020nfs_compare_remount_data(struct nfs_server *nfss,
1021			 struct nfs_fs_context *ctx)
1022{
1023	if ((ctx->flags ^ nfss->flags) & NFS_REMOUNT_CMP_FLAGMASK ||
1024	    ctx->rsize != nfss->rsize ||
1025	    ctx->wsize != nfss->wsize ||
1026	    ctx->version != nfss->nfs_client->rpc_ops->version ||
1027	    ctx->minorversion != nfss->nfs_client->cl_minorversion ||
1028	    ctx->retrans != nfss->client->cl_timeout->to_retries ||
1029	    !nfs_auth_info_match(&ctx->auth_info, nfss->client->cl_auth->au_flavor) ||
1030	    ctx->acregmin != nfss->acregmin / HZ ||
1031	    ctx->acregmax != nfss->acregmax / HZ ||
1032	    ctx->acdirmin != nfss->acdirmin / HZ ||
1033	    ctx->acdirmax != nfss->acdirmax / HZ ||
1034	    ctx->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) ||
1035	    (ctx->options & NFS_OPTION_FSCACHE) != (nfss->options & NFS_OPTION_FSCACHE) ||
1036	    ctx->nfs_server.port != nfss->port ||
1037	    ctx->nfs_server.addrlen != nfss->nfs_client->cl_addrlen ||
1038	    !rpc_cmp_addr((struct sockaddr *)&ctx->nfs_server.address,
1039			  (struct sockaddr *)&nfss->nfs_client->cl_addr))
1040		return -EINVAL;
1041
1042	return 0;
1043}
1044
1045int nfs_reconfigure(struct fs_context *fc)
1046{
1047	struct nfs_fs_context *ctx = nfs_fc2context(fc);
1048	struct super_block *sb = fc->root->d_sb;
1049	struct nfs_server *nfss = sb->s_fs_info;
1050	int ret;
1051
1052	sync_filesystem(sb);
1053
1054	/*
1055	 * Userspace mount programs that send binary options generally send
1056	 * them populated with default values. We have no way to know which
1057	 * ones were explicitly specified. Fall back to legacy behavior and
1058	 * just return success.
1059	 */
1060	if (ctx->skip_reconfig_option_check)
1061		return 0;
1062
1063	/*
1064	 * noac is a special case. It implies -o sync, but that's not
1065	 * necessarily reflected in the mtab options. reconfigure_super
1066	 * will clear SB_SYNCHRONOUS if -o sync wasn't specified in the
1067	 * remount options, so we have to explicitly reset it.
1068	 */
1069	if (ctx->flags & NFS_MOUNT_NOAC) {
1070		fc->sb_flags |= SB_SYNCHRONOUS;
1071		fc->sb_flags_mask |= SB_SYNCHRONOUS;
1072	}
1073
1074	/* compare new mount options with old ones */
1075	ret = nfs_compare_remount_data(nfss, ctx);
1076	if (ret)
1077		return ret;
1078
1079	return nfs_probe_server(nfss, NFS_FH(d_inode(fc->root)));
1080}
1081EXPORT_SYMBOL_GPL(nfs_reconfigure);
1082
1083/*
1084 * Finish setting up an NFS superblock
1085 */
1086static void nfs_fill_super(struct super_block *sb, struct nfs_fs_context *ctx)
1087{
1088	struct nfs_server *server = NFS_SB(sb);
1089
1090	sb->s_blocksize_bits = 0;
1091	sb->s_blocksize = 0;
1092	sb->s_xattr = server->nfs_client->cl_nfs_mod->xattr;
1093	sb->s_op = server->nfs_client->cl_nfs_mod->sops;
1094	if (server->bsize)
1095		sb->s_blocksize =
1096			nfs_block_size(server->bsize, &sb->s_blocksize_bits);
1097
1098	switch (server->nfs_client->rpc_ops->version) {
1099	case 2:
1100		sb->s_time_gran = 1000;
1101		sb->s_time_min = 0;
1102		sb->s_time_max = U32_MAX;
1103		break;
1104	case 3:
1105		/*
1106		 * The VFS shouldn't apply the umask to mode bits.
1107		 * We will do so ourselves when necessary.
1108		 */
1109		sb->s_flags |= SB_POSIXACL;
1110		sb->s_time_gran = 1;
1111		sb->s_time_min = 0;
1112		sb->s_time_max = U32_MAX;
1113		sb->s_export_op = &nfs_export_ops;
1114		break;
1115	case 4:
1116		sb->s_iflags |= SB_I_NOUMASK;
1117		sb->s_time_gran = 1;
1118		sb->s_time_min = S64_MIN;
1119		sb->s_time_max = S64_MAX;
1120		if (server->caps & NFS_CAP_ATOMIC_OPEN_V1)
1121			sb->s_export_op = &nfs_export_ops;
1122		break;
1123	}
1124
1125	sb->s_magic = NFS_SUPER_MAGIC;
1126
1127	/* We probably want something more informative here */
1128	snprintf(sb->s_id, sizeof(sb->s_id),
1129		 "%u:%u", MAJOR(sb->s_dev), MINOR(sb->s_dev));
1130
1131	if (sb->s_blocksize == 0)
1132		sb->s_blocksize = nfs_block_bits(server->wsize,
1133						 &sb->s_blocksize_bits);
1134
1135	nfs_super_set_maxbytes(sb, server->maxfilesize);
1136	nfs_sysfs_move_server_to_sb(sb);
1137	server->has_sec_mnt_opts = ctx->has_sec_mnt_opts;
1138}
1139
1140static int nfs_compare_mount_options(const struct super_block *s, const struct nfs_server *b,
1141				     const struct fs_context *fc)
1142{
1143	const struct nfs_server *a = s->s_fs_info;
1144	const struct rpc_clnt *clnt_a = a->client;
1145	const struct rpc_clnt *clnt_b = b->client;
1146
1147	if ((s->s_flags & NFS_SB_MASK) != (fc->sb_flags & NFS_SB_MASK))
1148		goto Ebusy;
1149	if (a->nfs_client != b->nfs_client)
1150		goto Ebusy;
1151	if ((a->flags ^ b->flags) & NFS_MOUNT_CMP_FLAGMASK)
1152		goto Ebusy;
1153	if (a->wsize != b->wsize)
1154		goto Ebusy;
1155	if (a->rsize != b->rsize)
1156		goto Ebusy;
1157	if (a->acregmin != b->acregmin)
1158		goto Ebusy;
1159	if (a->acregmax != b->acregmax)
1160		goto Ebusy;
1161	if (a->acdirmin != b->acdirmin)
1162		goto Ebusy;
1163	if (a->acdirmax != b->acdirmax)
1164		goto Ebusy;
1165	if (clnt_a->cl_auth->au_flavor != clnt_b->cl_auth->au_flavor)
1166		goto Ebusy;
1167	return 1;
1168Ebusy:
1169	return 0;
1170}
1171
1172static int nfs_set_super(struct super_block *s, struct fs_context *fc)
1173{
1174	struct nfs_server *server = fc->s_fs_info;
1175	int ret;
1176
1177	set_default_d_op(s, server->nfs_client->rpc_ops->dentry_ops);
1178	ret = set_anon_super(s, server);
1179	if (ret == 0)
1180		server->s_dev = s->s_dev;
1181	return ret;
1182}
1183
1184static int nfs_compare_super_address(struct nfs_server *server1,
1185				     struct nfs_server *server2)
1186{
1187	struct sockaddr *sap1, *sap2;
1188	struct rpc_xprt *xprt1 = server1->client->cl_xprt;
1189	struct rpc_xprt *xprt2 = server2->client->cl_xprt;
1190
1191	if (!net_eq(xprt1->xprt_net, xprt2->xprt_net))
1192		return 0;
1193
1194	sap1 = (struct sockaddr *)&server1->nfs_client->cl_addr;
1195	sap2 = (struct sockaddr *)&server2->nfs_client->cl_addr;
1196
1197	if (sap1->sa_family != sap2->sa_family)
1198		return 0;
1199
1200	switch (sap1->sa_family) {
1201	case AF_INET: {
1202		struct sockaddr_in *sin1 = (struct sockaddr_in *)sap1;
1203		struct sockaddr_in *sin2 = (struct sockaddr_in *)sap2;
1204		if (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr)
1205			return 0;
1206		if (sin1->sin_port != sin2->sin_port)
1207			return 0;
1208		break;
1209	}
1210	case AF_INET6: {
1211		struct sockaddr_in6 *sin1 = (struct sockaddr_in6 *)sap1;
1212		struct sockaddr_in6 *sin2 = (struct sockaddr_in6 *)sap2;
1213		if (!ipv6_addr_equal(&sin1->sin6_addr, &sin2->sin6_addr))
1214			return 0;
1215		if (sin1->sin6_port != sin2->sin6_port)
1216			return 0;
1217		break;
1218	}
1219	default:
1220		return 0;
1221	}
1222
1223	return 1;
1224}
1225
1226static int nfs_compare_userns(const struct nfs_server *old,
1227		const struct nfs_server *new)
1228{
1229	const struct user_namespace *oldns = &init_user_ns;
1230	const struct user_namespace *newns = &init_user_ns;
1231
1232	if (old->client && old->client->cl_cred)
1233		oldns = old->client->cl_cred->user_ns;
1234	if (new->client && new->client->cl_cred)
1235		newns = new->client->cl_cred->user_ns;
1236	if (oldns != newns)
1237		return 0;
1238	return 1;
1239}
1240
1241static int nfs_compare_super(struct super_block *sb, struct fs_context *fc)
1242{
1243	struct nfs_server *server = fc->s_fs_info, *old = NFS_SB(sb);
1244
1245	if (!nfs_compare_super_address(old, server))
1246		return 0;
1247	/* Note: NFS_MOUNT_UNSHARED == NFS4_MOUNT_UNSHARED */
1248	if (old->flags & NFS_MOUNT_UNSHARED)
1249		return 0;
1250	if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0)
1251		return 0;
1252	if (!nfs_compare_userns(old, server))
1253		return 0;
1254	if ((old->has_sec_mnt_opts || fc->security) &&
1255			security_sb_mnt_opts_compat(sb, fc->security))
1256		return 0;
1257	return nfs_compare_mount_options(sb, server, fc);
1258}
1259
1260#ifdef CONFIG_NFS_FSCACHE
1261static int nfs_get_cache_cookie(struct super_block *sb,
1262				struct nfs_fs_context *ctx)
1263{
1264	struct nfs_server *nfss = NFS_SB(sb);
1265	char *uniq = NULL;
1266	int ulen = 0;
1267
1268	nfss->fscache = NULL;
1269
1270	if (!ctx)
1271		return 0;
1272
1273	if (ctx->clone_data.sb) {
1274		struct nfs_server *mnt_s = NFS_SB(ctx->clone_data.sb);
1275		if (!(mnt_s->options & NFS_OPTION_FSCACHE))
1276			return 0;
1277		if (mnt_s->fscache_uniq) {
1278			uniq = mnt_s->fscache_uniq;
1279			ulen = strlen(uniq);
1280		}
1281	} else {
1282		if (!(ctx->options & NFS_OPTION_FSCACHE))
1283			return 0;
1284		if (ctx->fscache_uniq) {
1285			uniq = ctx->fscache_uniq;
1286			ulen = strlen(ctx->fscache_uniq);
1287		}
1288	}
1289
1290	return nfs_fscache_get_super_cookie(sb, uniq, ulen);
1291}
1292#else
1293static int nfs_get_cache_cookie(struct super_block *sb,
1294				struct nfs_fs_context *ctx)
1295{
1296	return 0;
1297}
1298#endif
1299
1300int nfs_get_tree_common(struct fs_context *fc)
1301{
1302	struct nfs_fs_context *ctx = nfs_fc2context(fc);
1303	struct super_block *s;
1304	int (*compare_super)(struct super_block *, struct fs_context *) = nfs_compare_super;
1305	struct nfs_server *server = ctx->server;
1306	int error;
1307
1308	ctx->server = NULL;
1309	if (IS_ERR(server))
1310		return PTR_ERR(server);
1311
1312	if (server->flags & NFS_MOUNT_UNSHARED)
1313		compare_super = NULL;
1314
1315	/* -o noac implies -o sync */
1316	if (server->flags & NFS_MOUNT_NOAC)
1317		fc->sb_flags |= SB_SYNCHRONOUS;
1318
1319	/* Get a superblock - note that we may end up sharing one that already exists */
1320	fc->s_fs_info = server;
1321	s = sget_fc(fc, compare_super, nfs_set_super);
1322	fc->s_fs_info = NULL;
1323	if (IS_ERR(s)) {
1324		error = PTR_ERR(s);
1325		nfs_errorf(fc, "NFS: Couldn't get superblock");
1326		goto out_err_nosb;
1327	}
1328
1329	if (s->s_fs_info != server) {
1330		nfs_free_server(server);
1331		server = NULL;
1332	} else {
1333		error = super_setup_bdi_name(s, "%u:%u", MAJOR(server->s_dev),
1334					     MINOR(server->s_dev));
1335		if (error)
1336			goto error_splat_super;
1337		s->s_bdi->io_pages = server->rpages;
1338		server->super = s;
1339	}
1340
1341	if (!s->s_root) {
1342		/* initial superblock/root creation */
1343		nfs_fill_super(s, ctx);
1344		error = nfs_get_cache_cookie(s, ctx);
1345		if (error < 0)
1346			goto error_splat_super;
1347	}
1348
1349	error = nfs_get_root(s, fc);
1350	if (error < 0) {
1351		nfs_errorf(fc, "NFS: Couldn't get root dentry");
1352		goto error_splat_super;
1353	}
1354
1355	s->s_flags |= SB_ACTIVE;
1356	error = 0;
1357
1358out:
1359	return error;
1360
1361out_err_nosb:
1362	nfs_free_server(server);
1363	goto out;
1364error_splat_super:
1365	deactivate_locked_super(s);
1366	goto out;
1367}
1368
1369/*
1370 * Destroy an NFS superblock
1371 */
1372void nfs_kill_super(struct super_block *s)
1373{
1374	struct nfs_server *server = NFS_SB(s);
1375
1376	nfs_sysfs_move_sb_to_server(server);
1377	kill_anon_super(s);
1378
1379	nfs_fscache_release_super_cookie(s);
1380
1381	nfs_free_server(server);
1382}
1383EXPORT_SYMBOL_GPL(nfs_kill_super);
1384
1385#if IS_ENABLED(CONFIG_NFS_V4)
1386
1387/*
1388 * NFS v4 module parameters need to stay in the
1389 * NFS client for backwards compatibility
1390 */
1391unsigned int nfs_callback_set_tcpport;
1392unsigned short nfs_callback_nr_threads;
1393/* Default cache timeout is 10 minutes */
1394unsigned int nfs_idmap_cache_timeout = 600;
1395/* Turn off NFSv4 uid/gid mapping when using AUTH_SYS */
1396bool nfs4_disable_idmapping = true;
1397unsigned short max_session_slots = NFS4_DEF_SLOT_TABLE_SIZE;
1398unsigned short max_session_cb_slots = NFS4_DEF_CB_SLOT_TABLE_SIZE;
1399unsigned short send_implementation_id = 1;
1400char nfs4_client_id_uniquifier[NFS4_CLIENT_ID_UNIQ_LEN] = "";
1401bool recover_lost_locks = false;
1402short nfs_delay_retrans = -1;
1403
1404EXPORT_SYMBOL_GPL(nfs_callback_nr_threads);
1405EXPORT_SYMBOL_GPL(nfs_callback_set_tcpport);
1406EXPORT_SYMBOL_GPL(nfs_idmap_cache_timeout);
1407EXPORT_SYMBOL_GPL(nfs4_disable_idmapping);
1408EXPORT_SYMBOL_GPL(max_session_slots);
1409EXPORT_SYMBOL_GPL(max_session_cb_slots);
1410EXPORT_SYMBOL_GPL(send_implementation_id);
1411EXPORT_SYMBOL_GPL(nfs4_client_id_uniquifier);
1412EXPORT_SYMBOL_GPL(recover_lost_locks);
1413EXPORT_SYMBOL_GPL(nfs_delay_retrans);
1414
1415#define NFS_CALLBACK_MAXPORTNR (65535U)
1416
1417static int param_set_portnr(const char *val, const struct kernel_param *kp)
1418{
1419	unsigned long num;
1420	int ret;
1421
1422	if (!val)
1423		return -EINVAL;
1424	ret = kstrtoul(val, 0, &num);
1425	if (ret || num > NFS_CALLBACK_MAXPORTNR)
1426		return -EINVAL;
1427	*((unsigned int *)kp->arg) = num;
1428	return 0;
1429}
1430static const struct kernel_param_ops param_ops_portnr = {
1431	.set = param_set_portnr,
1432	.get = param_get_uint,
1433};
1434#define param_check_portnr(name, p) __param_check(name, p, unsigned int)
1435
1436module_param_named(callback_tcpport, nfs_callback_set_tcpport, portnr, 0644);
1437module_param_named(callback_nr_threads, nfs_callback_nr_threads, ushort, 0644);
1438MODULE_PARM_DESC(callback_nr_threads, "Number of threads that will be "
1439		"assigned to the NFSv4 callback channels.");
1440module_param(nfs_idmap_cache_timeout, int, 0644);
1441module_param(nfs4_disable_idmapping, bool, 0644);
1442module_param_string(nfs4_unique_id, nfs4_client_id_uniquifier,
1443			NFS4_CLIENT_ID_UNIQ_LEN, 0600);
1444MODULE_PARM_DESC(nfs4_disable_idmapping,
1445		"Turn off NFSv4 idmapping when using 'sec=sys'");
1446module_param(max_session_slots, ushort, 0644);
1447MODULE_PARM_DESC(max_session_slots, "Maximum number of outstanding NFSv4.1 "
1448		"requests the client will negotiate");
1449module_param(max_session_cb_slots, ushort, 0644);
1450MODULE_PARM_DESC(max_session_cb_slots, "Maximum number of parallel NFSv4.1 "
1451		"callbacks the client will process for a given server");
1452module_param(send_implementation_id, ushort, 0644);
1453MODULE_PARM_DESC(send_implementation_id,
1454		"Send implementation ID with NFSv4.1 exchange_id");
1455MODULE_PARM_DESC(nfs4_unique_id, "nfs_client_id4 uniquifier string");
1456
1457module_param(recover_lost_locks, bool, 0644);
1458MODULE_PARM_DESC(recover_lost_locks,
1459		 "If the server reports that a lock might be lost, "
1460		 "try to recover it risking data corruption.");
1461
1462module_param_named(delay_retrans, nfs_delay_retrans, short, 0644);
1463MODULE_PARM_DESC(delay_retrans,
1464		 "Unless negative, specifies the number of times the NFSv4 "
1465		 "client retries a request before returning an EAGAIN error, "
1466		 "after a reply of NFS4ERR_DELAY from the server.");
1467#endif /* CONFIG_NFS_V4 */