~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,3 +1,4 @@
	1	+// SPDX-License-Identifier: GPL-2.0-only
1	2	/*
2	3	* linux/fs/nfs/dir.c
3	4	*
..	..	@@ -57,7 +58,7 @@
57	58	const struct file_operations nfs_dir_operations = {
58	59	.llseek = nfs_llseek_dir,
59	60	.read = generic_read_dir,
60		- .iterate = nfs_readdir,
	61	+ .iterate_shared = nfs_readdir,
61	62	.open = nfs_opendir,
62	63	.release = nfs_closedir,
63	64	.fsync = nfs_fsync_dir,
..	..	@@ -67,7 +68,7 @@
67	68	.freepage = nfs_readdir_clear_array,
68	69	};
69	70
70		-static struct nfs_open_dir_context alloc_nfs_open_dir_context(struct inode dir, struct rpc_cred *cred)
	71	+static struct nfs_open_dir_context alloc_nfs_open_dir_context(struct inode dir, const struct cred *cred)
71	72	{
72	73	struct nfs_inode *nfsi = NFS_I(dir);
73	74	struct nfs_open_dir_context *ctx;
..	..	@@ -77,8 +78,12 @@
77	78	ctx->attr_gencount = nfsi->attr_gencount;
78	79	ctx->dir_cookie = 0;
79	80	ctx->dup_cookie = 0;
80		- ctx->cred = get_rpccred(cred);
	81	+ ctx->cred = get_cred(cred);
81	82	spin_lock(&dir->i_lock);
	83	+ if (list_empty(&nfsi->open_files) &&
	84	+ (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER))
	85	+ nfsi->cache_validity \|= NFS_INO_INVALID_DATA \|
	86	+ NFS_INO_REVAL_FORCED;
82	87	list_add(&ctx->list, &nfsi->open_files);
83	88	spin_unlock(&dir->i_lock);
84	89	return ctx;
..	..	@@ -91,7 +96,7 @@
91	96	spin_lock(&dir->i_lock);
92	97	list_del(&ctx->list);
93	98	spin_unlock(&dir->i_lock);
94		- put_rpccred(ctx->cred);
	99	+ put_cred(ctx->cred);
95	100	kfree(ctx);
96	101	}
97	102
..	..	@@ -103,23 +108,18 @@
103	108	{
104	109	int res = 0;
105	110	struct nfs_open_dir_context *ctx;
106		- struct rpc_cred *cred;
107	111
108	112	dfprintk(FILE, "NFS: open dir(%pD2)\n", filp);
109	113
110	114	nfs_inc_stats(inode, NFSIOS_VFSOPEN);
111	115
112		- cred = rpc_lookup_cred();
113		- if (IS_ERR(cred))
114		- return PTR_ERR(cred);
115		- ctx = alloc_nfs_open_dir_context(inode, cred);
	116	+ ctx = alloc_nfs_open_dir_context(inode, current_cred());
116	117	if (IS_ERR(ctx)) {
117	118	res = PTR_ERR(ctx);
118	119	goto out;
119	120	}
120	121	filp->private_data = ctx;
121	122	out:
122		- put_rpccred(cred);
123	123	return res;
124	124	}
125	125
..	..	@@ -141,10 +141,9 @@
141	141	int size;
142	142	int eof_index;
143	143	u64 last_cookie;
144		- struct nfs_cache_array_entry array[0];
	144	+ struct nfs_cache_array_entry array[];
145	145	};
146	146
147		-typedef int (decode_dirent_t)(struct xdr_stream , struct nfs_entry *, bool);
148	147	typedef struct {
149	148	struct file *file;
150	149	struct page *page;
..	..	@@ -153,8 +152,9 @@
153	152	u64 *dir_cookie;
154	153	u64 last_cookie;
155	154	loff_t current_index;
156		- decode_dirent_t decode;
	155	+ loff_t prev_index;
157	156
	157	+ unsigned long dir_verifier;
158	158	unsigned long timestamp;
159	159	unsigned long gencount;
160	160	unsigned int cache_entry_index;
..	..	@@ -198,7 +198,7 @@
198	198	int nfs_readdir_make_qstr(struct qstr string, const char name, unsigned int len)
199	199	{
200	200	string->len = len;
201		- string->name = kmemdup(name, len, GFP_KERNEL);
	201	+ string->name = kmemdup_nul(name, len, GFP_KERNEL);
202	202	if (string->name == NULL)
203	203	return -ENOMEM;
204	204	/*
..	..	@@ -237,6 +237,25 @@
237	237	out:
238	238	kunmap(page);
239	239	return ret;
	240	+}
	241	+
	242	+static inline
	243	+int is_32bit_api(void)
	244	+{
	245	+#ifdef CONFIG_COMPAT
	246	+ return in_compat_syscall();
	247	+#else
	248	+ return (BITS_PER_LONG == 32);
	249	+#endif
	250	+}
	251	+
	252	+static
	253	+bool nfs_readdir_use_cookie(const struct file *filp)
	254	+{
	255	+ if ((filp->f_mode & FMODE_32BITHASH) \|\|
	256	+ (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
	257	+ return false;
	258	+ return true;
240	259	}
241	260
242	261	static
..	..	@@ -288,7 +307,7 @@
288	307	!nfs_readdir_inode_mapping_valid(nfsi)) {
289	308	ctx->duped = 0;
290	309	ctx->attr_gencount = nfsi->attr_gencount;
291		- } else if (new_pos < desc->ctx->pos) {
	310	+ } else if (new_pos < desc->prev_index) {
292	311	if (ctx->duped > 0
293	312	&& ctx->dup_cookie == *desc->dir_cookie) {
294	313	if (printk_ratelimit()) {
..	..	@@ -304,7 +323,11 @@
304	323	ctx->dup_cookie = *desc->dir_cookie;
305	324	ctx->duped = -1;
306	325	}
307		- desc->ctx->pos = new_pos;
	326	+ if (nfs_readdir_use_cookie(desc->file))
	327	+ desc->ctx->pos = *desc->dir_cookie;
	328	+ else
	329	+ desc->ctx->pos = new_pos;
	330	+ desc->prev_index = new_pos;
308	331	desc->cache_entry_index = i;
309	332	return 0;
310	333	}
..	..	@@ -346,13 +369,14 @@
346	369	struct nfs_entry entry, struct file file, struct inode *inode)
347	370	{
348	371	struct nfs_open_dir_context *ctx = file->private_data;
349		- struct rpc_cred *cred = ctx->cred;
	372	+ const struct cred *cred = ctx->cred;
350	373	unsigned long timestamp, gencount;
351	374	int error;
352	375
353	376	again:
354	377	timestamp = jiffies;
355	378	gencount = nfs_inc_attr_generation_counter();
	379	+ desc->dir_verifier = nfs_save_change_attribute(inode);
356	380	error = NFS_PROTO(inode)->readdir(file_dentry(file), cred, entry->cookie, pages,
357	381	NFS_SERVER(inode)->dtsize, desc->plus);
358	382	if (error < 0) {
..	..	@@ -374,9 +398,10 @@
374	398	static int xdr_decode(nfs_readdir_descriptor_t *desc,
375	399	struct nfs_entry entry, struct xdr_stream xdr)
376	400	{
	401	+ struct inode *inode = file_inode(desc->file);
377	402	int error;
378	403
379		- error = desc->decode(xdr, entry, desc->plus);
	404	+ error = NFS_PROTO(inode)->decode_dirent(xdr, entry, desc->plus);
380	405	if (error)
381	406	return error;
382	407	entry->fattr->time_start = desc->timestamp;
..	..	@@ -449,18 +474,19 @@
449	474	if (nfs_server_capable(dir, NFS_CAP_READDIRPLUS) &&
450	475	!list_empty(&nfsi->open_files)) {
451	476	set_bit(NFS_INO_ADVISE_RDPLUS, &nfsi->flags);
452		- invalidate_mapping_pages(dir->i_mapping, 0, -1);
	477	+ invalidate_mapping_pages(dir->i_mapping,
	478	+ nfsi->page_index + 1, -1);
453	479	}
454	480	}
455	481
456	482	static
457		-void nfs_prime_dcache(struct dentry parent, struct nfs_entry entry)
	483	+void nfs_prime_dcache(struct dentry parent, struct nfs_entry entry,
	484	+ unsigned long dir_verifier)
458	485	{
459	486	struct qstr filename = QSTR_INIT(entry->name, entry->len);
460		- DECLARE_SWAIT_QUEUE_HEAD_ONSTACK(wq);
	487	+ DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
461	488	struct dentry *dentry;
462	489	struct dentry *alias;
463		- struct inode *dir = d_inode(parent);
464	490	struct inode *inode;
465	491	int status;
466	492
..	..	@@ -499,7 +525,7 @@
499	525	if (nfs_same_file(dentry, entry)) {
500	526	if (!entry->fh->size)
501	527	goto out;
502		- nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
	528	+ nfs_set_verifier(dentry, dir_verifier);
503	529	status = nfs_refresh_inode(d_inode(dentry), entry->fattr);
504	530	if (!status)
505	531	nfs_setsecurity(d_inode(dentry), entry->fattr, entry->label);
..	..	@@ -525,7 +551,7 @@
525	551	dput(dentry);
526	552	dentry = alias;
527	553	}
528		- nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
	554	+ nfs_set_verifier(dentry, dir_verifier);
529	555	out:
530	556	dput(dentry);
531	557	}
..	..	@@ -566,7 +592,8 @@
566	592	count++;
567	593
568	594	if (desc->plus)
569		- nfs_prime_dcache(file_dentry(desc->file), entry);
	595	+ nfs_prime_dcache(file_dentry(desc->file), entry,
	596	+ desc->dir_verifier);
570	597
571	598	status = nfs_readdir_add_to_array(entry, page);
572	599	if (status != 0)
..	..	@@ -594,8 +621,8 @@
594	621	}
595	622
596	623	/*
597		- * nfs_readdir_large_page will allocate pages that must be freed with a call
598		- * to nfs_readdir_free_pagearray
	624	+ * nfs_readdir_alloc_pages() will allocate pages that must be freed with a call
	625	+ * to nfs_readdir_free_pages()
599	626	*/
600	627	static
601	628	int nfs_readdir_alloc_pages(struct page **pages, unsigned int npages)
..	..	@@ -723,6 +750,8 @@
723	750	static
724	751	int find_and_lock_cache_page(nfs_readdir_descriptor_t *desc)
725	752	{
	753	+ struct inode *inode = file_inode(desc->file);
	754	+ struct nfs_inode *nfsi = NFS_I(inode);
726	755	int res;
727	756
728	757	desc->page = get_cache_page(desc);
..	..	@@ -734,8 +763,10 @@
734	763	res = -EAGAIN;
735	764	if (desc->page->mapping != NULL) {
736	765	res = nfs_readdir_search_array(desc);
737		- if (res == 0)
	766	+ if (res == 0) {
	767	+ nfsi->page_index = desc->page_index;
738	768	return 0;
	769	+ }
739	770	}
740	771	unlock_page(desc->page);
741	772	error:
..	..	@@ -751,6 +782,7 @@
751	782
752	783	if (desc->page_index == 0) {
753	784	desc->current_index = 0;
	785	+ desc->prev_index = 0;
754	786	desc->last_cookie = 0;
755	787	}
756	788	do {
..	..	@@ -781,11 +813,14 @@
781	813	desc->eof = true;
782	814	break;
783	815	}
784		- desc->ctx->pos++;
785	816	if (i < (array->size-1))
786	817	*desc->dir_cookie = array->array[i+1].cookie;
787	818	else
788	819	*desc->dir_cookie = array->last_cookie;
	820	+ if (nfs_readdir_use_cookie(file))
	821	+ desc->ctx->pos = *desc->dir_cookie;
	822	+ else
	823	+ desc->ctx->pos++;
789	824	if (ctx->duped != 0)
790	825	ctx->duped = 1;
791	826	}
..	..	@@ -855,9 +890,14 @@
855	890	{
856	891	struct dentry *dentry = file_dentry(file);
857	892	struct inode *inode = d_inode(dentry);
858		- nfs_readdir_descriptor_t my_desc,
859		- *desc = &my_desc;
860	893	struct nfs_open_dir_context *dir_ctx = file->private_data;
	894	+ nfs_readdir_descriptor_t my_desc = {
	895	+ .file = file,
	896	+ .ctx = ctx,
	897	+ .dir_cookie = &dir_ctx->dir_cookie,
	898	+ .plus = nfs_use_readdirplus(inode, ctx),
	899	+ },
	900	+ *desc = &my_desc;
861	901	int res = 0;
862	902
863	903	dfprintk(FILE, "NFS: readdir(%pD2) starting at cookie %llu\n",
..	..	@@ -870,14 +910,6 @@
870	910	* to either find the entry with the appropriate number or
871	911	* revalidate the cookie.
872	912	*/
873		- memset(desc, 0, sizeof(*desc));
874		-
875		- desc->file = file;
876		- desc->ctx = ctx;
877		- desc->dir_cookie = &dir_ctx->dir_cookie;
878		- desc->decode = NFS_PROTO(inode)->decode_dirent;
879		- desc->plus = nfs_use_readdirplus(inode, ctx);
880		-
881	913	if (ctx->pos == 0 \|\| nfs_attribute_cache_expired(inode))
882	914	res = nfs_revalidate_mapping(inode, file->f_mapping);
883	915	if (res < 0)
..	..	@@ -923,7 +955,6 @@
923	955
924	956	static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int whence)
925	957	{
926		- struct inode *inode = file_inode(filp);
927	958	struct nfs_open_dir_context *dir_ctx = filp->private_data;
928	959
929	960	dfprintk(FILE, "NFS: llseek dir(%pD2, %lld, %d)\n",
..	..	@@ -935,24 +966,27 @@
935	966	case SEEK_SET:
936	967	if (offset < 0)
937	968	return -EINVAL;
938		- inode_lock(inode);
	969	+ spin_lock(&filp->f_lock);
939	970	break;
940	971	case SEEK_CUR:
941	972	if (offset == 0)
942	973	return filp->f_pos;
943		- inode_lock(inode);
	974	+ spin_lock(&filp->f_lock);
944	975	offset += filp->f_pos;
945	976	if (offset < 0) {
946		- inode_unlock(inode);
	977	+ spin_unlock(&filp->f_lock);
947	978	return -EINVAL;
948	979	}
949	980	}
950	981	if (offset != filp->f_pos) {
951	982	filp->f_pos = offset;
952		- dir_ctx->dir_cookie = 0;
	983	+ if (nfs_readdir_use_cookie(filp))
	984	+ dir_ctx->dir_cookie = offset;
	985	+ else
	986	+ dir_ctx->dir_cookie = 0;
953	987	dir_ctx->duped = 0;
954	988	}
955		- inode_unlock(inode);
	989	+ spin_unlock(&filp->f_lock);
956	990	return offset;
957	991	}
958	992
..	..	@@ -963,31 +997,125 @@
963	997	static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
964	998	int datasync)
965	999	{
966		- struct inode *inode = file_inode(filp);
967		-
968	1000	dfprintk(FILE, "NFS: fsync dir(%pD2) datasync %d\n", filp, datasync);
969	1001
970		- inode_lock(inode);
971		- nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
972		- inode_unlock(inode);
	1002	+ nfs_inc_stats(file_inode(filp), NFSIOS_VFSFSYNC);
973	1003	return 0;
974	1004	}
975	1005
976	1006	/**
977	1007	* nfs_force_lookup_revalidate - Mark the directory as having changed
978		- * @dir - pointer to directory inode
	1008	+ * @dir: pointer to directory inode
979	1009	*
980	1010	* This forces the revalidation code in nfs_lookup_revalidate() to do a
981	1011	* full lookup on all child dentries of 'dir' whenever a change occurs
982	1012	* on the server that might have invalidated our dcache.
983	1013	*
	1014	+ * Note that we reserve bit '0' as a tag to let us know when a dentry
	1015	+ * was revalidated while holding a delegation on its inode.
	1016	+ *
984	1017	* The caller should be holding dir->i_lock
985	1018	*/
986	1019	void nfs_force_lookup_revalidate(struct inode *dir)
987	1020	{
988		- NFS_I(dir)->cache_change_attribute++;
	1021	+ NFS_I(dir)->cache_change_attribute += 2;
989	1022	}
990	1023	EXPORT_SYMBOL_GPL(nfs_force_lookup_revalidate);
	1024	+
	1025	+/**
	1026	+ * nfs_verify_change_attribute - Detects NFS remote directory changes
	1027	+ * @dir: pointer to parent directory inode
	1028	+ * @verf: previously saved change attribute
	1029	+ *
	1030	+ * Return "false" if the verifiers doesn't match the change attribute.
	1031	+ * This would usually indicate that the directory contents have changed on
	1032	+ * the server, and that any dentries need revalidating.
	1033	+ */
	1034	+static bool nfs_verify_change_attribute(struct inode *dir, unsigned long verf)
	1035	+{
	1036	+ return (verf & ~1UL) == nfs_save_change_attribute(dir);
	1037	+}
	1038	+
	1039	+static void nfs_set_verifier_delegated(unsigned long *verf)
	1040	+{
	1041	+ *verf \|= 1UL;
	1042	+}
	1043	+
	1044	+#if IS_ENABLED(CONFIG_NFS_V4)
	1045	+static void nfs_unset_verifier_delegated(unsigned long *verf)
	1046	+{
	1047	+ *verf &= ~1UL;
	1048	+}
	1049	+#endif /* IS_ENABLED(CONFIG_NFS_V4) */
	1050	+
	1051	+static bool nfs_test_verifier_delegated(unsigned long verf)
	1052	+{
	1053	+ return verf & 1;
	1054	+}
	1055	+
	1056	+static bool nfs_verifier_is_delegated(struct dentry *dentry)
	1057	+{
	1058	+ return nfs_test_verifier_delegated(dentry->d_time);
	1059	+}
	1060	+
	1061	+static void nfs_set_verifier_locked(struct dentry *dentry, unsigned long verf)
	1062	+{
	1063	+ struct inode *inode = d_inode(dentry);
	1064	+ struct inode *dir = d_inode(dentry->d_parent);
	1065	+
	1066	+ if (!nfs_verify_change_attribute(dir, verf))
	1067	+ return;
	1068	+ if (inode && NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
	1069	+ nfs_set_verifier_delegated(&verf);
	1070	+ dentry->d_time = verf;
	1071	+}
	1072	+
	1073	+/**
	1074	+ * nfs_set_verifier - save a parent directory verifier in the dentry
	1075	+ * @dentry: pointer to dentry
	1076	+ * @verf: verifier to save
	1077	+ *
	1078	+ * Saves the parent directory verifier in @dentry. If the inode has
	1079	+ * a delegation, we also tag the dentry as having been revalidated
	1080	+ * while holding a delegation so that we know we don't have to
	1081	+ * look it up again after a directory change.
	1082	+ */
	1083	+void nfs_set_verifier(struct dentry *dentry, unsigned long verf)
	1084	+{
	1085	+
	1086	+ spin_lock(&dentry->d_lock);
	1087	+ nfs_set_verifier_locked(dentry, verf);
	1088	+ spin_unlock(&dentry->d_lock);
	1089	+}
	1090	+EXPORT_SYMBOL_GPL(nfs_set_verifier);
	1091	+
	1092	+#if IS_ENABLED(CONFIG_NFS_V4)
	1093	+/**
	1094	+ * nfs_clear_verifier_delegated - clear the dir verifier delegation tag
	1095	+ * @inode: pointer to inode
	1096	+ *
	1097	+ * Iterates through the dentries in the inode alias list and clears
	1098	+ * the tag used to indicate that the dentry has been revalidated
	1099	+ * while holding a delegation.
	1100	+ * This function is intended for use when the delegation is being
	1101	+ * returned or revoked.
	1102	+ */
	1103	+void nfs_clear_verifier_delegated(struct inode *inode)
	1104	+{
	1105	+ struct dentry *alias;
	1106	+
	1107	+ if (!inode)
	1108	+ return;
	1109	+ spin_lock(&inode->i_lock);
	1110	+ hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
	1111	+ spin_lock(&alias->d_lock);
	1112	+ nfs_unset_verifier_delegated(&alias->d_time);
	1113	+ spin_unlock(&alias->d_lock);
	1114	+ }
	1115	+ spin_unlock(&inode->i_lock);
	1116	+}
	1117	+EXPORT_SYMBOL_GPL(nfs_clear_verifier_delegated);
	1118	+#endif /* IS_ENABLED(CONFIG_NFS_V4) */
