~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,3 +1,4 @@
	1	+// SPDX-License-Identifier: GPL-2.0-only
1	2	/*
2	3	* linux/fs/nfs/super.c
3	4	*
..	..	@@ -56,6 +57,7 @@
56	57	#include <linux/rcupdate.h>
57	58
58	59	#include <linux/uaccess.h>
	60	+#include <linux/nfs_ssc.h>
59	61
60	62	#include "nfs4_fs.h"
61	63	#include "callback.h"
..	..	@@ -68,248 +70,10 @@
68	70	#include "nfs.h"
69	71
70	72	#define NFSDBG_FACILITY NFSDBG_VFS
71		-#define NFS_TEXT_DATA 1
72		-
73		-#if IS_ENABLED(CONFIG_NFS_V3)
74		-#define NFS_DEFAULT_VERSION 3
75		-#else
76		-#define NFS_DEFAULT_VERSION 2
77		-#endif
78		-
79		-enum {
80		- /* Mount options that take no arguments */
81		- Opt_soft, Opt_hard,
82		- Opt_posix, Opt_noposix,
83		- Opt_cto, Opt_nocto,
84		- Opt_ac, Opt_noac,
85		- Opt_lock, Opt_nolock,
86		- Opt_udp, Opt_tcp, Opt_rdma,
87		- Opt_acl, Opt_noacl,
88		- Opt_rdirplus, Opt_nordirplus,
89		- Opt_sharecache, Opt_nosharecache,
90		- Opt_resvport, Opt_noresvport,
91		- Opt_fscache, Opt_nofscache,
92		- Opt_migration, Opt_nomigration,
93		-
94		- /* Mount options that take integer arguments */
95		- Opt_port,
96		- Opt_rsize, Opt_wsize, Opt_bsize,
97		- Opt_timeo, Opt_retrans,
98		- Opt_acregmin, Opt_acregmax,
99		- Opt_acdirmin, Opt_acdirmax,
100		- Opt_actimeo,
101		- Opt_namelen,
102		- Opt_mountport,
103		- Opt_mountvers,
104		- Opt_minorversion,
105		-
106		- /* Mount options that take string arguments */
107		- Opt_nfsvers,
108		- Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost,
109		- Opt_addr, Opt_mountaddr, Opt_clientaddr,
110		- Opt_lookupcache,
111		- Opt_fscache_uniq,
112		- Opt_local_lock,
113		-
114		- /* Special mount options */
115		- Opt_userspace, Opt_deprecated, Opt_sloppy,
116		-
117		- Opt_err
118		-};
119		-
120		-static const match_table_t nfs_mount_option_tokens = {
121		- { Opt_userspace, "bg" },
122		- { Opt_userspace, "fg" },
123		- { Opt_userspace, "retry=%s" },
124		-
125		- { Opt_sloppy, "sloppy" },
126		-
127		- { Opt_soft, "soft" },
128		- { Opt_hard, "hard" },
129		- { Opt_deprecated, "intr" },
130		- { Opt_deprecated, "nointr" },
131		- { Opt_posix, "posix" },
132		- { Opt_noposix, "noposix" },
133		- { Opt_cto, "cto" },
134		- { Opt_nocto, "nocto" },
135		- { Opt_ac, "ac" },
136		- { Opt_noac, "noac" },
137		- { Opt_lock, "lock" },
138		- { Opt_nolock, "nolock" },
139		- { Opt_udp, "udp" },
140		- { Opt_tcp, "tcp" },
141		- { Opt_rdma, "rdma" },
142		- { Opt_acl, "acl" },
143		- { Opt_noacl, "noacl" },
144		- { Opt_rdirplus, "rdirplus" },
145		- { Opt_nordirplus, "nordirplus" },
146		- { Opt_sharecache, "sharecache" },
147		- { Opt_nosharecache, "nosharecache" },
148		- { Opt_resvport, "resvport" },
149		- { Opt_noresvport, "noresvport" },
150		- { Opt_fscache, "fsc" },
151		- { Opt_nofscache, "nofsc" },
152		- { Opt_migration, "migration" },
153		- { Opt_nomigration, "nomigration" },
154		-
155		- { Opt_port, "port=%s" },
156		- { Opt_rsize, "rsize=%s" },
157		- { Opt_wsize, "wsize=%s" },
158		- { Opt_bsize, "bsize=%s" },
159		- { Opt_timeo, "timeo=%s" },
160		- { Opt_retrans, "retrans=%s" },
161		- { Opt_acregmin, "acregmin=%s" },
162		- { Opt_acregmax, "acregmax=%s" },
163		- { Opt_acdirmin, "acdirmin=%s" },
164		- { Opt_acdirmax, "acdirmax=%s" },
165		- { Opt_actimeo, "actimeo=%s" },
166		- { Opt_namelen, "namlen=%s" },
167		- { Opt_mountport, "mountport=%s" },
168		- { Opt_mountvers, "mountvers=%s" },
169		- { Opt_minorversion, "minorversion=%s" },
170		-
171		- { Opt_nfsvers, "nfsvers=%s" },
172		- { Opt_nfsvers, "vers=%s" },
173		-
174		- { Opt_sec, "sec=%s" },
175		- { Opt_proto, "proto=%s" },
176		- { Opt_mountproto, "mountproto=%s" },
177		- { Opt_addr, "addr=%s" },
178		- { Opt_clientaddr, "clientaddr=%s" },
179		- { Opt_mounthost, "mounthost=%s" },
180		- { Opt_mountaddr, "mountaddr=%s" },
181		-
182		- { Opt_lookupcache, "lookupcache=%s" },
183		- { Opt_fscache_uniq, "fsc=%s" },
184		- { Opt_local_lock, "local_lock=%s" },
185		-
186		- /* The following needs to be listed after all other options */
187		- { Opt_nfsvers, "v%s" },
188		-
189		- { Opt_err, NULL }
190		-};
191		-
192		-enum {
193		- Opt_xprt_udp, Opt_xprt_udp6, Opt_xprt_tcp, Opt_xprt_tcp6, Opt_xprt_rdma,
194		- Opt_xprt_rdma6,
195		-
196		- Opt_xprt_err
197		-};
198		-
199		-static const match_table_t nfs_xprt_protocol_tokens = {
200		- { Opt_xprt_udp, "udp" },
201		- { Opt_xprt_udp6, "udp6" },
202		- { Opt_xprt_tcp, "tcp" },
203		- { Opt_xprt_tcp6, "tcp6" },
204		- { Opt_xprt_rdma, "rdma" },
205		- { Opt_xprt_rdma6, "rdma6" },
206		-
207		- { Opt_xprt_err, NULL }
208		-};
209		-
210		-enum {
211		- Opt_sec_none, Opt_sec_sys,
212		- Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
213		- Opt_sec_lkey, Opt_sec_lkeyi, Opt_sec_lkeyp,
214		- Opt_sec_spkm, Opt_sec_spkmi, Opt_sec_spkmp,
215		-
216		- Opt_sec_err
217		-};
218		-
219		-static const match_table_t nfs_secflavor_tokens = {
220		- { Opt_sec_none, "none" },
221		- { Opt_sec_none, "null" },
222		- { Opt_sec_sys, "sys" },
223		-
224		- { Opt_sec_krb5, "krb5" },
225		- { Opt_sec_krb5i, "krb5i" },
226		- { Opt_sec_krb5p, "krb5p" },
227		-
228		- { Opt_sec_lkey, "lkey" },
229		- { Opt_sec_lkeyi, "lkeyi" },
230		- { Opt_sec_lkeyp, "lkeyp" },
231		-
232		- { Opt_sec_spkm, "spkm3" },
233		- { Opt_sec_spkmi, "spkm3i" },
234		- { Opt_sec_spkmp, "spkm3p" },
235		-
236		- { Opt_sec_err, NULL }
237		-};
238		-
239		-enum {
240		- Opt_lookupcache_all, Opt_lookupcache_positive,
241		- Opt_lookupcache_none,
242		-
243		- Opt_lookupcache_err
244		-};
245		-
246		-static match_table_t nfs_lookupcache_tokens = {
247		- { Opt_lookupcache_all, "all" },
248		- { Opt_lookupcache_positive, "pos" },
249		- { Opt_lookupcache_positive, "positive" },
250		- { Opt_lookupcache_none, "none" },
251		-
252		- { Opt_lookupcache_err, NULL }
253		-};
254		-
255		-enum {
256		- Opt_local_lock_all, Opt_local_lock_flock, Opt_local_lock_posix,
257		- Opt_local_lock_none,
258		-
259		- Opt_local_lock_err
260		-};
261		-
262		-static match_table_t nfs_local_lock_tokens = {
263		- { Opt_local_lock_all, "all" },
264		- { Opt_local_lock_flock, "flock" },
265		- { Opt_local_lock_posix, "posix" },
266		- { Opt_local_lock_none, "none" },
267		-
268		- { Opt_local_lock_err, NULL }
269		-};
270		-
271		-enum {
272		- Opt_vers_2, Opt_vers_3, Opt_vers_4, Opt_vers_4_0,
273		- Opt_vers_4_1, Opt_vers_4_2,
274		-
275		- Opt_vers_err
276		-};
277		-
278		-static match_table_t nfs_vers_tokens = {
279		- { Opt_vers_2, "2" },
280		- { Opt_vers_3, "3" },
281		- { Opt_vers_4, "4" },
282		- { Opt_vers_4_0, "4.0" },
283		- { Opt_vers_4_1, "4.1" },
284		- { Opt_vers_4_2, "4.2" },
285		-
286		- { Opt_vers_err, NULL }
287		-};
288		-
289		-static struct dentry nfs_xdev_mount(struct file_system_type fs_type,
290		- int flags, const char dev_name, void raw_data);
291		-
292		-struct file_system_type nfs_fs_type = {
293		- .owner = THIS_MODULE,
294		- .name = "nfs",
295		- .mount = nfs_fs_mount,
296		- .kill_sb = nfs_kill_super,
297		- .fs_flags = FS_RENAME_DOES_D_MOVE\|FS_BINARY_MOUNTDATA,
298		-};
299		-MODULE_ALIAS_FS("nfs");
300		-EXPORT_SYMBOL_GPL(nfs_fs_type);
301		-
302		-struct file_system_type nfs_xdev_fs_type = {
303		- .owner = THIS_MODULE,
304		- .name = "nfs",
305		- .mount = nfs_xdev_mount,
306		- .kill_sb = nfs_kill_super,
307		- .fs_flags = FS_RENAME_DOES_D_MOVE\|FS_BINARY_MOUNTDATA,
308		-};
309	73
310	74	const struct super_operations nfs_sops = {
311	75	.alloc_inode = nfs_alloc_inode,
312		- .destroy_inode = nfs_destroy_inode,
	76	+ .free_inode = nfs_free_inode,
313	77	.write_inode = nfs_write_inode,
314	78	.drop_inode = nfs_drop_inode,
315	79	.statfs = nfs_statfs,
..	..	@@ -319,26 +83,14 @@
319	83	.show_devname = nfs_show_devname,
320	84	.show_path = nfs_show_path,
321	85	.show_stats = nfs_show_stats,
322		- .remount_fs = nfs_remount,
323	86	};
324	87	EXPORT_SYMBOL_GPL(nfs_sops);
325	88
326		-#if IS_ENABLED(CONFIG_NFS_V4)
327		-static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *);
328		-static int nfs4_validate_mount_data(void *options,
329		- struct nfs_parsed_mount_data args, const char dev_name);
330		-
331		-struct file_system_type nfs4_fs_type = {
332		- .owner = THIS_MODULE,
333		- .name = "nfs4",
334		- .mount = nfs_fs_mount,
335		- .kill_sb = nfs_kill_super,
336		- .fs_flags = FS_RENAME_DOES_D_MOVE\|FS_BINARY_MOUNTDATA,
	89	+static const struct nfs_ssc_client_ops nfs_ssc_clnt_ops_tbl = {
	90	+ .sco_sb_deactive = nfs_sb_deactive,
337	91	};
338		-MODULE_ALIAS_FS("nfs4");
339		-MODULE_ALIAS("nfs4");
340		-EXPORT_SYMBOL_GPL(nfs4_fs_type);
341	92
	93	+#if IS_ENABLED(CONFIG_NFS_V4)
342	94	static int __init register_nfs4_fs(void)
343	95	{
344	96	return register_filesystem(&nfs4_fs_type);
..	..	@@ -358,6 +110,16 @@
358	110	{
359	111	}
360	112	#endif
	113	+
	114	+static void nfs_ssc_register_ops(void)
	115	+{
	116	+ nfs_ssc_register(&nfs_ssc_clnt_ops_tbl);
	117	+}
	118	+
	119	+static void nfs_ssc_unregister_ops(void)
	120	+{
	121	+ nfs_ssc_unregister(&nfs_ssc_clnt_ops_tbl);
	122	+}
361	123
362	124	static struct shrinker acl_shrinker = {
363	125	.count_objects = nfs_access_cache_count,
..	..	@@ -386,6 +148,7 @@
386	148	ret = register_shrinker(&acl_shrinker);
387	149	if (ret < 0)
388	150	goto error_3;
	151	+ nfs_ssc_register_ops();
389	152	return 0;
390	153	error_3:
391	154	nfs_unregister_sysctl();
..	..	@@ -405,6 +168,7 @@
405	168	unregister_shrinker(&acl_shrinker);
406	169	nfs_unregister_sysctl();
407	170	unregister_nfs4_fs();
	171	+ nfs_ssc_unregister_ops();
408	172	unregister_filesystem(&nfs_fs_type);
409	173	}
410	174
..	..	@@ -429,6 +193,41 @@
429	193	}
430	194	EXPORT_SYMBOL_GPL(nfs_sb_deactive);
431	195
	196	+static int __nfs_list_for_each_server(struct list_head *head,
	197	+ int (fn)(struct nfs_server , void *),
	198	+ void *data)
	199	+{
	200	+ struct nfs_server server, last = NULL;
	201	+ int ret = 0;
	202	+
	203	+ rcu_read_lock();
	204	+ list_for_each_entry_rcu(server, head, client_link) {
	205	+ if (!(server->super && nfs_sb_active(server->super)))
	206	+ continue;
	207	+ rcu_read_unlock();
	208	+ if (last)
	209	+ nfs_sb_deactive(last->super);
	210	+ last = server;
	211	+ ret = fn(server, data);
	212	+ if (ret)
	213	+ goto out;
	214	+ rcu_read_lock();
	215	+ }
	216	+ rcu_read_unlock();
	217	+out:
	218	+ if (last)
	219	+ nfs_sb_deactive(last->super);
	220	+ return ret;
	221	+}
	222	+
	223	+int nfs_client_for_each_server(struct nfs_client *clp,
	224	+ int (fn)(struct nfs_server , void *),
	225	+ void *data)
	226	+{
	227	+ return __nfs_list_for_each_server(&clp->cl_superblocks, fn, data);
	228	+}
	229	+EXPORT_SYMBOL_GPL(nfs_client_for_each_server);
	230	+
432	231	/*
433	232	* Deliver file system statistics to userspace
434	233	*/
..	..	@@ -450,10 +249,8 @@
450	249	struct dentry *pd_dentry;
451	250
452	251	pd_dentry = dget_parent(dentry);
453		- if (pd_dentry != NULL) {
454		- nfs_zap_caches(d_inode(pd_dentry));
455		- dput(pd_dentry);
456		- }
	252	+ nfs_zap_caches(d_inode(pd_dentry));
	253	+ dput(pd_dentry);
457	254	}
458	255	nfs_free_fattr(res.fattr);
459	256	if (error < 0)
..	..	@@ -580,7 +377,7 @@
580	377	}
581	378	default:
582	379	if (showdefaults)
583		- seq_printf(m, ",mountaddr=unspecified");
	380	+ seq_puts(m, ",mountaddr=unspecified");
