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