991	1119
992	1120	/*
993	1121	* A check for whether or not the parent directory has changed.
..	..	@@ -1050,7 +1178,7 @@
1050	1178	/* A NFSv4 OPEN will revalidate later */
1051	1179	if (server->caps & NFS_CAP_ATOMIC_OPEN)
1052	1180	goto out;
1053		- /* Fallthrough */
	1181	+ fallthrough;
1054	1182	case S_IFDIR:
1055	1183	if (server->flags & NFS_MOUNT_NOCTO)
1056	1184	break;
..	..	@@ -1071,6 +1199,15 @@
1071	1199	if (ret != 0)
1072	1200	return ret;
1073	1201	goto out;
	1202	+}
	1203	+
	1204	+static void nfs_mark_dir_for_revalidate(struct inode *inode)
	1205	+{
	1206	+ struct nfs_inode *nfsi = NFS_I(inode);
	1207	+
	1208	+ spin_lock(&inode->i_lock);
	1209	+ nfsi->cache_validity \|= NFS_INO_REVAL_PAGECACHE;
	1210	+ spin_unlock(&inode->i_lock);
1074	1211	}
1075	1212
1076	1213	/*
..	..	@@ -1107,19 +1244,14 @@
1107	1244	__func__, dentry);
1108	1245	return 1;
1109	1246	case 0:
1110		- nfs_mark_for_revalidate(dir);
1111		- if (inode && S_ISDIR(inode->i_mode)) {
1112		- /* Purge readdir caches. */
1113		- nfs_zap_caches(inode);
1114		- /*
1115		- * We can't d_drop the root of a disconnected tree:
1116		- * its d_hash is on the s_anon list and d_drop() would hide
1117		- * it from shrink_dcache_for_unmount(), leading to busy
1118		- * inodes on unmount and further oopses.
1119		- */
1120		- if (IS_ROOT(dentry))
1121		- return 1;
1122		- }
	1247	+ /*
	1248	+ * We can't d_drop the root of a disconnected tree:
	1249	+ * its d_hash is on the s_anon list and d_drop() would hide
	1250	+ * it from shrink_dcache_for_unmount(), leading to busy
	1251	+ * inodes on unmount and further oopses.
	1252	+ */
	1253	+ if (inode && IS_ROOT(dentry))
	1254	+ return 1;