584	381	}
585	382
586	383	if (nfss->mountd_version \|\| showdefaults)
..	..	@@ -628,7 +425,9 @@
628	425	const char *str;
629	426	const char *nostr;
630	427	} nfs_info[] = {
631		- { NFS_MOUNT_SOFT, ",soft", ",hard" },
	428	+ { NFS_MOUNT_SOFT, ",soft", "" },
	429	+ { NFS_MOUNT_SOFTERR, ",softerr", "" },
	430	+ { NFS_MOUNT_SOFTREVAL, ",softreval", "" },
632	431	{ NFS_MOUNT_POSIX, ",posix", "" },
633	432	{ NFS_MOUNT_NOCTO, ",nocto", "" },
634	433	{ NFS_MOUNT_NOAC, ",noac", "" },
..	..	@@ -658,6 +457,8 @@
658	457	seq_printf(m, ",acdirmin=%u", nfss->acdirmin/HZ);
659	458	if (nfss->acdirmax != NFS_DEF_ACDIRMAX*HZ \|\| showdefaults)
660	459	seq_printf(m, ",acdirmax=%u", nfss->acdirmax/HZ);
	460	+ if (!(nfss->flags & (NFS_MOUNT_SOFT\|NFS_MOUNT_SOFTERR)))
	461	+ seq_puts(m, ",hard");
661	462	for (nfs_infop = nfs_info; nfs_infop->flag; nfs_infop++) {
662	463	if (nfss->flags & nfs_infop->flag)
663	464	seq_puts(m, nfs_infop->str);
..	..	@@ -668,6 +469,8 @@
668	469	seq_printf(m, ",proto=%s",
669	470	rpc_peeraddr2str(nfss->client, RPC_DISPLAY_NETID));
670	471	rcu_read_unlock();
	472	+ if (clp->cl_nconnect > 0)
	473	+ seq_printf(m, ",nconnect=%u", clp->cl_nconnect);
671	474	if (version == 4) {
672	475	if (nfss->port != NFS_PORT)
673	476	seq_printf(m, ",port=%u", nfss->port);
..	..	@@ -685,29 +488,29 @@
685	488	nfs_show_nfsv4_options(m, nfss, showdefaults);
686	489
687	490	if (nfss->options & NFS_OPTION_FSCACHE)
688		- seq_printf(m, ",fsc");
	491	+ seq_puts(m, ",fsc");
689	492
690	493	if (nfss->options & NFS_OPTION_MIGRATION)
691		- seq_printf(m, ",migration");
	494	+ seq_puts(m, ",migration");
692	495
693	496	if (nfss->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG) {
694	497	if (nfss->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
695		- seq_printf(m, ",lookupcache=none");
	498	+ seq_puts(m, ",lookupcache=none");
696	499	else
697		- seq_printf(m, ",lookupcache=pos");
	500	+ seq_puts(m, ",lookupcache=pos");
698	501	}
699	502
700	503	local_flock = nfss->flags & NFS_MOUNT_LOCAL_FLOCK;
701	504	local_fcntl = nfss->flags & NFS_MOUNT_LOCAL_FCNTL;
702	505
703	506	if (!local_flock && !local_fcntl)
704		- seq_printf(m, ",local_lock=none");
	507	+ seq_puts(m, ",local_lock=none");
705	508	else if (local_flock && local_fcntl)
706		- seq_printf(m, ",local_lock=all");
	509	+ seq_puts(m, ",local_lock=all");
707	510	else if (local_flock)
708		- seq_printf(m, ",local_lock=flock");
	511	+ seq_puts(m, ",local_lock=flock");
709	512	else
710		- seq_printf(m, ",local_lock=posix");
	513	+ seq_puts(m, ",local_lock=posix");
711	514	}
712	515
713	516	/*
..	..	@@ -730,11 +533,21 @@
730	533	EXPORT_SYMBOL_GPL(nfs_show_options);
731	534
732	535	#if IS_ENABLED(CONFIG_NFS_V4)
	536	+static void show_lease(struct seq_file m, struct nfs_server server)
	537	+{
	538	+ struct nfs_client *clp = server->nfs_client;
	539	+ unsigned long expire;
	540	+
	541	+ seq_printf(m, ",lease_time=%ld", clp->cl_lease_time / HZ);
	542	+ expire = clp->cl_last_renewal + clp->cl_lease_time;
	543	+ seq_printf(m, ",lease_expired=%ld",
	544	+ time_after(expire, jiffies) ? 0 : (jiffies - expire) / HZ);
	545	+}
733	546	#ifdef CONFIG_NFS_V4_1
734	547	static void show_sessions(struct seq_file m, struct nfs_server server)
735	548	{
736	549	if (nfs4_has_session(server->nfs_client))
737		- seq_printf(m, ",sessions");
	550	+ seq_puts(m, ",sessions");
738	551	}
739	552	#else
740	553	static void show_sessions(struct seq_file m, struct nfs_server server) {}
..	..	@@ -811,7 +624,7 @@
811	624	/*
812	625	* Display all mount option settings
813	626	*/
814		- seq_printf(m, "\n\topts:\t");
	627	+ seq_puts(m, "\n\topts:\t");
815	628	seq_puts(m, sb_rdonly(root->d_sb) ? "ro" : "rw");
816	629	seq_puts(m, root->d_sb->s_flags & SB_SYNCHRONOUS ? ",sync" : "");
817	630	seq_puts(m, root->d_sb->s_flags & SB_NOATIME ? ",noatime" : "");
..	..	@@ -822,7 +635,7 @@
822	635
823	636	show_implementation_id(m, nfss);
824	637
825		- seq_printf(m, "\n\tcaps:\t");
	638	+ seq_puts(m, "\n\tcaps:\t");
826	639	seq_printf(m, "caps=0x%x", nfss->caps);
827	640	seq_printf(m, ",wtmult=%u", nfss->wtmult);
828	641	seq_printf(m, ",dtsize=%u", nfss->dtsize);
..	..	@@ -831,13 +644,14 @@
831	644
832	645	#if IS_ENABLED(CONFIG_NFS_V4)
833	646	if (nfss->nfs_client->rpc_ops->version == 4) {
834		- seq_printf(m, "\n\tnfsv4:\t");
	647	+ seq_puts(m, "\n\tnfsv4:\t");
835	648	seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]);
836	649	seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]);
837	650	seq_printf(m, ",bm2=0x%x", nfss->attr_bitmask[2]);
838	651	seq_printf(m, ",acl=0x%x", nfss->acl_bitmask);
839	652	show_sessions(m, nfss);
840	653	show_pnfs(m, nfss);
	654	+ show_lease(m, nfss);
841	655	}
842	656	#endif
843	657
..	..	@@ -869,20 +683,20 @@
869	683	preempt_enable();
870	684	}
871	685
872		- seq_printf(m, "\n\tevents:\t");
	686	+ seq_puts(m, "\n\tevents:\t");
873	687	for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
874	688	seq_printf(m, "%lu ", totals.events[i]);
875		- seq_printf(m, "\n\tbytes:\t");
	689	+ seq_puts(m, "\n\tbytes:\t");
876	690	for (i = 0; i < __NFSIOS_BYTESMAX; i++)
877	691	seq_printf(m, "%Lu ", totals.bytes[i]);
878	692	#ifdef CONFIG_NFS_FSCACHE
879	693	if (nfss->options & NFS_OPTION_FSCACHE) {
880		- seq_printf(m, "\n\tfsc:\t");
	694	+ seq_puts(m, "\n\tfsc:\t");
881	695	for (i = 0; i < __NFSIOS_FSCACHEMAX; i++)
882	696	seq_printf(m, "%Lu ", totals.fscache[i]);
883	697	}
884	698	#endif
885		- seq_printf(m, "\n");
	699	+ seq_putc(m, '\n');
