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