1123	1255	dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is invalid\n",
1124	1256	__func__, dentry);
1125	1257	return 0;
..	..	@@ -1157,6 +1289,7 @@
1157	1289	struct nfs_fh *fhandle;
1158	1290	struct nfs_fattr *fattr;
1159	1291	struct nfs4_label *label;
	1292	+ unsigned long dir_verifier;
1160	1293	int ret;
1161	1294
1162	1295	ret = -ENOMEM;
..	..	@@ -1166,10 +1299,18 @@
1166	1299	if (fhandle == NULL \|\| fattr == NULL \|\| IS_ERR(label))
1167	1300	goto out;
1168	1301
1169		- ret = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
	1302	+ dir_verifier = nfs_save_change_attribute(dir);
	1303	+ ret = NFS_PROTO(dir)->lookup(dir, dentry, fhandle, fattr, label);
1170	1304	if (ret < 0) {
1171		- if (ret == -ESTALE \|\| ret == -ENOENT)
	1305	+ switch (ret) {
	1306	+ case -ESTALE:
	1307	+ case -ENOENT:
1172	1308	ret = 0;
	1309	+ break;
	1310	+ case -ETIMEDOUT:
	1311	+ if (NFS_SERVER(inode)->flags & NFS_MOUNT_SOFTREVAL)
	1312	+ ret = 1;
	1313	+ }
1173	1314	goto out;
1174	1315	}
1175	1316	ret = 0;
..	..	@@ -1179,7 +1320,7 @@
1179	1320	goto out;
1180	1321
1181	1322	nfs_setsecurity(inode, fattr, label);
1182		- nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
	1323	+ nfs_set_verifier(dentry, dir_verifier);