886	700
887	701	rpc_clnt_show_stats(m, nfss->client);
888	702
..	..	@@ -910,141 +724,6 @@
910	724	}
911	725	EXPORT_SYMBOL_GPL(nfs_umount_begin);
912	726
913		-static struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(void)
914		-{
915		- struct nfs_parsed_mount_data *data;
916		-
917		- data = kzalloc(sizeof(*data), GFP_KERNEL);
918		- if (data) {
919		- data->timeo = NFS_UNSPEC_TIMEO;
920		- data->retrans = NFS_UNSPEC_RETRANS;
921		- data->acregmin = NFS_DEF_ACREGMIN;
922		- data->acregmax = NFS_DEF_ACREGMAX;
923		- data->acdirmin = NFS_DEF_ACDIRMIN;
924		- data->acdirmax = NFS_DEF_ACDIRMAX;
925		- data->mount_server.port = NFS_UNSPEC_PORT;
926		- data->nfs_server.port = NFS_UNSPEC_PORT;
927		- data->nfs_server.protocol = XPRT_TRANSPORT_TCP;
928		- data->selected_flavor = RPC_AUTH_MAXFLAVOR;
929		- data->minorversion = 0;
930		- data->need_mount = true;
931		- data->net = current->nsproxy->net_ns;
932		- security_init_mnt_opts(&data->lsm_opts);
933		- }
934		- return data;
935		-}
936		-
937		-static void nfs_free_parsed_mount_data(struct nfs_parsed_mount_data *data)
938		-{
939		- if (data) {
940		- kfree(data->client_address);
941		- kfree(data->mount_server.hostname);
942		- kfree(data->nfs_server.export_path);
943		- kfree(data->nfs_server.hostname);
944		- kfree(data->fscache_uniq);
945		- security_free_mnt_opts(&data->lsm_opts);
946		- kfree(data);
947		- }
948		-}
949		-
950		-/*
951		- * Sanity-check a server address provided by the mount command.
952		- *
953		- * Address family must be initialized, and address must not be
954		- * the ANY address for that family.
955		- */
956		-static int nfs_verify_server_address(struct sockaddr *addr)
957		-{
958		- switch (addr->sa_family) {
959		- case AF_INET: {
960		- struct sockaddr_in sa = (struct sockaddr_in )addr;
961		- return sa->sin_addr.s_addr != htonl(INADDR_ANY);
962		- }
963		- case AF_INET6: {
964		- struct in6_addr sa = &((struct sockaddr_in6 )addr)->sin6_addr;
965		- return !ipv6_addr_any(sa);
966		- }
967		- }
968		-
969		- dfprintk(MOUNT, "NFS: Invalid IP address specified\n");
970		- return 0;
971		-}
972		-
973		-/*
974		- * Select between a default port value and a user-specified port value.
975		- * If a zero value is set, then autobind will be used.
976		- */
977		-static void nfs_set_port(struct sockaddr sap, int port,
978		- const unsigned short default_port)
979		-{
980		- if (*port == NFS_UNSPEC_PORT)
981		- *port = default_port;
982		-
983		- rpc_set_port(sap, *port);
984		-}
985		-
986		-/*
987		- * Sanity check the NFS transport protocol.
988		- *
989		- */
990		-static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data *mnt)
991		-{
992		- switch (mnt->nfs_server.protocol) {
993		- case XPRT_TRANSPORT_UDP:
994		- case XPRT_TRANSPORT_TCP:
995		- case XPRT_TRANSPORT_RDMA:
996		- break;
997		- default:
998		- mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
999		- }
1000		-}
1001		-
1002		-/*
1003		- * For text based NFSv2/v3 mounts, the mount protocol transport default
1004		- * settings should depend upon the specified NFS transport.
1005		- */
1006		-static void nfs_set_mount_transport_protocol(struct nfs_parsed_mount_data *mnt)
1007		-{
1008		- nfs_validate_transport_protocol(mnt);
1009		-
1010		- if (mnt->mount_server.protocol == XPRT_TRANSPORT_UDP \|\|
1011		- mnt->mount_server.protocol == XPRT_TRANSPORT_TCP)
1012		- return;
1013		- switch (mnt->nfs_server.protocol) {
1014		- case XPRT_TRANSPORT_UDP:
1015		- mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
1016		- break;
1017		- case XPRT_TRANSPORT_TCP:
1018		- case XPRT_TRANSPORT_RDMA:
1019		- mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
1020		- }
1021		-}
1022		-
1023		-/*
1024		- * Add 'flavor' to 'auth_info' if not already present.
1025		- * Returns true if 'flavor' ends up in the list, false otherwise
1026		- */
1027		-static bool nfs_auth_info_add(struct nfs_auth_info *auth_info,
1028		- rpc_authflavor_t flavor)
1029		-{
1030		- unsigned int i;
1031		- unsigned int max_flavor_len = ARRAY_SIZE(auth_info->flavors);
1032		-
1033		- /* make sure this flavor isn't already in the list */
1034		- for (i = 0; i < auth_info->flavor_len; i++) {
1035		- if (flavor == auth_info->flavors[i])
1036		- return true;
1037		- }
1038		-
1039		- if (auth_info->flavor_len + 1 >= max_flavor_len) {
1040		- dfprintk(MOUNT, "NFS: too many sec= flavors\n");
1041		- return false;
1042		- }
1043		-
1044		- auth_info->flavors[auth_info->flavor_len++] = flavor;
1045		- return true;
1046		-}
1047		-
1048	727	/*
1049	728	* Return true if 'match' is in auth_info or auth_info is empty.
1050	729	* Return false otherwise.
..	..	@@ -1066,634 +745,13 @@
1066	745	EXPORT_SYMBOL_GPL(nfs_auth_info_match);
1067	746
1068	747	/*
1069		- * Parse the value of the 'sec=' option.
1070		- */
1071		-static int nfs_parse_security_flavors(char *value,
1072		- struct nfs_parsed_mount_data *mnt)
1073		-{
1074		- substring_t args[MAX_OPT_ARGS];
1075		- rpc_authflavor_t pseudoflavor;
1076		- char *p;
1077		-
1078		- dfprintk(MOUNT, "NFS: parsing sec=%s option\n", value);
1079		-
1080		- while ((p = strsep(&value, ":")) != NULL) {
1081		- switch (match_token(p, nfs_secflavor_tokens, args)) {
1082		- case Opt_sec_none:
1083		- pseudoflavor = RPC_AUTH_NULL;
1084		- break;
1085		- case Opt_sec_sys:
1086		- pseudoflavor = RPC_AUTH_UNIX;
1087		- break;
1088		- case Opt_sec_krb5:
1089		- pseudoflavor = RPC_AUTH_GSS_KRB5;
1090		- break;
1091		- case Opt_sec_krb5i:
1092		- pseudoflavor = RPC_AUTH_GSS_KRB5I;
1093		- break;
1094		- case Opt_sec_krb5p:
1095		- pseudoflavor = RPC_AUTH_GSS_KRB5P;
1096		- break;
1097		- case Opt_sec_lkey:
1098		- pseudoflavor = RPC_AUTH_GSS_LKEY;
1099		- break;
1100		- case Opt_sec_lkeyi:
1101		- pseudoflavor = RPC_AUTH_GSS_LKEYI;
1102		- break;
1103		- case Opt_sec_lkeyp:
1104		- pseudoflavor = RPC_AUTH_GSS_LKEYP;
1105		- break;
1106		- case Opt_sec_spkm:
1107		- pseudoflavor = RPC_AUTH_GSS_SPKM;
1108		- break;
1109		- case Opt_sec_spkmi:
1110		- pseudoflavor = RPC_AUTH_GSS_SPKMI;
1111		- break;
1112		- case Opt_sec_spkmp:
1113		- pseudoflavor = RPC_AUTH_GSS_SPKMP;
1114		- break;
1115		- default:
1116		- dfprintk(MOUNT,
1117		- "NFS: sec= option '%s' not recognized\n", p);
1118		- return 0;
1119		- }
1120		-
1121		- if (!nfs_auth_info_add(&mnt->auth_info, pseudoflavor))
1122		- return 0;
1123		- }
1124		-
1125		- return 1;
1126		-}
1127		-
1128		-static int nfs_parse_version_string(char *string,
1129		- struct nfs_parsed_mount_data *mnt,
1130		- substring_t *args)
1131		-{
1132		- mnt->flags &= ~NFS_MOUNT_VER3;
1133		- switch (match_token(string, nfs_vers_tokens, args)) {
1134		- case Opt_vers_2:
1135		- mnt->version = 2;
1136		- break;
1137		- case Opt_vers_3:
1138		- mnt->flags \|= NFS_MOUNT_VER3;
1139		- mnt->version = 3;
1140		- break;
1141		- case Opt_vers_4:
1142		- /* Backward compatibility option. In future,
1143		- * the mount program should always supply
1144		- * a NFSv4 minor version number.
1145		- */
1146		- mnt->version = 4;
1147		- break;
1148		- case Opt_vers_4_0:
1149		- mnt->version = 4;
1150		- mnt->minorversion = 0;
1151		- break;
1152		- case Opt_vers_4_1:
1153		- mnt->version = 4;
1154		- mnt->minorversion = 1;
1155		- break;
1156		- case Opt_vers_4_2:
1157		- mnt->version = 4;
1158		- mnt->minorversion = 2;
1159		- break;
1160		- default:
1161		- return 0;
1162		- }
1163		- return 1;
1164		-}
1165		-
1166		-static int nfs_get_option_str(substring_t args[], char **option)
1167		-{
1168		- kfree(*option);
1169		- *option = match_strdup(args);
1170		- return !*option;
1171		-}
1172		-
1173		-static int nfs_get_option_ul(substring_t args[], unsigned long *option)
1174		-{
1175		- int rc;
1176		- char *string;
1177		-
1178		- string = match_strdup(args);
1179		- if (string == NULL)
1180		- return -ENOMEM;
1181		- rc = kstrtoul(string, 10, option);
1182		- kfree(string);
1183		-
1184		- return rc;
1185		-}
1186		-
1187		-static int nfs_get_option_ul_bound(substring_t args[], unsigned long *option,
1188		- unsigned long l_bound, unsigned long u_bound)
1189		-{
1190		- int ret;
1191		-
1192		- ret = nfs_get_option_ul(args, option);
1193		- if (ret != 0)
1194		- return ret;
1195		- if (option < l_bound \|\| option > u_bound)
1196		- return -ERANGE;
1197		- return 0;
1198		-}
1199		-
1200		-/*
1201		- * Error-check and convert a string of mount options from user space into
1202		- * a data structure. The whole mount string is processed; bad options are
1203		- * skipped as they are encountered. If there were no errors, return 1;
1204		- * otherwise return 0 (zero).
1205		- */
1206		-static int nfs_parse_mount_options(char *raw,
1207		- struct nfs_parsed_mount_data *mnt)
1208		-{
1209		- char p, string, *secdata;
1210		- int rc, sloppy = 0, invalid_option = 0;
1211		- unsigned short protofamily = AF_UNSPEC;
1212		- unsigned short mountfamily = AF_UNSPEC;
1213		-
1214		- if (!raw) {
1215		- dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
1216		- return 1;
1217		- }
1218		- dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
1219		-
1220		- secdata = alloc_secdata();
1221		- if (!secdata)
1222		- goto out_nomem;
1223		-
1224		- rc = security_sb_copy_data(raw, secdata);
1225		- if (rc)
1226		- goto out_security_failure;
1227		-
1228		- rc = security_sb_parse_opts_str(secdata, &mnt->lsm_opts);
1229		- if (rc)
1230		- goto out_security_failure;
1231		-
1232		- free_secdata(secdata);
1233		-
1234		- while ((p = strsep(&raw, ",")) != NULL) {
1235		- substring_t args[MAX_OPT_ARGS];
1236		- unsigned long option;
1237		- int token;
1238		-
1239		- if (!*p)
1240		- continue;
1241		-
1242		- dfprintk(MOUNT, "NFS: parsing nfs mount option '%s'\n", p);
1243		-
1244		- token = match_token(p, nfs_mount_option_tokens, args);
1245		- switch (token) {
1246		-
1247		- /*
1248		- * boolean options: foo/nofoo
1249		- */
1250		- case Opt_soft:
1251		- mnt->flags \|= NFS_MOUNT_SOFT;
1252		- break;
1253		- case Opt_hard:
1254		- mnt->flags &= ~NFS_MOUNT_SOFT;
1255		- break;
1256		- case Opt_posix:
1257		- mnt->flags \|= NFS_MOUNT_POSIX;
1258		- break;
1259		- case Opt_noposix:
1260		- mnt->flags &= ~NFS_MOUNT_POSIX;
1261		- break;
1262		- case Opt_cto:
1263		- mnt->flags &= ~NFS_MOUNT_NOCTO;
1264		- break;
1265		- case Opt_nocto:
1266		- mnt->flags \|= NFS_MOUNT_NOCTO;
1267		- break;
1268		- case Opt_ac:
1269		- mnt->flags &= ~NFS_MOUNT_NOAC;
1270		- break;
1271		- case Opt_noac:
1272		- mnt->flags \|= NFS_MOUNT_NOAC;
1273		- break;
1274		- case Opt_lock:
1275		- mnt->flags &= ~NFS_MOUNT_NONLM;
1276		- mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK \|
1277		- NFS_MOUNT_LOCAL_FCNTL);
1278		- break;
1279		- case Opt_nolock:
1280		- mnt->flags \|= NFS_MOUNT_NONLM;
1281		- mnt->flags \|= (NFS_MOUNT_LOCAL_FLOCK \|
1282		- NFS_MOUNT_LOCAL_FCNTL);
1283		- break;
1284		- case Opt_udp:
1285		- mnt->flags &= ~NFS_MOUNT_TCP;
1286		- mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1287		- break;
1288		- case Opt_tcp:
1289		- mnt->flags \|= NFS_MOUNT_TCP;
1290		- mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1291		- break;
1292		- case Opt_rdma:
1293		- mnt->flags \|= NFS_MOUNT_TCP; /* for side protocols */
1294		- mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
1295		- xprt_load_transport(p);
1296		- break;
1297		- case Opt_acl:
1298		- mnt->flags &= ~NFS_MOUNT_NOACL;
1299		- break;
1300		- case Opt_noacl:
1301		- mnt->flags \|= NFS_MOUNT_NOACL;
1302		- break;
1303		- case Opt_rdirplus:
1304		- mnt->flags &= ~NFS_MOUNT_NORDIRPLUS;
1305		- break;
1306		- case Opt_nordirplus:
1307		- mnt->flags \|= NFS_MOUNT_NORDIRPLUS;
1308		- break;
1309		- case Opt_sharecache:
1310		- mnt->flags &= ~NFS_MOUNT_UNSHARED;
1311		- break;
1312		- case Opt_nosharecache:
1313		- mnt->flags \|= NFS_MOUNT_UNSHARED;
1314		- break;
1315		- case Opt_resvport:
1316		- mnt->flags &= ~NFS_MOUNT_NORESVPORT;
1317		- break;
1318		- case Opt_noresvport:
1319		- mnt->flags \|= NFS_MOUNT_NORESVPORT;
1320		- break;
1321		- case Opt_fscache:
1322		- mnt->options \|= NFS_OPTION_FSCACHE;
1323		- kfree(mnt->fscache_uniq);
1324		- mnt->fscache_uniq = NULL;
1325		- break;
1326		- case Opt_nofscache:
1327		- mnt->options &= ~NFS_OPTION_FSCACHE;
1328		- kfree(mnt->fscache_uniq);
1329		- mnt->fscache_uniq = NULL;
1330		- break;
1331		- case Opt_migration:
1332		- mnt->options \|= NFS_OPTION_MIGRATION;
1333		- break;
1334		- case Opt_nomigration:
1335		- mnt->options &= ~NFS_OPTION_MIGRATION;
1336		- break;
1337		-
1338		- /*
1339		- * options that take numeric values
1340		- */
1341		- case Opt_port:
1342		- if (nfs_get_option_ul(args, &option) \|\|
1343		- option > USHRT_MAX)
1344		- goto out_invalid_value;
1345		- mnt->nfs_server.port = option;
1346		- break;
1347		- case Opt_rsize:
1348		- if (nfs_get_option_ul(args, &option))
1349		- goto out_invalid_value;
1350		- mnt->rsize = option;
1351		- break;
1352		- case Opt_wsize:
1353		- if (nfs_get_option_ul(args, &option))
1354		- goto out_invalid_value;
1355		- mnt->wsize = option;
1356		- break;
1357		- case Opt_bsize:
1358		- if (nfs_get_option_ul(args, &option))
1359		- goto out_invalid_value;
1360		- mnt->bsize = option;
1361		- break;
1362		- case Opt_timeo:
1363		- if (nfs_get_option_ul_bound(args, &option, 1, INT_MAX))
1364		- goto out_invalid_value;
1365		- mnt->timeo = option;
1366		- break;
1367		- case Opt_retrans:
1368		- if (nfs_get_option_ul_bound(args, &option, 0, INT_MAX))
1369		- goto out_invalid_value;
1370		- mnt->retrans = option;
1371		- break;
1372		- case Opt_acregmin:
1373		- if (nfs_get_option_ul(args, &option))
1374		- goto out_invalid_value;
1375		- mnt->acregmin = option;
1376		- break;
1377		- case Opt_acregmax:
1378		- if (nfs_get_option_ul(args, &option))
1379		- goto out_invalid_value;
1380		- mnt->acregmax = option;
1381		- break;
1382		- case Opt_acdirmin:
1383		- if (nfs_get_option_ul(args, &option))
1384		- goto out_invalid_value;
1385		- mnt->acdirmin = option;
1386		- break;
1387		- case Opt_acdirmax:
1388		- if (nfs_get_option_ul(args, &option))
1389		- goto out_invalid_value;
1390		- mnt->acdirmax = option;
1391		- break;
1392		- case Opt_actimeo:
1393		- if (nfs_get_option_ul(args, &option))
1394		- goto out_invalid_value;
1395		- mnt->acregmin = mnt->acregmax =
1396		- mnt->acdirmin = mnt->acdirmax = option;
1397		- break;
1398		- case Opt_namelen:
1399		- if (nfs_get_option_ul(args, &option))
1400		- goto out_invalid_value;
1401		- mnt->namlen = option;
1402		- break;
1403		- case Opt_mountport:
1404		- if (nfs_get_option_ul(args, &option) \|\|
1405		- option > USHRT_MAX)
1406		- goto out_invalid_value;
1407		- mnt->mount_server.port = option;
1408		- break;
1409		- case Opt_mountvers:
1410		- if (nfs_get_option_ul(args, &option) \|\|
1411		- option < NFS_MNT_VERSION \|\|
1412		- option > NFS_MNT3_VERSION)
1413		- goto out_invalid_value;
1414		- mnt->mount_server.version = option;
1415		- break;
1416		- case Opt_minorversion:
1417		- if (nfs_get_option_ul(args, &option))
1418		- goto out_invalid_value;
1419		- if (option > NFS4_MAX_MINOR_VERSION)
1420		- goto out_invalid_value;
1421		- mnt->minorversion = option;
1422		- break;
1423		-
1424		- /*
1425		- * options that take text values
1426		- */
1427		- case Opt_nfsvers:
1428		- string = match_strdup(args);
1429		- if (string == NULL)
1430		- goto out_nomem;
1431		- rc = nfs_parse_version_string(string, mnt, args);
1432		- kfree(string);
1433		- if (!rc)
1434		- goto out_invalid_value;
1435		- break;
1436		- case Opt_sec:
1437		- string = match_strdup(args);
1438		- if (string == NULL)
1439		- goto out_nomem;
1440		- rc = nfs_parse_security_flavors(string, mnt);
1441		- kfree(string);
1442		- if (!rc) {
1443		- dfprintk(MOUNT, "NFS: unrecognized "
1444		- "security flavor\n");
1445		- return 0;
1446		- }
1447		- break;
1448		- case Opt_proto:
1449		- string = match_strdup(args);
1450		- if (string == NULL)
1451		- goto out_nomem;
1452		- token = match_token(string,
1453		- nfs_xprt_protocol_tokens, args);
1454		-
1455		- protofamily = AF_INET;
1456		- switch (token) {
1457		- case Opt_xprt_udp6:
1458		- protofamily = AF_INET6;
1459		- /* fall through */
1460		- case Opt_xprt_udp:
1461		- mnt->flags &= ~NFS_MOUNT_TCP;
1462		- mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1463		- break;
1464		- case Opt_xprt_tcp6:
1465		- protofamily = AF_INET6;
1466		- /* fall through */
1467		- case Opt_xprt_tcp:
1468		- mnt->flags \|= NFS_MOUNT_TCP;
1469		- mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1470		- break;
1471		- case Opt_xprt_rdma6:
1472		- protofamily = AF_INET6;
1473		- /* fall through */
1474		- case Opt_xprt_rdma:
1475		- /* vector side protocols to TCP */
1476		- mnt->flags \|= NFS_MOUNT_TCP;
1477		- mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
1478		- xprt_load_transport(string);
1479		- break;
1480		- default:
1481		- dfprintk(MOUNT, "NFS: unrecognized "
1482		- "transport protocol\n");
1483		- kfree(string);
1484		- return 0;
1485		- }
1486		- kfree(string);
1487		- break;
1488		- case Opt_mountproto:
1489		- string = match_strdup(args);
1490		- if (string == NULL)
1491		- goto out_nomem;
1492		- token = match_token(string,
1493		- nfs_xprt_protocol_tokens, args);
1494		- kfree(string);
1495		-
1496		- mountfamily = AF_INET;
1497		- switch (token) {
1498		- case Opt_xprt_udp6:
1499		- mountfamily = AF_INET6;
1500		- /* fall through */
1501		- case Opt_xprt_udp:
1502		- mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
1503		- break;
1504		- case Opt_xprt_tcp6:
1505		- mountfamily = AF_INET6;
1506		- /* fall through */
1507		- case Opt_xprt_tcp:
1508		- mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
1509		- break;
1510		- case Opt_xprt_rdma: /* not used for side protocols */
1511		- default:
1512		- dfprintk(MOUNT, "NFS: unrecognized "
1513		- "transport protocol\n");
1514		- return 0;
1515		- }
1516		- break;
1517		- case Opt_addr:
1518		- string = match_strdup(args);
1519		- if (string == NULL)
1520		- goto out_nomem;
1521		- mnt->nfs_server.addrlen =
1522		- rpc_pton(mnt->net, string, strlen(string),
1523		- (struct sockaddr *)
1524		- &mnt->nfs_server.address,
1525		- sizeof(mnt->nfs_server.address));
1526		- kfree(string);
1527		- if (mnt->nfs_server.addrlen == 0)
1528		- goto out_invalid_address;
1529		- break;
1530		- case Opt_clientaddr:
1531		- if (nfs_get_option_str(args, &mnt->client_address))
1532		- goto out_nomem;
1533		- break;
1534		- case Opt_mounthost:
1535		- if (nfs_get_option_str(args,
1536		- &mnt->mount_server.hostname))
1537		- goto out_nomem;
1538		- break;
1539		- case Opt_mountaddr:
1540		- string = match_strdup(args);
1541		- if (string == NULL)
1542		- goto out_nomem;
1543		- mnt->mount_server.addrlen =
1544		- rpc_pton(mnt->net, string, strlen(string),
1545		- (struct sockaddr *)
1546		- &mnt->mount_server.address,
1547		- sizeof(mnt->mount_server.address));
1548		- kfree(string);
1549		- if (mnt->mount_server.addrlen == 0)
1550		- goto out_invalid_address;
1551		- break;
1552		- case Opt_lookupcache:
1553		- string = match_strdup(args);
1554		- if (string == NULL)
1555		- goto out_nomem;
1556		- token = match_token(string,
1557		- nfs_lookupcache_tokens, args);
1558		- kfree(string);
1559		- switch (token) {
1560		- case Opt_lookupcache_all:
1561		- mnt->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG\|NFS_MOUNT_LOOKUP_CACHE_NONE);
1562		- break;
1563		- case Opt_lookupcache_positive:
1564		- mnt->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE;
1565		- mnt->flags \|= NFS_MOUNT_LOOKUP_CACHE_NONEG;
1566		- break;
1567		- case Opt_lookupcache_none:
1568		- mnt->flags \|= NFS_MOUNT_LOOKUP_CACHE_NONEG\|NFS_MOUNT_LOOKUP_CACHE_NONE;
1569		- break;
1570		- default:
1571		- dfprintk(MOUNT, "NFS: invalid "
1572		- "lookupcache argument\n");
1573		- return 0;
1574		- };
1575		- break;
1576		- case Opt_fscache_uniq:
1577		- if (nfs_get_option_str(args, &mnt->fscache_uniq))
1578		- goto out_nomem;
1579		- mnt->options \|= NFS_OPTION_FSCACHE;
1580		- break;
1581		- case Opt_local_lock:
1582		- string = match_strdup(args);
1583		- if (string == NULL)
1584		- goto out_nomem;
1585		- token = match_token(string, nfs_local_lock_tokens,
1586		- args);
1587		- kfree(string);
1588		- switch (token) {
1589		- case Opt_local_lock_all:
1590		- mnt->flags \|= (NFS_MOUNT_LOCAL_FLOCK \|
1591		- NFS_MOUNT_LOCAL_FCNTL);
1592		- break;
1593		- case Opt_local_lock_flock:
1594		- mnt->flags \|= NFS_MOUNT_LOCAL_FLOCK;
1595		- break;
1596		- case Opt_local_lock_posix:
1597		- mnt->flags \|= NFS_MOUNT_LOCAL_FCNTL;
1598		- break;
1599		- case Opt_local_lock_none:
1600		- mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK \|
1601		- NFS_MOUNT_LOCAL_FCNTL);
1602		- break;
1603		- default:
1604		- dfprintk(MOUNT, "NFS: invalid "
1605		- "local_lock argument\n");
1606		- return 0;
1607		- };
1608		- break;
1609		-
1610		- /*
1611		- * Special options
1612		- */
1613		- case Opt_sloppy:
1614		- sloppy = 1;
1615		- dfprintk(MOUNT, "NFS: relaxing parsing rules\n");
1616		- break;
1617		- case Opt_userspace:
1618		- case Opt_deprecated:
1619		- dfprintk(MOUNT, "NFS: ignoring mount option "
1620		- "'%s'\n", p);
1621		- break;
1622		-
1623		- default:
1624		- invalid_option = 1;
1625		- dfprintk(MOUNT, "NFS: unrecognized mount option "
1626		- "'%s'\n", p);
1627		- }
1628		- }
1629		-
1630		- if (!sloppy && invalid_option)
1631		- return 0;
1632		-
1633		- if (mnt->minorversion && mnt->version != 4)
1634		- goto out_minorversion_mismatch;
1635		-
1636		- if (mnt->options & NFS_OPTION_MIGRATION &&
1637		- (mnt->version != 4 \|\| mnt->minorversion != 0))
1638		- goto out_migration_misuse;
1639		-
1640		- /*
1641		- * verify that any proto=/mountproto= options match the address
1642		- * families in the addr=/mountaddr= options.
1643		- */
1644		- if (protofamily != AF_UNSPEC &&
1645		- protofamily != mnt->nfs_server.address.ss_family)
1646		- goto out_proto_mismatch;
1647		-
1648		- if (mountfamily != AF_UNSPEC) {
1649		- if (mnt->mount_server.addrlen) {
1650		- if (mountfamily != mnt->mount_server.address.ss_family)
1651		- goto out_mountproto_mismatch;
1652		- } else {
1653		- if (mountfamily != mnt->nfs_server.address.ss_family)
1654		- goto out_mountproto_mismatch;
1655		- }
1656		- }
1657		-
1658		- return 1;
1659		-
1660		-out_mountproto_mismatch:
1661		- printk(KERN_INFO "NFS: mount server address does not match mountproto= "
1662		- "option\n");
1663		- return 0;
1664		-out_proto_mismatch:
1665		- printk(KERN_INFO "NFS: server address does not match proto= option\n");
1666		- return 0;
1667		-out_invalid_address:
1668		- printk(KERN_INFO "NFS: bad IP address specified: %s\n", p);
1669		- return 0;
1670		-out_invalid_value:
1671		- printk(KERN_INFO "NFS: bad mount option value specified: %s\n", p);
1672		- return 0;
1673		-out_minorversion_mismatch:
1674		- printk(KERN_INFO "NFS: mount option vers=%u does not support "
1675		- "minorversion=%u\n", mnt->version, mnt->minorversion);
1676		- return 0;
1677		-out_migration_misuse:
1678		- printk(KERN_INFO
1679		- "NFS: 'migration' not supported for this NFS version\n");
1680		- return 0;
1681		-out_nomem:
1682		- printk(KERN_INFO "NFS: not enough memory to parse option\n");
1683		- return 0;
1684		-out_security_failure:
1685		- free_secdata(secdata);
1686		- printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
1687		- return 0;
1688		-}
1689		-
1690		-/*
1691		- * Ensure that a specified authtype in args->auth_info is supported by
1692		- * the server. Returns 0 and sets args->selected_flavor if it's ok, and
	748	+ * Ensure that a specified authtype in ctx->auth_info is supported by
	749	+ * the server. Returns 0 and sets ctx->selected_flavor if it's ok, and
1693	750	* -EACCES if not.
1694	751	*/
1695		-static int nfs_verify_authflavors(struct nfs_parsed_mount_data *args,
1696		- rpc_authflavor_t *server_authlist, unsigned int count)
	752	+static int nfs_verify_authflavors(struct nfs_fs_context *ctx,
	753	+ rpc_authflavor_t *server_authlist,
	754	+ unsigned int count)
