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