1183	1324
1184	1325	/* set a readdirplus hint that we had a cache miss */
1185	1326	nfs_force_use_readdirplus(dir);
..	..	@@ -1188,6 +1329,13 @@
1188	1329	nfs_free_fattr(fattr);
1189	1330	nfs_free_fhandle(fhandle);
1190	1331	nfs4_label_free(label);
	1332	+
	1333	+ /*
	1334	+ * If the lookup failed despite the dentry change attribute being
	1335	+ * a match, then we should revalidate the directory cache.
	1336	+ */
	1337	+ if (!ret && nfs_verify_change_attribute(dir, dentry->d_time))
	1338	+ nfs_mark_dir_for_revalidate(dir);
1191	1339	return nfs_lookup_revalidate_done(dir, dentry, inode, ret);
1192	1340	}
1193	1341
..	..	@@ -1221,7 +1369,7 @@
1221	1369	goto out_bad;
1222	1370	}
1223	1371
1224		- if (NFS_PROTO(dir)->have_delegation(inode, FMODE_READ))
	1372	+ if (nfs_verifier_is_delegated(dentry))
1225	1373	return nfs_lookup_revalidate_delegated(dir, dentry, inode);
1226	1374
1227	1375	/* Force a full look up iff the parent directory has changed */
..	..	@@ -1230,7 +1378,7 @@
1230	1378	error = nfs_lookup_verify_inode(inode, flags);
1231	1379	if (error) {
1232	1380	if (error == -ESTALE)
1233		- nfs_zap_caches(dir);
	1381	+ nfs_mark_dir_for_revalidate(dir);
1234	1382	goto out_bad;
1235	1383	}
1236	1384	nfs_advise_use_readdirplus(dir);
..	..	@@ -1406,6 +1554,7 @@
1406	1554	struct nfs_fh *fhandle = NULL;
1407	1555	struct nfs_fattr *fattr = NULL;
1408	1556	struct nfs4_label *label = NULL;
	1557	+ unsigned long dir_verifier;