1697	755	{
1698	756	rpc_authflavor_t flavor = RPC_AUTH_MAXFLAVOR;
1699	757	bool found_auth_null = false;
..	..	@@ -1714,7 +772,7 @@
1714	772	for (i = 0; i < count; i++) {
1715	773	flavor = server_authlist[i];
1716	774
1717		- if (nfs_auth_info_match(&args->auth_info, flavor))
	775	+ if (nfs_auth_info_match(&ctx->auth_info, flavor))
1718	776	goto out;
1719	777
1720	778	if (flavor == RPC_AUTH_NULL)
..	..	@@ -1722,7 +780,7 @@
1722	780	}
1723	781
1724	782	if (found_auth_null) {
1725		- flavor = args->auth_info.flavors[0];
	783	+ flavor = ctx->auth_info.flavors[0];
1726	784	goto out;
1727	785	}
1728	786
..	..	@@ -1731,8 +789,8 @@
1731	789	return -EACCES;
1732	790
1733	791	out:
1734		- args->selected_flavor = flavor;
1735		- dfprintk(MOUNT, "NFS: using auth flavor %u\n", args->selected_flavor);
	792	+ ctx->selected_flavor = flavor;
	793	+ dfprintk(MOUNT, "NFS: using auth flavor %u\n", ctx->selected_flavor);
1736	794	return 0;
1737	795	}
1738	796
..	..	@@ -1740,50 +798,51 @@
1740	798	* Use the remote server's MOUNT service to request the NFS file handle
1741	799	* corresponding to the provided path.
1742	800	*/
1743		-static int nfs_request_mount(struct nfs_parsed_mount_data *args,
	801	+static int nfs_request_mount(struct fs_context *fc,
1744	802	struct nfs_fh *root_fh,
1745	803	rpc_authflavor_t *server_authlist,
1746	804	unsigned int *server_authlist_len)
1747	805	{
	806	+ struct nfs_fs_context *ctx = nfs_fc2context(fc);
1748	807	struct nfs_mount_request request = {
1749	808	.sap = (struct sockaddr *)
1750		- &args->mount_server.address,
1751		- .dirpath = args->nfs_server.export_path,
1752		- .protocol = args->mount_server.protocol,
	809	+ &ctx->mount_server.address,
	810	+ .dirpath = ctx->nfs_server.export_path,
	811	+ .protocol = ctx->mount_server.protocol,
1753	812	.fh = root_fh,
1754		- .noresvport = args->flags & NFS_MOUNT_NORESVPORT,
	813	+ .noresvport = ctx->flags & NFS_MOUNT_NORESVPORT,
1755	814	.auth_flav_len = server_authlist_len,
1756	815	.auth_flavs = server_authlist,
1757		- .net = args->net,
	816	+ .net = fc->net_ns,
1758	817	};
1759	818	int status;
1760	819
1761		- if (args->mount_server.version == 0) {
1762		- switch (args->version) {
	820	+ if (ctx->mount_server.version == 0) {
	821	+ switch (ctx->version) {
1763	822	default:
1764		- args->mount_server.version = NFS_MNT3_VERSION;
	823	+ ctx->mount_server.version = NFS_MNT3_VERSION;
1765	824	break;
1766	825	case 2:
1767		- args->mount_server.version = NFS_MNT_VERSION;
	826	+ ctx->mount_server.version = NFS_MNT_VERSION;
1768	827	}
1769	828	}
1770		- request.version = args->mount_server.version;
	829	+ request.version = ctx->mount_server.version;
1771	830
1772		- if (args->mount_server.hostname)
1773		- request.hostname = args->mount_server.hostname;
	831	+ if (ctx->mount_server.hostname)
	832	+ request.hostname = ctx->mount_server.hostname;
1774	833	else
1775		- request.hostname = args->nfs_server.hostname;
	834	+ request.hostname = ctx->nfs_server.hostname;
1776	835
1777	836	/*
1778	837	* Construct the mount server's address.
1779	838	*/
1780		- if (args->mount_server.address.ss_family == AF_UNSPEC) {
1781		- memcpy(request.sap, &args->nfs_server.address,
1782		- args->nfs_server.addrlen);
1783		- args->mount_server.addrlen = args->nfs_server.addrlen;
	839	+ if (ctx->mount_server.address.sa_family == AF_UNSPEC) {
	840	+ memcpy(request.sap, &ctx->nfs_server.address,
	841	+ ctx->nfs_server.addrlen);
	842	+ ctx->mount_server.addrlen = ctx->nfs_server.addrlen;
1784	843	}
1785		- request.salen = args->mount_server.addrlen;
1786		- nfs_set_port(request.sap, &args->mount_server.port, 0);
	844	+ request.salen = ctx->mount_server.addrlen;
	845	+ nfs_set_port(request.sap, &ctx->mount_server.port, 0);
1787	846
1788	847	/*
1789	848	* Now ask the mount server to map our export path
..	..	@@ -1799,20 +858,18 @@
1799	858	return 0;
1800	859	}
1801	860
1802		-static struct nfs_server nfs_try_mount_request(struct nfs_mount_info mount_info,
1803		- struct nfs_subversion *nfs_mod)
	861	+static struct nfs_server nfs_try_mount_request(struct fs_context fc)
1804	862	{
	863	+ struct nfs_fs_context *ctx = nfs_fc2context(fc);
1805	864	int status;
1806	865	unsigned int i;
1807	866	bool tried_auth_unix = false;
1808	867	bool auth_null_in_list = false;
1809	868	struct nfs_server *server = ERR_PTR(-EACCES);
1810		- struct nfs_parsed_mount_data *args = mount_info->parsed;
1811	869	rpc_authflavor_t authlist[NFS_MAX_SECFLAVORS];
1812	870	unsigned int authlist_len = ARRAY_SIZE(authlist);
1813	871
1814		- status = nfs_request_mount(args, mount_info->mntfh, authlist,
1815		- &authlist_len);
	872	+ status = nfs_request_mount(fc, ctx->mntfh, authlist, &authlist_len);
1816	873	if (status)
1817	874	return ERR_PTR(status);
1818	875
..	..	@@ -1820,13 +877,13 @@
1820	877	* Was a sec= authflavor specified in the options? First, verify
1821	878	* whether the server supports it, and then just try to use it if so.
1822	879	*/
1823		- if (args->auth_info.flavor_len > 0) {
1824		- status = nfs_verify_authflavors(args, authlist, authlist_len);
	880	+ if (ctx->auth_info.flavor_len > 0) {
	881	+ status = nfs_verify_authflavors(ctx, authlist, authlist_len);
1825	882	dfprintk(MOUNT, "NFS: using auth flavor %u\n",
1826		- args->selected_flavor);
	883	+ ctx->selected_flavor);
1827	884	if (status)
1828	885	return ERR_PTR(status);
1829		- return nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
	886	+ return ctx->nfs_mod->rpc_ops->create_server(fc);
1830	887	}
1831	888
1832	889	/*
..	..	@@ -1849,11 +906,11 @@
1849	906	default:
1850	907	if (rpcauth_get_gssinfo(flavor, &info) != 0)
1851	908	continue;
1852		- /* Fallthrough */
	909	+ break;
1853	910	}
1854	911	dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", flavor);
1855		- args->selected_flavor = flavor;
1856		- server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
	912	+ ctx->selected_flavor = flavor;
	913	+ server = ctx->nfs_mod->rpc_ops->create_server(fc);
1857	914	if (!IS_ERR(server))
1858	915	return server;
1859	916	}
..	..	@@ -1868,347 +925,23 @@
1868	925
1869	926	/* Last chance! Try AUTH_UNIX */
1870	927	dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", RPC_AUTH_UNIX);
1871		- args->selected_flavor = RPC_AUTH_UNIX;
1872		- return nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
	928	+ ctx->selected_flavor = RPC_AUTH_UNIX;
	929	+ return ctx->nfs_mod->rpc_ops->create_server(fc);
1873	930	}
1874	931
1875		-struct dentry nfs_try_mount(int flags, const char dev_name,
1876		- struct nfs_mount_info *mount_info,
1877		- struct nfs_subversion *nfs_mod)
	932	+int nfs_try_get_tree(struct fs_context *fc)
1878	933	{
1879		- struct nfs_server *server;
	934	+ struct nfs_fs_context *ctx = nfs_fc2context(fc);
1880	935
1881		- if (mount_info->parsed->need_mount)
1882		- server = nfs_try_mount_request(mount_info, nfs_mod);
	936	+ if (ctx->need_mount)
	937	+ ctx->server = nfs_try_mount_request(fc);
1883	938	else
1884		- server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
	939	+ ctx->server = ctx->nfs_mod->rpc_ops->create_server(fc);
1885	940
1886		- if (IS_ERR(server))
1887		- return ERR_CAST(server);
1888		-
1889		- return nfs_fs_mount_common(server, flags, dev_name, mount_info, nfs_mod);
	941	+ return nfs_get_tree_common(fc);
1890	942	}
1891		-EXPORT_SYMBOL_GPL(nfs_try_mount);
	943	+EXPORT_SYMBOL_GPL(nfs_try_get_tree);
1892	944
1893		-/*
1894		- * Split "dev_name" into "hostname:export_path".
1895		- *
1896		- * The leftmost colon demarks the split between the server's hostname
1897		- * and the export path. If the hostname starts with a left square
1898		- * bracket, then it may contain colons.
1899		- *
1900		- * Note: caller frees hostname and export path, even on error.
1901		- */
1902		-static int nfs_parse_devname(const char *dev_name,
1903		- char **hostname, size_t maxnamlen,
1904		- char **export_path, size_t maxpathlen)
1905		-{
1906		- size_t len;
1907		- char *end;
1908		-
1909		- if (unlikely(!dev_name \|\| !*dev_name)) {
1910		- dfprintk(MOUNT, "NFS: device name not specified\n");
1911		- return -EINVAL;
1912		- }
1913		-
1914		- /* Is the host name protected with square brakcets? */
1915		- if (*dev_name == '[') {
1916		- end = strchr(++dev_name, ']');
1917		- if (end == NULL \|\| end[1] != ':')
1918		- goto out_bad_devname;
1919		-
1920		- len = end - dev_name;
1921		- end++;
1922		- } else {
1923		- char *comma;
1924		-
1925		- end = strchr(dev_name, ':');
1926		- if (end == NULL)
1927		- goto out_bad_devname;
1928		- len = end - dev_name;
1929		-
1930		- /* kill possible hostname list: not supported */
1931		- comma = strchr(dev_name, ',');
1932		- if (comma != NULL && comma < end)
1933		- len = comma - dev_name;
1934		- }
1935		-
1936		- if (len > maxnamlen)
1937		- goto out_hostname;
1938		-
1939		- /* N.B. caller will free nfs_server.hostname in all cases */
1940		- *hostname = kstrndup(dev_name, len, GFP_KERNEL);
1941		- if (*hostname == NULL)
1942		- goto out_nomem;
1943		- len = strlen(++end);
1944		- if (len > maxpathlen)
1945		- goto out_path;
1946		- *export_path = kstrndup(end, len, GFP_KERNEL);
1947		- if (!*export_path)
1948		- goto out_nomem;
1949		-
1950		- dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", *export_path);
1951		- return 0;
1952		-
1953		-out_bad_devname:
1954		- dfprintk(MOUNT, "NFS: device name not in host:path format\n");
1955		- return -EINVAL;
1956		-
1957		-out_nomem:
1958		- dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
1959		- return -ENOMEM;
1960		-
1961		-out_hostname:
1962		- dfprintk(MOUNT, "NFS: server hostname too long\n");
1963		- return -ENAMETOOLONG;
1964		-
1965		-out_path:
1966		- dfprintk(MOUNT, "NFS: export pathname too long\n");
1967		- return -ENAMETOOLONG;
1968		-}
1969		-
1970		-/*
1971		- * Validate the NFS2/NFS3 mount data
1972		- * - fills in the mount root filehandle
1973		- *
1974		- * For option strings, user space handles the following behaviors:
1975		- *
1976		- * + DNS: mapping server host name to IP address ("addr=" option)
1977		- *
1978		- * + failure mode: how to behave if a mount request can't be handled
1979		- * immediately ("fg/bg" option)
1980		- *
1981		- * + retry: how often to retry a mount request ("retry=" option)
1982		- *
1983		- * + breaking back: trying proto=udp after proto=tcp, v2 after v3,
1984		- * mountproto=tcp after mountproto=udp, and so on
1985		- */
1986		-static int nfs23_validate_mount_data(void *options,
1987		- struct nfs_parsed_mount_data *args,
1988		- struct nfs_fh *mntfh,
1989		- const char *dev_name)
1990		-{
1991		- struct nfs_mount_data data = (struct nfs_mount_data )options;
1992		- struct sockaddr sap = (struct sockaddr )&args->nfs_server.address;
1993		- int extra_flags = NFS_MOUNT_LEGACY_INTERFACE;
1994		-
1995		- if (data == NULL)
1996		- goto out_no_data;
1997		-
1998		- args->version = NFS_DEFAULT_VERSION;
1999		- switch (data->version) {
2000		- case 1:
2001		- data->namlen = 0; /* fall through */
2002		- case 2:
2003		- data->bsize = 0; /* fall through */
2004		- case 3:
2005		- if (data->flags & NFS_MOUNT_VER3)
2006		- goto out_no_v3;
2007		- data->root.size = NFS2_FHSIZE;
2008		- memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
2009		- /* Turn off security negotiation */
2010		- extra_flags \|= NFS_MOUNT_SECFLAVOUR;
2011		- /* fall through */
2012		- case 4:
2013		- if (data->flags & NFS_MOUNT_SECFLAVOUR)
2014		- goto out_no_sec;
2015		- /* fall through */
2016		- case 5:
2017		- memset(data->context, 0, sizeof(data->context));
2018		- /* fall through */
2019		- case 6:
2020		- if (data->flags & NFS_MOUNT_VER3) {
2021		- if (data->root.size > NFS3_FHSIZE \|\| data->root.size == 0)
2022		- goto out_invalid_fh;
2023		- mntfh->size = data->root.size;
2024		- args->version = 3;
2025		- } else {
2026		- mntfh->size = NFS2_FHSIZE;
2027		- args->version = 2;
2028		- }
2029		-
2030		-
2031		- memcpy(mntfh->data, data->root.data, mntfh->size);
2032		- if (mntfh->size < sizeof(mntfh->data))
2033		- memset(mntfh->data + mntfh->size, 0,
2034		- sizeof(mntfh->data) - mntfh->size);
2035		-
2036		- /*
2037		- * Translate to nfs_parsed_mount_data, which nfs_fill_super
2038		- * can deal with.
2039		- */
2040		- args->flags = data->flags & NFS_MOUNT_FLAGMASK;
2041		- args->flags \|= extra_flags;
2042		- args->rsize = data->rsize;
2043		- args->wsize = data->wsize;
2044		- args->timeo = data->timeo;
2045		- args->retrans = data->retrans;
2046		- args->acregmin = data->acregmin;
2047		- args->acregmax = data->acregmax;
2048		- args->acdirmin = data->acdirmin;
2049		- args->acdirmax = data->acdirmax;
2050		- args->need_mount = false;
2051		-
2052		- memcpy(sap, &data->addr, sizeof(data->addr));
2053		- args->nfs_server.addrlen = sizeof(data->addr);
2054		- args->nfs_server.port = ntohs(data->addr.sin_port);
2055		- if (sap->sa_family != AF_INET \|\|
2056		- !nfs_verify_server_address(sap))
2057		- goto out_no_address;
2058		-
2059		- if (!(data->flags & NFS_MOUNT_TCP))
2060		- args->nfs_server.protocol = XPRT_TRANSPORT_UDP;
2061		- /* N.B. caller will free nfs_server.hostname in all cases */
2062		- args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
2063		- args->namlen = data->namlen;
2064		- args->bsize = data->bsize;
2065		-
2066		- if (data->flags & NFS_MOUNT_SECFLAVOUR)
2067		- args->selected_flavor = data->pseudoflavor;
2068		- else
2069		- args->selected_flavor = RPC_AUTH_UNIX;
2070		- if (!args->nfs_server.hostname)
2071		- goto out_nomem;
2072		-
2073		- if (!(data->flags & NFS_MOUNT_NONLM))
2074		- args->flags &= ~(NFS_MOUNT_LOCAL_FLOCK\|
2075		- NFS_MOUNT_LOCAL_FCNTL);
2076		- else
2077		- args->flags \|= (NFS_MOUNT_LOCAL_FLOCK\|
2078		- NFS_MOUNT_LOCAL_FCNTL);
2079		- /*
2080		- * The legacy version 6 binary mount data from userspace has a
2081		- * field used only to transport selinux information into the
2082		- * the kernel. To continue to support that functionality we
2083		- * have a touch of selinux knowledge here in the NFS code. The
2084		- * userspace code converted context=blah to just blah so we are
2085		- * converting back to the full string selinux understands.
2086		- */
2087		- if (data->context[0]){
2088		-#ifdef CONFIG_SECURITY_SELINUX
2089		- int rc;
2090		- char *opts_str = kmalloc(sizeof(data->context) + 8, GFP_KERNEL);
2091		- if (!opts_str)
2092		- return -ENOMEM;
2093		- strcpy(opts_str, "context=");
2094		- data->context[NFS_MAX_CONTEXT_LEN] = '\0';
2095		- strcat(opts_str, &data->context[0]);
2096		- rc = security_sb_parse_opts_str(opts_str, &args->lsm_opts);
2097		- kfree(opts_str);
2098		- if (rc)
2099		- return rc;
2100		-#else
2101		- return -EINVAL;
2102		-#endif
2103		- }
2104		-
2105		- break;
2106		- default:
2107		- return NFS_TEXT_DATA;
2108		- }
2109		-
2110		- return 0;
2111		-
2112		-out_no_data:
2113		- dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n");
2114		- return -EINVAL;
2115		-
2116		-out_no_v3:
2117		- dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n",
2118		- data->version);
2119		- return -EINVAL;
2120		-
2121		-out_no_sec:
2122		- dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n");
2123		- return -EINVAL;
2124		-
2125		-out_nomem:
2126		- dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n");
2127		- return -ENOMEM;
2128		-
2129		-out_no_address:
2130		- dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
2131		- return -EINVAL;
2132		-
2133		-out_invalid_fh:
2134		- dfprintk(MOUNT, "NFS: invalid root filehandle\n");
2135		- return -EINVAL;
2136		-}
2137		-
2138		-#if IS_ENABLED(CONFIG_NFS_V4)
2139		-static int nfs_validate_mount_data(struct file_system_type *fs_type,
2140		- void *options,
2141		- struct nfs_parsed_mount_data *args,
2142		- struct nfs_fh *mntfh,
2143		- const char *dev_name)
2144		-{
2145		- if (fs_type == &nfs_fs_type)
2146		- return nfs23_validate_mount_data(options, args, mntfh, dev_name);
2147		- return nfs4_validate_mount_data(options, args, dev_name);
2148		-}
2149		-#else
2150		-static int nfs_validate_mount_data(struct file_system_type *fs_type,
2151		- void *options,
2152		- struct nfs_parsed_mount_data *args,
2153		- struct nfs_fh *mntfh,
2154		- const char *dev_name)
2155		-{
2156		- return nfs23_validate_mount_data(options, args, mntfh, dev_name);
2157		-}
2158		-#endif
2159		-
2160		-static int nfs_validate_text_mount_data(void *options,
2161		- struct nfs_parsed_mount_data *args,
2162		- const char *dev_name)
2163		-{
2164		- int port = 0;
2165		- int max_namelen = PAGE_SIZE;
2166		- int max_pathlen = NFS_MAXPATHLEN;
2167		- struct sockaddr sap = (struct sockaddr )&args->nfs_server.address;
2168		-
2169		- if (nfs_parse_mount_options((char *)options, args) == 0)
2170		- return -EINVAL;
2171		-
2172		- if (!nfs_verify_server_address(sap))
2173		- goto out_no_address;
2174		-
2175		- if (args->version == 4) {
2176		-#if IS_ENABLED(CONFIG_NFS_V4)
2177		- port = NFS_PORT;
2178		- max_namelen = NFS4_MAXNAMLEN;
2179		- max_pathlen = NFS4_MAXPATHLEN;
2180		- nfs_validate_transport_protocol(args);
2181		- if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP)
2182		- goto out_invalid_transport_udp;
2183		- nfs4_validate_mount_flags(args);
2184		-#else
2185		- goto out_v4_not_compiled;
2186		-#endif /* CONFIG_NFS_V4 */
2187		- } else
2188		- nfs_set_mount_transport_protocol(args);
2189		-
2190		- nfs_set_port(sap, &args->nfs_server.port, port);
2191		-
2192		- return nfs_parse_devname(dev_name,
2193		- &args->nfs_server.hostname,
2194		- max_namelen,
2195		- &args->nfs_server.export_path,
2196		- max_pathlen);
2197		-
2198		-#if !IS_ENABLED(CONFIG_NFS_V4)
2199		-out_v4_not_compiled:
2200		- dfprintk(MOUNT, "NFS: NFSv4 is not compiled into kernel\n");
2201		- return -EPROTONOSUPPORT;
2202		-#else
2203		-out_invalid_transport_udp:
2204		- dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
2205		- return -EINVAL;
2206		-#endif /* !CONFIG_NFS_V4 */
2207		-
2208		-out_no_address:
2209		- dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
2210		- return -EINVAL;
2211		-}
2212	945
2213	946	#define NFS_REMOUNT_CMP_FLAGMASK ~(NFS_MOUNT_INTR \
2214	947	\| NFS_MOUNT_SECURE \
..	..	@@ -2225,39 +958,35 @@
2225	958
2226	959	static int
2227	960	nfs_compare_remount_data(struct nfs_server *nfss,
2228		- struct nfs_parsed_mount_data *data)
	961	+ struct nfs_fs_context *ctx)
