xref: /linux/fs/nfs/dir.c (revision d3d90cc2891c9cf4ecba7b85c0af716ab755c7e5)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  linux/fs/nfs/dir.c
4  *
5  *  Copyright (C) 1992  Rick Sladkey
6  *
7  *  nfs directory handling functions
8  *
9  * 10 Apr 1996	Added silly rename for unlink	--okir
10  * 28 Sep 1996	Improved directory cache --okir
11  * 23 Aug 1997  Claus Heine claus@momo.math.rwth-aachen.de
12  *              Re-implemented silly rename for unlink, newly implemented
13  *              silly rename for nfs_rename() following the suggestions
14  *              of Olaf Kirch (okir) found in this file.
15  *              Following Linus comments on my original hack, this version
16  *              depends only on the dcache stuff and doesn't touch the inode
17  *              layer (iput() and friends).
18  *  6 Jun 1999	Cache readdir lookups in the page cache. -DaveM
19  */
20 
21 #include <linux/compat.h>
22 #include <linux/module.h>
23 #include <linux/time.h>
24 #include <linux/errno.h>
25 #include <linux/stat.h>
26 #include <linux/fcntl.h>
27 #include <linux/string.h>
28 #include <linux/kernel.h>
29 #include <linux/slab.h>
30 #include <linux/mm.h>
31 #include <linux/sunrpc/clnt.h>
32 #include <linux/nfs_fs.h>
33 #include <linux/nfs_mount.h>
34 #include <linux/pagemap.h>
35 #include <linux/pagevec.h>
36 #include <linux/namei.h>
37 #include <linux/mount.h>
38 #include <linux/swap.h>
39 #include <linux/sched.h>
40 #include <linux/kmemleak.h>
41 #include <linux/xattr.h>
42 #include <linux/hash.h>
43 
44 #include "delegation.h"
45 #include "iostat.h"
46 #include "internal.h"
47 #include "fscache.h"
48 
49 #include "nfstrace.h"
50 
51 /* #define NFS_DEBUG_VERBOSE 1 */
52 
53 static int nfs_opendir(struct inode *, struct file *);
54 static int nfs_closedir(struct inode *, struct file *);
55 static int nfs_readdir(struct file *, struct dir_context *);
56 static int nfs_fsync_dir(struct file *, loff_t, loff_t, int);
57 static loff_t nfs_llseek_dir(struct file *, loff_t, int);
58 static void nfs_readdir_clear_array(struct folio *);
59 static int nfs_do_create(struct inode *dir, struct dentry *dentry,
60 			 umode_t mode, int open_flags);
61 
62 const struct file_operations nfs_dir_operations = {
63 	.llseek		= nfs_llseek_dir,
64 	.read		= generic_read_dir,
65 	.iterate_shared	= nfs_readdir,
66 	.open		= nfs_opendir,
67 	.release	= nfs_closedir,
68 	.fsync		= nfs_fsync_dir,
69 };
70 
71 const struct address_space_operations nfs_dir_aops = {
72 	.free_folio = nfs_readdir_clear_array,
73 };
74 
75 #define NFS_INIT_DTSIZE PAGE_SIZE
76 
77 static struct nfs_open_dir_context *
alloc_nfs_open_dir_context(struct inode * dir)78 alloc_nfs_open_dir_context(struct inode *dir)
79 {
80 	struct nfs_inode *nfsi = NFS_I(dir);
81 	struct nfs_open_dir_context *ctx;
82 
83 	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL_ACCOUNT);
84 	if (ctx != NULL) {
85 		ctx->attr_gencount = nfsi->attr_gencount;
86 		ctx->dtsize = NFS_INIT_DTSIZE;
87 		spin_lock(&dir->i_lock);
88 		if (list_empty(&nfsi->open_files) &&
89 		    (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER))
90 			nfs_set_cache_invalid(dir,
91 					      NFS_INO_INVALID_DATA |
92 						      NFS_INO_REVAL_FORCED);
93 		list_add_tail_rcu(&ctx->list, &nfsi->open_files);
94 		memcpy(ctx->verf, nfsi->cookieverf, sizeof(ctx->verf));
95 		spin_unlock(&dir->i_lock);
96 		return ctx;
97 	}
98 	return  ERR_PTR(-ENOMEM);
99 }
100 
put_nfs_open_dir_context(struct inode * dir,struct nfs_open_dir_context * ctx)101 static void put_nfs_open_dir_context(struct inode *dir, struct nfs_open_dir_context *ctx)
102 {
103 	spin_lock(&dir->i_lock);
104 	list_del_rcu(&ctx->list);
105 	spin_unlock(&dir->i_lock);
106 	kfree_rcu(ctx, rcu_head);
107 }
108 
109 /*
110  * Open file
111  */
112 static int
nfs_opendir(struct inode * inode,struct file * filp)113 nfs_opendir(struct inode *inode, struct file *filp)
114 {
115 	int res = 0;
116 	struct nfs_open_dir_context *ctx;
117 
118 	dfprintk(FILE, "NFS: open dir(%pD2)\n", filp);
119 
120 	nfs_inc_stats(inode, NFSIOS_VFSOPEN);
121 
122 	ctx = alloc_nfs_open_dir_context(inode);
123 	if (IS_ERR(ctx)) {
124 		res = PTR_ERR(ctx);
125 		goto out;
126 	}
127 	filp->private_data = ctx;
128 out:
129 	return res;
130 }
131 
132 static int
nfs_closedir(struct inode * inode,struct file * filp)133 nfs_closedir(struct inode *inode, struct file *filp)
134 {
135 	put_nfs_open_dir_context(file_inode(filp), filp->private_data);
136 	return 0;
137 }
138 
139 struct nfs_cache_array_entry {
140 	u64 cookie;
141 	u64 ino;
142 	const char *name;
143 	unsigned int name_len;
144 	unsigned char d_type;
145 };
146 
147 struct nfs_cache_array {
148 	u64 change_attr;
149 	u64 last_cookie;
150 	unsigned int size;
151 	unsigned char folio_full : 1,
152 		      folio_is_eof : 1,
153 		      cookies_are_ordered : 1;
154 	struct nfs_cache_array_entry array[] __counted_by(size);
155 };
156 
157 struct nfs_readdir_descriptor {
158 	struct file	*file;
159 	struct folio	*folio;
160 	struct dir_context *ctx;
161 	pgoff_t		folio_index;
162 	pgoff_t		folio_index_max;
163 	u64		dir_cookie;
164 	u64		last_cookie;
165 	loff_t		current_index;
166 
167 	__be32		verf[NFS_DIR_VERIFIER_SIZE];
168 	unsigned long	dir_verifier;
169 	unsigned long	timestamp;
170 	unsigned long	gencount;
171 	unsigned long	attr_gencount;
172 	unsigned int	cache_entry_index;
173 	unsigned int	buffer_fills;
174 	unsigned int	dtsize;
175 	bool clear_cache;
176 	bool plus;
177 	bool eob;
178 	bool eof;
179 };
180 
nfs_set_dtsize(struct nfs_readdir_descriptor * desc,unsigned int sz)181 static void nfs_set_dtsize(struct nfs_readdir_descriptor *desc, unsigned int sz)
182 {
183 	struct nfs_server *server = NFS_SERVER(file_inode(desc->file));
184 	unsigned int maxsize = server->dtsize;
185 
186 	if (sz > maxsize)
187 		sz = maxsize;
188 	if (sz < NFS_MIN_FILE_IO_SIZE)
189 		sz = NFS_MIN_FILE_IO_SIZE;
190 	desc->dtsize = sz;
191 }
192 
nfs_shrink_dtsize(struct nfs_readdir_descriptor * desc)193 static void nfs_shrink_dtsize(struct nfs_readdir_descriptor *desc)
194 {
195 	nfs_set_dtsize(desc, desc->dtsize >> 1);
196 }
197 
nfs_grow_dtsize(struct nfs_readdir_descriptor * desc)198 static void nfs_grow_dtsize(struct nfs_readdir_descriptor *desc)
199 {
200 	nfs_set_dtsize(desc, desc->dtsize << 1);
201 }
202 
nfs_readdir_folio_init_array(struct folio * folio,u64 last_cookie,u64 change_attr)203 static void nfs_readdir_folio_init_array(struct folio *folio, u64 last_cookie,
204 					 u64 change_attr)
205 {
206 	struct nfs_cache_array *array;
207 
208 	array = kmap_local_folio(folio, 0);
209 	array->change_attr = change_attr;
210 	array->last_cookie = last_cookie;
211 	array->size = 0;
212 	array->folio_full = 0;
213 	array->folio_is_eof = 0;
214 	array->cookies_are_ordered = 1;
215 	kunmap_local(array);
216 }
217 
218 /*
219  * we are freeing strings created by nfs_add_to_readdir_array()
220  */
nfs_readdir_clear_array(struct folio * folio)221 static void nfs_readdir_clear_array(struct folio *folio)
222 {
223 	struct nfs_cache_array *array;
224 	unsigned int i;
225 
226 	array = kmap_local_folio(folio, 0);
227 	for (i = 0; i < array->size; i++)
228 		kfree(array->array[i].name);
229 	array->size = 0;
230 	kunmap_local(array);
231 }
232 
nfs_readdir_folio_reinit_array(struct folio * folio,u64 last_cookie,u64 change_attr)233 static void nfs_readdir_folio_reinit_array(struct folio *folio, u64 last_cookie,
234 					   u64 change_attr)
235 {
236 	nfs_readdir_clear_array(folio);
237 	nfs_readdir_folio_init_array(folio, last_cookie, change_attr);
238 }
239 
240 static struct folio *
nfs_readdir_folio_array_alloc(u64 last_cookie,gfp_t gfp_flags)241 nfs_readdir_folio_array_alloc(u64 last_cookie, gfp_t gfp_flags)
242 {
243 	struct folio *folio = folio_alloc(gfp_flags, 0);
244 	if (folio)
245 		nfs_readdir_folio_init_array(folio, last_cookie, 0);
246 	return folio;
247 }
248 
nfs_readdir_folio_array_free(struct folio * folio)249 static void nfs_readdir_folio_array_free(struct folio *folio)
250 {
251 	if (folio) {
252 		nfs_readdir_clear_array(folio);
253 		folio_put(folio);
254 	}
255 }
256 
nfs_readdir_array_index_cookie(struct nfs_cache_array * array)257 static u64 nfs_readdir_array_index_cookie(struct nfs_cache_array *array)
258 {
259 	return array->size == 0 ? array->last_cookie : array->array[0].cookie;
260 }
261 
nfs_readdir_array_set_eof(struct nfs_cache_array * array)262 static void nfs_readdir_array_set_eof(struct nfs_cache_array *array)
263 {
264 	array->folio_is_eof = 1;
265 	array->folio_full = 1;
266 }
267 
nfs_readdir_array_is_full(struct nfs_cache_array * array)268 static bool nfs_readdir_array_is_full(struct nfs_cache_array *array)
269 {
270 	return array->folio_full;
271 }
272 
273 /*
274  * the caller is responsible for freeing qstr.name
275  * when called by nfs_readdir_add_to_array, the strings will be freed in
276  * nfs_clear_readdir_array()
277  */
nfs_readdir_copy_name(const char * name,unsigned int len)278 static const char *nfs_readdir_copy_name(const char *name, unsigned int len)
279 {
280 	const char *ret = kmemdup_nul(name, len, GFP_KERNEL);
281 
282 	/*
283 	 * Avoid a kmemleak false positive. The pointer to the name is stored
284 	 * in a page cache page which kmemleak does not scan.
285 	 */
286 	if (ret != NULL)
287 		kmemleak_not_leak(ret);
288 	return ret;
289 }
290 
nfs_readdir_array_maxentries(void)291 static size_t nfs_readdir_array_maxentries(void)
292 {
293 	return (PAGE_SIZE - sizeof(struct nfs_cache_array)) /
294 	       sizeof(struct nfs_cache_array_entry);
295 }
296 
297 /*
298  * Check that the next array entry lies entirely within the page bounds
299  */
nfs_readdir_array_can_expand(struct nfs_cache_array * array)300 static int nfs_readdir_array_can_expand(struct nfs_cache_array *array)
301 {
302 	if (array->folio_full)
303 		return -ENOSPC;
304 	if (array->size == nfs_readdir_array_maxentries()) {
305 		array->folio_full = 1;
306 		return -ENOSPC;
307 	}
308 	return 0;
309 }
310 
nfs_readdir_folio_array_append(struct folio * folio,const struct nfs_entry * entry,u64 * cookie)311 static int nfs_readdir_folio_array_append(struct folio *folio,
312 					  const struct nfs_entry *entry,
313 					  u64 *cookie)
314 {
315 	struct nfs_cache_array *array;
316 	struct nfs_cache_array_entry *cache_entry;
317 	const char *name;
318 	int ret = -ENOMEM;
319 
320 	name = nfs_readdir_copy_name(entry->name, entry->len);
321 
322 	array = kmap_local_folio(folio, 0);
323 	if (!name)
324 		goto out;
325 	ret = nfs_readdir_array_can_expand(array);
326 	if (ret) {
327 		kfree(name);
328 		goto out;
329 	}
330 
331 	array->size++;
332 	cache_entry = &array->array[array->size - 1];
333 	cache_entry->cookie = array->last_cookie;
334 	cache_entry->ino = entry->ino;
335 	cache_entry->d_type = entry->d_type;
336 	cache_entry->name_len = entry->len;
337 	cache_entry->name = name;
338 	array->last_cookie = entry->cookie;
339 	if (array->last_cookie <= cache_entry->cookie)
340 		array->cookies_are_ordered = 0;
341 	if (entry->eof != 0)
342 		nfs_readdir_array_set_eof(array);
343 out:
344 	*cookie = array->last_cookie;
345 	kunmap_local(array);
346 	return ret;
347 }
348 
349 #define NFS_READDIR_COOKIE_MASK (U32_MAX >> 14)
350 /*
351  * Hash algorithm allowing content addressible access to sequences
352  * of directory cookies. Content is addressed by the value of the
353  * cookie index of the first readdir entry in a page.
354  *
355  * We select only the first 18 bits to avoid issues with excessive
356  * memory use for the page cache XArray. 18 bits should allow the caching
357  * of 262144 pages of sequences of readdir entries. Since each page holds
358  * 127 readdir entries for a typical 64-bit system, that works out to a
359  * cache of ~ 33 million entries per directory.
360  */
nfs_readdir_folio_cookie_hash(u64 cookie)361 static pgoff_t nfs_readdir_folio_cookie_hash(u64 cookie)
362 {
363 	if (cookie == 0)
364 		return 0;
365 	return hash_64(cookie, 18);
366 }
367 
nfs_readdir_folio_validate(struct folio * folio,u64 last_cookie,u64 change_attr)368 static bool nfs_readdir_folio_validate(struct folio *folio, u64 last_cookie,
369 				       u64 change_attr)
370 {
371 	struct nfs_cache_array *array = kmap_local_folio(folio, 0);
372 	int ret = true;
373 
374 	if (array->change_attr != change_attr)
375 		ret = false;
376 	if (nfs_readdir_array_index_cookie(array) != last_cookie)
377 		ret = false;
378 	kunmap_local(array);
379 	return ret;
380 }
381 
nfs_readdir_folio_unlock_and_put(struct folio * folio)382 static void nfs_readdir_folio_unlock_and_put(struct folio *folio)
383 {
384 	folio_unlock(folio);
385 	folio_put(folio);
386 }
387 
nfs_readdir_folio_init_and_validate(struct folio * folio,u64 cookie,u64 change_attr)388 static void nfs_readdir_folio_init_and_validate(struct folio *folio, u64 cookie,
389 						u64 change_attr)
390 {
391 	if (folio_test_uptodate(folio)) {
392 		if (nfs_readdir_folio_validate(folio, cookie, change_attr))
393 			return;
394 		nfs_readdir_clear_array(folio);
395 	}
396 	nfs_readdir_folio_init_array(folio, cookie, change_attr);
397 	folio_mark_uptodate(folio);
398 }
399 
nfs_readdir_folio_get_locked(struct address_space * mapping,u64 cookie,u64 change_attr)400 static struct folio *nfs_readdir_folio_get_locked(struct address_space *mapping,
401 						  u64 cookie, u64 change_attr)
402 {
403 	pgoff_t index = nfs_readdir_folio_cookie_hash(cookie);
404 	struct folio *folio;
405 
406 	folio = filemap_grab_folio(mapping, index);
407 	if (IS_ERR(folio))
408 		return NULL;
409 	nfs_readdir_folio_init_and_validate(folio, cookie, change_attr);
410 	return folio;
411 }
412 
nfs_readdir_folio_last_cookie(struct folio * folio)413 static u64 nfs_readdir_folio_last_cookie(struct folio *folio)
414 {
415 	struct nfs_cache_array *array;
416 	u64 ret;
417 
418 	array = kmap_local_folio(folio, 0);
419 	ret = array->last_cookie;
420 	kunmap_local(array);
421 	return ret;
422 }
423 
nfs_readdir_folio_needs_filling(struct folio * folio)424 static bool nfs_readdir_folio_needs_filling(struct folio *folio)
425 {
426 	struct nfs_cache_array *array;
427 	bool ret;
428 
429 	array = kmap_local_folio(folio, 0);
430 	ret = !nfs_readdir_array_is_full(array);
431 	kunmap_local(array);
432 	return ret;
433 }
434 
nfs_readdir_folio_set_eof(struct folio * folio)435 static void nfs_readdir_folio_set_eof(struct folio *folio)
436 {
437 	struct nfs_cache_array *array;
438 
439 	array = kmap_local_folio(folio, 0);
440 	nfs_readdir_array_set_eof(array);
441 	kunmap_local(array);
442 }
443 
nfs_readdir_folio_get_next(struct address_space * mapping,u64 cookie,u64 change_attr)444 static struct folio *nfs_readdir_folio_get_next(struct address_space *mapping,
445 						u64 cookie, u64 change_attr)
446 {
447 	pgoff_t index = nfs_readdir_folio_cookie_hash(cookie);
448 	struct folio *folio;
449 
450 	folio = __filemap_get_folio(mapping, index,
451 			FGP_LOCK|FGP_CREAT|FGP_NOFS|FGP_NOWAIT,
452 			mapping_gfp_mask(mapping));
453 	if (IS_ERR(folio))
454 		return NULL;
455 	nfs_readdir_folio_init_and_validate(folio, cookie, change_attr);
456 	if (nfs_readdir_folio_last_cookie(folio) != cookie)
457 		nfs_readdir_folio_reinit_array(folio, cookie, change_attr);
458 	return folio;
459 }
460 
461 static inline
is_32bit_api(void)462 int is_32bit_api(void)
463 {
464 #ifdef CONFIG_COMPAT
465 	return in_compat_syscall();
466 #else
467 	return (BITS_PER_LONG == 32);
468 #endif
469 }
470 
471 static
nfs_readdir_use_cookie(const struct file * filp)472 bool nfs_readdir_use_cookie(const struct file *filp)
473 {
474 	if ((filp->f_mode & FMODE_32BITHASH) ||
475 	    (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
476 		return false;
477 	return true;
478 }
479 
nfs_readdir_seek_next_array(struct nfs_cache_array * array,struct nfs_readdir_descriptor * desc)480 static void nfs_readdir_seek_next_array(struct nfs_cache_array *array,
481 					struct nfs_readdir_descriptor *desc)
482 {
483 	if (array->folio_full) {
484 		desc->last_cookie = array->last_cookie;
485 		desc->current_index += array->size;
486 		desc->cache_entry_index = 0;
487 		desc->folio_index++;
488 	} else
489 		desc->last_cookie = nfs_readdir_array_index_cookie(array);
490 }
491 
nfs_readdir_rewind_search(struct nfs_readdir_descriptor * desc)492 static void nfs_readdir_rewind_search(struct nfs_readdir_descriptor *desc)
493 {
494 	desc->current_index = 0;
495 	desc->last_cookie = 0;
496 	desc->folio_index = 0;
497 }
498 
nfs_readdir_search_for_pos(struct nfs_cache_array * array,struct nfs_readdir_descriptor * desc)499 static int nfs_readdir_search_for_pos(struct nfs_cache_array *array,
500 				      struct nfs_readdir_descriptor *desc)
501 {
502 	loff_t diff = desc->ctx->pos - desc->current_index;
503 	unsigned int index;
504 
505 	if (diff < 0)
506 		goto out_eof;
507 	if (diff >= array->size) {
508 		if (array->folio_is_eof)
509 			goto out_eof;
510 		nfs_readdir_seek_next_array(array, desc);
511 		return -EAGAIN;
512 	}
513 
514 	index = (unsigned int)diff;
515 	desc->dir_cookie = array->array[index].cookie;
516 	desc->cache_entry_index = index;
517 	return 0;
518 out_eof:
519 	desc->eof = true;
520 	return -EBADCOOKIE;
521 }
522 
nfs_readdir_array_cookie_in_range(struct nfs_cache_array * array,u64 cookie)523 static bool nfs_readdir_array_cookie_in_range(struct nfs_cache_array *array,
524 					      u64 cookie)
525 {
526 	if (!array->cookies_are_ordered)
527 		return true;
528 	/* Optimisation for monotonically increasing cookies */
529 	if (cookie >= array->last_cookie)
530 		return false;
531 	if (array->size && cookie < array->array[0].cookie)
532 		return false;
533 	return true;
534 }
535 
nfs_readdir_search_for_cookie(struct nfs_cache_array * array,struct nfs_readdir_descriptor * desc)536 static int nfs_readdir_search_for_cookie(struct nfs_cache_array *array,
537 					 struct nfs_readdir_descriptor *desc)
538 {
539 	unsigned int i;
540 	int status = -EAGAIN;
541 
542 	if (!nfs_readdir_array_cookie_in_range(array, desc->dir_cookie))
543 		goto check_eof;
544 
545 	for (i = 0; i < array->size; i++) {
546 		if (array->array[i].cookie == desc->dir_cookie) {
547 			if (nfs_readdir_use_cookie(desc->file))
548 				desc->ctx->pos = desc->dir_cookie;
549 			else
550 				desc->ctx->pos = desc->current_index + i;
551 			desc->cache_entry_index = i;
552 			return 0;
553 		}
554 	}
555 check_eof:
556 	if (array->folio_is_eof) {
557 		status = -EBADCOOKIE;
558 		if (desc->dir_cookie == array->last_cookie)
559 			desc->eof = true;
560 	} else
561 		nfs_readdir_seek_next_array(array, desc);
562 	return status;
563 }
564 
nfs_readdir_search_array(struct nfs_readdir_descriptor * desc)565 static int nfs_readdir_search_array(struct nfs_readdir_descriptor *desc)
566 {
567 	struct nfs_cache_array *array;
568 	int status;
569 
570 	array = kmap_local_folio(desc->folio, 0);
571 
572 	if (desc->dir_cookie == 0)
573 		status = nfs_readdir_search_for_pos(array, desc);
574 	else
575 		status = nfs_readdir_search_for_cookie(array, desc);
576 
577 	kunmap_local(array);
578 	return status;
579 }
580 
581 /* Fill a page with xdr information before transferring to the cache page */
nfs_readdir_xdr_filler(struct nfs_readdir_descriptor * desc,__be32 * verf,u64 cookie,struct page ** pages,size_t bufsize,__be32 * verf_res)582 static int nfs_readdir_xdr_filler(struct nfs_readdir_descriptor *desc,
583 				  __be32 *verf, u64 cookie,
584 				  struct page **pages, size_t bufsize,
585 				  __be32 *verf_res)
586 {
587 	struct inode *inode = file_inode(desc->file);
588 	struct nfs_readdir_arg arg = {
589 		.dentry = file_dentry(desc->file),
590 		.cred = desc->file->f_cred,
591 		.verf = verf,
592 		.cookie = cookie,
593 		.pages = pages,
594 		.page_len = bufsize,
595 		.plus = desc->plus,
596 	};
597 	struct nfs_readdir_res res = {
598 		.verf = verf_res,
599 	};
600 	unsigned long	timestamp, gencount;
601 	int		error;
602 
603  again:
604 	timestamp = jiffies;
605 	gencount = nfs_inc_attr_generation_counter();
606 	desc->dir_verifier = nfs_save_change_attribute(inode);
607 	error = NFS_PROTO(inode)->readdir(&arg, &res);
608 	if (error < 0) {
609 		/* We requested READDIRPLUS, but the server doesn't grok it */
610 		if (error == -ENOTSUPP && desc->plus) {
611 			NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS;
612 			desc->plus = arg.plus = false;
613 			goto again;
614 		}
615 		goto error;
616 	}
617 	desc->timestamp = timestamp;
618 	desc->gencount = gencount;
619 error:
620 	return error;
621 }
622 
xdr_decode(struct nfs_readdir_descriptor * desc,struct nfs_entry * entry,struct xdr_stream * xdr)623 static int xdr_decode(struct nfs_readdir_descriptor *desc,
624 		      struct nfs_entry *entry, struct xdr_stream *xdr)
625 {
626 	struct inode *inode = file_inode(desc->file);
627 	int error;
628 
629 	error = NFS_PROTO(inode)->decode_dirent(xdr, entry, desc->plus);
630 	if (error)
631 		return error;
632 	entry->fattr->time_start = desc->timestamp;
633 	entry->fattr->gencount = desc->gencount;
634 	return 0;
635 }
636 
637 /* Match file and dirent using either filehandle or fileid
638  * Note: caller is responsible for checking the fsid
639  */
640 static
nfs_same_file(struct dentry * dentry,struct nfs_entry * entry)641 int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry)
642 {
643 	struct inode *inode;
644 	struct nfs_inode *nfsi;
645 
646 	if (d_really_is_negative(dentry))
647 		return 0;
648 
649 	inode = d_inode(dentry);
650 	if (is_bad_inode(inode) || NFS_STALE(inode))
651 		return 0;
652 
653 	nfsi = NFS_I(inode);
654 	if (entry->fattr->fileid != nfsi->fileid)
655 		return 0;
656 	if (entry->fh->size && nfs_compare_fh(entry->fh, &nfsi->fh) != 0)
657 		return 0;
658 	return 1;
659 }
660 
661 #define NFS_READDIR_CACHE_USAGE_THRESHOLD (8UL)
662 
nfs_use_readdirplus(struct inode * dir,struct dir_context * ctx,unsigned int cache_hits,unsigned int cache_misses)663 static bool nfs_use_readdirplus(struct inode *dir, struct dir_context *ctx,
664 				unsigned int cache_hits,
665 				unsigned int cache_misses)
666 {
667 	if (!nfs_server_capable(dir, NFS_CAP_READDIRPLUS))
668 		return false;
669 	if (ctx->pos == 0 ||
670 	    cache_hits + cache_misses > NFS_READDIR_CACHE_USAGE_THRESHOLD)
671 		return true;
672 	return false;
673 }
674 
675 /*
676  * This function is called by the getattr code to request the
677  * use of readdirplus to accelerate any future lookups in the same
678  * directory.
679  */
nfs_readdir_record_entry_cache_hit(struct inode * dir)680 void nfs_readdir_record_entry_cache_hit(struct inode *dir)
681 {
682 	struct nfs_inode *nfsi = NFS_I(dir);
683 	struct nfs_open_dir_context *ctx;
684 
685 	if (nfs_server_capable(dir, NFS_CAP_READDIRPLUS) &&
686 	    S_ISDIR(dir->i_mode)) {
687 		rcu_read_lock();
688 		list_for_each_entry_rcu (ctx, &nfsi->open_files, list)
689 			atomic_inc(&ctx->cache_hits);
690 		rcu_read_unlock();
691 	}
692 }
693 
694 /*
695  * This function is mainly for use by nfs_getattr().
696  *
697  * If this is an 'ls -l', we want to force use of readdirplus.
698  */
nfs_readdir_record_entry_cache_miss(struct inode * dir)699 void nfs_readdir_record_entry_cache_miss(struct inode *dir)
700 {
701 	struct nfs_inode *nfsi = NFS_I(dir);
702 	struct nfs_open_dir_context *ctx;
703 
704 	if (nfs_server_capable(dir, NFS_CAP_READDIRPLUS) &&
705 	    S_ISDIR(dir->i_mode)) {
706 		rcu_read_lock();
707 		list_for_each_entry_rcu (ctx, &nfsi->open_files, list)
708 			atomic_inc(&ctx->cache_misses);
709 		rcu_read_unlock();
710 	}
711 }
712 
nfs_lookup_advise_force_readdirplus(struct inode * dir,unsigned int flags)713 static void nfs_lookup_advise_force_readdirplus(struct inode *dir,
714 						unsigned int flags)
715 {
716 	if (nfs_server_capable(dir, NFS_CAP_CASE_INSENSITIVE))
717 		return;
718 	if (flags & (LOOKUP_EXCL | LOOKUP_PARENT | LOOKUP_REVAL))
719 		return;
720 	nfs_readdir_record_entry_cache_miss(dir);
721 }
722 
723 static
nfs_prime_dcache(struct dentry * parent,struct nfs_entry * entry,unsigned long dir_verifier)724 void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry,
725 		unsigned long dir_verifier)
726 {
727 	struct qstr filename = QSTR_INIT(entry->name, entry->len);
728 	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
729 	struct dentry *dentry;
730 	struct dentry *alias;
731 	struct inode *inode;
732 	int status;
733 
734 	if (!(entry->fattr->valid & NFS_ATTR_FATTR_FILEID))
735 		return;
736 	if (!(entry->fattr->valid & NFS_ATTR_FATTR_FSID))
737 		return;
738 	if (filename.len == 0)
739 		return;
740 	/* Validate that the name doesn't contain any illegal '\0' */
741 	if (strnlen(filename.name, filename.len) != filename.len)
742 		return;
743 	/* ...or '/' */
744 	if (strnchr(filename.name, filename.len, '/'))
745 		return;
746 	if (filename.name[0] == '.') {
747 		if (filename.len == 1)
748 			return;
749 		if (filename.len == 2 && filename.name[1] == '.')
750 			return;
751 	}
752 	filename.hash = full_name_hash(parent, filename.name, filename.len);
753 
754 	dentry = d_lookup(parent, &filename);
755 again:
756 	if (!dentry) {
757 		dentry = d_alloc_parallel(parent, &filename, &wq);
758 		if (IS_ERR(dentry))
759 			return;
760 	}
761 	if (!d_in_lookup(dentry)) {
762 		/* Is there a mountpoint here? If so, just exit */
763 		if (!nfs_fsid_equal(&NFS_SB(dentry->d_sb)->fsid,
764 					&entry->fattr->fsid))
765 			goto out;
766 		if (nfs_same_file(dentry, entry)) {
767 			if (!entry->fh->size)
768 				goto out;
769 			nfs_set_verifier(dentry, dir_verifier);
770 			status = nfs_refresh_inode(d_inode(dentry), entry->fattr);
771 			if (!status)
772 				nfs_setsecurity(d_inode(dentry), entry->fattr);
773 			trace_nfs_readdir_lookup_revalidate(d_inode(parent),
774 							    dentry, 0, status);
775 			goto out;
776 		} else {
777 			trace_nfs_readdir_lookup_revalidate_failed(
778 				d_inode(parent), dentry, 0);
779 			d_invalidate(dentry);
780 			dput(dentry);
781 			dentry = NULL;
782 			goto again;
783 		}
784 	}
785 	if (!entry->fh->size) {
786 		d_lookup_done(dentry);
787 		goto out;
788 	}
789 
790 	inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr);
791 	alias = d_splice_alias(inode, dentry);
792 	d_lookup_done(dentry);
793 	if (alias) {
794 		if (IS_ERR(alias))
795 			goto out;
796 		dput(dentry);
797 		dentry = alias;
798 	}
799 	nfs_set_verifier(dentry, dir_verifier);
800 	trace_nfs_readdir_lookup(d_inode(parent), dentry, 0);
801 out:
802 	dput(dentry);
803 }
804 
nfs_readdir_entry_decode(struct nfs_readdir_descriptor * desc,struct nfs_entry * entry,struct xdr_stream * stream)805 static int nfs_readdir_entry_decode(struct nfs_readdir_descriptor *desc,
806 				    struct nfs_entry *entry,
807 				    struct xdr_stream *stream)
808 {
809 	int ret;
810 
811 	if (entry->fattr->label)
812 		entry->fattr->label->len = NFS4_MAXLABELLEN;
813 	ret = xdr_decode(desc, entry, stream);
814 	if (ret || !desc->plus)
815 		return ret;
816 	nfs_prime_dcache(file_dentry(desc->file), entry, desc->dir_verifier);
817 	return 0;
818 }
819 
820 /* Perform conversion from xdr to cache array */
nfs_readdir_folio_filler(struct nfs_readdir_descriptor * desc,struct nfs_entry * entry,struct page ** xdr_pages,unsigned int buflen,struct folio ** arrays,size_t narrays,u64 change_attr)821 static int nfs_readdir_folio_filler(struct nfs_readdir_descriptor *desc,
822 				    struct nfs_entry *entry,
823 				    struct page **xdr_pages, unsigned int buflen,
824 				    struct folio **arrays, size_t narrays,
825 				    u64 change_attr)
826 {
827 	struct address_space *mapping = desc->file->f_mapping;
828 	struct folio *new, *folio = *arrays;
829 	struct xdr_stream stream;
830 	struct page *scratch;
831 	struct xdr_buf buf;
832 	u64 cookie;
833 	int status;
834 
835 	scratch = alloc_page(GFP_KERNEL);
836 	if (scratch == NULL)
837 		return -ENOMEM;
838 
839 	xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen);
840 	xdr_set_scratch_page(&stream, scratch);
841 
842 	do {
843 		status = nfs_readdir_entry_decode(desc, entry, &stream);
844 		if (status != 0)
845 			break;
846 
847 		status = nfs_readdir_folio_array_append(folio, entry, &cookie);
848 		if (status != -ENOSPC)
849 			continue;
850 
851 		if (folio->mapping != mapping) {
852 			if (!--narrays)
853 				break;
854 			new = nfs_readdir_folio_array_alloc(cookie, GFP_KERNEL);
855 			if (!new)
856 				break;
857 			arrays++;
858 			*arrays = folio = new;
859 		} else {
860 			new = nfs_readdir_folio_get_next(mapping, cookie,
861 							 change_attr);
862 			if (!new)
863 				break;
864 			if (folio != *arrays)
865 				nfs_readdir_folio_unlock_and_put(folio);
866 			folio = new;
867 		}
868 		desc->folio_index_max++;
869 		status = nfs_readdir_folio_array_append(folio, entry, &cookie);
870 	} while (!status && !entry->eof);
871 
872 	switch (status) {
873 	case -EBADCOOKIE:
874 		if (!entry->eof)
875 			break;
876 		nfs_readdir_folio_set_eof(folio);
877 		fallthrough;
878 	case -EAGAIN:
879 		status = 0;
880 		break;
881 	case -ENOSPC:
882 		status = 0;
883 		if (!desc->plus)
884 			break;
885 		while (!nfs_readdir_entry_decode(desc, entry, &stream))
886 			;
887 	}
888 
889 	if (folio != *arrays)
890 		nfs_readdir_folio_unlock_and_put(folio);
891 
892 	put_page(scratch);
893 	return status;
894 }
895 
nfs_readdir_free_pages(struct page ** pages,size_t npages)896 static void nfs_readdir_free_pages(struct page **pages, size_t npages)
897 {
898 	while (npages--)
899 		put_page(pages[npages]);
900 	kfree(pages);
901 }
902 
903 /*
904  * nfs_readdir_alloc_pages() will allocate pages that must be freed with a call
905  * to nfs_readdir_free_pages()
906  */
nfs_readdir_alloc_pages(size_t npages)907 static struct page **nfs_readdir_alloc_pages(size_t npages)
908 {
909 	struct page **pages;
910 	size_t i;
911 
912 	pages = kmalloc_array(npages, sizeof(*pages), GFP_KERNEL);
913 	if (!pages)
914 		return NULL;
915 	for (i = 0; i < npages; i++) {
916 		struct page *page = alloc_page(GFP_KERNEL);
917 		if (page == NULL)
918 			goto out_freepages;
919 		pages[i] = page;
920 	}
921 	return pages;
922 
923 out_freepages:
924 	nfs_readdir_free_pages(pages, i);
925 	return NULL;
926 }
927 
nfs_readdir_xdr_to_array(struct nfs_readdir_descriptor * desc,__be32 * verf_arg,__be32 * verf_res,struct folio ** arrays,size_t narrays)928 static int nfs_readdir_xdr_to_array(struct nfs_readdir_descriptor *desc,
929 				    __be32 *verf_arg, __be32 *verf_res,
930 				    struct folio **arrays, size_t narrays)
931 {
932 	u64 change_attr;
933 	struct page **pages;
934 	struct folio *folio = *arrays;
935 	struct nfs_entry *entry;
936 	size_t array_size;
937 	struct inode *inode = file_inode(desc->file);
938 	unsigned int dtsize = desc->dtsize;
939 	unsigned int pglen;
940 	int status = -ENOMEM;
941 
942 	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
943 	if (!entry)
944 		return -ENOMEM;
945 	entry->cookie = nfs_readdir_folio_last_cookie(folio);
946 	entry->fh = nfs_alloc_fhandle();
947 	entry->fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode));
948 	entry->server = NFS_SERVER(inode);
949 	if (entry->fh == NULL || entry->fattr == NULL)
950 		goto out;
951 
952 	array_size = (dtsize + PAGE_SIZE - 1) >> PAGE_SHIFT;
953 	pages = nfs_readdir_alloc_pages(array_size);
954 	if (!pages)
955 		goto out;
956 
957 	change_attr = inode_peek_iversion_raw(inode);
958 	status = nfs_readdir_xdr_filler(desc, verf_arg, entry->cookie, pages,
959 					dtsize, verf_res);
960 	if (status < 0)
961 		goto free_pages;
962 
963 	pglen = status;
964 	if (pglen != 0)
965 		status = nfs_readdir_folio_filler(desc, entry, pages, pglen,
966 						  arrays, narrays, change_attr);
967 	else
968 		nfs_readdir_folio_set_eof(folio);
969 	desc->buffer_fills++;
970 
971 free_pages:
972 	nfs_readdir_free_pages(pages, array_size);
973 out:
974 	nfs_free_fattr(entry->fattr);
975 	nfs_free_fhandle(entry->fh);
976 	kfree(entry);
977 	return status;
978 }
979 
nfs_readdir_folio_put(struct nfs_readdir_descriptor * desc)980 static void nfs_readdir_folio_put(struct nfs_readdir_descriptor *desc)
981 {
982 	folio_put(desc->folio);
983 	desc->folio = NULL;
984 }
985 
986 static void
nfs_readdir_folio_unlock_and_put_cached(struct nfs_readdir_descriptor * desc)987 nfs_readdir_folio_unlock_and_put_cached(struct nfs_readdir_descriptor *desc)
988 {
989 	folio_unlock(desc->folio);
990 	nfs_readdir_folio_put(desc);
991 }
992 
993 static struct folio *
nfs_readdir_folio_get_cached(struct nfs_readdir_descriptor * desc)994 nfs_readdir_folio_get_cached(struct nfs_readdir_descriptor *desc)
995 {
996 	struct address_space *mapping = desc->file->f_mapping;
997 	u64 change_attr = inode_peek_iversion_raw(mapping->host);
998 	u64 cookie = desc->last_cookie;
999 	struct folio *folio;
1000 
1001 	folio = nfs_readdir_folio_get_locked(mapping, cookie, change_attr);
1002 	if (!folio)
1003 		return NULL;
1004 	if (desc->clear_cache && !nfs_readdir_folio_needs_filling(folio))
1005 		nfs_readdir_folio_reinit_array(folio, cookie, change_attr);
1006 	return folio;
1007 }
1008 
1009 /*
1010  * Returns 0 if desc->dir_cookie was found on page desc->page_index
1011  * and locks the page to prevent removal from the page cache.
1012  */
find_and_lock_cache_page(struct nfs_readdir_descriptor * desc)1013 static int find_and_lock_cache_page(struct nfs_readdir_descriptor *desc)
1014 {
1015 	struct inode *inode = file_inode(desc->file);
1016 	struct nfs_inode *nfsi = NFS_I(inode);
1017 	__be32 verf[NFS_DIR_VERIFIER_SIZE];
1018 	int res;
1019 
1020 	desc->folio = nfs_readdir_folio_get_cached(desc);
1021 	if (!desc->folio)
1022 		return -ENOMEM;
1023 	if (nfs_readdir_folio_needs_filling(desc->folio)) {
1024 		/* Grow the dtsize if we had to go back for more pages */
1025 		if (desc->folio_index == desc->folio_index_max)
1026 			nfs_grow_dtsize(desc);
1027 		desc->folio_index_max = desc->folio_index;
1028 		trace_nfs_readdir_cache_fill(desc->file, nfsi->cookieverf,
1029 					     desc->last_cookie,
1030 					     desc->folio->index, desc->dtsize);
1031 		res = nfs_readdir_xdr_to_array(desc, nfsi->cookieverf, verf,
1032 					       &desc->folio, 1);
1033 		if (res < 0) {
1034 			nfs_readdir_folio_unlock_and_put_cached(desc);
1035 			trace_nfs_readdir_cache_fill_done(inode, res);
1036 			if (res == -EBADCOOKIE || res == -ENOTSYNC) {
1037 				invalidate_inode_pages2(desc->file->f_mapping);
1038 				nfs_readdir_rewind_search(desc);
1039 				trace_nfs_readdir_invalidate_cache_range(
1040 					inode, 0, MAX_LFS_FILESIZE);
1041 				return -EAGAIN;
1042 			}
1043 			return res;
1044 		}
1045 		/*
1046 		 * Set the cookie verifier if the page cache was empty
1047 		 */
1048 		if (desc->last_cookie == 0 &&
1049 		    memcmp(nfsi->cookieverf, verf, sizeof(nfsi->cookieverf))) {
1050 			memcpy(nfsi->cookieverf, verf,
1051 			       sizeof(nfsi->cookieverf));
1052 			invalidate_inode_pages2_range(desc->file->f_mapping, 1,
1053 						      -1);
1054 			trace_nfs_readdir_invalidate_cache_range(
1055 				inode, 1, MAX_LFS_FILESIZE);
1056 		}
1057 		desc->clear_cache = false;
1058 	}
1059 	res = nfs_readdir_search_array(desc);
1060 	if (res == 0)
1061 		return 0;
1062 	nfs_readdir_folio_unlock_and_put_cached(desc);
1063 	return res;
1064 }
1065 
1066 /* Search for desc->dir_cookie from the beginning of the page cache */
readdir_search_pagecache(struct nfs_readdir_descriptor * desc)1067 static int readdir_search_pagecache(struct nfs_readdir_descriptor *desc)
1068 {
1069 	int res;
1070 
1071 	do {
1072 		res = find_and_lock_cache_page(desc);
1073 	} while (res == -EAGAIN);
1074 	return res;
1075 }
1076 
1077 #define NFS_READDIR_CACHE_MISS_THRESHOLD (16UL)
1078 
1079 /*
1080  * Once we've found the start of the dirent within a page: fill 'er up...
1081  */
nfs_do_filldir(struct nfs_readdir_descriptor * desc,const __be32 * verf)1082 static void nfs_do_filldir(struct nfs_readdir_descriptor *desc,
1083 			   const __be32 *verf)
1084 {
1085 	struct file	*file = desc->file;
1086 	struct nfs_cache_array *array;
1087 	unsigned int i;
1088 	bool first_emit = !desc->dir_cookie;
1089 
1090 	array = kmap_local_folio(desc->folio, 0);
1091 	for (i = desc->cache_entry_index; i < array->size; i++) {
1092 		struct nfs_cache_array_entry *ent;
1093 
1094 		/*
1095 		 * nfs_readdir_handle_cache_misses return force clear at
1096 		 * (cache_misses > NFS_READDIR_CACHE_MISS_THRESHOLD) for
1097 		 * readdir heuristic, NFS_READDIR_CACHE_MISS_THRESHOLD + 1
1098 		 * entries need be emitted here.
1099 		 */
1100 		if (first_emit && i > NFS_READDIR_CACHE_MISS_THRESHOLD + 2) {
1101 			desc->eob = true;
1102 			break;
1103 		}
1104 
1105 		ent = &array->array[i];
1106 		if (!dir_emit(desc->ctx, ent->name, ent->name_len,
1107 		    nfs_compat_user_ino64(ent->ino), ent->d_type)) {
1108 			desc->eob = true;
1109 			break;
1110 		}
1111 		memcpy(desc->verf, verf, sizeof(desc->verf));
1112 		if (i == array->size - 1) {
1113 			desc->dir_cookie = array->last_cookie;
1114 			nfs_readdir_seek_next_array(array, desc);
1115 		} else {
1116 			desc->dir_cookie = array->array[i + 1].cookie;
1117 			desc->last_cookie = array->array[0].cookie;
1118 		}
1119 		if (nfs_readdir_use_cookie(file))
1120 			desc->ctx->pos = desc->dir_cookie;
1121 		else
1122 			desc->ctx->pos++;
1123 	}
1124 	if (array->folio_is_eof)
1125 		desc->eof = !desc->eob;
1126 
1127 	kunmap_local(array);
1128 	dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %llu\n",
1129 			(unsigned long long)desc->dir_cookie);
1130 }
1131 
1132 /*
1133  * If we cannot find a cookie in our cache, we suspect that this is
1134  * because it points to a deleted file, so we ask the server to return
1135  * whatever it thinks is the next entry. We then feed this to filldir.
1136  * If all goes well, we should then be able to find our way round the
1137  * cache on the next call to readdir_search_pagecache();
1138  *
1139  * NOTE: we cannot add the anonymous page to the pagecache because
1140  *	 the data it contains might not be page aligned. Besides,
1141  *	 we should already have a complete representation of the
1142  *	 directory in the page cache by the time we get here.
1143  */
uncached_readdir(struct nfs_readdir_descriptor * desc)1144 static int uncached_readdir(struct nfs_readdir_descriptor *desc)
1145 {
1146 	struct folio	**arrays;
1147 	size_t		i, sz = 512;
1148 	__be32		verf[NFS_DIR_VERIFIER_SIZE];
1149 	int		status = -ENOMEM;
1150 
1151 	dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %llu\n",
1152 			(unsigned long long)desc->dir_cookie);
1153 
1154 	arrays = kcalloc(sz, sizeof(*arrays), GFP_KERNEL);
1155 	if (!arrays)
1156 		goto out;
1157 	arrays[0] = nfs_readdir_folio_array_alloc(desc->dir_cookie, GFP_KERNEL);
1158 	if (!arrays[0])
1159 		goto out;
1160 
1161 	desc->folio_index = 0;
1162 	desc->cache_entry_index = 0;
1163 	desc->last_cookie = desc->dir_cookie;
1164 	desc->folio_index_max = 0;
1165 
1166 	trace_nfs_readdir_uncached(desc->file, desc->verf, desc->last_cookie,
1167 				   -1, desc->dtsize);
1168 
1169 	status = nfs_readdir_xdr_to_array(desc, desc->verf, verf, arrays, sz);
1170 	if (status < 0) {
1171 		trace_nfs_readdir_uncached_done(file_inode(desc->file), status);
1172 		goto out_free;
1173 	}
1174 
1175 	for (i = 0; !desc->eob && i < sz && arrays[i]; i++) {
1176 		desc->folio = arrays[i];
1177 		nfs_do_filldir(desc, verf);
1178 	}
1179 	desc->folio = NULL;
1180 
1181 	/*
1182 	 * Grow the dtsize if we have to go back for more pages,
1183 	 * or shrink it if we're reading too many.
1184 	 */
1185 	if (!desc->eof) {
1186 		if (!desc->eob)
1187 			nfs_grow_dtsize(desc);
1188 		else if (desc->buffer_fills == 1 &&
1189 			 i < (desc->folio_index_max >> 1))
1190 			nfs_shrink_dtsize(desc);
1191 	}
1192 out_free:
1193 	for (i = 0; i < sz && arrays[i]; i++)
1194 		nfs_readdir_folio_array_free(arrays[i]);
1195 out:
1196 	if (!nfs_readdir_use_cookie(desc->file))
1197 		nfs_readdir_rewind_search(desc);
1198 	desc->folio_index_max = -1;
1199 	kfree(arrays);
1200 	dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __func__, status);
1201 	return status;
1202 }
1203 
nfs_readdir_handle_cache_misses(struct inode * inode,struct nfs_readdir_descriptor * desc,unsigned int cache_misses,bool force_clear)1204 static bool nfs_readdir_handle_cache_misses(struct inode *inode,
1205 					    struct nfs_readdir_descriptor *desc,
1206 					    unsigned int cache_misses,
1207 					    bool force_clear)
1208 {
1209 	if (desc->ctx->pos == 0 || !desc->plus)
1210 		return false;
1211 	if (cache_misses <= NFS_READDIR_CACHE_MISS_THRESHOLD && !force_clear)
1212 		return false;
1213 	trace_nfs_readdir_force_readdirplus(inode);
1214 	return true;
1215 }
1216 
1217 /* The file offset position represents the dirent entry number.  A
1218    last cookie cache takes care of the common case of reading the
1219    whole directory.
1220  */
nfs_readdir(struct file * file,struct dir_context * ctx)1221 static int nfs_readdir(struct file *file, struct dir_context *ctx)
1222 {
1223 	struct dentry	*dentry = file_dentry(file);
1224 	struct inode	*inode = d_inode(dentry);
1225 	struct nfs_inode *nfsi = NFS_I(inode);
1226 	struct nfs_open_dir_context *dir_ctx = file->private_data;
1227 	struct nfs_readdir_descriptor *desc;
1228 	unsigned int cache_hits, cache_misses;
1229 	bool force_clear;
1230 	int res;
1231 
1232 	dfprintk(FILE, "NFS: readdir(%pD2) starting at cookie %llu\n",
1233 			file, (long long)ctx->pos);
1234 	nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);
1235 
1236 	/*
1237 	 * ctx->pos points to the dirent entry number.
1238 	 * *desc->dir_cookie has the cookie for the next entry. We have
1239 	 * to either find the entry with the appropriate number or
1240 	 * revalidate the cookie.
1241 	 */
1242 	nfs_revalidate_mapping(inode, file->f_mapping);
1243 
1244 	res = -ENOMEM;
1245 	desc = kzalloc(sizeof(*desc), GFP_KERNEL);
1246 	if (!desc)
1247 		goto out;
1248 	desc->file = file;
1249 	desc->ctx = ctx;
1250 	desc->folio_index_max = -1;
1251 
1252 	spin_lock(&file->f_lock);
1253 	desc->dir_cookie = dir_ctx->dir_cookie;
1254 	desc->folio_index = dir_ctx->page_index;
1255 	desc->last_cookie = dir_ctx->last_cookie;
1256 	desc->attr_gencount = dir_ctx->attr_gencount;
1257 	desc->eof = dir_ctx->eof;
1258 	nfs_set_dtsize(desc, dir_ctx->dtsize);
1259 	memcpy(desc->verf, dir_ctx->verf, sizeof(desc->verf));
1260 	cache_hits = atomic_xchg(&dir_ctx->cache_hits, 0);
1261 	cache_misses = atomic_xchg(&dir_ctx->cache_misses, 0);
1262 	force_clear = dir_ctx->force_clear;
1263 	spin_unlock(&file->f_lock);
1264 
1265 	if (desc->eof) {
1266 		res = 0;
1267 		goto out_free;
1268 	}
1269 
1270 	desc->plus = nfs_use_readdirplus(inode, ctx, cache_hits, cache_misses);
1271 	force_clear = nfs_readdir_handle_cache_misses(inode, desc, cache_misses,
1272 						      force_clear);
1273 	desc->clear_cache = force_clear;
1274 
1275 	do {
1276 		res = readdir_search_pagecache(desc);
1277 
1278 		if (res == -EBADCOOKIE) {
1279 			res = 0;
1280 			/* This means either end of directory */
1281 			if (desc->dir_cookie && !desc->eof) {
1282 				/* Or that the server has 'lost' a cookie */
1283 				res = uncached_readdir(desc);
1284 				if (res == 0)
1285 					continue;
1286 				if (res == -EBADCOOKIE || res == -ENOTSYNC)
1287 					res = 0;
1288 			}
1289 			break;
1290 		}
1291 		if (res == -ETOOSMALL && desc->plus) {
1292 			nfs_zap_caches(inode);
1293 			desc->plus = false;
1294 			desc->eof = false;
1295 			continue;
1296 		}
1297 		if (res < 0)
1298 			break;
1299 
1300 		nfs_do_filldir(desc, nfsi->cookieverf);
1301 		nfs_readdir_folio_unlock_and_put_cached(desc);
1302 		if (desc->folio_index == desc->folio_index_max)
1303 			desc->clear_cache = force_clear;
1304 	} while (!desc->eob && !desc->eof);
1305 
1306 	spin_lock(&file->f_lock);
1307 	dir_ctx->dir_cookie = desc->dir_cookie;
1308 	dir_ctx->last_cookie = desc->last_cookie;
1309 	dir_ctx->attr_gencount = desc->attr_gencount;
1310 	dir_ctx->page_index = desc->folio_index;
1311 	dir_ctx->force_clear = force_clear;
1312 	dir_ctx->eof = desc->eof;
1313 	dir_ctx->dtsize = desc->dtsize;
1314 	memcpy(dir_ctx->verf, desc->verf, sizeof(dir_ctx->verf));
1315 	spin_unlock(&file->f_lock);
1316 out_free:
1317 	kfree(desc);
1318 
1319 out:
1320 	dfprintk(FILE, "NFS: readdir(%pD2) returns %d\n", file, res);
1321 	return res;
1322 }
1323 
nfs_llseek_dir(struct file * filp,loff_t offset,int whence)1324 static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int whence)
1325 {
1326 	struct nfs_open_dir_context *dir_ctx = filp->private_data;
1327 
1328 	dfprintk(FILE, "NFS: llseek dir(%pD2, %lld, %d)\n",
1329 			filp, offset, whence);
1330 
1331 	switch (whence) {
1332 	default:
1333 		return -EINVAL;
1334 	case SEEK_SET:
1335 		if (offset < 0)
1336 			return -EINVAL;
1337 		spin_lock(&filp->f_lock);
1338 		break;
1339 	case SEEK_CUR:
1340 		if (offset == 0)
1341 			return filp->f_pos;
1342 		spin_lock(&filp->f_lock);
1343 		offset += filp->f_pos;
1344 		if (offset < 0) {
1345 			spin_unlock(&filp->f_lock);
1346 			return -EINVAL;
1347 		}
1348 	}
1349 	if (offset != filp->f_pos) {
1350 		filp->f_pos = offset;
1351 		dir_ctx->page_index = 0;
1352 		if (!nfs_readdir_use_cookie(filp)) {
1353 			dir_ctx->dir_cookie = 0;
1354 			dir_ctx->last_cookie = 0;
1355 		} else {
1356 			dir_ctx->dir_cookie = offset;
1357 			dir_ctx->last_cookie = offset;
1358 		}
1359 		dir_ctx->eof = false;
1360 	}
1361 	spin_unlock(&filp->f_lock);
1362 	return offset;
1363 }
1364 
1365 /*
1366  * All directory operations under NFS are synchronous, so fsync()
1367  * is a dummy operation.
1368  */
nfs_fsync_dir(struct file * filp,loff_t start,loff_t end,int datasync)1369 static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
1370 			 int datasync)
1371 {
1372 	dfprintk(FILE, "NFS: fsync dir(%pD2) datasync %d\n", filp, datasync);
1373 
1374 	nfs_inc_stats(file_inode(filp), NFSIOS_VFSFSYNC);
1375 	return 0;
1376 }
1377 
1378 /**
1379  * nfs_force_lookup_revalidate - Mark the directory as having changed
1380  * @dir: pointer to directory inode
1381  *
1382  * This forces the revalidation code in nfs_lookup_revalidate() to do a
1383  * full lookup on all child dentries of 'dir' whenever a change occurs
1384  * on the server that might have invalidated our dcache.
1385  *
1386  * Note that we reserve bit '0' as a tag to let us know when a dentry
1387  * was revalidated while holding a delegation on its inode.
1388  *
1389  * The caller should be holding dir->i_lock
1390  */
nfs_force_lookup_revalidate(struct inode * dir)1391 void nfs_force_lookup_revalidate(struct inode *dir)
1392 {
1393 	NFS_I(dir)->cache_change_attribute += 2;
1394 }
1395 EXPORT_SYMBOL_GPL(nfs_force_lookup_revalidate);
1396 
1397 /**
1398  * nfs_verify_change_attribute - Detects NFS remote directory changes
1399  * @dir: pointer to parent directory inode
1400  * @verf: previously saved change attribute
1401  *
1402  * Return "false" if the verifiers doesn't match the change attribute.
1403  * This would usually indicate that the directory contents have changed on
1404  * the server, and that any dentries need revalidating.
1405  */
nfs_verify_change_attribute(struct inode * dir,unsigned long verf)1406 static bool nfs_verify_change_attribute(struct inode *dir, unsigned long verf)
1407 {
1408 	return (verf & ~1UL) == nfs_save_change_attribute(dir);
1409 }
1410 
nfs_set_verifier_delegated(unsigned long * verf)1411 static void nfs_set_verifier_delegated(unsigned long *verf)
1412 {
1413 	*verf |= 1UL;
1414 }
1415 
1416 #if IS_ENABLED(CONFIG_NFS_V4)
nfs_unset_verifier_delegated(unsigned long * verf)1417 static void nfs_unset_verifier_delegated(unsigned long *verf)
1418 {
1419 	*verf &= ~1UL;
1420 }
1421 #endif /* IS_ENABLED(CONFIG_NFS_V4) */
1422 
nfs_test_verifier_delegated(unsigned long verf)1423 static bool nfs_test_verifier_delegated(unsigned long verf)
1424 {
1425 	return verf & 1;
1426 }
1427 
nfs_verifier_is_delegated(struct dentry * dentry)1428 static bool nfs_verifier_is_delegated(struct dentry *dentry)
1429 {
1430 	return nfs_test_verifier_delegated(dentry->d_time);
1431 }
1432 
nfs_set_verifier_locked(struct dentry * dentry,unsigned long verf)1433 static void nfs_set_verifier_locked(struct dentry *dentry, unsigned long verf)
1434 {
1435 	struct inode *inode = d_inode(dentry);
1436 	struct inode *dir = d_inode_rcu(dentry->d_parent);
1437 
1438 	if (!dir || !nfs_verify_change_attribute(dir, verf))
1439 		return;
1440 	if (inode && NFS_PROTO(inode)->have_delegation(inode, FMODE_READ, 0))
1441 		nfs_set_verifier_delegated(&verf);
1442 	dentry->d_time = verf;
1443 }
1444 
1445 /**
1446  * nfs_set_verifier - save a parent directory verifier in the dentry
1447  * @dentry: pointer to dentry
1448  * @verf: verifier to save
1449  *
1450  * Saves the parent directory verifier in @dentry. If the inode has
1451  * a delegation, we also tag the dentry as having been revalidated
1452  * while holding a delegation so that we know we don't have to
1453  * look it up again after a directory change.
1454  */
nfs_set_verifier(struct dentry * dentry,unsigned long verf)1455 void nfs_set_verifier(struct dentry *dentry, unsigned long verf)
1456 {
1457 
1458 	spin_lock(&dentry->d_lock);
1459 	nfs_set_verifier_locked(dentry, verf);
1460 	spin_unlock(&dentry->d_lock);
1461 }
1462 EXPORT_SYMBOL_GPL(nfs_set_verifier);
1463 
1464 #if IS_ENABLED(CONFIG_NFS_V4)
1465 /**
1466  * nfs_clear_verifier_delegated - clear the dir verifier delegation tag
1467  * @inode: pointer to inode
1468  *
1469  * Iterates through the dentries in the inode alias list and clears
1470  * the tag used to indicate that the dentry has been revalidated
1471  * while holding a delegation.
1472  * This function is intended for use when the delegation is being
1473  * returned or revoked.
1474  */
nfs_clear_verifier_delegated(struct inode * inode)1475 void nfs_clear_verifier_delegated(struct inode *inode)
1476 {
1477 	struct dentry *alias;
1478 
1479 	if (!inode)
1480 		return;
1481 	spin_lock(&inode->i_lock);
1482 	hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
1483 		spin_lock(&alias->d_lock);
1484 		nfs_unset_verifier_delegated(&alias->d_time);
1485 		spin_unlock(&alias->d_lock);
1486 	}
1487 	spin_unlock(&inode->i_lock);
1488 }
1489 EXPORT_SYMBOL_GPL(nfs_clear_verifier_delegated);
1490 #endif /* IS_ENABLED(CONFIG_NFS_V4) */
1491 
nfs_dentry_verify_change(struct inode * dir,struct dentry * dentry)1492 static int nfs_dentry_verify_change(struct inode *dir, struct dentry *dentry)
1493 {
1494 	if (nfs_server_capable(dir, NFS_CAP_CASE_INSENSITIVE) &&
1495 	    d_really_is_negative(dentry))
1496 		return dentry->d_time == inode_peek_iversion_raw(dir);
1497 	return nfs_verify_change_attribute(dir, dentry->d_time);
1498 }
1499 
1500 /*
1501  * A check for whether or not the parent directory has changed.
1502  * In the case it has, we assume that the dentries are untrustworthy
1503  * and may need to be looked up again.
1504  * If rcu_walk prevents us from performing a full check, return 0.
1505  */
nfs_check_verifier(struct inode * dir,struct dentry * dentry,int rcu_walk)1506 static int nfs_check_verifier(struct inode *dir, struct dentry *dentry,
1507 			      int rcu_walk)
1508 {
1509 	if (IS_ROOT(dentry))
1510 		return 1;
1511 	if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
1512 		return 0;
1513 	if (!nfs_dentry_verify_change(dir, dentry))
1514 		return 0;
1515 	/* Revalidate nfsi->cache_change_attribute before we declare a match */
1516 	if (nfs_mapping_need_revalidate_inode(dir)) {
1517 		if (rcu_walk)
1518 			return 0;
1519 		if (__nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0)
1520 			return 0;
1521 	}
1522 	if (!nfs_dentry_verify_change(dir, dentry))
1523 		return 0;
1524 	return 1;
1525 }
1526 
1527 /*
1528  * Use intent information to check whether or not we're going to do
1529  * an O_EXCL create using this path component.
1530  */
nfs_is_exclusive_create(struct inode * dir,unsigned int flags)1531 static int nfs_is_exclusive_create(struct inode *dir, unsigned int flags)
1532 {
1533 	if (NFS_PROTO(dir)->version == 2)
1534 		return 0;
1535 	return flags & LOOKUP_EXCL;
1536 }
1537 
1538 /*
1539  * Inode and filehandle revalidation for lookups.
1540  *
1541  * We force revalidation in the cases where the VFS sets LOOKUP_REVAL,
1542  * or if the intent information indicates that we're about to open this
1543  * particular file and the "nocto" mount flag is not set.
1544  *
1545  */
1546 static
nfs_lookup_verify_inode(struct inode * inode,unsigned int flags)1547 int nfs_lookup_verify_inode(struct inode *inode, unsigned int flags)
1548 {
1549 	struct nfs_server *server = NFS_SERVER(inode);
1550 	int ret;
1551 
1552 	if (IS_AUTOMOUNT(inode))
1553 		return 0;
1554 
1555 	if (flags & LOOKUP_OPEN) {
1556 		switch (inode->i_mode & S_IFMT) {
1557 		case S_IFREG:
1558 			/* A NFSv4 OPEN will revalidate later */
1559 			if (server->caps & NFS_CAP_ATOMIC_OPEN)
1560 				goto out;
1561 			fallthrough;
1562 		case S_IFDIR:
1563 			if (server->flags & NFS_MOUNT_NOCTO)
1564 				break;
1565 			/* NFS close-to-open cache consistency validation */
1566 			goto out_force;
1567 		}
1568 	}
1569 
1570 	/* VFS wants an on-the-wire revalidation */
1571 	if (flags & LOOKUP_REVAL)
1572 		goto out_force;
1573 out:
1574 	if (inode->i_nlink > 0 ||
1575 	    (inode->i_nlink == 0 &&
1576 	     test_bit(NFS_INO_PRESERVE_UNLINKED, &NFS_I(inode)->flags)))
1577 		return 0;
1578 	else
1579 		return -ESTALE;
1580 out_force:
1581 	if (flags & LOOKUP_RCU)
1582 		return -ECHILD;
1583 	ret = __nfs_revalidate_inode(server, inode);
1584 	if (ret != 0)
1585 		return ret;
1586 	goto out;
1587 }
1588 
nfs_mark_dir_for_revalidate(struct inode * inode)1589 static void nfs_mark_dir_for_revalidate(struct inode *inode)
1590 {
1591 	spin_lock(&inode->i_lock);
1592 	nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE);
1593 	spin_unlock(&inode->i_lock);
1594 }
1595 
1596 /*
1597  * We judge how long we want to trust negative
1598  * dentries by looking at the parent inode mtime.
1599  *
1600  * If parent mtime has changed, we revalidate, else we wait for a
1601  * period corresponding to the parent's attribute cache timeout value.
1602  *
1603  * If LOOKUP_RCU prevents us from performing a full check, return 1
1604  * suggesting a reval is needed.
1605  *
1606  * Note that when creating a new file, or looking up a rename target,
1607  * then it shouldn't be necessary to revalidate a negative dentry.
1608  */
1609 static inline
nfs_neg_need_reval(struct inode * dir,struct dentry * dentry,unsigned int flags)1610 int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
1611 		       unsigned int flags)
1612 {
1613 	if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
1614 		return 0;
1615 	if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
1616 		return 1;
1617 	/* Case insensitive server? Revalidate negative dentries */
1618 	if (nfs_server_capable(dir, NFS_CAP_CASE_INSENSITIVE))
1619 		return 1;
1620 	return !nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU);
1621 }
1622 
1623 static int
nfs_lookup_revalidate_done(struct inode * dir,struct dentry * dentry,struct inode * inode,int error)1624 nfs_lookup_revalidate_done(struct inode *dir, struct dentry *dentry,
1625 			   struct inode *inode, int error)
1626 {
1627 	switch (error) {
1628 	case 1:
1629 		break;
1630 	case -ETIMEDOUT:
1631 		if (inode && (IS_ROOT(dentry) ||
1632 			      NFS_SERVER(inode)->flags & NFS_MOUNT_SOFTREVAL))
1633 			error = 1;
1634 		break;
1635 	case -ESTALE:
1636 	case -ENOENT:
1637 		error = 0;
1638 		fallthrough;
1639 	default:
1640 		/*
1641 		 * We can't d_drop the root of a disconnected tree:
1642 		 * its d_hash is on the s_anon list and d_drop() would hide
1643 		 * it from shrink_dcache_for_unmount(), leading to busy
1644 		 * inodes on unmount and further oopses.
1645 		 */
1646 		if (inode && IS_ROOT(dentry))
1647 			error = 1;
1648 		break;
1649 	}
1650 	trace_nfs_lookup_revalidate_exit(dir, dentry, 0, error);
1651 	return error;
1652 }
1653 
1654 static int
nfs_lookup_revalidate_negative(struct inode * dir,struct dentry * dentry,unsigned int flags)1655 nfs_lookup_revalidate_negative(struct inode *dir, struct dentry *dentry,
1656 			       unsigned int flags)
1657 {
1658 	int ret = 1;
1659 	if (nfs_neg_need_reval(dir, dentry, flags)) {
1660 		if (flags & LOOKUP_RCU)
1661 			return -ECHILD;
1662 		ret = 0;
1663 	}
1664 	return nfs_lookup_revalidate_done(dir, dentry, NULL, ret);
1665 }
1666 
1667 static int
nfs_lookup_revalidate_delegated(struct inode * dir,struct dentry * dentry,struct inode * inode)1668 nfs_lookup_revalidate_delegated(struct inode *dir, struct dentry *dentry,
1669 				struct inode *inode)
1670 {
1671 	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1672 	return nfs_lookup_revalidate_done(dir, dentry, inode, 1);
1673 }
1674 
nfs_lookup_revalidate_dentry(struct inode * dir,const struct qstr * name,struct dentry * dentry,struct inode * inode,unsigned int flags)1675 static int nfs_lookup_revalidate_dentry(struct inode *dir, const struct qstr *name,
1676 					struct dentry *dentry,
1677 					struct inode *inode, unsigned int flags)
1678 {
1679 	struct nfs_fh *fhandle;
1680 	struct nfs_fattr *fattr;
1681 	unsigned long dir_verifier;
1682 	int ret;
1683 
1684 	trace_nfs_lookup_revalidate_enter(dir, dentry, flags);
1685 
1686 	ret = -ENOMEM;
1687 	fhandle = nfs_alloc_fhandle();
1688 	fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode));
1689 	if (fhandle == NULL || fattr == NULL)
1690 		goto out;
1691 
1692 	dir_verifier = nfs_save_change_attribute(dir);
1693 	ret = NFS_PROTO(dir)->lookup(dir, dentry, name, fhandle, fattr);
1694 	if (ret < 0)
1695 		goto out;
1696 
1697 	/* Request help from readdirplus */
1698 	nfs_lookup_advise_force_readdirplus(dir, flags);
1699 
1700 	ret = 0;
1701 	if (nfs_compare_fh(NFS_FH(inode), fhandle))
1702 		goto out;
1703 	if (nfs_refresh_inode(inode, fattr) < 0)
1704 		goto out;
1705 
1706 	nfs_setsecurity(inode, fattr);
1707 	nfs_set_verifier(dentry, dir_verifier);
1708 
1709 	ret = 1;
1710 out:
1711 	nfs_free_fattr(fattr);
1712 	nfs_free_fhandle(fhandle);
1713 
1714 	/*
1715 	 * If the lookup failed despite the dentry change attribute being
1716 	 * a match, then we should revalidate the directory cache.
1717 	 */
1718 	if (!ret && nfs_dentry_verify_change(dir, dentry))
1719 		nfs_mark_dir_for_revalidate(dir);
1720 	return nfs_lookup_revalidate_done(dir, dentry, inode, ret);
1721 }
1722 
1723 /*
1724  * This is called every time the dcache has a lookup hit,
1725  * and we should check whether we can really trust that
1726  * lookup.
1727  *
1728  * NOTE! The hit can be a negative hit too, don't assume
1729  * we have an inode!
1730  *
1731  * If the parent directory is seen to have changed, we throw out the
1732  * cached dentry and do a new lookup.
1733  */
1734 static int
nfs_do_lookup_revalidate(struct inode * dir,const struct qstr * name,struct dentry * dentry,unsigned int flags)1735 nfs_do_lookup_revalidate(struct inode *dir, const struct qstr *name,
1736 			 struct dentry *dentry, unsigned int flags)
1737 {
1738 	struct inode *inode;
1739 	int error = 0;
1740 
1741 	nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
1742 	inode = d_inode(dentry);
1743 
1744 	if (!inode)
1745 		return nfs_lookup_revalidate_negative(dir, dentry, flags);
1746 
1747 	if (is_bad_inode(inode)) {
1748 		dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n",
1749 				__func__, dentry);
1750 		goto out_bad;
1751 	}
1752 
1753 	if ((flags & LOOKUP_RENAME_TARGET) && d_count(dentry) < 2 &&
1754 	    nfs_server_capable(dir, NFS_CAP_CASE_INSENSITIVE))
1755 		goto out_bad;
1756 
1757 	if (nfs_verifier_is_delegated(dentry))
1758 		return nfs_lookup_revalidate_delegated(dir, dentry, inode);
1759 
1760 	/* Force a full look up iff the parent directory has changed */
1761 	if (!(flags & (LOOKUP_EXCL | LOOKUP_REVAL)) &&
1762 	    nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU)) {
1763 		error = nfs_lookup_verify_inode(inode, flags);
1764 		if (error) {
1765 			if (error == -ESTALE)
1766 				nfs_mark_dir_for_revalidate(dir);
1767 			goto out_bad;
1768 		}
1769 		goto out_valid;
1770 	}
1771 
1772 	if (flags & LOOKUP_RCU)
1773 		return -ECHILD;
1774 
1775 	if (NFS_STALE(inode))
1776 		goto out_bad;
1777 
1778 	return nfs_lookup_revalidate_dentry(dir, name, dentry, inode, flags);
1779 out_valid:
1780 	return nfs_lookup_revalidate_done(dir, dentry, inode, 1);
1781 out_bad:
1782 	if (flags & LOOKUP_RCU)
1783 		return -ECHILD;
1784 	return nfs_lookup_revalidate_done(dir, dentry, inode, error);
1785 }
1786 
1787 static int
__nfs_lookup_revalidate(struct dentry * dentry,unsigned int flags)1788 __nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
1789 {
1790 	if (flags & LOOKUP_RCU) {
1791 		if (dentry->d_fsdata == NFS_FSDATA_BLOCKED)
1792 			return -ECHILD;
1793 	} else {
1794 		/* Wait for unlink to complete - see unblock_revalidate() */
1795 		wait_var_event(&dentry->d_fsdata,
1796 			       smp_load_acquire(&dentry->d_fsdata)
1797 			       != NFS_FSDATA_BLOCKED);
1798 	}
1799 	return 0;
1800 }
1801 
nfs_lookup_revalidate(struct inode * dir,const struct qstr * name,struct dentry * dentry,unsigned int flags)1802 static int nfs_lookup_revalidate(struct inode *dir, const struct qstr *name,
1803 				 struct dentry *dentry, unsigned int flags)
1804 {
1805 	if (__nfs_lookup_revalidate(dentry, flags))
1806 		return -ECHILD;
1807 	return nfs_do_lookup_revalidate(dir, name, dentry, flags);
1808 }
1809 
block_revalidate(struct dentry * dentry)1810 static void block_revalidate(struct dentry *dentry)
1811 {
1812 	/* old devname - just in case */
1813 	kfree(dentry->d_fsdata);
1814 
1815 	/* Any new reference that could lead to an open
1816 	 * will take ->d_lock in lookup_open() -> d_lookup().
1817 	 * Holding this lock ensures we cannot race with
1818 	 * __nfs_lookup_revalidate() and removes and need
1819 	 * for further barriers.
1820 	 */
1821 	lockdep_assert_held(&dentry->d_lock);
1822 
1823 	dentry->d_fsdata = NFS_FSDATA_BLOCKED;
1824 }
1825 
unblock_revalidate(struct dentry * dentry)1826 static void unblock_revalidate(struct dentry *dentry)
1827 {
1828 	/* store_release ensures wait_var_event() sees the update */
1829 	smp_store_release(&dentry->d_fsdata, NULL);
1830 	wake_up_var(&dentry->d_fsdata);
1831 }
1832 
1833 /*
1834  * A weaker form of d_revalidate for revalidating just the d_inode(dentry)
1835  * when we don't really care about the dentry name. This is called when a
1836  * pathwalk ends on a dentry that was not found via a normal lookup in the
1837  * parent dir (e.g.: ".", "..", procfs symlinks or mountpoint traversals).
1838  *
1839  * In this situation, we just want to verify that the inode itself is OK
1840  * since the dentry might have changed on the server.
1841  */
nfs_weak_revalidate(struct dentry * dentry,unsigned int flags)1842 static int nfs_weak_revalidate(struct dentry *dentry, unsigned int flags)
1843 {
1844 	struct inode *inode = d_inode(dentry);
1845 	int error = 0;
1846 
1847 	/*
1848 	 * I believe we can only get a negative dentry here in the case of a
1849 	 * procfs-style symlink. Just assume it's correct for now, but we may
1850 	 * eventually need to do something more here.
1851 	 */
1852 	if (!inode) {
1853 		dfprintk(LOOKUPCACHE, "%s: %pd2 has negative inode\n",
1854 				__func__, dentry);
1855 		return 1;
1856 	}
1857 
1858 	if (is_bad_inode(inode)) {
1859 		dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n",
1860 				__func__, dentry);
1861 		return 0;
1862 	}
1863 
1864 	error = nfs_lookup_verify_inode(inode, flags);
1865 	dfprintk(LOOKUPCACHE, "NFS: %s: inode %lu is %s\n",
1866 			__func__, inode->i_ino, error ? "invalid" : "valid");
1867 	return !error;
1868 }
1869 
1870 /*
1871  * This is called from dput() when d_count is going to 0.
1872  */
nfs_dentry_delete(const struct dentry * dentry)1873 static int nfs_dentry_delete(const struct dentry *dentry)
1874 {
1875 	dfprintk(VFS, "NFS: dentry_delete(%pd2, %x)\n",
1876 		dentry, dentry->d_flags);
1877 
1878 	/* Unhash any dentry with a stale inode */
1879 	if (d_really_is_positive(dentry) && NFS_STALE(d_inode(dentry)))
1880 		return 1;
1881 
1882 	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1883 		/* Unhash it, so that ->d_iput() would be called */
1884 		return 1;
1885 	}
1886 	if (!(dentry->d_sb->s_flags & SB_ACTIVE)) {
1887 		/* Unhash it, so that ancestors of killed async unlink
1888 		 * files will be cleaned up during umount */
1889 		return 1;
1890 	}
1891 	return 0;
1892 
1893 }
1894 
1895 /* Ensure that we revalidate inode->i_nlink */
nfs_drop_nlink(struct inode * inode)1896 static void nfs_drop_nlink(struct inode *inode)
1897 {
1898 	spin_lock(&inode->i_lock);
1899 	/* drop the inode if we're reasonably sure this is the last link */
1900 	if (inode->i_nlink > 0)
1901 		drop_nlink(inode);
1902 	NFS_I(inode)->attr_gencount = nfs_inc_attr_generation_counter();
1903 	nfs_set_cache_invalid(
1904 		inode, NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_CTIME |
1905 			       NFS_INO_INVALID_NLINK);
1906 	spin_unlock(&inode->i_lock);
1907 }
1908 
1909 /*
1910  * Called when the dentry loses inode.
1911  * We use it to clean up silly-renamed files.
1912  */
nfs_dentry_iput(struct dentry * dentry,struct inode * inode)1913 static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode)
1914 {
1915 	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1916 		nfs_complete_unlink(dentry, inode);
1917 		nfs_drop_nlink(inode);
1918 	}
1919 	iput(inode);
1920 }
1921 
nfs_d_release(struct dentry * dentry)1922 static void nfs_d_release(struct dentry *dentry)
1923 {
1924 	/* free cached devname value, if it survived that far */
1925 	if (unlikely(dentry->d_fsdata)) {
1926 		if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
1927 			WARN_ON(1);
1928 		else
1929 			kfree(dentry->d_fsdata);
1930 	}
1931 }
1932 
1933 const struct dentry_operations nfs_dentry_operations = {
1934 	.d_revalidate	= nfs_lookup_revalidate,
1935 	.d_weak_revalidate	= nfs_weak_revalidate,
1936 	.d_delete	= nfs_dentry_delete,
1937 	.d_iput		= nfs_dentry_iput,
1938 	.d_automount	= nfs_d_automount,
1939 	.d_release	= nfs_d_release,
1940 };
1941 EXPORT_SYMBOL_GPL(nfs_dentry_operations);
1942 
nfs_lookup(struct inode * dir,struct dentry * dentry,unsigned int flags)1943 struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
1944 {
1945 	struct dentry *res;
1946 	struct inode *inode = NULL;
1947 	struct nfs_fh *fhandle = NULL;
1948 	struct nfs_fattr *fattr = NULL;
1949 	unsigned long dir_verifier;
1950 	int error;
1951 
1952 	dfprintk(VFS, "NFS: lookup(%pd2)\n", dentry);
1953 	nfs_inc_stats(dir, NFSIOS_VFSLOOKUP);
1954 
1955 	if (unlikely(dentry->d_name.len > NFS_SERVER(dir)->namelen))
1956 		return ERR_PTR(-ENAMETOOLONG);
1957 
1958 	/*
1959 	 * If we're doing an exclusive create, optimize away the lookup
1960 	 * but don't hash the dentry.
1961 	 */
1962 	if (nfs_is_exclusive_create(dir, flags) || flags & LOOKUP_RENAME_TARGET)
1963 		return NULL;
1964 
1965 	res = ERR_PTR(-ENOMEM);
1966 	fhandle = nfs_alloc_fhandle();
1967 	fattr = nfs_alloc_fattr_with_label(NFS_SERVER(dir));
1968 	if (fhandle == NULL || fattr == NULL)
1969 		goto out;
1970 
1971 	dir_verifier = nfs_save_change_attribute(dir);
1972 	trace_nfs_lookup_enter(dir, dentry, flags);
1973 	error = NFS_PROTO(dir)->lookup(dir, dentry, &dentry->d_name,
1974 				       fhandle, fattr);
1975 	if (error == -ENOENT) {
1976 		if (nfs_server_capable(dir, NFS_CAP_CASE_INSENSITIVE))
1977 			dir_verifier = inode_peek_iversion_raw(dir);
1978 		goto no_entry;
1979 	}
1980 	if (error < 0) {
1981 		res = ERR_PTR(error);
1982 		goto out;
1983 	}
1984 	inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
1985 	res = ERR_CAST(inode);
1986 	if (IS_ERR(res))
1987 		goto out;
1988 
1989 	/* Notify readdir to use READDIRPLUS */
1990 	nfs_lookup_advise_force_readdirplus(dir, flags);
1991 
1992 no_entry:
1993 	res = d_splice_alias(inode, dentry);
1994 	if (res != NULL) {
1995 		if (IS_ERR(res))
1996 			goto out;
1997 		dentry = res;
1998 	}
1999 	nfs_set_verifier(dentry, dir_verifier);
2000 out:
2001 	trace_nfs_lookup_exit(dir, dentry, flags, PTR_ERR_OR_ZERO(res));
2002 	nfs_free_fattr(fattr);
2003 	nfs_free_fhandle(fhandle);
2004 	return res;
2005 }
2006 EXPORT_SYMBOL_GPL(nfs_lookup);
2007 
nfs_d_prune_case_insensitive_aliases(struct inode * inode)2008 void nfs_d_prune_case_insensitive_aliases(struct inode *inode)
2009 {
2010 	/* Case insensitive server? Revalidate dentries */
2011 	if (inode && nfs_server_capable(inode, NFS_CAP_CASE_INSENSITIVE))
2012 		d_prune_aliases(inode);
2013 }
2014 EXPORT_SYMBOL_GPL(nfs_d_prune_case_insensitive_aliases);
2015 
2016 #if IS_ENABLED(CONFIG_NFS_V4)
2017 static int nfs4_lookup_revalidate(struct inode *, const struct qstr *,
2018 				  struct dentry *, unsigned int);
2019 
2020 const struct dentry_operations nfs4_dentry_operations = {
2021 	.d_revalidate	= nfs4_lookup_revalidate,
2022 	.d_weak_revalidate	= nfs_weak_revalidate,
2023 	.d_delete	= nfs_dentry_delete,
2024 	.d_iput		= nfs_dentry_iput,
2025 	.d_automount	= nfs_d_automount,
2026 	.d_release	= nfs_d_release,
2027 };
2028 EXPORT_SYMBOL_GPL(nfs4_dentry_operations);
2029 
create_nfs_open_context(struct dentry * dentry,int open_flags,struct file * filp)2030 static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags, struct file *filp)
2031 {
2032 	return alloc_nfs_open_context(dentry, flags_to_mode(open_flags), filp);
2033 }
2034 
do_open(struct inode * inode,struct file * filp)2035 static int do_open(struct inode *inode, struct file *filp)
2036 {
2037 	nfs_fscache_open_file(inode, filp);
2038 	return 0;
2039 }
2040 
nfs_finish_open(struct nfs_open_context * ctx,struct dentry * dentry,struct file * file,unsigned open_flags)2041 static int nfs_finish_open(struct nfs_open_context *ctx,
2042 			   struct dentry *dentry,
2043 			   struct file *file, unsigned open_flags)
2044 {
2045 	int err;
2046 
2047 	err = finish_open(file, dentry, do_open);
2048 	if (err)
2049 		goto out;
2050 	if (S_ISREG(file_inode(file)->i_mode))
2051 		nfs_file_set_open_context(file, ctx);
2052 	else
2053 		err = -EOPENSTALE;
2054 out:
2055 	return err;
2056 }
2057 
nfs_atomic_open(struct inode * dir,struct dentry * dentry,struct file * file,unsigned open_flags,umode_t mode)2058 int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
2059 		    struct file *file, unsigned open_flags,
2060 		    umode_t mode)
2061 {
2062 	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
2063 	struct nfs_open_context *ctx;
2064 	struct dentry *res;
2065 	struct iattr attr = { .ia_valid = ATTR_OPEN };
2066 	struct inode *inode;
2067 	unsigned int lookup_flags = 0;
2068 	unsigned long dir_verifier;
2069 	bool switched = false;
2070 	int created = 0;
2071 	int err;
2072 
2073 	/* Expect a negative dentry */
2074 	BUG_ON(d_inode(dentry));
2075 
2076 	dfprintk(VFS, "NFS: atomic_open(%s/%lu), %pd\n",
2077 			dir->i_sb->s_id, dir->i_ino, dentry);
2078 
2079 	err = nfs_check_flags(open_flags);
2080 	if (err)
2081 		return err;
2082 
2083 	/* NFS only supports OPEN on regular files */
2084 	if ((open_flags & O_DIRECTORY)) {
2085 		if (!d_in_lookup(dentry)) {
2086 			/*
2087 			 * Hashed negative dentry with O_DIRECTORY: dentry was
2088 			 * revalidated and is fine, no need to perform lookup
2089 			 * again
2090 			 */
2091 			return -ENOENT;
2092 		}
2093 		lookup_flags = LOOKUP_OPEN|LOOKUP_DIRECTORY;
2094 		goto no_open;
2095 	}
2096 
2097 	if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
2098 		return -ENAMETOOLONG;
2099 
2100 	if (open_flags & O_CREAT) {
2101 		struct nfs_server *server = NFS_SERVER(dir);
2102 
2103 		if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
2104 			mode &= ~current_umask();
2105 
2106 		attr.ia_valid |= ATTR_MODE;
2107 		attr.ia_mode = mode;
2108 	}
2109 	if (open_flags & O_TRUNC) {
2110 		attr.ia_valid |= ATTR_SIZE;
2111 		attr.ia_size = 0;
2112 	}
2113 
2114 	if (!(open_flags & O_CREAT) && !d_in_lookup(dentry)) {
2115 		d_drop(dentry);
2116 		switched = true;
2117 		dentry = d_alloc_parallel(dentry->d_parent,
2118 					  &dentry->d_name, &wq);
2119 		if (IS_ERR(dentry))
2120 			return PTR_ERR(dentry);
2121 		if (unlikely(!d_in_lookup(dentry)))
2122 			return finish_no_open(file, dentry);
2123 	}
2124 
2125 	ctx = create_nfs_open_context(dentry, open_flags, file);
2126 	err = PTR_ERR(ctx);
2127 	if (IS_ERR(ctx))
2128 		goto out;
2129 
2130 	trace_nfs_atomic_open_enter(dir, ctx, open_flags);
2131 	inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr, &created);
2132 	if (created)
2133 		file->f_mode |= FMODE_CREATED;
2134 	if (IS_ERR(inode)) {
2135 		err = PTR_ERR(inode);
2136 		trace_nfs_atomic_open_exit(dir, ctx, open_flags, err);
2137 		put_nfs_open_context(ctx);
2138 		d_drop(dentry);
2139 		switch (err) {
2140 		case -ENOENT:
2141 			d_splice_alias(NULL, dentry);
2142 			if (nfs_server_capable(dir, NFS_CAP_CASE_INSENSITIVE))
2143 				dir_verifier = inode_peek_iversion_raw(dir);
2144 			else
2145 				dir_verifier = nfs_save_change_attribute(dir);
2146 			nfs_set_verifier(dentry, dir_verifier);
2147 			break;
2148 		case -EISDIR:
2149 		case -ENOTDIR:
2150 			goto no_open;
2151 		case -ELOOP:
2152 			if (!(open_flags & O_NOFOLLOW))
2153 				goto no_open;
2154 			break;
2155 			/* case -EINVAL: */
2156 		default:
2157 			break;
2158 		}
2159 		goto out;
2160 	}
2161 	file->f_mode |= FMODE_CAN_ODIRECT;
2162 
2163 	err = nfs_finish_open(ctx, ctx->dentry, file, open_flags);
2164 	trace_nfs_atomic_open_exit(dir, ctx, open_flags, err);
2165 	put_nfs_open_context(ctx);
2166 out:
2167 	if (unlikely(switched)) {
2168 		d_lookup_done(dentry);
2169 		dput(dentry);
2170 	}
2171 	return err;
2172 
2173 no_open:
2174 	res = nfs_lookup(dir, dentry, lookup_flags);
2175 	if (!res) {
2176 		inode = d_inode(dentry);
2177 		if ((lookup_flags & LOOKUP_DIRECTORY) && inode &&
2178 		    !(S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)))
2179 			res = ERR_PTR(-ENOTDIR);
2180 		else if (inode && S_ISREG(inode->i_mode))
2181 			res = ERR_PTR(-EOPENSTALE);
2182 	} else if (!IS_ERR(res)) {
2183 		inode = d_inode(res);
2184 		if ((lookup_flags & LOOKUP_DIRECTORY) && inode &&
2185 		    !(S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))) {
2186 			dput(res);
2187 			res = ERR_PTR(-ENOTDIR);
2188 		} else if (inode && S_ISREG(inode->i_mode)) {
2189 			dput(res);
2190 			res = ERR_PTR(-EOPENSTALE);
2191 		}
2192 	}
2193 	if (switched) {
2194 		d_lookup_done(dentry);
2195 		if (!res)
2196 			res = dentry;
2197 		else
2198 			dput(dentry);
2199 	}
2200 	if (IS_ERR(res))
2201 		return PTR_ERR(res);
2202 	return finish_no_open(file, res);
2203 }
2204 EXPORT_SYMBOL_GPL(nfs_atomic_open);
2205 
2206 static int
nfs4_lookup_revalidate(struct inode * dir,const struct qstr * name,struct dentry * dentry,unsigned int flags)2207 nfs4_lookup_revalidate(struct inode *dir, const struct qstr *name,
2208 		       struct dentry *dentry, unsigned int flags)
2209 {
2210 	struct inode *inode;
2211 
2212 	if (__nfs_lookup_revalidate(dentry, flags))
2213 		return -ECHILD;
2214 
2215 	trace_nfs_lookup_revalidate_enter(dir, dentry, flags);
2216 
2217 	if (!(flags & LOOKUP_OPEN) || (flags & LOOKUP_DIRECTORY))
2218 		goto full_reval;
2219 	if (d_mountpoint(dentry))
2220 		goto full_reval;
2221 
2222 	inode = d_inode(dentry);
2223 
2224 	/* We can't create new files in nfs_open_revalidate(), so we
2225 	 * optimize away revalidation of negative dentries.
2226 	 */
2227 	if (inode == NULL)
2228 		goto full_reval;
2229 
2230 	if (nfs_verifier_is_delegated(dentry))
2231 		return nfs_lookup_revalidate_delegated(dir, dentry, inode);
2232 
2233 	/* NFS only supports OPEN on regular files */
2234 	if (!S_ISREG(inode->i_mode))
2235 		goto full_reval;
2236 
2237 	/* We cannot do exclusive creation on a positive dentry */
2238 	if (flags & (LOOKUP_EXCL | LOOKUP_REVAL))
2239 		goto reval_dentry;
2240 
2241 	/* Check if the directory changed */
2242 	if (!nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU))
2243 		goto reval_dentry;
2244 
2245 	/* Let f_op->open() actually open (and revalidate) the file */
2246 	return 1;
2247 reval_dentry:
2248 	if (flags & LOOKUP_RCU)
2249 		return -ECHILD;
2250 	return nfs_lookup_revalidate_dentry(dir, name, dentry, inode, flags);
2251 
2252 full_reval:
2253 	return nfs_do_lookup_revalidate(dir, name, dentry, flags);
2254 }
2255 
2256 #endif /* CONFIG_NFSV4 */
2257 
nfs_atomic_open_v23(struct inode * dir,struct dentry * dentry,struct file * file,unsigned int open_flags,umode_t mode)2258 int nfs_atomic_open_v23(struct inode *dir, struct dentry *dentry,
2259 			struct file *file, unsigned int open_flags,
2260 			umode_t mode)
2261 {
2262 
2263 	/* Same as look+open from lookup_open(), but with different O_TRUNC
2264 	 * handling.
2265 	 */
2266 	int error = 0;
2267 
2268 	if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
2269 		return -ENAMETOOLONG;
2270 
2271 	if (open_flags & O_CREAT) {
2272 		file->f_mode |= FMODE_CREATED;
2273 		error = nfs_do_create(dir, dentry, mode, open_flags);
2274 		if (error)
2275 			return error;
2276 		return finish_open(file, dentry, NULL);
2277 	} else if (d_in_lookup(dentry)) {
2278 		/* The only flags nfs_lookup considers are
2279 		 * LOOKUP_EXCL and LOOKUP_RENAME_TARGET, and
2280 		 * we want those to be zero so the lookup isn't skipped.
2281 		 */
2282 		struct dentry *res = nfs_lookup(dir, dentry, 0);
2283 
2284 		d_lookup_done(dentry);
2285 		if (unlikely(res)) {
2286 			if (IS_ERR(res))
2287 				return PTR_ERR(res);
2288 			return finish_no_open(file, res);
2289 		}
2290 	}
2291 	return finish_no_open(file, NULL);
2292 
2293 }
2294 EXPORT_SYMBOL_GPL(nfs_atomic_open_v23);
2295 
2296 struct dentry *
nfs_add_or_obtain(struct dentry * dentry,struct nfs_fh * fhandle,struct nfs_fattr * fattr)2297 nfs_add_or_obtain(struct dentry *dentry, struct nfs_fh *fhandle,
2298 				struct nfs_fattr *fattr)
2299 {
2300 	struct dentry *parent = dget_parent(dentry);
2301 	struct inode *dir = d_inode(parent);
2302 	struct inode *inode;
2303 	struct dentry *d;
2304 	int error;
2305 
2306 	d_drop(dentry);
2307 
2308 	if (fhandle->size == 0) {
2309 		error = NFS_PROTO(dir)->lookup(dir, dentry, &dentry->d_name,
2310 					       fhandle, fattr);
2311 		if (error)
2312 			goto out_error;
2313 	}
2314 	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
2315 	if (!(fattr->valid & NFS_ATTR_FATTR)) {
2316 		struct nfs_server *server = NFS_SB(dentry->d_sb);
2317 		error = server->nfs_client->rpc_ops->getattr(server, fhandle,
2318 				fattr, NULL);
2319 		if (error < 0)
2320 			goto out_error;
2321 	}
2322 	inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
2323 	d = d_splice_alias(inode, dentry);
2324 out:
2325 	dput(parent);
2326 	return d;
2327 out_error:
2328 	d = ERR_PTR(error);
2329 	goto out;
2330 }
2331 EXPORT_SYMBOL_GPL(nfs_add_or_obtain);
2332 
2333 /*
2334  * Code common to create, mkdir, and mknod.
2335  */
nfs_instantiate(struct dentry * dentry,struct nfs_fh * fhandle,struct nfs_fattr * fattr)2336 int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
2337 				struct nfs_fattr *fattr)
2338 {
2339 	struct dentry *d;
2340 
2341 	d = nfs_add_or_obtain(dentry, fhandle, fattr);
2342 	if (IS_ERR(d))
2343 		return PTR_ERR(d);
2344 
2345 	/* Callers don't care */
2346 	dput(d);
2347 	return 0;
2348 }
2349 EXPORT_SYMBOL_GPL(nfs_instantiate);
2350 
2351 /*
2352  * Following a failed create operation, we drop the dentry rather
2353  * than retain a negative dentry. This avoids a problem in the event
2354  * that the operation succeeded on the server, but an error in the
2355  * reply path made it appear to have failed.
2356  */
nfs_do_create(struct inode * dir,struct dentry * dentry,umode_t mode,int open_flags)2357 static int nfs_do_create(struct inode *dir, struct dentry *dentry,
2358 			 umode_t mode, int open_flags)
2359 {
2360 	struct iattr attr;
2361 	int error;
2362 
2363 	open_flags |= O_CREAT;
2364 
2365 	dfprintk(VFS, "NFS: create(%s/%lu), %pd\n",
2366 			dir->i_sb->s_id, dir->i_ino, dentry);
2367 
2368 	attr.ia_mode = mode;
2369 	attr.ia_valid = ATTR_MODE;
2370 	if (open_flags & O_TRUNC) {
2371 		attr.ia_size = 0;
2372 		attr.ia_valid |= ATTR_SIZE;
2373 	}
2374 
2375 	trace_nfs_create_enter(dir, dentry, open_flags);
2376 	error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags);
2377 	trace_nfs_create_exit(dir, dentry, open_flags, error);
2378 	if (error != 0)
2379 		goto out_err;
2380 	return 0;
2381 out_err:
2382 	d_drop(dentry);
2383 	return error;
2384 }
2385 
nfs_create(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,umode_t mode,bool excl)2386 int nfs_create(struct mnt_idmap *idmap, struct inode *dir,
2387 	       struct dentry *dentry, umode_t mode, bool excl)
2388 {
2389 	return nfs_do_create(dir, dentry, mode, excl ? O_EXCL : 0);
2390 }
2391 EXPORT_SYMBOL_GPL(nfs_create);
2392 
2393 /*
2394  * See comments for nfs_proc_create regarding failed operations.
2395  */
2396 int
nfs_mknod(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,umode_t mode,dev_t rdev)2397 nfs_mknod(struct mnt_idmap *idmap, struct inode *dir,
2398 	  struct dentry *dentry, umode_t mode, dev_t rdev)
2399 {
2400 	struct iattr attr;
2401 	int status;
2402 
2403 	dfprintk(VFS, "NFS: mknod(%s/%lu), %pd\n",
2404 			dir->i_sb->s_id, dir->i_ino, dentry);
2405 
2406 	attr.ia_mode = mode;
2407 	attr.ia_valid = ATTR_MODE;
2408 
2409 	trace_nfs_mknod_enter(dir, dentry);
2410 	status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev);
2411 	trace_nfs_mknod_exit(dir, dentry, status);
2412 	if (status != 0)
2413 		goto out_err;
2414 	return 0;
2415 out_err:
2416 	d_drop(dentry);
2417 	return status;
2418 }
2419 EXPORT_SYMBOL_GPL(nfs_mknod);
2420 
2421 /*
2422  * See comments for nfs_proc_create regarding failed operations.
2423  */
nfs_mkdir(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,umode_t mode)2424 int nfs_mkdir(struct mnt_idmap *idmap, struct inode *dir,
2425 	      struct dentry *dentry, umode_t mode)
2426 {
2427 	struct iattr attr;
2428 	int error;
2429 
2430 	dfprintk(VFS, "NFS: mkdir(%s/%lu), %pd\n",
2431 			dir->i_sb->s_id, dir->i_ino, dentry);
2432 
2433 	attr.ia_valid = ATTR_MODE;
2434 	attr.ia_mode = mode | S_IFDIR;
2435 
2436 	trace_nfs_mkdir_enter(dir, dentry);
2437 	error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr);
2438 	trace_nfs_mkdir_exit(dir, dentry, error);
2439 	if (error != 0)
2440 		goto out_err;
2441 	return 0;
2442 out_err:
2443 	d_drop(dentry);
2444 	return error;
2445 }
2446 EXPORT_SYMBOL_GPL(nfs_mkdir);
2447 
nfs_dentry_handle_enoent(struct dentry * dentry)2448 static void nfs_dentry_handle_enoent(struct dentry *dentry)
2449 {
2450 	if (simple_positive(dentry))
2451 		d_delete(dentry);
2452 }
2453 
nfs_dentry_remove_handle_error(struct inode * dir,struct dentry * dentry,int error)2454 static void nfs_dentry_remove_handle_error(struct inode *dir,
2455 					   struct dentry *dentry, int error)
2456 {
2457 	switch (error) {
2458 	case -ENOENT:
2459 		if (d_really_is_positive(dentry))
2460 			d_delete(dentry);
2461 		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
2462 		break;
2463 	case 0:
2464 		nfs_d_prune_case_insensitive_aliases(d_inode(dentry));
2465 		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
2466 	}
2467 }
2468 
nfs_rmdir(struct inode * dir,struct dentry * dentry)2469 int nfs_rmdir(struct inode *dir, struct dentry *dentry)
2470 {
2471 	int error;
2472 
2473 	dfprintk(VFS, "NFS: rmdir(%s/%lu), %pd\n",
2474 			dir->i_sb->s_id, dir->i_ino, dentry);
2475 
2476 	trace_nfs_rmdir_enter(dir, dentry);
2477 	if (d_really_is_positive(dentry)) {
2478 		down_write(&NFS_I(d_inode(dentry))->rmdir_sem);
2479 		error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
2480 		/* Ensure the VFS deletes this inode */
2481 		switch (error) {
2482 		case 0:
2483 			clear_nlink(d_inode(dentry));
2484 			break;
2485 		case -ENOENT:
2486 			nfs_dentry_handle_enoent(dentry);
2487 		}
2488 		up_write(&NFS_I(d_inode(dentry))->rmdir_sem);
2489 	} else
2490 		error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
2491 	nfs_dentry_remove_handle_error(dir, dentry, error);
2492 	trace_nfs_rmdir_exit(dir, dentry, error);
2493 
2494 	return error;
2495 }
2496 EXPORT_SYMBOL_GPL(nfs_rmdir);
2497 
2498 /*
2499  * Remove a file after making sure there are no pending writes,
2500  * and after checking that the file has only one user.
2501  *
2502  * We invalidate the attribute cache and free the inode prior to the operation
2503  * to avoid possible races if the server reuses the inode.
2504  */
nfs_safe_remove(struct dentry * dentry)2505 static int nfs_safe_remove(struct dentry *dentry)
2506 {
2507 	struct inode *dir = d_inode(dentry->d_parent);
2508 	struct inode *inode = d_inode(dentry);
2509 	int error = -EBUSY;
2510 
2511 	dfprintk(VFS, "NFS: safe_remove(%pd2)\n", dentry);
2512 
2513 	/* If the dentry was sillyrenamed, we simply call d_delete() */
2514 	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
2515 		error = 0;
2516 		goto out;
2517 	}
2518 
2519 	trace_nfs_remove_enter(dir, dentry);
2520 	if (inode != NULL) {
2521 		error = NFS_PROTO(dir)->remove(dir, dentry);
2522 		if (error == 0)
2523 			nfs_drop_nlink(inode);
2524 	} else
2525 		error = NFS_PROTO(dir)->remove(dir, dentry);
2526 	if (error == -ENOENT)
2527 		nfs_dentry_handle_enoent(dentry);
2528 	trace_nfs_remove_exit(dir, dentry, error);
2529 out:
2530 	return error;
2531 }
2532 
2533 /*  We do silly rename. In case sillyrename() returns -EBUSY, the inode
2534  *  belongs to an active ".nfs..." file and we return -EBUSY.
2535  *
2536  *  If sillyrename() returns 0, we do nothing, otherwise we unlink.
2537  */
nfs_unlink(struct inode * dir,struct dentry * dentry)2538 int nfs_unlink(struct inode *dir, struct dentry *dentry)
2539 {
2540 	int error;
2541 
2542 	dfprintk(VFS, "NFS: unlink(%s/%lu, %pd)\n", dir->i_sb->s_id,
2543 		dir->i_ino, dentry);
2544 
2545 	trace_nfs_unlink_enter(dir, dentry);
2546 	spin_lock(&dentry->d_lock);
2547 	if (d_count(dentry) > 1 && !test_bit(NFS_INO_PRESERVE_UNLINKED,
2548 					     &NFS_I(d_inode(dentry))->flags)) {
2549 		spin_unlock(&dentry->d_lock);
2550 		/* Start asynchronous writeout of the inode */
2551 		write_inode_now(d_inode(dentry), 0);
2552 		error = nfs_sillyrename(dir, dentry);
2553 		goto out;
2554 	}
2555 	/* We must prevent any concurrent open until the unlink
2556 	 * completes.  ->d_revalidate will wait for ->d_fsdata
2557 	 * to clear.  We set it here to ensure no lookup succeeds until
2558 	 * the unlink is complete on the server.
2559 	 */
2560 	error = -ETXTBSY;
2561 	if (WARN_ON(dentry->d_flags & DCACHE_NFSFS_RENAMED) ||
2562 	    WARN_ON(dentry->d_fsdata == NFS_FSDATA_BLOCKED)) {
2563 		spin_unlock(&dentry->d_lock);
2564 		goto out;
2565 	}
2566 	block_revalidate(dentry);
2567 
2568 	spin_unlock(&dentry->d_lock);
2569 	error = nfs_safe_remove(dentry);
2570 	nfs_dentry_remove_handle_error(dir, dentry, error);
2571 	unblock_revalidate(dentry);
2572 out:
2573 	trace_nfs_unlink_exit(dir, dentry, error);
2574 	return error;
2575 }
2576 EXPORT_SYMBOL_GPL(nfs_unlink);
2577 
2578 /*
2579  * To create a symbolic link, most file systems instantiate a new inode,
2580  * add a page to it containing the path, then write it out to the disk
2581  * using prepare_write/commit_write.
2582  *
2583  * Unfortunately the NFS client can't create the in-core inode first
2584  * because it needs a file handle to create an in-core inode (see
2585  * fs/nfs/inode.c:nfs_fhget).  We only have a file handle *after* the
2586  * symlink request has completed on the server.
2587  *
2588  * So instead we allocate a raw page, copy the symname into it, then do
2589  * the SYMLINK request with the page as the buffer.  If it succeeds, we
2590  * now have a new file handle and can instantiate an in-core NFS inode
2591  * and move the raw page into its mapping.
2592  */
nfs_symlink(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,const char * symname)2593 int nfs_symlink(struct mnt_idmap *idmap, struct inode *dir,
2594 		struct dentry *dentry, const char *symname)
2595 {
2596 	struct folio *folio;
2597 	char *kaddr;
2598 	struct iattr attr;
2599 	unsigned int pathlen = strlen(symname);
2600 	int error;
2601 
2602 	dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s)\n", dir->i_sb->s_id,
2603 		dir->i_ino, dentry, symname);
2604 
2605 	if (pathlen > PAGE_SIZE)
2606 		return -ENAMETOOLONG;
2607 
2608 	attr.ia_mode = S_IFLNK | S_IRWXUGO;
2609 	attr.ia_valid = ATTR_MODE;
2610 
2611 	folio = folio_alloc(GFP_USER, 0);
2612 	if (!folio)
2613 		return -ENOMEM;
2614 
2615 	kaddr = folio_address(folio);
2616 	memcpy(kaddr, symname, pathlen);
2617 	if (pathlen < PAGE_SIZE)
2618 		memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen);
2619 
2620 	trace_nfs_symlink_enter(dir, dentry);
2621 	error = NFS_PROTO(dir)->symlink(dir, dentry, folio, pathlen, &attr);
2622 	trace_nfs_symlink_exit(dir, dentry, error);
2623 	if (error != 0) {
2624 		dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s) error %d\n",
2625 			dir->i_sb->s_id, dir->i_ino,
2626 			dentry, symname, error);
2627 		d_drop(dentry);
2628 		folio_put(folio);
2629 		return error;
2630 	}
2631 
2632 	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
2633 
2634 	/*
2635 	 * No big deal if we can't add this page to the page cache here.
2636 	 * READLINK will get the missing page from the server if needed.
2637 	 */
2638 	if (filemap_add_folio(d_inode(dentry)->i_mapping, folio, 0,
2639 							GFP_KERNEL) == 0) {
2640 		folio_mark_uptodate(folio);
2641 		folio_unlock(folio);
2642 	}
2643 
2644 	folio_put(folio);
2645 	return 0;
2646 }
2647 EXPORT_SYMBOL_GPL(nfs_symlink);
2648 
2649 int
nfs_link(struct dentry * old_dentry,struct inode * dir,struct dentry * dentry)2650 nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
2651 {
2652 	struct inode *inode = d_inode(old_dentry);
2653 	int error;
2654 
2655 	dfprintk(VFS, "NFS: link(%pd2 -> %pd2)\n",
2656 		old_dentry, dentry);
2657 
2658 	trace_nfs_link_enter(inode, dir, dentry);
2659 	d_drop(dentry);
2660 	if (S_ISREG(inode->i_mode))
2661 		nfs_sync_inode(inode);
2662 	error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
2663 	if (error == 0) {
2664 		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
2665 		ihold(inode);
2666 		d_add(dentry, inode);
2667 	}
2668 	trace_nfs_link_exit(inode, dir, dentry, error);
2669 	return error;
2670 }
2671 EXPORT_SYMBOL_GPL(nfs_link);
2672 
2673 static void
nfs_unblock_rename(struct rpc_task * task,struct nfs_renamedata * data)2674 nfs_unblock_rename(struct rpc_task *task, struct nfs_renamedata *data)
2675 {
2676 	struct dentry *new_dentry = data->new_dentry;
2677 
2678 	unblock_revalidate(new_dentry);
2679 }
2680 
2681 /*
2682  * RENAME
2683  * FIXME: Some nfsds, like the Linux user space nfsd, may generate a
2684  * different file handle for the same inode after a rename (e.g. when
2685  * moving to a different directory). A fail-safe method to do so would
2686  * be to look up old_dir/old_name, create a link to new_dir/new_name and
2687  * rename the old file using the sillyrename stuff. This way, the original
2688  * file in old_dir will go away when the last process iput()s the inode.
2689  *
2690  * FIXED.
2691  *
2692  * It actually works quite well. One needs to have the possibility for
2693  * at least one ".nfs..." file in each directory the file ever gets
2694  * moved or linked to which happens automagically with the new
2695  * implementation that only depends on the dcache stuff instead of
2696  * using the inode layer
2697  *
2698  * Unfortunately, things are a little more complicated than indicated
2699  * above. For a cross-directory move, we want to make sure we can get
2700  * rid of the old inode after the operation.  This means there must be
2701  * no pending writes (if it's a file), and the use count must be 1.
2702  * If these conditions are met, we can drop the dentries before doing
2703  * the rename.
2704  */
nfs_rename(struct mnt_idmap * idmap,struct inode * old_dir,struct dentry * old_dentry,struct inode * new_dir,struct dentry * new_dentry,unsigned int flags)2705 int nfs_rename(struct mnt_idmap *idmap, struct inode *old_dir,
2706 	       struct dentry *old_dentry, struct inode *new_dir,
2707 	       struct dentry *new_dentry, unsigned int flags)
2708 {
2709 	struct inode *old_inode = d_inode(old_dentry);
2710 	struct inode *new_inode = d_inode(new_dentry);
2711 	struct dentry *dentry = NULL;
2712 	struct rpc_task *task;
2713 	bool must_unblock = false;
2714 	int error = -EBUSY;
2715 
2716 	if (flags)
2717 		return -EINVAL;
2718 
2719 	dfprintk(VFS, "NFS: rename(%pd2 -> %pd2, ct=%d)\n",
2720 		 old_dentry, new_dentry,
2721 		 d_count(new_dentry));
2722 
2723 	trace_nfs_rename_enter(old_dir, old_dentry, new_dir, new_dentry);
2724 	/*
2725 	 * For non-directories, check whether the target is busy and if so,
2726 	 * make a copy of the dentry and then do a silly-rename. If the
2727 	 * silly-rename succeeds, the copied dentry is hashed and becomes
2728 	 * the new target.
2729 	 */
2730 	if (new_inode && !S_ISDIR(new_inode->i_mode)) {
2731 		/* We must prevent any concurrent open until the unlink
2732 		 * completes.  ->d_revalidate will wait for ->d_fsdata
2733 		 * to clear.  We set it here to ensure no lookup succeeds until
2734 		 * the unlink is complete on the server.
2735 		 */
2736 		error = -ETXTBSY;
2737 		if (WARN_ON(new_dentry->d_flags & DCACHE_NFSFS_RENAMED) ||
2738 		    WARN_ON(new_dentry->d_fsdata == NFS_FSDATA_BLOCKED))
2739 			goto out;
2740 
2741 		spin_lock(&new_dentry->d_lock);
2742 		if (d_count(new_dentry) > 2) {
2743 			int err;
2744 
2745 			spin_unlock(&new_dentry->d_lock);
2746 
2747 			/* copy the target dentry's name */
2748 			dentry = d_alloc(new_dentry->d_parent,
2749 					 &new_dentry->d_name);
2750 			if (!dentry)
2751 				goto out;
2752 
2753 			/* silly-rename the existing target ... */
2754 			err = nfs_sillyrename(new_dir, new_dentry);
2755 			if (err)
2756 				goto out;
2757 
2758 			new_dentry = dentry;
2759 			new_inode = NULL;
2760 		} else {
2761 			block_revalidate(new_dentry);
2762 			must_unblock = true;
2763 			spin_unlock(&new_dentry->d_lock);
2764 		}
2765 
2766 	}
2767 
2768 	if (S_ISREG(old_inode->i_mode))
2769 		nfs_sync_inode(old_inode);
2770 	task = nfs_async_rename(old_dir, new_dir, old_dentry, new_dentry,
2771 				must_unblock ? nfs_unblock_rename : NULL);
2772 	if (IS_ERR(task)) {
2773 		if (must_unblock)
2774 			unblock_revalidate(new_dentry);
2775 		error = PTR_ERR(task);
2776 		goto out;
2777 	}
2778 
2779 	error = rpc_wait_for_completion_task(task);
2780 	if (error != 0) {
2781 		((struct nfs_renamedata *)task->tk_calldata)->cancelled = 1;
2782 		/* Paired with the atomic_dec_and_test() barrier in rpc_do_put_task() */
2783 		smp_wmb();
2784 	} else
2785 		error = task->tk_status;
2786 	rpc_put_task(task);
2787 	/* Ensure the inode attributes are revalidated */
2788 	if (error == 0) {
2789 		spin_lock(&old_inode->i_lock);
2790 		NFS_I(old_inode)->attr_gencount = nfs_inc_attr_generation_counter();
2791 		nfs_set_cache_invalid(old_inode, NFS_INO_INVALID_CHANGE |
2792 							 NFS_INO_INVALID_CTIME |
2793 							 NFS_INO_REVAL_FORCED);
2794 		spin_unlock(&old_inode->i_lock);
2795 	}
2796 out:
2797 	trace_nfs_rename_exit(old_dir, old_dentry,
2798 			new_dir, new_dentry, error);
2799 	if (!error) {
2800 		if (new_inode != NULL)
2801 			nfs_drop_nlink(new_inode);
2802 		/*
2803 		 * The d_move() should be here instead of in an async RPC completion
2804 		 * handler because we need the proper locks to move the dentry.  If
2805 		 * we're interrupted by a signal, the async RPC completion handler
2806 		 * should mark the directories for revalidation.
2807 		 */
2808 		d_move(old_dentry, new_dentry);
2809 		nfs_set_verifier(old_dentry,
2810 					nfs_save_change_attribute(new_dir));
2811 	} else if (error == -ENOENT)
2812 		nfs_dentry_handle_enoent(old_dentry);
2813 
2814 	/* new dentry created? */
2815 	if (dentry)
2816 		dput(dentry);
2817 	return error;
2818 }
2819 EXPORT_SYMBOL_GPL(nfs_rename);
2820 
2821 static DEFINE_SPINLOCK(nfs_access_lru_lock);
2822 static LIST_HEAD(nfs_access_lru_list);
2823 static atomic_long_t nfs_access_nr_entries;
2824 
2825 static unsigned long nfs_access_max_cachesize = 4*1024*1024;
2826 module_param(nfs_access_max_cachesize, ulong, 0644);
2827 MODULE_PARM_DESC(nfs_access_max_cachesize, "NFS access maximum total cache length");
2828 
nfs_access_free_entry(struct nfs_access_entry * entry)2829 static void nfs_access_free_entry(struct nfs_access_entry *entry)
2830 {
2831 	put_group_info(entry->group_info);
2832 	kfree_rcu(entry, rcu_head);
2833 	smp_mb__before_atomic();
2834 	atomic_long_dec(&nfs_access_nr_entries);
2835 	smp_mb__after_atomic();
2836 }
2837 
nfs_access_free_list(struct list_head * head)2838 static void nfs_access_free_list(struct list_head *head)
2839 {
2840 	struct nfs_access_entry *cache;
2841 
2842 	while (!list_empty(head)) {
2843 		cache = list_entry(head->next, struct nfs_access_entry, lru);
2844 		list_del(&cache->lru);
2845 		nfs_access_free_entry(cache);
2846 	}
2847 }
2848 
2849 static unsigned long
nfs_do_access_cache_scan(unsigned int nr_to_scan)2850 nfs_do_access_cache_scan(unsigned int nr_to_scan)
2851 {
2852 	LIST_HEAD(head);
2853 	struct nfs_inode *nfsi, *next;
2854 	struct nfs_access_entry *cache;
2855 	long freed = 0;
2856 
2857 	spin_lock(&nfs_access_lru_lock);
2858 	list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) {
2859 		struct inode *inode;
2860 
2861 		if (nr_to_scan-- == 0)
2862 			break;
2863 		inode = &nfsi->vfs_inode;
2864 		spin_lock(&inode->i_lock);
2865 		if (list_empty(&nfsi->access_cache_entry_lru))
2866 			goto remove_lru_entry;
2867 		cache = list_entry(nfsi->access_cache_entry_lru.next,
2868 				struct nfs_access_entry, lru);
2869 		list_move(&cache->lru, &head);
2870 		rb_erase(&cache->rb_node, &nfsi->access_cache);
2871 		freed++;
2872 		if (!list_empty(&nfsi->access_cache_entry_lru))
2873 			list_move_tail(&nfsi->access_cache_inode_lru,
2874 					&nfs_access_lru_list);
2875 		else {
2876 remove_lru_entry:
2877 			list_del_init(&nfsi->access_cache_inode_lru);
2878 			smp_mb__before_atomic();
2879 			clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags);
2880 			smp_mb__after_atomic();
2881 		}
2882 		spin_unlock(&inode->i_lock);
2883 	}
2884 	spin_unlock(&nfs_access_lru_lock);
2885 	nfs_access_free_list(&head);
2886 	return freed;
2887 }
2888 
2889 unsigned long
nfs_access_cache_scan(struct shrinker * shrink,struct shrink_control * sc)2890 nfs_access_cache_scan(struct shrinker *shrink, struct shrink_control *sc)
2891 {
2892 	int nr_to_scan = sc->nr_to_scan;
2893 	gfp_t gfp_mask = sc->gfp_mask;
2894 
2895 	if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL)
2896 		return SHRINK_STOP;
2897 	return nfs_do_access_cache_scan(nr_to_scan);
2898 }
2899 
2900 
2901 unsigned long
nfs_access_cache_count(struct shrinker * shrink,struct shrink_control * sc)2902 nfs_access_cache_count(struct shrinker *shrink, struct shrink_control *sc)
2903 {
2904 	return vfs_pressure_ratio(atomic_long_read(&nfs_access_nr_entries));
2905 }
2906 
2907 static void
nfs_access_cache_enforce_limit(void)2908 nfs_access_cache_enforce_limit(void)
2909 {
2910 	long nr_entries = atomic_long_read(&nfs_access_nr_entries);
2911 	unsigned long diff;
2912 	unsigned int nr_to_scan;
2913 
2914 	if (nr_entries < 0 || nr_entries <= nfs_access_max_cachesize)
2915 		return;
2916 	nr_to_scan = 100;
2917 	diff = nr_entries - nfs_access_max_cachesize;
2918 	if (diff < nr_to_scan)
2919 		nr_to_scan = diff;
2920 	nfs_do_access_cache_scan(nr_to_scan);
2921 }
2922 
__nfs_access_zap_cache(struct nfs_inode * nfsi,struct list_head * head)2923 static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head)
2924 {
2925 	struct rb_root *root_node = &nfsi->access_cache;
2926 	struct rb_node *n;
2927 	struct nfs_access_entry *entry;
2928 
2929 	/* Unhook entries from the cache */
2930 	while ((n = rb_first(root_node)) != NULL) {
2931 		entry = rb_entry(n, struct nfs_access_entry, rb_node);
2932 		rb_erase(n, root_node);
2933 		list_move(&entry->lru, head);
2934 	}
2935 	nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS;
2936 }
2937 
nfs_access_zap_cache(struct inode * inode)2938 void nfs_access_zap_cache(struct inode *inode)
2939 {
2940 	LIST_HEAD(head);
2941 
2942 	if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0)
2943 		return;
2944 	/* Remove from global LRU init */
2945 	spin_lock(&nfs_access_lru_lock);
2946 	if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
2947 		list_del_init(&NFS_I(inode)->access_cache_inode_lru);
2948 
2949 	spin_lock(&inode->i_lock);
2950 	__nfs_access_zap_cache(NFS_I(inode), &head);
2951 	spin_unlock(&inode->i_lock);
2952 	spin_unlock(&nfs_access_lru_lock);
2953 	nfs_access_free_list(&head);
2954 }
2955 EXPORT_SYMBOL_GPL(nfs_access_zap_cache);
2956 
access_cmp(const struct cred * a,const struct nfs_access_entry * b)2957 static int access_cmp(const struct cred *a, const struct nfs_access_entry *b)
2958 {
2959 	struct group_info *ga, *gb;
2960 	int g;
2961 
2962 	if (uid_lt(a->fsuid, b->fsuid))
2963 		return -1;
2964 	if (uid_gt(a->fsuid, b->fsuid))
2965 		return 1;
2966 
2967 	if (gid_lt(a->fsgid, b->fsgid))
2968 		return -1;
2969 	if (gid_gt(a->fsgid, b->fsgid))
2970 		return 1;
2971 
2972 	ga = a->group_info;
2973 	gb = b->group_info;
2974 	if (ga == gb)
2975 		return 0;
2976 	if (ga == NULL)
2977 		return -1;
2978 	if (gb == NULL)
2979 		return 1;
2980 	if (ga->ngroups < gb->ngroups)
2981 		return -1;
2982 	if (ga->ngroups > gb->ngroups)
2983 		return 1;
2984 
2985 	for (g = 0; g < ga->ngroups; g++) {
2986 		if (gid_lt(ga->gid[g], gb->gid[g]))
2987 			return -1;
2988 		if (gid_gt(ga->gid[g], gb->gid[g]))
2989 			return 1;
2990 	}
2991 	return 0;
2992 }
2993 
nfs_access_search_rbtree(struct inode * inode,const struct cred * cred)2994 static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, const struct cred *cred)
2995 {
2996 	struct rb_node *n = NFS_I(inode)->access_cache.rb_node;
2997 
2998 	while (n != NULL) {
2999 		struct nfs_access_entry *entry =
3000 			rb_entry(n, struct nfs_access_entry, rb_node);
3001 		int cmp = access_cmp(cred, entry);
3002 
3003 		if (cmp < 0)
3004 			n = n->rb_left;
3005 		else if (cmp > 0)
3006 			n = n->rb_right;
3007 		else
3008 			return entry;
3009 	}
3010 	return NULL;
3011 }
3012 
nfs_access_login_time(const struct task_struct * task,const struct cred * cred)3013 static u64 nfs_access_login_time(const struct task_struct *task,
3014 				 const struct cred *cred)
3015 {
3016 	const struct task_struct *parent;
3017 	const struct cred *pcred;
3018 	u64 ret;
3019 
3020 	rcu_read_lock();
3021 	for (;;) {
3022 		parent = rcu_dereference(task->real_parent);
3023 		pcred = __task_cred(parent);
3024 		if (parent == task || cred_fscmp(pcred, cred) != 0)
3025 			break;
3026 		task = parent;
3027 	}
3028 	ret = task->start_time;
3029 	rcu_read_unlock();
3030 	return ret;
3031 }
3032 
nfs_access_get_cached_locked(struct inode * inode,const struct cred * cred,u32 * mask,bool may_block)3033 static int nfs_access_get_cached_locked(struct inode *inode, const struct cred *cred, u32 *mask, bool may_block)
3034 {
3035 	struct nfs_inode *nfsi = NFS_I(inode);
3036 	u64 login_time = nfs_access_login_time(current, cred);
3037 	struct nfs_access_entry *cache;
3038 	bool retry = true;
3039 	int err;
3040 
3041 	spin_lock(&inode->i_lock);
3042 	for(;;) {
3043 		if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
3044 			goto out_zap;
3045 		cache = nfs_access_search_rbtree(inode, cred);
3046 		err = -ENOENT;
3047 		if (cache == NULL)
3048 			goto out;
3049 		/* Found an entry, is our attribute cache valid? */
3050 		if (!nfs_check_cache_invalid(inode, NFS_INO_INVALID_ACCESS))
3051 			break;
3052 		if (!retry)
3053 			break;
3054 		err = -ECHILD;
3055 		if (!may_block)
3056 			goto out;
3057 		spin_unlock(&inode->i_lock);
3058 		err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
3059 		if (err)
3060 			return err;
3061 		spin_lock(&inode->i_lock);
3062 		retry = false;
3063 	}
3064 	err = -ENOENT;
3065 	if ((s64)(login_time - cache->timestamp) > 0)
3066 		goto out;
3067 	*mask = cache->mask;
3068 	list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru);
3069 	err = 0;
3070 out:
3071 	spin_unlock(&inode->i_lock);
3072 	return err;
3073 out_zap:
3074 	spin_unlock(&inode->i_lock);
3075 	nfs_access_zap_cache(inode);
3076 	return -ENOENT;
3077 }
3078 
nfs_access_get_cached_rcu(struct inode * inode,const struct cred * cred,u32 * mask)3079 static int nfs_access_get_cached_rcu(struct inode *inode, const struct cred *cred, u32 *mask)
3080 {
3081 	/* Only check the most recently returned cache entry,
3082 	 * but do it without locking.
3083 	 */
3084 	struct nfs_inode *nfsi = NFS_I(inode);
3085 	u64 login_time = nfs_access_login_time(current, cred);
3086 	struct nfs_access_entry *cache;
3087 	int err = -ECHILD;
3088 	struct list_head *lh;
3089 
3090 	rcu_read_lock();
3091 	if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
3092 		goto out;
3093 	lh = rcu_dereference(list_tail_rcu(&nfsi->access_cache_entry_lru));
3094 	cache = list_entry(lh, struct nfs_access_entry, lru);
3095 	if (lh == &nfsi->access_cache_entry_lru ||
3096 	    access_cmp(cred, cache) != 0)
3097 		cache = NULL;
3098 	if (cache == NULL)
3099 		goto out;
3100 	if ((s64)(login_time - cache->timestamp) > 0)
3101 		goto out;
3102 	if (nfs_check_cache_invalid(inode, NFS_INO_INVALID_ACCESS))
3103 		goto out;
3104 	*mask = cache->mask;
3105 	err = 0;
3106 out:
3107 	rcu_read_unlock();
3108 	return err;
3109 }
3110 
nfs_access_get_cached(struct inode * inode,const struct cred * cred,u32 * mask,bool may_block)3111 int nfs_access_get_cached(struct inode *inode, const struct cred *cred,
3112 			  u32 *mask, bool may_block)
3113 {
3114 	int status;
3115 
3116 	status = nfs_access_get_cached_rcu(inode, cred, mask);
3117 	if (status != 0)
3118 		status = nfs_access_get_cached_locked(inode, cred, mask,
3119 		    may_block);
3120 
3121 	return status;
3122 }
3123 EXPORT_SYMBOL_GPL(nfs_access_get_cached);
3124 
nfs_access_add_rbtree(struct inode * inode,struct nfs_access_entry * set,const struct cred * cred)3125 static void nfs_access_add_rbtree(struct inode *inode,
3126 				  struct nfs_access_entry *set,
3127 				  const struct cred *cred)
3128 {
3129 	struct nfs_inode *nfsi = NFS_I(inode);
3130 	struct rb_root *root_node = &nfsi->access_cache;
3131 	struct rb_node **p = &root_node->rb_node;
3132 	struct rb_node *parent = NULL;
3133 	struct nfs_access_entry *entry;
3134 	int cmp;
3135 
3136 	spin_lock(&inode->i_lock);
3137 	while (*p != NULL) {
3138 		parent = *p;
3139 		entry = rb_entry(parent, struct nfs_access_entry, rb_node);
3140 		cmp = access_cmp(cred, entry);
3141 
3142 		if (cmp < 0)
3143 			p = &parent->rb_left;
3144 		else if (cmp > 0)
3145 			p = &parent->rb_right;
3146 		else
3147 			goto found;
3148 	}
3149 	rb_link_node(&set->rb_node, parent, p);
3150 	rb_insert_color(&set->rb_node, root_node);
3151 	list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
3152 	spin_unlock(&inode->i_lock);
3153 	return;
3154 found:
3155 	rb_replace_node(parent, &set->rb_node, root_node);
3156 	list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
3157 	list_del(&entry->lru);
3158 	spin_unlock(&inode->i_lock);
3159 	nfs_access_free_entry(entry);
3160 }
3161 
nfs_access_add_cache(struct inode * inode,struct nfs_access_entry * set,const struct cred * cred)3162 void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set,
3163 			  const struct cred *cred)
3164 {
3165 	struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL);
3166 	if (cache == NULL)
3167 		return;
3168 	RB_CLEAR_NODE(&cache->rb_node);
3169 	cache->fsuid = cred->fsuid;
3170 	cache->fsgid = cred->fsgid;
3171 	cache->group_info = get_group_info(cred->group_info);
3172 	cache->mask = set->mask;
3173 	cache->timestamp = ktime_get_ns();
3174 
3175 	/* The above field assignments must be visible
3176 	 * before this item appears on the lru.  We cannot easily
3177 	 * use rcu_assign_pointer, so just force the memory barrier.
3178 	 */
3179 	smp_wmb();
3180 	nfs_access_add_rbtree(inode, cache, cred);
3181 
3182 	/* Update accounting */
3183 	smp_mb__before_atomic();
3184 	atomic_long_inc(&nfs_access_nr_entries);
3185 	smp_mb__after_atomic();
3186 
3187 	/* Add inode to global LRU list */
3188 	if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) {
3189 		spin_lock(&nfs_access_lru_lock);
3190 		if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
3191 			list_add_tail(&NFS_I(inode)->access_cache_inode_lru,
3192 					&nfs_access_lru_list);
3193 		spin_unlock(&nfs_access_lru_lock);
3194 	}
3195 	nfs_access_cache_enforce_limit();
3196 }
3197 EXPORT_SYMBOL_GPL(nfs_access_add_cache);
3198 
3199 #define NFS_MAY_READ (NFS_ACCESS_READ)
3200 #define NFS_MAY_WRITE (NFS_ACCESS_MODIFY | \
3201 		NFS_ACCESS_EXTEND | \
3202 		NFS_ACCESS_DELETE)
3203 #define NFS_FILE_MAY_WRITE (NFS_ACCESS_MODIFY | \
3204 		NFS_ACCESS_EXTEND)
3205 #define NFS_DIR_MAY_WRITE NFS_MAY_WRITE
3206 #define NFS_MAY_LOOKUP (NFS_ACCESS_LOOKUP)
3207 #define NFS_MAY_EXECUTE (NFS_ACCESS_EXECUTE)
3208 static int
nfs_access_calc_mask(u32 access_result,umode_t umode)3209 nfs_access_calc_mask(u32 access_result, umode_t umode)
3210 {
3211 	int mask = 0;
3212 
3213 	if (access_result & NFS_MAY_READ)
3214 		mask |= MAY_READ;
3215 	if (S_ISDIR(umode)) {
3216 		if ((access_result & NFS_DIR_MAY_WRITE) == NFS_DIR_MAY_WRITE)
3217 			mask |= MAY_WRITE;
3218 		if ((access_result & NFS_MAY_LOOKUP) == NFS_MAY_LOOKUP)
3219 			mask |= MAY_EXEC;
3220 	} else if (S_ISREG(umode)) {
3221 		if ((access_result & NFS_FILE_MAY_WRITE) == NFS_FILE_MAY_WRITE)
3222 			mask |= MAY_WRITE;
3223 		if ((access_result & NFS_MAY_EXECUTE) == NFS_MAY_EXECUTE)
3224 			mask |= MAY_EXEC;
3225 	} else if (access_result & NFS_MAY_WRITE)
3226 			mask |= MAY_WRITE;
3227 	return mask;
3228 }
3229 
nfs_access_set_mask(struct nfs_access_entry * entry,u32 access_result)3230 void nfs_access_set_mask(struct nfs_access_entry *entry, u32 access_result)
3231 {
3232 	entry->mask = access_result;
3233 }
3234 EXPORT_SYMBOL_GPL(nfs_access_set_mask);
3235 
nfs_do_access(struct inode * inode,const struct cred * cred,int mask)3236 static int nfs_do_access(struct inode *inode, const struct cred *cred, int mask)
3237 {
3238 	struct nfs_access_entry cache;
3239 	bool may_block = (mask & MAY_NOT_BLOCK) == 0;
3240 	int cache_mask = -1;
3241 	int status;
3242 
3243 	trace_nfs_access_enter(inode);
3244 
3245 	status = nfs_access_get_cached(inode, cred, &cache.mask, may_block);
3246 	if (status == 0)
3247 		goto out_cached;
3248 
3249 	status = -ECHILD;
3250 	if (!may_block)
3251 		goto out;
3252 
3253 	/*
3254 	 * Determine which access bits we want to ask for...
3255 	 */
3256 	cache.mask = NFS_ACCESS_READ | NFS_ACCESS_MODIFY | NFS_ACCESS_EXTEND |
3257 		     nfs_access_xattr_mask(NFS_SERVER(inode));
3258 	if (S_ISDIR(inode->i_mode))
3259 		cache.mask |= NFS_ACCESS_DELETE | NFS_ACCESS_LOOKUP;
3260 	else
3261 		cache.mask |= NFS_ACCESS_EXECUTE;
3262 	status = NFS_PROTO(inode)->access(inode, &cache, cred);
3263 	if (status != 0) {
3264 		if (status == -ESTALE) {
3265 			if (!S_ISDIR(inode->i_mode))
3266 				nfs_set_inode_stale(inode);
3267 			else
3268 				nfs_zap_caches(inode);
3269 		}
3270 		goto out;
3271 	}
3272 	nfs_access_add_cache(inode, &cache, cred);
3273 out_cached:
3274 	cache_mask = nfs_access_calc_mask(cache.mask, inode->i_mode);
3275 	if ((mask & ~cache_mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) != 0)
3276 		status = -EACCES;
3277 out:
3278 	trace_nfs_access_exit(inode, mask, cache_mask, status);
3279 	return status;
3280 }
3281 
nfs_open_permission_mask(int openflags)3282 static int nfs_open_permission_mask(int openflags)
3283 {
3284 	int mask = 0;
3285 
3286 	if (openflags & __FMODE_EXEC) {
3287 		/* ONLY check exec rights */
3288 		mask = MAY_EXEC;
3289 	} else {
3290 		if ((openflags & O_ACCMODE) != O_WRONLY)
3291 			mask |= MAY_READ;
3292 		if ((openflags & O_ACCMODE) != O_RDONLY)
3293 			mask |= MAY_WRITE;
3294 	}
3295 
3296 	return mask;
3297 }
3298 
nfs_may_open(struct inode * inode,const struct cred * cred,int openflags)3299 int nfs_may_open(struct inode *inode, const struct cred *cred, int openflags)
3300 {
3301 	return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags));
3302 }
3303 EXPORT_SYMBOL_GPL(nfs_may_open);
3304 
nfs_execute_ok(struct inode * inode,int mask)3305 static int nfs_execute_ok(struct inode *inode, int mask)
3306 {
3307 	struct nfs_server *server = NFS_SERVER(inode);
3308 	int ret = 0;
3309 
3310 	if (S_ISDIR(inode->i_mode))
3311 		return 0;
3312 	if (nfs_check_cache_invalid(inode, NFS_INO_INVALID_MODE)) {
3313 		if (mask & MAY_NOT_BLOCK)
3314 			return -ECHILD;
3315 		ret = __nfs_revalidate_inode(server, inode);
3316 	}
3317 	if (ret == 0 && !execute_ok(inode))
3318 		ret = -EACCES;
3319 	return ret;
3320 }
3321 
nfs_permission(struct mnt_idmap * idmap,struct inode * inode,int mask)3322 int nfs_permission(struct mnt_idmap *idmap,
3323 		   struct inode *inode,
3324 		   int mask)
3325 {
3326 	const struct cred *cred = current_cred();
3327 	int res = 0;
3328 
3329 	nfs_inc_stats(inode, NFSIOS_VFSACCESS);
3330 
3331 	if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
3332 		goto out;
3333 	/* Is this sys_access() ? */
3334 	if (mask & (MAY_ACCESS | MAY_CHDIR))
3335 		goto force_lookup;
3336 
3337 	switch (inode->i_mode & S_IFMT) {
3338 		case S_IFLNK:
3339 			goto out;
3340 		case S_IFREG:
3341 			if ((mask & MAY_OPEN) &&
3342 			   nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN))
3343 				return 0;
3344 			break;
3345 		case S_IFDIR:
3346 			/*
3347 			 * Optimize away all write operations, since the server
3348 			 * will check permissions when we perform the op.
3349 			 */
3350 			if ((mask & MAY_WRITE) && !(mask & MAY_READ))
3351 				goto out;
3352 	}
3353 
3354 force_lookup:
3355 	if (!NFS_PROTO(inode)->access)
3356 		goto out_notsup;
3357 
3358 	res = nfs_do_access(inode, cred, mask);
3359 out:
3360 	if (!res && (mask & MAY_EXEC))
3361 		res = nfs_execute_ok(inode, mask);
3362 
3363 	dfprintk(VFS, "NFS: permission(%s/%lu), mask=0x%x, res=%d\n",
3364 		inode->i_sb->s_id, inode->i_ino, mask, res);
3365 	return res;
3366 out_notsup:
3367 	if (mask & MAY_NOT_BLOCK)
3368 		return -ECHILD;
3369 
3370 	res = nfs_revalidate_inode(inode, NFS_INO_INVALID_MODE |
3371 						  NFS_INO_INVALID_OTHER);
3372 	if (res == 0)
3373 		res = generic_permission(&nop_mnt_idmap, inode, mask);
3374 	goto out;
3375 }
3376 EXPORT_SYMBOL_GPL(nfs_permission);
3377