1409	1558	int error;
1410	1559
1411	1560	dfprintk(VFS, "NFS: lookup(%pd2)\n", dentry);
..	..	@@ -1431,8 +1580,9 @@
1431	1580	if (IS_ERR(label))
1432	1581	goto out;
1433	1582
	1583	+ dir_verifier = nfs_save_change_attribute(dir);
1434	1584	trace_nfs_lookup_enter(dir, dentry, flags);
1435		- error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
	1585	+ error = NFS_PROTO(dir)->lookup(dir, dentry, fhandle, fattr, label);
1436	1586	if (error == -ENOENT)
1437	1587	goto no_entry;
1438	1588	if (error < 0) {
..	..	@@ -1454,7 +1604,7 @@
1454	1604	goto out_label;
1455	1605	dentry = res;
1456	1606	}
1457		- nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
	1607	+ nfs_set_verifier(dentry, dir_verifier);
1458	1608	out_label:
1459	1609	trace_nfs_lookup_exit(dir, dentry, flags, error);
1460	1610	nfs4_label_free(label);
..	..	@@ -1477,16 +1627,6 @@
1477	1627	.d_release = nfs_d_release,
1478	1628	};
1479	1629	EXPORT_SYMBOL_GPL(nfs4_dentry_operations);
1480		-
1481		-static fmode_t flags_to_mode(int flags)
1482		-{
1483		- fmode_t res = (__force fmode_t)flags & FMODE_EXEC;
1484		- if ((flags & O_ACCMODE) != O_WRONLY)
1485		- res \|= FMODE_READ;
1486		- if ((flags & O_ACCMODE) != O_RDONLY)
1487		- res \|= FMODE_WRITE;
1488		- return res;
1489		-}
1490	1630
1491	1631	static struct nfs_open_context create_nfs_open_context(struct dentry dentry, int open_flags, struct file *filp)
1492	1632	{
..	..	@@ -1520,7 +1660,7 @@
1520	1660	struct file *file, unsigned open_flags,
1521	1661	umode_t mode)
1522	1662	{
1523		- DECLARE_SWAIT_QUEUE_HEAD_ONSTACK(wq);
	1663	+ DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
1524	1664	struct nfs_open_context *ctx;
1525	1665	struct dentry *res;
1526	1666	struct iattr attr = { .ia_valid = ATTR_OPEN };
..	..	@@ -1677,7 +1817,7 @@
1677	1817	if (inode == NULL)
1678	1818	goto full_reval;
1679	1819
1680		- if (NFS_PROTO(dir)->have_delegation(inode, FMODE_READ))
	1820	+ if (nfs_verifier_is_delegated(dentry))
1681	1821	return nfs_lookup_revalidate_delegated(dir, dentry, inode);
1682	1822
1683	1823	/* NFS only supports OPEN on regular files */
..	..	@@ -1697,7 +1837,7 @@
1697	1837	reval_dentry:
1698	1838	if (flags & LOOKUP_RCU)
1699	1839	return -ECHILD;
1700		- return nfs_lookup_revalidate_dentry(dir, dentry, inode);;
	1840	+ return nfs_lookup_revalidate_dentry(dir, dentry, inode);
1701	1841
1702	1842	full_reval:
1703	1843	return nfs_do_lookup_revalidate(dir, dentry, flags);
..	..	@@ -1711,10 +1851,8 @@
1711	1851
1712	1852	#endif /* CONFIG_NFSV4 */
1713	1853
1714		-/*
1715		- * Code common to create, mkdir, and mknod.
1716		- */
1717		-int nfs_instantiate(struct dentry dentry, struct nfs_fh fhandle,
	1854	+struct dentry *
	1855	+nfs_add_or_obtain(struct dentry dentry, struct nfs_fh fhandle,
1718	1856	struct nfs_fattr *fattr,
1719	1857	struct nfs4_label *label)
1720	1858	{
..	..	@@ -1722,15 +1860,12 @@
1722	1860	struct inode *dir = d_inode(parent);
1723	1861	struct inode *inode;
1724	1862	struct dentry *d;
1725		- int error = -EACCES;
	1863	+ int error;
1726	1864
1727	1865	d_drop(dentry);
1728	1866
1729		- /* We may have been initialized further down */
1730		- if (d_really_is_positive(dentry))
1731		- goto out;
1732	1867	if (fhandle->size == 0) {
1733		- error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, NULL);
	1868	+ error = NFS_PROTO(dir)->lookup(dir, dentry, fhandle, fattr, NULL);
1734	1869	if (error)
1735	1870	goto out_error;
1736	1871	}
..	..	@@ -1744,18 +1879,31 @@
1744	1879	}
1745	1880	inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
1746	1881	d = d_splice_alias(inode, dentry);
1747		- if (IS_ERR(d)) {
1748		- error = PTR_ERR(d);
1749		- goto out_error;
1750		- }
1751		- dput(d);
1752	1882	out:
1753	1883	dput(parent);
1754		- return 0;
	1884	+ return d;
1755	1885	out_error:
1756		- nfs_mark_for_revalidate(dir);
1757		- dput(parent);
1758		- return error;
	1886	+ d = ERR_PTR(error);
	1887	+ goto out;
	1888	+}
	1889	+EXPORT_SYMBOL_GPL(nfs_add_or_obtain);
	1890	+
	1891	+/*
	1892	+ * Code common to create, mkdir, and mknod.
	1893	+ */
	1894	+int nfs_instantiate(struct dentry dentry, struct nfs_fh fhandle,
	1895	+ struct nfs_fattr *fattr,
	1896	+ struct nfs4_label *label)
	1897	+{
	1898	+ struct dentry *d;
	1899	+
	1900	+ d = nfs_add_or_obtain(dentry, fhandle, fattr, label);
	1901	+ if (IS_ERR(d))
	1902	+ return PTR_ERR(d);
	1903	+
	1904	+ /* Callers don't care */
	1905	+ dput(d);
	1906	+ return 0;
1759	1907	}
1760	1908	EXPORT_SYMBOL_GPL(nfs_instantiate);
1761	1909
..	..	@@ -1858,11 +2006,7 @@
1858	2006
1859	2007	trace_nfs_rmdir_enter(dir, dentry);
1860	2008	if (d_really_is_positive(dentry)) {
1861		-#ifdef CONFIG_PREEMPT_RT_BASE
1862		- down(&NFS_I(d_inode(dentry))->rmdir_sem);
1863		-#else
1864	2009	down_write(&NFS_I(d_inode(dentry))->rmdir_sem);
1865		-#endif
1866	2010	error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
1867	2011	/* Ensure the VFS deletes this inode */
1868	2012	switch (error) {
..	..	@@ -1872,11 +2016,7 @@
1872	2016	case -ENOENT:
1873	2017	nfs_dentry_handle_enoent(dentry);
1874	2018	}
1875		-#ifdef CONFIG_PREEMPT_RT_BASE
1876		- up(&NFS_I(d_inode(dentry))->rmdir_sem);
1877		-#else
1878	2019	up_write(&NFS_I(d_inode(dentry))->rmdir_sem);
1879		-#endif
1880	2020	} else
1881	2021	error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
1882	2022	trace_nfs_rmdir_exit(dir, dentry, error);
..	..	@@ -2188,13 +2328,13 @@
2188	2328	static LIST_HEAD(nfs_access_lru_list);
2189	2329	static atomic_long_t nfs_access_nr_entries;
2190	2330
2191		-static unsigned long nfs_access_max_cachesize = ULONG_MAX;
	2331	+static unsigned long nfs_access_max_cachesize = 410241024;