2229	962	{
2230		- if ((data->flags ^ nfss->flags) & NFS_REMOUNT_CMP_FLAGMASK \|\|
2231		- data->rsize != nfss->rsize \|\|
2232		- data->wsize != nfss->wsize \|\|
2233		- data->version != nfss->nfs_client->rpc_ops->version \|\|
2234		- data->minorversion != nfss->nfs_client->cl_minorversion \|\|
2235		- data->retrans != nfss->client->cl_timeout->to_retries \|\|
2236		- !nfs_auth_info_match(&data->auth_info, nfss->client->cl_auth->au_flavor) \|\|
2237		- data->acregmin != nfss->acregmin / HZ \|\|
2238		- data->acregmax != nfss->acregmax / HZ \|\|
2239		- data->acdirmin != nfss->acdirmin / HZ \|\|
2240		- data->acdirmax != nfss->acdirmax / HZ \|\|
2241		- data->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) \|\|
2242		- (data->options & NFS_OPTION_FSCACHE) != (nfss->options & NFS_OPTION_FSCACHE) \|\|
2243		- data->nfs_server.port != nfss->port \|\|
2244		- data->nfs_server.addrlen != nfss->nfs_client->cl_addrlen \|\|
2245		- !rpc_cmp_addr((struct sockaddr *)&data->nfs_server.address,
	963	+ if ((ctx->flags ^ nfss->flags) & NFS_REMOUNT_CMP_FLAGMASK \|\|
	964	+ ctx->rsize != nfss->rsize \|\|
	965	+ ctx->wsize != nfss->wsize \|\|
	966	+ ctx->version != nfss->nfs_client->rpc_ops->version \|\|
	967	+ ctx->minorversion != nfss->nfs_client->cl_minorversion \|\|
	968	+ ctx->retrans != nfss->client->cl_timeout->to_retries \|\|
	969	+ !nfs_auth_info_match(&ctx->auth_info, nfss->client->cl_auth->au_flavor) \|\|
	970	+ ctx->acregmin != nfss->acregmin / HZ \|\|
	971	+ ctx->acregmax != nfss->acregmax / HZ \|\|
	972	+ ctx->acdirmin != nfss->acdirmin / HZ \|\|
	973	+ ctx->acdirmax != nfss->acdirmax / HZ \|\|
	974	+ ctx->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) \|\|
	975	+ (ctx->options & NFS_OPTION_FSCACHE) != (nfss->options & NFS_OPTION_FSCACHE) \|\|
	976	+ ctx->nfs_server.port != nfss->port \|\|
	977	+ ctx->nfs_server.addrlen != nfss->nfs_client->cl_addrlen \|\|
	978	+ !rpc_cmp_addr((struct sockaddr *)&ctx->nfs_server.address,
2246	979	(struct sockaddr *)&nfss->nfs_client->cl_addr))
2247	980	return -EINVAL;
2248	981
2249	982	return 0;
2250	983	}
2251	984
2252		-int
2253		-nfs_remount(struct super_block sb, int flags, char *raw_data)
	985	+int nfs_reconfigure(struct fs_context *fc)
