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