2192	2332	module_param(nfs_access_max_cachesize, ulong, 0644);
2193	2333	MODULE_PARM_DESC(nfs_access_max_cachesize, "NFS access maximum total cache length");
2194	2334
2195	2335	static void nfs_access_free_entry(struct nfs_access_entry *entry)
2196	2336	{
2197		- put_rpccred(entry->cred);
	2337	+ put_cred(entry->cred);
2198	2338	kfree_rcu(entry, rcu_head);
2199	2339	smp_mb__before_atomic();
2200	2340	atomic_long_dec(&nfs_access_nr_entries);
..	..	@@ -2320,17 +2460,18 @@
2320	2460	}
2321	2461	EXPORT_SYMBOL_GPL(nfs_access_zap_cache);
2322	2462
2323		-static struct nfs_access_entry nfs_access_search_rbtree(struct inode inode, struct rpc_cred *cred)
	2463	+static struct nfs_access_entry nfs_access_search_rbtree(struct inode inode, const struct cred *cred)
2324	2464	{
2325	2465	struct rb_node *n = NFS_I(inode)->access_cache.rb_node;
2326		- struct nfs_access_entry *entry;
2327	2466
2328	2467	while (n != NULL) {
2329		- entry = rb_entry(n, struct nfs_access_entry, rb_node);
	2468	+ struct nfs_access_entry *entry =
	2469	+ rb_entry(n, struct nfs_access_entry, rb_node);
	2470	+ int cmp = cred_fscmp(cred, entry->cred);
2330	2471
2331		- if (cred < entry->cred)
	2472	+ if (cmp < 0)
2332	2473	n = n->rb_left;
2333		- else if (cred > entry->cred)
	2474	+ else if (cmp > 0)
2334	2475	n = n->rb_right;
2335	2476	else
2336	2477	return entry;
..	..	@@ -2338,7 +2479,7 @@
2338	2479	return NULL;
2339	2480	}
2340	2481
2341		-static int nfs_access_get_cached(struct inode inode, struct rpc_cred cred, struct nfs_access_entry *res, bool may_block)
	2482	+static int nfs_access_get_cached_locked(struct inode inode, const struct cred cred, u32 *mask, bool may_block)
2342	2483	{
2343	2484	struct nfs_inode *nfsi = NFS_I(inode);
2344	2485	struct nfs_access_entry *cache;
..	..	@@ -2356,11 +2497,11 @@
2356	2497	/* Found an entry, is our attribute cache valid? */
2357	2498	if (!nfs_check_cache_invalid(inode, NFS_INO_INVALID_ACCESS))
2358	2499	break;
	2500	+ if (!retry)
	2501	+ break;
2359	2502	err = -ECHILD;
2360	2503	if (!may_block)
2361	2504	goto out;
2362		- if (!retry)
2363		- goto out_zap;
2364	2505	spin_unlock(&inode->i_lock);
2365	2506	err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
2366	2507	if (err)
..	..	@@ -2368,8 +2509,7 @@
2368	2509	spin_lock(&inode->i_lock);
2369	2510	retry = false;
2370	2511	}
2371		- res->cred = cache->cred;
2372		- res->mask = cache->mask;
	2512	+ *mask = cache->mask;
2373	2513	list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru);
2374	2514	err = 0;
2375	2515	out:
..	..	@@ -2381,7 +2521,7 @@
2381	2521	return -ENOENT;
2382	2522	}
2383	2523
2384		-static int nfs_access_get_cached_rcu(struct inode inode, struct rpc_cred cred, struct nfs_access_entry *res)
	2524	+static int nfs_access_get_cached_rcu(struct inode inode, const struct cred cred, u32 *mask)