2254	986	{
2255		- int error;
	987	+ struct nfs_fs_context *ctx = nfs_fc2context(fc);
	988	+ struct super_block *sb = fc->root->d_sb;
2256	989	struct nfs_server *nfss = sb->s_fs_info;
2257		- struct nfs_parsed_mount_data *data;
2258		- struct nfs_mount_data options = (struct nfs_mount_data )raw_data;
2259		- struct nfs4_mount_data options4 = (struct nfs4_mount_data )raw_data;
2260		- u32 nfsvers = nfss->nfs_client->rpc_ops->version;
2261	990
2262	991	sync_filesystem(sb);
2263	992
..	..	@@ -2267,62 +996,65 @@
2267	996	* ones were explicitly specified. Fall back to legacy behavior and
2268	997	* just return success.
2269	998	*/
2270		- if ((nfsvers == 4 && (!options4 \|\| options4->version == 1)) \|\|
2271		- (nfsvers <= 3 && (!options \|\| (options->version >= 1 &&
2272		- options->version <= 6))))
	999	+ if (ctx->skip_reconfig_option_check)
2273	1000	return 0;
2274		-
2275		- data = kzalloc(sizeof(*data), GFP_KERNEL);
2276		- if (data == NULL)
2277		- return -ENOMEM;
2278		-
2279		- /* fill out struct with values from existing mount */
2280		- data->flags = nfss->flags;
2281		- data->rsize = nfss->rsize;
2282		- data->wsize = nfss->wsize;
2283		- data->retrans = nfss->client->cl_timeout->to_retries;
2284		- data->selected_flavor = nfss->client->cl_auth->au_flavor;
2285		- data->acregmin = nfss->acregmin / HZ;
2286		- data->acregmax = nfss->acregmax / HZ;
2287		- data->acdirmin = nfss->acdirmin / HZ;
2288		- data->acdirmax = nfss->acdirmax / HZ;
2289		- data->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ;
2290		- data->nfs_server.port = nfss->port;
2291		- data->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
2292		- data->version = nfsvers;
2293		- data->minorversion = nfss->nfs_client->cl_minorversion;
2294		- data->net = current->nsproxy->net_ns;
2295		- memcpy(&data->nfs_server.address, &nfss->nfs_client->cl_addr,
2296		- data->nfs_server.addrlen);
2297		-
2298		- /* overwrite those values with any that were specified */
2299		- error = -EINVAL;
2300		- if (!nfs_parse_mount_options((char *)options, data))
2301		- goto out;
2302	1001
2303	1002	/*
2304	1003	* noac is a special case. It implies -o sync, but that's not
2305		- * necessarily reflected in the mtab options. do_remount_sb
	1004	+ * necessarily reflected in the mtab options. reconfigure_super
2306	1005	* will clear SB_SYNCHRONOUS if -o sync wasn't specified in the
2307	1006	* remount options, so we have to explicitly reset it.
2308	1007	*/
2309		- if (data->flags & NFS_MOUNT_NOAC)
2310		- *flags \|= SB_SYNCHRONOUS;
	1008	+ if (ctx->flags & NFS_MOUNT_NOAC) {
	1009	+ fc->sb_flags \|= SB_SYNCHRONOUS;
	1010	+ fc->sb_flags_mask \|= SB_SYNCHRONOUS;
	1011	+ }
2311	1012
2312	1013	/* compare new mount options with old ones */
2313		- error = nfs_compare_remount_data(nfss, data);
2314		-out:
2315		- kfree(data);
2316		- return error;
	1014	+ return nfs_compare_remount_data(nfss, ctx);
2317	1015	}
2318		-EXPORT_SYMBOL_GPL(nfs_remount);
	1016	+EXPORT_SYMBOL_GPL(nfs_reconfigure);