2385	2525	{
2386	2526	/* Only check the most recently returned cache entry,
2387	2527	* but do it without locking.
..	..	@@ -2394,22 +2534,35 @@
2394	2534	rcu_read_lock();
2395	2535	if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
2396	2536	goto out;
2397		- lh = rcu_dereference(nfsi->access_cache_entry_lru.prev);
	2537	+ lh = rcu_dereference(list_tail_rcu(&nfsi->access_cache_entry_lru));
2398	2538	cache = list_entry(lh, struct nfs_access_entry, lru);
2399	2539	if (lh == &nfsi->access_cache_entry_lru \|\|
2400		- cred != cache->cred)
	2540	+ cred_fscmp(cred, cache->cred) != 0)
2401	2541	cache = NULL;
2402	2542	if (cache == NULL)
2403	2543	goto out;
2404	2544	if (nfs_check_cache_invalid(inode, NFS_INO_INVALID_ACCESS))
2405	2545	goto out;
2406		- res->cred = cache->cred;
2407		- res->mask = cache->mask;
	2546	+ *mask = cache->mask;
2408	2547	err = 0;
2409	2548	out:
2410	2549	rcu_read_unlock();
2411	2550	return err;
2412	2551	}
	2552	+
	2553	+int nfs_access_get_cached(struct inode inode, const struct cred cred,
	2554	+ u32 *mask, bool may_block)
	2555	+{
	2556	+ int status;
	2557	+
	2558	+ status = nfs_access_get_cached_rcu(inode, cred, mask);
	2559	+ if (status != 0)
	2560	+ status = nfs_access_get_cached_locked(inode, cred, mask,
	2561	+ may_block);
	2562	+
	2563	+ return status;
	2564	+}
	2565	+EXPORT_SYMBOL_GPL(nfs_access_get_cached);
2413	2566
2414	2567	static void nfs_access_add_rbtree(struct inode inode, struct nfs_access_entry set)
2415	2568	{
..	..	@@ -2418,15 +2571,17 @@
2418	2571	struct rb_node **p = &root_node->rb_node;
2419	2572	struct rb_node *parent = NULL;
2420	2573	struct nfs_access_entry *entry;
	2574	+ int cmp;
2421	2575
2422	2576	spin_lock(&inode->i_lock);
2423	2577	while (*p != NULL) {
2424	2578	parent = *p;
2425	2579	entry = rb_entry(parent, struct nfs_access_entry, rb_node);
	2580	+ cmp = cred_fscmp(set->cred, entry->cred);
2426	2581
2427		- if (set->cred < entry->cred)
	2582	+ if (cmp < 0)
2428	2583	p = &parent->rb_left;
2429		- else if (set->cred > entry->cred)
	2584	+ else if (cmp > 0)
2430	2585	p = &parent->rb_right;
2431	2586	else
2432	2587	goto found;
..	..	@@ -2450,7 +2605,7 @@
2450	2605	if (cache == NULL)
2451	2606	return;
2452	2607	RB_CLEAR_NODE(&cache->rb_node);
2453		- cache->cred = get_rpccred(set->cred);
	2608	+ cache->cred = get_cred(set->cred);
2454	2609	cache->mask = set->mask;
2455	2610
2456	2611	/* The above field assignments must be visible
..	..	@@ -2514,18 +2669,16 @@
2514	2669	}
2515	2670	EXPORT_SYMBOL_GPL(nfs_access_set_mask);
2516	2671
2517		-static int nfs_do_access(struct inode inode, struct rpc_cred cred, int mask)
	2672	+static int nfs_do_access(struct inode inode, const struct cred cred, int mask)
2518	2673	{
2519	2674	struct nfs_access_entry cache;
2520	2675	bool may_block = (mask & MAY_NOT_BLOCK) == 0;
2521		- int cache_mask;
	2676	+ int cache_mask = -1;
2522	2677	int status;
2523	2678
2524	2679	trace_nfs_access_enter(inode);
2525	2680
2526		- status = nfs_access_get_cached_rcu(inode, cred, &cache);
2527		- if (status != 0)
2528		- status = nfs_access_get_cached(inode, cred, &cache, may_block);
	2681	+ status = nfs_access_get_cached(inode, cred, &cache.mask, may_block);
2529	2682	if (status == 0)
2530	2683	goto out_cached;
2531	2684
..	..	@@ -2537,6 +2690,10 @@
2537	2690	* Determine which access bits we want to ask for...
2538	2691	*/
2539	2692	cache.mask = NFS_ACCESS_READ \| NFS_ACCESS_MODIFY \| NFS_ACCESS_EXTEND;
	2693	+ if (nfs_server_capable(inode, NFS_CAP_XATTR)) {
	2694	+ cache.mask \|= NFS_ACCESS_XAREAD \| NFS_ACCESS_XAWRITE \|
	2695	+ NFS_ACCESS_XALIST;
	2696	+ }
2540	2697	if (S_ISDIR(inode->i_mode))
2541	2698	cache.mask \|= NFS_ACCESS_DELETE \| NFS_ACCESS_LOOKUP;
2542	2699	else
..	..	@@ -2545,9 +2702,10 @@
2545	2702	status = NFS_PROTO(inode)->access(inode, &cache);
2546	2703	if (status != 0) {
2547	2704	if (status == -ESTALE) {
2548		- nfs_zap_caches(inode);
2549	2705	if (!S_ISDIR(inode->i_mode))
2550		- set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
	2706	+ nfs_set_inode_stale(inode);
	2707	+ else
	2708	+ nfs_zap_caches(inode);
2551	2709	}
2552	2710	goto out;
2553	2711	}
..	..	@@ -2557,7 +2715,7 @@
2557	2715	if ((mask & ~cache_mask & (MAY_READ \| MAY_WRITE \| MAY_EXEC)) != 0)
2558	2716	status = -EACCES;
2559	2717	out:
2560		- trace_nfs_access_exit(inode, status);
	2718	+ trace_nfs_access_exit(inode, mask, cache_mask, status);
2561	2719	return status;
2562	2720	}
2563	2721
..	..	@@ -2578,7 +2736,7 @@
2578	2736	return mask;
2579	2737	}
2580	2738
2581		-int nfs_may_open(struct inode inode, struct rpc_cred cred, int openflags)
	2739	+int nfs_may_open(struct inode inode, const struct cred cred, int openflags)
2582	2740	{
2583	2741	return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags));
2584	2742	}
..	..	@@ -2603,7 +2761,7 @@
2603	2761
2604	2762	int nfs_permission(struct inode *inode, int mask)
2605	2763	{
2606		- struct rpc_cred *cred;
	2764	+ const struct cred *cred = current_cred();
2607	2765	int res = 0;
2608	2766
2609	2767	nfs_inc_stats(inode, NFSIOS_VFSACCESS);
..	..	@@ -2635,23 +2793,7 @@
2635	2793	if (!NFS_PROTO(inode)->access)
2636	2794	goto out_notsup;
2637	2795
2638		- /* Always try fast lookups first */
2639		- rcu_read_lock();
2640		- cred = rpc_lookup_cred_nonblock();
2641		- if (!IS_ERR(cred))
2642		- res = nfs_do_access(inode, cred, mask\|MAY_NOT_BLOCK);
2643		- else
2644		- res = PTR_ERR(cred);
2645		- rcu_read_unlock();
2646		- if (res == -ECHILD && !(mask & MAY_NOT_BLOCK)) {
2647		- /* Fast lookup failed, try the slow way */
2648		- cred = rpc_lookup_cred();
2649		- if (!IS_ERR(cred)) {
2650		- res = nfs_do_access(inode, cred, mask);
2651		- put_rpccred(cred);
2652		- } else
2653		- res = PTR_ERR(cred);
2654		- }
	2796	+ res = nfs_do_access(inode, cred, mask);
2655	2797	out:
2656	2798	if (!res && (mask & MAY_EXEC))
2657	2799	res = nfs_execute_ok(inode, mask);