2319	1017
2320	1018	/*
2321		- * Initialise the common bits of the superblock
	1019	+ * Finish setting up an NFS superblock
2322	1020	*/
2323		-static void nfs_initialise_sb(struct super_block *sb)
	1021	+static void nfs_fill_super(struct super_block sb, struct nfs_fs_context ctx)
2324	1022	{
2325	1023	struct nfs_server *server = NFS_SB(sb);
	1024	+
	1025	+ sb->s_blocksize_bits = 0;
	1026	+ sb->s_blocksize = 0;
	1027	+ sb->s_xattr = server->nfs_client->cl_nfs_mod->xattr;
	1028	+ sb->s_op = server->nfs_client->cl_nfs_mod->sops;
	1029	+ if (ctx && ctx->bsize)
	1030	+ sb->s_blocksize = nfs_block_size(ctx->bsize, &sb->s_blocksize_bits);
	1031	+
	1032	+ switch (server->nfs_client->rpc_ops->version) {
	1033	+ case 2:
	1034	+ sb->s_time_gran = 1000;
	1035	+ sb->s_time_min = 0;
	1036	+ sb->s_time_max = U32_MAX;
	1037	+ break;
	1038	+ case 3:
	1039	+ /*
	1040	+ * The VFS shouldn't apply the umask to mode bits.
	1041	+ * We will do so ourselves when necessary.
	1042	+ */
	1043	+ sb->s_flags \|= SB_POSIXACL;
	1044	+ sb->s_time_gran = 1;
	1045	+ sb->s_time_min = 0;
	1046	+ sb->s_time_max = U32_MAX;
	1047	+ sb->s_export_op = &nfs_export_ops;
	1048	+ break;
	1049	+ case 4:
	1050	+ sb->s_flags \|= SB_POSIXACL;
	1051	+ sb->s_time_gran = 1;
	1052	+ sb->s_time_min = S64_MIN;
	1053	+ sb->s_time_max = S64_MAX;
	1054	+ if (server->caps & NFS_CAP_ATOMIC_OPEN_V1)
	1055	+ sb->s_export_op = &nfs_export_ops;
	1056	+ break;
	1057	+ }
2326	1058
2327	1059	sb->s_magic = NFS_SUPER_MAGIC;
2328	1060
..	..	@@ -2337,68 +1069,14 @@
2337	1069	nfs_super_set_maxbytes(sb, server->maxfilesize);
2338	1070	}
2339	1071
2340		-/*
2341		- * Finish setting up an NFS2/3 superblock
2342		- */
2343		-void nfs_fill_super(struct super_block sb, struct nfs_mount_info mount_info)
2344		-{
2345		- struct nfs_parsed_mount_data *data = mount_info->parsed;
2346		- struct nfs_server *server = NFS_SB(sb);
2347		-
2348		- sb->s_blocksize_bits = 0;
2349		- sb->s_blocksize = 0;
2350		- sb->s_xattr = server->nfs_client->cl_nfs_mod->xattr;
2351		- sb->s_op = server->nfs_client->cl_nfs_mod->sops;
2352		- if (data && data->bsize)
2353		- sb->s_blocksize = nfs_block_size(data->bsize, &sb->s_blocksize_bits);
2354		-
2355		- if (server->nfs_client->rpc_ops->version != 2) {
2356		- /* The VFS shouldn't apply the umask to mode bits. We will do
2357		- * so ourselves when necessary.
2358		- */
2359		- sb->s_flags \|= SB_POSIXACL;
2360		- sb->s_time_gran = 1;
2361		- sb->s_export_op = &nfs_export_ops;
2362		- }
2363		-
2364		- nfs_initialise_sb(sb);
2365		-}
2366		-EXPORT_SYMBOL_GPL(nfs_fill_super);
2367		-
2368		-/*
2369		- * Finish setting up a cloned NFS2/3/4 superblock
2370		- */
2371		-static void nfs_clone_super(struct super_block *sb,
2372		- struct nfs_mount_info *mount_info)
2373		-{
2374		- const struct super_block *old_sb = mount_info->cloned->sb;
2375		- struct nfs_server *server = NFS_SB(sb);
2376		-
2377		- sb->s_blocksize_bits = old_sb->s_blocksize_bits;
2378		- sb->s_blocksize = old_sb->s_blocksize;
2379		- sb->s_maxbytes = old_sb->s_maxbytes;
2380		- sb->s_xattr = old_sb->s_xattr;
2381		- sb->s_op = old_sb->s_op;
2382		- sb->s_time_gran = 1;
2383		- sb->s_export_op = old_sb->s_export_op;
2384		-
2385		- if (server->nfs_client->rpc_ops->version != 2) {
2386		- /* The VFS shouldn't apply the umask to mode bits. We will do
2387		- * so ourselves when necessary.
2388		- */
2389		- sb->s_flags \|= SB_POSIXACL;
2390		- }
2391		-
2392		- nfs_initialise_sb(sb);
2393		-}
2394		-
2395		-static int nfs_compare_mount_options(const struct super_block s, const struct nfs_server b, int flags)
	1072	+static int nfs_compare_mount_options(const struct super_block s, const struct nfs_server b,
	1073	+ const struct fs_context *fc)
2396	1074	{
2397	1075	const struct nfs_server *a = s->s_fs_info;
2398	1076	const struct rpc_clnt *clnt_a = a->client;
2399	1077	const struct rpc_clnt *clnt_b = b->client;
2400	1078
2401		- if ((s->s_flags & NFS_MS_MASK) != (flags & NFS_MS_MASK))
	1079	+ if ((s->s_flags & NFS_SB_MASK) != (fc->sb_flags & NFS_SB_MASK))
2402	1080	goto Ebusy;
2403	1081	if (a->nfs_client != b->nfs_client)
2404	1082	goto Ebusy;
..	..	@@ -2423,19 +1101,11 @@
2423	1101	return 0;
2424	1102	}
2425	1103
2426		-struct nfs_sb_mountdata {
2427		- struct nfs_server *server;
2428		- int mntflags;
2429		-};
2430		-
2431		-static int nfs_set_super(struct super_block s, void data)
	1104	+static int nfs_set_super(struct super_block s, struct fs_context fc)
2432	1105	{
2433		- struct nfs_sb_mountdata *sb_mntdata = data;
2434		- struct nfs_server *server = sb_mntdata->server;
	1106	+ struct nfs_server *server = fc->s_fs_info;
2435	1107	int ret;
2436	1108
2437		- s->s_flags = sb_mntdata->mntflags;
2438		- s->s_fs_info = server;
2439	1109	s->s_d_op = server->nfs_client->rpc_ops->dentry_ops;
2440	1110	ret = set_anon_super(s, server);
2441	1111	if (ret == 0)
..	..	@@ -2485,11 +1155,24 @@
2485	1155	return 1;
2486	1156	}
2487	1157
2488		-static int nfs_compare_super(struct super_block sb, void data)
	1158	+static int nfs_compare_userns(const struct nfs_server *old,
	1159	+ const struct nfs_server *new)
2489	1160	{
2490		- struct nfs_sb_mountdata *sb_mntdata = data;
2491		- struct nfs_server server = sb_mntdata->server, old = NFS_SB(sb);
2492		- int mntflags = sb_mntdata->mntflags;
	1161	+ const struct user_namespace *oldns = &init_user_ns;
	1162	+ const struct user_namespace *newns = &init_user_ns;
	1163	+
	1164	+ if (old->client && old->client->cl_cred)
	1165	+ oldns = old->client->cl_cred->user_ns;
	1166	+ if (new->client && new->client->cl_cred)
	1167	+ newns = new->client->cl_cred->user_ns;
	1168	+ if (oldns != newns)
	1169	+ return 0;
	1170	+ return 1;
	1171	+}
	1172	+
	1173	+static int nfs_compare_super(struct super_block sb, struct fs_context fc)
	1174	+{
	1175	+ struct nfs_server server = fc->s_fs_info, old = NFS_SB(sb);
2493	1176
2494	1177	if (!nfs_compare_super_address(old, server))
2495	1178	return 0;
..	..	@@ -2498,13 +1181,14 @@
2498	1181	return 0;
2499	1182	if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0)
2500	1183	return 0;
2501		- return nfs_compare_mount_options(sb, server, mntflags);
	1184	+ if (!nfs_compare_userns(old, server))
	1185	+ return 0;
	1186	+ return nfs_compare_mount_options(sb, server, fc);
2502	1187	}
2503	1188
2504	1189	#ifdef CONFIG_NFS_FSCACHE
2505	1190	static void nfs_get_cache_cookie(struct super_block *sb,
2506		- struct nfs_parsed_mount_data *parsed,
2507		- struct nfs_clone_mount *cloned)
	1191	+ struct nfs_fs_context *ctx)
2508	1192	{
2509	1193	struct nfs_server *nfss = NFS_SB(sb);
2510	1194	char *uniq = NULL;
..	..	@@ -2513,109 +1197,68 @@
2513	1197	nfss->fscache_key = NULL;
2514	1198	nfss->fscache = NULL;
2515	1199
2516		- if (parsed) {
2517		- if (!(parsed->options & NFS_OPTION_FSCACHE))
2518		- return;
2519		- if (parsed->fscache_uniq) {
2520		- uniq = parsed->fscache_uniq;
2521		- ulen = strlen(parsed->fscache_uniq);
2522		- }
2523		- } else if (cloned) {
2524		- struct nfs_server *mnt_s = NFS_SB(cloned->sb);
	1200	+ if (!ctx)
	1201	+ return;
	1202	+
	1203	+ if (ctx->clone_data.sb) {
	1204	+ struct nfs_server *mnt_s = NFS_SB(ctx->clone_data.sb);
2525	1205	if (!(mnt_s->options & NFS_OPTION_FSCACHE))
2526	1206	return;
2527	1207	if (mnt_s->fscache_key) {
2528	1208	uniq = mnt_s->fscache_key->key.uniquifier;
2529	1209	ulen = mnt_s->fscache_key->key.uniq_len;
2530		- };
2531		- } else
2532		- return;
	1210	+ }
	1211	+ } else {
	1212	+ if (!(ctx->options & NFS_OPTION_FSCACHE))
	1213	+ return;
	1214	+ if (ctx->fscache_uniq) {
	1215	+ uniq = ctx->fscache_uniq;
	1216	+ ulen = strlen(ctx->fscache_uniq);
	1217	+ }
	1218	+ }
2533	1219
2534	1220	nfs_fscache_get_super_cookie(sb, uniq, ulen);
2535	1221	}
2536	1222	#else
2537	1223	static void nfs_get_cache_cookie(struct super_block *sb,
2538		- struct nfs_parsed_mount_data *parsed,
2539		- struct nfs_clone_mount *cloned)
	1224	+ struct nfs_fs_context *ctx)
2540	1225	{
2541	1226	}
2542	1227	#endif
2543	1228
2544		-int nfs_set_sb_security(struct super_block s, struct dentry mntroot,
2545		- struct nfs_mount_info *mount_info)
	1229	+int nfs_get_tree_common(struct fs_context *fc)
2546	1230	{
2547		- int error;
2548		- unsigned long kflags = 0, kflags_out = 0;
2549		- if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL)
2550		- kflags \|= SECURITY_LSM_NATIVE_LABELS;
2551		-
2552		- error = security_sb_set_mnt_opts(s, &mount_info->parsed->lsm_opts,
2553		- kflags, &kflags_out);
2554		- if (error)
2555		- goto err;
2556		-
2557		- if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL &&
2558		- !(kflags_out & SECURITY_LSM_NATIVE_LABELS))
2559		- NFS_SB(s)->caps &= ~NFS_CAP_SECURITY_LABEL;
2560		-err:
2561		- return error;
2562		-}
2563		-EXPORT_SYMBOL_GPL(nfs_set_sb_security);
2564		-
2565		-int nfs_clone_sb_security(struct super_block s, struct dentry mntroot,
2566		- struct nfs_mount_info *mount_info)
2567		-{
2568		- int error;
2569		- unsigned long kflags = 0, kflags_out = 0;
2570		-
2571		- /* clone any lsm security options from the parent to the new sb */
2572		- if (d_inode(mntroot)->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops)
2573		- return -ESTALE;
2574		-
2575		- if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL)
2576		- kflags \|= SECURITY_LSM_NATIVE_LABELS;
2577		-
2578		- error = security_sb_clone_mnt_opts(mount_info->cloned->sb, s, kflags,
2579		- &kflags_out);
2580		- if (error)
2581		- return error;
2582		-
2583		- if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL &&
2584		- !(kflags_out & SECURITY_LSM_NATIVE_LABELS))
2585		- NFS_SB(s)->caps &= ~NFS_CAP_SECURITY_LABEL;
2586		- return 0;
2587		-}
2588		-EXPORT_SYMBOL_GPL(nfs_clone_sb_security);
2589		-
2590		-struct dentry nfs_fs_mount_common(struct nfs_server server,
2591		- int flags, const char *dev_name,
2592		- struct nfs_mount_info *mount_info,
2593		- struct nfs_subversion *nfs_mod)
2594		-{
	1231	+ struct nfs_fs_context *ctx = nfs_fc2context(fc);
2595	1232	struct super_block *s;
2596		- struct dentry *mntroot = ERR_PTR(-ENOMEM);
2597		- int (compare_super)(struct super_block , void *) = nfs_compare_super;
2598		- struct nfs_sb_mountdata sb_mntdata = {
2599		- .mntflags = flags,
2600		- .server = server,
2601		- };
	1233	+ int (compare_super)(struct super_block , struct fs_context *) = nfs_compare_super;
	1234	+ struct nfs_server *server = ctx->server;
2602	1235	int error;
	1236	+
	1237	+ ctx->server = NULL;
	1238	+ if (IS_ERR(server))
	1239	+ return PTR_ERR(server);
2603	1240
2604	1241	if (server->flags & NFS_MOUNT_UNSHARED)
2605	1242	compare_super = NULL;
2606	1243
2607	1244	/* -o noac implies -o sync */
2608	1245	if (server->flags & NFS_MOUNT_NOAC)
2609		- sb_mntdata.mntflags \|= SB_SYNCHRONOUS;
	1246	+ fc->sb_flags \|= SB_SYNCHRONOUS;
2610	1247
2611		- if (mount_info->cloned != NULL && mount_info->cloned->sb != NULL)
2612		- if (mount_info->cloned->sb->s_flags & SB_SYNCHRONOUS)
2613		- sb_mntdata.mntflags \|= SB_SYNCHRONOUS;
	1248	+ if (ctx->clone_data.sb)
	1249	+ if (ctx->clone_data.sb->s_flags & SB_SYNCHRONOUS)
	1250	+ fc->sb_flags \|= SB_SYNCHRONOUS;
	1251	+
	1252	+ if (server->caps & NFS_CAP_SECURITY_LABEL)
	1253	+ fc->lsm_flags \|= SECURITY_LSM_NATIVE_LABELS;
2614	1254
2615	1255	/* Get a superblock - note that we may end up sharing one that already exists */
2616		- s = sget(nfs_mod->nfs_fs, compare_super, nfs_set_super, flags, &sb_mntdata);
	1256	+ fc->s_fs_info = server;
	1257	+ s = sget_fc(fc, compare_super, nfs_set_super);
	1258	+ fc->s_fs_info = NULL;
2617	1259	if (IS_ERR(s)) {
2618		- mntroot = ERR_CAST(s);
	1260	+ error = PTR_ERR(s);
	1261	+ nfs_errorf(fc, "NFS: Couldn't get superblock");
2619	1262	goto out_err_nosb;
2620	1263	}
2621	1264
..	..	@@ -2625,88 +1268,42 @@
2625	1268	} else {
2626	1269	error = super_setup_bdi_name(s, "%u:%u", MAJOR(server->s_dev),
2627	1270	MINOR(server->s_dev));
2628		- if (error) {
2629		- mntroot = ERR_PTR(error);
	1271	+ if (error)
2630	1272	goto error_splat_super;
2631		- }
2632		- s->s_bdi->ra_pages = server->rpages * NFS_MAX_READAHEAD;
	1273	+ s->s_bdi->io_pages = server->rpages;
2633	1274	server->super = s;
2634	1275	}
2635	1276
2636	1277	if (!s->s_root) {
	1278	+ unsigned bsize = ctx->clone_data.inherited_bsize;
2637	1279	/* initial superblock/root creation */
2638		- mount_info->fill_super(s, mount_info);
2639		- nfs_get_cache_cookie(s, mount_info->parsed, mount_info->cloned);
2640		- if (!(server->flags & NFS_MOUNT_UNSHARED))
2641		- s->s_iflags \|= SB_I_MULTIROOT;
	1280	+ nfs_fill_super(s, ctx);
	1281	+ if (bsize) {
	1282	+ s->s_blocksize_bits = bsize;
	1283	+ s->s_blocksize = 1U << bsize;
	1284	+ }
	1285	+ nfs_get_cache_cookie(s, ctx);
2642	1286	}
2643	1287
2644		- mntroot = nfs_get_root(s, mount_info->mntfh, dev_name);
2645		- if (IS_ERR(mntroot))
	1288	+ error = nfs_get_root(s, fc);
	1289	+ if (error < 0) {
	1290	+ nfs_errorf(fc, "NFS: Couldn't get root dentry");
2646	1291	goto error_splat_super;
2647		-
2648		- error = mount_info->set_security(s, mntroot, mount_info);
2649		- if (error)
2650		- goto error_splat_root;
	1292	+ }
2651	1293
2652	1294	s->s_flags \|= SB_ACTIVE;
	1295	+ error = 0;
2653	1296
2654	1297	out:
2655		- return mntroot;
	1298	+ return error;
2656	1299
2657	1300	out_err_nosb:
2658	1301	nfs_free_server(server);
2659	1302	goto out;
2660		-
2661		-error_splat_root:
2662		- dput(mntroot);
2663		- mntroot = ERR_PTR(error);
2664	1303	error_splat_super:
2665	1304	deactivate_locked_super(s);
2666	1305	goto out;
2667	1306	}
2668		-EXPORT_SYMBOL_GPL(nfs_fs_mount_common);
2669		-
2670		-struct dentry nfs_fs_mount(struct file_system_type fs_type,
2671		- int flags, const char dev_name, void raw_data)
2672		-{
2673		- struct nfs_mount_info mount_info = {
2674		- .fill_super = nfs_fill_super,
2675		- .set_security = nfs_set_sb_security,
2676		- };
2677		- struct dentry *mntroot = ERR_PTR(-ENOMEM);
2678		- struct nfs_subversion *nfs_mod;
2679		- int error;
2680		-
2681		- mount_info.parsed = nfs_alloc_parsed_mount_data();
2682		- mount_info.mntfh = nfs_alloc_fhandle();
2683		- if (mount_info.parsed == NULL \|\| mount_info.mntfh == NULL)
2684		- goto out;
2685		-
2686		- /* Validate the mount data */
2687		- error = nfs_validate_mount_data(fs_type, raw_data, mount_info.parsed, mount_info.mntfh, dev_name);
2688		- if (error == NFS_TEXT_DATA)
2689		- error = nfs_validate_text_mount_data(raw_data, mount_info.parsed, dev_name);
2690		- if (error < 0) {
2691		- mntroot = ERR_PTR(error);
2692		- goto out;
2693		- }
2694		-
2695		- nfs_mod = get_nfs_version(mount_info.parsed->version);
2696		- if (IS_ERR(nfs_mod)) {
2697		- mntroot = ERR_CAST(nfs_mod);
2698		- goto out;
2699		- }
2700		-
2701		- mntroot = nfs_mod->rpc_ops->try_mount(flags, dev_name, &mount_info, nfs_mod);
2702		-
2703		- put_nfs_version(nfs_mod);
2704		-out:
2705		- nfs_free_parsed_mount_data(mount_info.parsed);
2706		- nfs_free_fhandle(mount_info.mntfh);
2707		- return mntroot;
2708		-}
2709		-EXPORT_SYMBOL_GPL(nfs_fs_mount);
2710	1307
2711	1308	/*
2712	1309	* Destroy an NFS2/3 superblock
..	..	@@ -2725,149 +1322,7 @@
2725	1322	}
2726	1323	EXPORT_SYMBOL_GPL(nfs_kill_super);
2727	1324
2728		-/*
2729		- * Clone an NFS2/3/4 server record on xdev traversal (FSID-change)
2730		- */
2731		-static struct dentry *
2732		-nfs_xdev_mount(struct file_system_type *fs_type, int flags,
2733		- const char dev_name, void raw_data)
2734		-{
2735		- struct nfs_clone_mount *data = raw_data;
2736		- struct nfs_mount_info mount_info = {
2737		- .fill_super = nfs_clone_super,
2738		- .set_security = nfs_clone_sb_security,
2739		- .cloned = data,
2740		- };
2741		- struct nfs_server *server;
2742		- struct dentry *mntroot = ERR_PTR(-ENOMEM);
2743		- struct nfs_subversion *nfs_mod = NFS_SB(data->sb)->nfs_client->cl_nfs_mod;
2744		-
2745		- dprintk("--> nfs_xdev_mount()\n");
2746		-
2747		- mount_info.mntfh = mount_info.cloned->fh;
2748		-
2749		- /* create a new volume representation */
2750		- server = nfs_mod->rpc_ops->clone_server(NFS_SB(data->sb), data->fh, data->fattr, data->authflavor);
2751		-
2752		- if (IS_ERR(server))
2753		- mntroot = ERR_CAST(server);
2754		- else
2755		- mntroot = nfs_fs_mount_common(server, flags,
2756		- dev_name, &mount_info, nfs_mod);
2757		-
2758		- dprintk("<-- nfs_xdev_mount() = %ld\n",
2759		- IS_ERR(mntroot) ? PTR_ERR(mntroot) : 0L);
2760		- return mntroot;
2761		-}
2762		-
2763	1325	#if IS_ENABLED(CONFIG_NFS_V4)
2764		-
2765		-static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args)
2766		-{
2767		- args->flags &= ~(NFS_MOUNT_NONLM\|NFS_MOUNT_NOACL\|NFS_MOUNT_VER3\|
2768		- NFS_MOUNT_LOCAL_FLOCK\|NFS_MOUNT_LOCAL_FCNTL);
2769		-}
2770		-
2771		-/*
2772		- * Validate NFSv4 mount options
2773		- */
2774		-static int nfs4_validate_mount_data(void *options,
2775		- struct nfs_parsed_mount_data *args,
2776		- const char *dev_name)
2777		-{
2778		- struct sockaddr sap = (struct sockaddr )&args->nfs_server.address;
2779		- struct nfs4_mount_data data = (struct nfs4_mount_data )options;
2780		- char *c;
2781		-
2782		- if (data == NULL)
2783		- goto out_no_data;
2784		-
2785		- args->version = 4;
2786		-
2787		- switch (data->version) {
2788		- case 1:
2789		- if (data->host_addrlen > sizeof(args->nfs_server.address))
2790		- goto out_no_address;
2791		- if (data->host_addrlen == 0)
2792		- goto out_no_address;
2793		- args->nfs_server.addrlen = data->host_addrlen;
2794		- if (copy_from_user(sap, data->host_addr, data->host_addrlen))
2795		- return -EFAULT;
2796		- if (!nfs_verify_server_address(sap))
2797		- goto out_no_address;
2798		- args->nfs_server.port = ntohs(((struct sockaddr_in *)sap)->sin_port);
2799		-
2800		- if (data->auth_flavourlen) {
2801		- rpc_authflavor_t pseudoflavor;
2802		- if (data->auth_flavourlen > 1)
2803		- goto out_inval_auth;
2804		- if (copy_from_user(&pseudoflavor,
2805		- data->auth_flavours,
2806		- sizeof(pseudoflavor)))
2807		- return -EFAULT;
2808		- args->selected_flavor = pseudoflavor;
2809		- } else
2810		- args->selected_flavor = RPC_AUTH_UNIX;
2811		-
2812		- c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
2813		- if (IS_ERR(c))
2814		- return PTR_ERR(c);
2815		- args->nfs_server.hostname = c;
2816		-
2817		- c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN);
2818		- if (IS_ERR(c))
2819		- return PTR_ERR(c);
2820		- args->nfs_server.export_path = c;
2821		- dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c);
2822		-
2823		- c = strndup_user(data->client_addr.data, 16);
2824		- if (IS_ERR(c))
2825		- return PTR_ERR(c);
2826		- args->client_address = c;
2827		-
2828		- /*
2829		- * Translate to nfs_parsed_mount_data, which nfs4_fill_super
2830		- * can deal with.
2831		- */
2832		-
2833		- args->flags = data->flags & NFS4_MOUNT_FLAGMASK;
2834		- args->rsize = data->rsize;
2835		- args->wsize = data->wsize;
2836		- args->timeo = data->timeo;
2837		- args->retrans = data->retrans;
2838		- args->acregmin = data->acregmin;
2839		- args->acregmax = data->acregmax;
2840		- args->acdirmin = data->acdirmin;
2841		- args->acdirmax = data->acdirmax;
2842		- args->nfs_server.protocol = data->proto;
2843		- nfs_validate_transport_protocol(args);
2844		- if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP)
2845		- goto out_invalid_transport_udp;
2846		-
2847		- break;
2848		- default:
2849		- return NFS_TEXT_DATA;
2850		- }
2851		-
2852		- return 0;
2853		-
2854		-out_no_data:
2855		- dfprintk(MOUNT, "NFS4: mount program didn't pass any mount data\n");
2856		- return -EINVAL;
2857		-
2858		-out_inval_auth:
2859		- dfprintk(MOUNT, "NFS4: Invalid number of RPC auth flavours %d\n",
2860		- data->auth_flavourlen);
2861		- return -EINVAL;
2862		-
2863		-out_no_address:
2864		- dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n");
2865		- return -EINVAL;
2866		-
2867		-out_invalid_transport_udp:
2868		- dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
2869		- return -EINVAL;
2870		-}
2871	1326
2872	1327	/*
2873	1328	* NFS v4 module parameters need to stay in the