1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <linux/module.h>
22#include <linux/time.h>
23#include <linux/errno.h>
24#include <linux/stat.h>
25#include <linux/fcntl.h>
26#include <linux/string.h>
27#include <linux/kernel.h>
28#include <linux/slab.h>
29#include <linux/mm.h>
30#include <linux/sunrpc/clnt.h>
31#include <linux/nfs_fs.h>
32#include <linux/nfs_mount.h>
33#include <linux/pagemap.h>
34#include <linux/pagevec.h>
35#include <linux/namei.h>
36#include <linux/mount.h>
37#include <linux/swap.h>
38#include <linux/sched.h>
39#include <linux/kmemleak.h>
40#include <linux/xattr.h>
41
42#include "delegation.h"
43#include "iostat.h"
44#include "internal.h"
45#include "fscache.h"
46
47#include "nfstrace.h"
48
49
50
51static int nfs_opendir(struct inode *, struct file *);
52static int nfs_closedir(struct inode *, struct file *);
53static int nfs_readdir(struct file *, struct dir_context *);
54static int nfs_fsync_dir(struct file *, loff_t, loff_t, int);
55static loff_t nfs_llseek_dir(struct file *, loff_t, int);
56static void nfs_readdir_clear_array(struct page*);
57
58const struct file_operations nfs_dir_operations = {
59 .llseek = nfs_llseek_dir,
60 .read = generic_read_dir,
61 .iterate_shared = nfs_readdir,
62 .open = nfs_opendir,
63 .release = nfs_closedir,
64 .fsync = nfs_fsync_dir,
65};
66
67const struct address_space_operations nfs_dir_aops = {
68 .freepage = nfs_readdir_clear_array,
69};
70
71static struct nfs_open_dir_context *alloc_nfs_open_dir_context(struct inode *dir, const struct cred *cred)
72{
73 struct nfs_inode *nfsi = NFS_I(dir);
74 struct nfs_open_dir_context *ctx;
75 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
76 if (ctx != NULL) {
77 ctx->duped = 0;
78 ctx->attr_gencount = nfsi->attr_gencount;
79 ctx->dir_cookie = 0;
80 ctx->dup_cookie = 0;
81 ctx->cred = get_cred(cred);
82 spin_lock(&dir->i_lock);
83 if (list_empty(&nfsi->open_files) &&
84 (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER))
85 nfsi->cache_validity |= NFS_INO_INVALID_DATA |
86 NFS_INO_REVAL_FORCED;
87 list_add(&ctx->list, &nfsi->open_files);
88 spin_unlock(&dir->i_lock);
89 return ctx;
90 }
91 return ERR_PTR(-ENOMEM);
92}
93
94static void put_nfs_open_dir_context(struct inode *dir, struct nfs_open_dir_context *ctx)
95{
96 spin_lock(&dir->i_lock);
97 list_del(&ctx->list);
98 spin_unlock(&dir->i_lock);
99 put_cred(ctx->cred);
100 kfree(ctx);
101}
102
103
104
105
106static int
107nfs_opendir(struct inode *inode, struct file *filp)
108{
109 int res = 0;
110 struct nfs_open_dir_context *ctx;
111
112 dfprintk(FILE, "NFS: open dir(%pD2)\n", filp);
113
114 nfs_inc_stats(inode, NFSIOS_VFSOPEN);
115
116 ctx = alloc_nfs_open_dir_context(inode, current_cred());
117 if (IS_ERR(ctx)) {
118 res = PTR_ERR(ctx);
119 goto out;
120 }
121 filp->private_data = ctx;
122out:
123 return res;
124}
125
126static int
127nfs_closedir(struct inode *inode, struct file *filp)
128{
129 put_nfs_open_dir_context(file_inode(filp), filp->private_data);
130 return 0;
131}
132
133struct nfs_cache_array_entry {
134 u64 cookie;
135 u64 ino;
136 struct qstr string;
137 unsigned char d_type;
138};
139
140struct nfs_cache_array {
141 int size;
142 int eof_index;
143 u64 last_cookie;
144 struct nfs_cache_array_entry array[];
145};
146
147typedef struct {
148 struct file *file;
149 struct page *page;
150 struct dir_context *ctx;
151 unsigned long page_index;
152 u64 *dir_cookie;
153 u64 last_cookie;
154 loff_t current_index;
155 loff_t prev_index;
156
157 unsigned long dir_verifier;
158 unsigned long timestamp;
159 unsigned long gencount;
160 unsigned int cache_entry_index;
161 bool plus;
162 bool eof;
163} nfs_readdir_descriptor_t;
164
165static
166void nfs_readdir_init_array(struct page *page)
167{
168 struct nfs_cache_array *array;
169
170 array = kmap_atomic(page);
171 memset(array, 0, sizeof(struct nfs_cache_array));
172 array->eof_index = -1;
173 kunmap_atomic(array);
174}
175
176
177
178
179static
180void nfs_readdir_clear_array(struct page *page)
181{
182 struct nfs_cache_array *array;
183 int i;
184
185 array = kmap_atomic(page);
186 for (i = 0; i < array->size; i++)
187 kfree(array->array[i].string.name);
188 array->size = 0;
189 kunmap_atomic(array);
190}
191
192
193
194
195
196
197static
198int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len)
199{
200 string->len = len;
201 string->name = kmemdup_nul(name, len, GFP_KERNEL);
202 if (string->name == NULL)
203 return -ENOMEM;
204
205
206
207
208 kmemleak_not_leak(string->name);
209 string->hash = full_name_hash(NULL, name, len);
210 return 0;
211}
212
213static
214int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page)
215{
216 struct nfs_cache_array *array = kmap(page);
217 struct nfs_cache_array_entry *cache_entry;
218 int ret;
219
220 cache_entry = &array->array[array->size];
221
222
223 ret = -ENOSPC;
224 if ((char *)&cache_entry[1] - (char *)page_address(page) > PAGE_SIZE)
225 goto out;
226
227 cache_entry->cookie = entry->prev_cookie;
228 cache_entry->ino = entry->ino;
229 cache_entry->d_type = entry->d_type;
230 ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len);
231 if (ret)
232 goto out;
233 array->last_cookie = entry->cookie;
234 array->size++;
235 if (entry->eof != 0)
236 array->eof_index = array->size;
237out:
238 kunmap(page);
239 return ret;
240}
241
242static inline
243int is_32bit_api(void)
244{
245#ifdef CONFIG_COMPAT
246 return in_compat_syscall();
247#else
248 return (BITS_PER_LONG == 32);
249#endif
250}
251
252static
253bool nfs_readdir_use_cookie(const struct file *filp)
254{
255 if ((filp->f_mode & FMODE_32BITHASH) ||
256 (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
257 return false;
258 return true;
259}
260
261static
262int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
263{
264 loff_t diff = desc->ctx->pos - desc->current_index;
265 unsigned int index;
266
267 if (diff < 0)
268 goto out_eof;
269 if (diff >= array->size) {
270 if (array->eof_index >= 0)
271 goto out_eof;
272 return -EAGAIN;
273 }
274
275 index = (unsigned int)diff;
276 *desc->dir_cookie = array->array[index].cookie;
277 desc->cache_entry_index = index;
278 return 0;
279out_eof:
280 desc->eof = true;
281 return -EBADCOOKIE;
282}
283
284static bool
285nfs_readdir_inode_mapping_valid(struct nfs_inode *nfsi)
286{
287 if (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA))
288 return false;
289 smp_rmb();
290 return !test_bit(NFS_INO_INVALIDATING, &nfsi->flags);
291}
292
293static
294int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
295{
296 int i;
297 loff_t new_pos;
298 int status = -EAGAIN;
299
300 for (i = 0; i < array->size; i++) {
301 if (array->array[i].cookie == *desc->dir_cookie) {
302 struct nfs_inode *nfsi = NFS_I(file_inode(desc->file));
303 struct nfs_open_dir_context *ctx = desc->file->private_data;
304
305 new_pos = desc->current_index + i;
306 if (ctx->attr_gencount != nfsi->attr_gencount ||
307 !nfs_readdir_inode_mapping_valid(nfsi)) {
308 ctx->duped = 0;
309 ctx->attr_gencount = nfsi->attr_gencount;
310 } else if (new_pos < desc->prev_index) {
311 if (ctx->duped > 0
312 && ctx->dup_cookie == *desc->dir_cookie) {
313 if (printk_ratelimit()) {
314 pr_notice("NFS: directory %pD2 contains a readdir loop."
315 "Please contact your server vendor. "
316 "The file: %.*s has duplicate cookie %llu\n",
317 desc->file, array->array[i].string.len,
318 array->array[i].string.name, *desc->dir_cookie);
319 }
320 status = -ELOOP;
321 goto out;
322 }
323 ctx->dup_cookie = *desc->dir_cookie;
324 ctx->duped = -1;
325 }
326 if (nfs_readdir_use_cookie(desc->file))
327 desc->ctx->pos = *desc->dir_cookie;
328 else
329 desc->ctx->pos = new_pos;
330 desc->prev_index = new_pos;
331 desc->cache_entry_index = i;
332 return 0;
333 }
334 }
335 if (array->eof_index >= 0) {
336 status = -EBADCOOKIE;
337 if (*desc->dir_cookie == array->last_cookie)
338 desc->eof = true;
339 }
340out:
341 return status;
342}
343
344static
345int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc)
346{
347 struct nfs_cache_array *array;
348 int status;
349
350 array = kmap(desc->page);
351
352 if (*desc->dir_cookie == 0)
353 status = nfs_readdir_search_for_pos(array, desc);
354 else
355 status = nfs_readdir_search_for_cookie(array, desc);
356
357 if (status == -EAGAIN) {
358 desc->last_cookie = array->last_cookie;
359 desc->current_index += array->size;
360 desc->page_index++;
361 }
362 kunmap(desc->page);
363 return status;
364}
365
366
367static
368int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc,
369 struct nfs_entry *entry, struct file *file, struct inode *inode)
370{
371 struct nfs_open_dir_context *ctx = file->private_data;
372 const struct cred *cred = ctx->cred;
373 unsigned long timestamp, gencount;
374 int error;
375
376 again:
377 timestamp = jiffies;
378 gencount = nfs_inc_attr_generation_counter();
379 desc->dir_verifier = nfs_save_change_attribute(inode);
380 error = NFS_PROTO(inode)->readdir(file_dentry(file), cred, entry->cookie, pages,
381 NFS_SERVER(inode)->dtsize, desc->plus);
382 if (error < 0) {
383
384 if (error == -ENOTSUPP && desc->plus) {
385 NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS;
386 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
387 desc->plus = false;
388 goto again;
389 }
390 goto error;
391 }
392 desc->timestamp = timestamp;
393 desc->gencount = gencount;
394error:
395 return error;
396}
397
398static int xdr_decode(nfs_readdir_descriptor_t *desc,
399 struct nfs_entry *entry, struct xdr_stream *xdr)
400{
401 struct inode *inode = file_inode(desc->file);
402 int error;
403
404 error = NFS_PROTO(inode)->decode_dirent(xdr, entry, desc->plus);
405 if (error)
406 return error;
407 entry->fattr->time_start = desc->timestamp;
408 entry->fattr->gencount = desc->gencount;
409 return 0;
410}
411
412
413
414
415static
416int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry)
417{
418 struct inode *inode;
419 struct nfs_inode *nfsi;
420
421 if (d_really_is_negative(dentry))
422 return 0;
423
424 inode = d_inode(dentry);
425 if (is_bad_inode(inode) || NFS_STALE(inode))
426 return 0;
427
428 nfsi = NFS_I(inode);
429 if (entry->fattr->fileid != nfsi->fileid)
430 return 0;
431 if (entry->fh->size && nfs_compare_fh(entry->fh, &nfsi->fh) != 0)
432 return 0;
433 return 1;
434}
435
436static
437bool nfs_use_readdirplus(struct inode *dir, struct dir_context *ctx)
438{
439 if (!nfs_server_capable(dir, NFS_CAP_READDIRPLUS))
440 return false;
441 if (test_and_clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags))
442 return true;
443 if (ctx->pos == 0)
444 return true;
445 return false;
446}
447
448
449
450
451
452
453void nfs_advise_use_readdirplus(struct inode *dir)
454{
455 struct nfs_inode *nfsi = NFS_I(dir);
456
457 if (nfs_server_capable(dir, NFS_CAP_READDIRPLUS) &&
458 !list_empty(&nfsi->open_files))
459 set_bit(NFS_INO_ADVISE_RDPLUS, &nfsi->flags);
460}
461
462
463
464
465
466
467
468
469
470void nfs_force_use_readdirplus(struct inode *dir)
471{
472 struct nfs_inode *nfsi = NFS_I(dir);
473
474 if (nfs_server_capable(dir, NFS_CAP_READDIRPLUS) &&
475 !list_empty(&nfsi->open_files)) {
476 set_bit(NFS_INO_ADVISE_RDPLUS, &nfsi->flags);
477 invalidate_mapping_pages(dir->i_mapping,
478 nfsi->page_index + 1, -1);
479 }
480}
481
482static
483void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry,
484 unsigned long dir_verifier)
485{
486 struct qstr filename = QSTR_INIT(entry->name, entry->len);
487 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
488 struct dentry *dentry;
489 struct dentry *alias;
490 struct inode *inode;
491 int status;
492
493 if (!(entry->fattr->valid & NFS_ATTR_FATTR_FILEID))
494 return;
495 if (!(entry->fattr->valid & NFS_ATTR_FATTR_FSID))
496 return;
497 if (filename.len == 0)
498 return;
499
500 if (strnlen(filename.name, filename.len) != filename.len)
501 return;
502
503 if (strnchr(filename.name, filename.len, '/'))
504 return;
505 if (filename.name[0] == '.') {
506 if (filename.len == 1)
507 return;
508 if (filename.len == 2 && filename.name[1] == '.')
509 return;
510 }
511 filename.hash = full_name_hash(parent, filename.name, filename.len);
512
513 dentry = d_lookup(parent, &filename);
514again:
515 if (!dentry) {
516 dentry = d_alloc_parallel(parent, &filename, &wq);
517 if (IS_ERR(dentry))
518 return;
519 }
520 if (!d_in_lookup(dentry)) {
521
522 if (!nfs_fsid_equal(&NFS_SB(dentry->d_sb)->fsid,
523 &entry->fattr->fsid))
524 goto out;
525 if (nfs_same_file(dentry, entry)) {
526 if (!entry->fh->size)
527 goto out;
528 nfs_set_verifier(dentry, dir_verifier);
529 status = nfs_refresh_inode(d_inode(dentry), entry->fattr);
530 if (!status)
531 nfs_setsecurity(d_inode(dentry), entry->fattr, entry->label);
532 goto out;
533 } else {
534 d_invalidate(dentry);
535 dput(dentry);
536 dentry = NULL;
537 goto again;
538 }
539 }
540 if (!entry->fh->size) {
541 d_lookup_done(dentry);
542 goto out;
543 }
544
545 inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr, entry->label);
546 alias = d_splice_alias(inode, dentry);
547 d_lookup_done(dentry);
548 if (alias) {
549 if (IS_ERR(alias))
550 goto out;
551 dput(dentry);
552 dentry = alias;
553 }
554 nfs_set_verifier(dentry, dir_verifier);
555out:
556 dput(dentry);
557}
558
559
560static
561int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry,
562 struct page **xdr_pages, struct page *page, unsigned int buflen)
563{
564 struct xdr_stream stream;
565 struct xdr_buf buf;
566 struct page *scratch;
567 struct nfs_cache_array *array;
568 unsigned int count = 0;
569 int status;
570
571 scratch = alloc_page(GFP_KERNEL);
572 if (scratch == NULL)
573 return -ENOMEM;
574
575 if (buflen == 0)
576 goto out_nopages;
577
578 xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen);
579 xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
580
581 do {
582 if (entry->label)
583 entry->label->len = NFS4_MAXLABELLEN;
584
585 status = xdr_decode(desc, entry, &stream);
586 if (status != 0) {
587 if (status == -EAGAIN)
588 status = 0;
589 break;
590 }
591
592 count++;
593
594 if (desc->plus)
595 nfs_prime_dcache(file_dentry(desc->file), entry,
596 desc->dir_verifier);
597
598 status = nfs_readdir_add_to_array(entry, page);
599 if (status != 0)
600 break;
601 } while (!entry->eof);
602
603out_nopages:
604 if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) {
605 array = kmap(page);
606 array->eof_index = array->size;
607 status = 0;
608 kunmap(page);
609 }
610
611 put_page(scratch);
612 return status;
613}
614
615static
616void nfs_readdir_free_pages(struct page **pages, unsigned int npages)
617{
618 unsigned int i;
619 for (i = 0; i < npages; i++)
620 put_page(pages[i]);
621}
622
623
624
625
626
627static
628int nfs_readdir_alloc_pages(struct page **pages, unsigned int npages)
629{
630 unsigned int i;
631
632 for (i = 0; i < npages; i++) {
633 struct page *page = alloc_page(GFP_KERNEL);
634 if (page == NULL)
635 goto out_freepages;
636 pages[i] = page;
637 }
638 return 0;
639
640out_freepages:
641 nfs_readdir_free_pages(pages, i);
642 return -ENOMEM;
643}
644
645static
646int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode)
647{
648 struct page *pages[NFS_MAX_READDIR_PAGES];
649 struct nfs_entry entry;
650 struct file *file = desc->file;
651 struct nfs_cache_array *array;
652 int status = -ENOMEM;
653 unsigned int array_size = ARRAY_SIZE(pages);
654
655 nfs_readdir_init_array(page);
656
657 entry.prev_cookie = 0;
658 entry.cookie = desc->last_cookie;
659 entry.eof = 0;
660 entry.fh = nfs_alloc_fhandle();
661 entry.fattr = nfs_alloc_fattr();
662 entry.server = NFS_SERVER(inode);
663 if (entry.fh == NULL || entry.fattr == NULL)
664 goto out;
665
666 entry.label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
667 if (IS_ERR(entry.label)) {
668 status = PTR_ERR(entry.label);
669 goto out;
670 }
671
672 array = kmap(page);
673
674 status = nfs_readdir_alloc_pages(pages, array_size);
675 if (status < 0)
676 goto out_release_array;
677 do {
678 unsigned int pglen;
679 status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode);
680
681 if (status < 0)
682 break;
683 pglen = status;
684 status = nfs_readdir_page_filler(desc, &entry, pages, page, pglen);
685 if (status < 0) {
686 if (status == -ENOSPC)
687 status = 0;
688 break;
689 }
690 } while (array->eof_index < 0);
691
692 nfs_readdir_free_pages(pages, array_size);
693out_release_array:
694 kunmap(page);
695 nfs4_label_free(entry.label);
696out:
697 nfs_free_fattr(entry.fattr);
698 nfs_free_fhandle(entry.fh);
699 return status;
700}
701
702
703
704
705
706
707
708static
709int nfs_readdir_filler(void *data, struct page* page)
710{
711 nfs_readdir_descriptor_t *desc = data;
712 struct inode *inode = file_inode(desc->file);
713 int ret;
714
715 ret = nfs_readdir_xdr_to_array(desc, page, inode);
716 if (ret < 0)
717 goto error;
718 SetPageUptodate(page);
719
720 if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) {
721
722 nfs_zap_mapping(inode, inode->i_mapping);
723 }
724 unlock_page(page);
725 return 0;
726 error:
727 nfs_readdir_clear_array(page);
728 unlock_page(page);
729 return ret;
730}
731
732static
733void cache_page_release(nfs_readdir_descriptor_t *desc)
734{
735 put_page(desc->page);
736 desc->page = NULL;
737}
738
739static
740struct page *get_cache_page(nfs_readdir_descriptor_t *desc)
741{
742 return read_cache_page(desc->file->f_mapping, desc->page_index,
743 nfs_readdir_filler, desc);
744}
745
746
747
748
749
750static
751int find_and_lock_cache_page(nfs_readdir_descriptor_t *desc)
752{
753 struct inode *inode = file_inode(desc->file);
754 struct nfs_inode *nfsi = NFS_I(inode);
755 int res;
756
757 desc->page = get_cache_page(desc);
758 if (IS_ERR(desc->page))
759 return PTR_ERR(desc->page);
760 res = lock_page_killable(desc->page);
761 if (res != 0)
762 goto error;
763 res = -EAGAIN;
764 if (desc->page->mapping != NULL) {
765 res = nfs_readdir_search_array(desc);
766 if (res == 0) {
767 nfsi->page_index = desc->page_index;
768 return 0;
769 }
770 }
771 unlock_page(desc->page);
772error:
773 cache_page_release(desc);
774 return res;
775}
776
777
778static inline
779int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
780{
781 int res;
782
783 if (desc->page_index == 0) {
784 desc->current_index = 0;
785 desc->prev_index = 0;
786 desc->last_cookie = 0;
787 }
788 do {
789 res = find_and_lock_cache_page(desc);
790 } while (res == -EAGAIN);
791 return res;
792}
793
794
795
796
797static
798int nfs_do_filldir(nfs_readdir_descriptor_t *desc)
799{
800 struct file *file = desc->file;
801 int i = 0;
802 int res = 0;
803 struct nfs_cache_array *array = NULL;
804 struct nfs_open_dir_context *ctx = file->private_data;
805
806 array = kmap(desc->page);
807 for (i = desc->cache_entry_index; i < array->size; i++) {
808 struct nfs_cache_array_entry *ent;
809
810 ent = &array->array[i];
811 if (!dir_emit(desc->ctx, ent->string.name, ent->string.len,
812 nfs_compat_user_ino64(ent->ino), ent->d_type)) {
813 desc->eof = true;
814 break;
815 }
816 if (i < (array->size-1))
817 *desc->dir_cookie = array->array[i+1].cookie;
818 else
819 *desc->dir_cookie = array->last_cookie;
820 if (nfs_readdir_use_cookie(file))
821 desc->ctx->pos = *desc->dir_cookie;
822 else
823 desc->ctx->pos++;
824 if (ctx->duped != 0)
825 ctx->duped = 1;
826 }
827 if (array->eof_index >= 0)
828 desc->eof = true;
829
830 kunmap(desc->page);
831 dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n",
832 (unsigned long long)*desc->dir_cookie, res);
833 return res;
834}
835
836
837
838
839
840
841
842
843
844
845
846
847
848static inline
849int uncached_readdir(nfs_readdir_descriptor_t *desc)
850{
851 struct page *page = NULL;
852 int status;
853 struct inode *inode = file_inode(desc->file);
854 struct nfs_open_dir_context *ctx = desc->file->private_data;
855
856 dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
857 (unsigned long long)*desc->dir_cookie);
858
859 page = alloc_page(GFP_HIGHUSER);
860 if (!page) {
861 status = -ENOMEM;
862 goto out;
863 }
864
865 desc->page_index = 0;
866 desc->last_cookie = *desc->dir_cookie;
867 desc->page = page;
868 ctx->duped = 0;
869
870 status = nfs_readdir_xdr_to_array(desc, page, inode);
871 if (status < 0)
872 goto out_release;
873
874 status = nfs_do_filldir(desc);
875
876 out_release:
877 nfs_readdir_clear_array(desc->page);
878 cache_page_release(desc);
879 out:
880 dfprintk(DIRCACHE, "NFS: %s: returns %d\n",
881 __func__, status);
882 return status;
883}
884
885
886
887
888
889static int nfs_readdir(struct file *file, struct dir_context *ctx)
890{
891 struct dentry *dentry = file_dentry(file);
892 struct inode *inode = d_inode(dentry);
893 struct nfs_open_dir_context *dir_ctx = file->private_data;
894 nfs_readdir_descriptor_t my_desc = {
895 .file = file,
896 .ctx = ctx,
897 .dir_cookie = &dir_ctx->dir_cookie,
898 .plus = nfs_use_readdirplus(inode, ctx),
899 },
900 *desc = &my_desc;
901 int res = 0;
902
903 dfprintk(FILE, "NFS: readdir(%pD2) starting at cookie %llu\n",
904 file, (long long)ctx->pos);
905 nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);
906
907
908
909
910
911
912
913 if (ctx->pos == 0 || nfs_attribute_cache_expired(inode))
914 res = nfs_revalidate_mapping(inode, file->f_mapping);
915 if (res < 0)
916 goto out;
917
918 do {
919 res = readdir_search_pagecache(desc);
920
921 if (res == -EBADCOOKIE) {
922 res = 0;
923
924 if (*desc->dir_cookie && !desc->eof) {
925
926 res = uncached_readdir(desc);
927 if (res == 0)
928 continue;
929 }
930 break;
931 }
932 if (res == -ETOOSMALL && desc->plus) {
933 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
934 nfs_zap_caches(inode);
935 desc->page_index = 0;
936 desc->plus = false;
937 desc->eof = false;
938 continue;
939 }
940 if (res < 0)
941 break;
942
943 res = nfs_do_filldir(desc);
944 unlock_page(desc->page);
945 cache_page_release(desc);
946 if (res < 0)
947 break;
948 } while (!desc->eof);
949out:
950 if (res > 0)
951 res = 0;
952 dfprintk(FILE, "NFS: readdir(%pD2) returns %d\n", file, res);
953 return res;
954}
955
956static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int whence)
957{
958 struct nfs_open_dir_context *dir_ctx = filp->private_data;
959
960 dfprintk(FILE, "NFS: llseek dir(%pD2, %lld, %d)\n",
961 filp, offset, whence);
962
963 switch (whence) {
964 default:
965 return -EINVAL;
966 case SEEK_SET:
967 if (offset < 0)
968 return -EINVAL;
969 spin_lock(&filp->f_lock);
970 break;
971 case SEEK_CUR:
972 if (offset == 0)
973 return filp->f_pos;
974 spin_lock(&filp->f_lock);
975 offset += filp->f_pos;
976 if (offset < 0) {
977 spin_unlock(&filp->f_lock);
978 return -EINVAL;
979 }
980 }
981 if (offset != filp->f_pos) {
982 filp->f_pos = offset;
983 if (nfs_readdir_use_cookie(filp))
984 dir_ctx->dir_cookie = offset;
985 else
986 dir_ctx->dir_cookie = 0;
987 dir_ctx->duped = 0;
988 }
989 spin_unlock(&filp->f_lock);
990 return offset;
991}
992
993
994
995
996
997static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
998 int datasync)
999{
1000 dfprintk(FILE, "NFS: fsync dir(%pD2) datasync %d\n", filp, datasync);
1001
1002 nfs_inc_stats(file_inode(filp), NFSIOS_VFSFSYNC);
1003 return 0;
1004}
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019void nfs_force_lookup_revalidate(struct inode *dir)
1020{
1021 NFS_I(dir)->cache_change_attribute += 2;
1022}
1023EXPORT_SYMBOL_GPL(nfs_force_lookup_revalidate);
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034static bool nfs_verify_change_attribute(struct inode *dir, unsigned long verf)
1035{
1036 return (verf & ~1UL) == nfs_save_change_attribute(dir);
1037}
1038
1039static void nfs_set_verifier_delegated(unsigned long *verf)
1040{
1041 *verf |= 1UL;
1042}
1043
1044#if IS_ENABLED(CONFIG_NFS_V4)
1045static void nfs_unset_verifier_delegated(unsigned long *verf)
1046{
1047 *verf &= ~1UL;
1048}
1049#endif
1050
1051static bool nfs_test_verifier_delegated(unsigned long verf)
1052{
1053 return verf & 1;
1054}
1055
1056static bool nfs_verifier_is_delegated(struct dentry *dentry)
1057{
1058 return nfs_test_verifier_delegated(dentry->d_time);
1059}
1060
1061static void nfs_set_verifier_locked(struct dentry *dentry, unsigned long verf)
1062{
1063 struct inode *inode = d_inode(dentry);
1064
1065 if (!nfs_verifier_is_delegated(dentry) &&
1066 !nfs_verify_change_attribute(d_inode(dentry->d_parent), verf))
1067 goto out;
1068 if (inode && NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
1069 nfs_set_verifier_delegated(&verf);
1070out:
1071 dentry->d_time = verf;
1072}
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084void nfs_set_verifier(struct dentry *dentry, unsigned long verf)
1085{
1086
1087 spin_lock(&dentry->d_lock);
1088 nfs_set_verifier_locked(dentry, verf);
1089 spin_unlock(&dentry->d_lock);
1090}
1091EXPORT_SYMBOL_GPL(nfs_set_verifier);
1092
1093#if IS_ENABLED(CONFIG_NFS_V4)
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104void nfs_clear_verifier_delegated(struct inode *inode)
1105{
1106 struct dentry *alias;
1107
1108 if (!inode)
1109 return;
1110 spin_lock(&inode->i_lock);
1111 hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
1112 spin_lock(&alias->d_lock);
1113 nfs_unset_verifier_delegated(&alias->d_time);
1114 spin_unlock(&alias->d_lock);
1115 }
1116 spin_unlock(&inode->i_lock);
1117}
1118EXPORT_SYMBOL_GPL(nfs_clear_verifier_delegated);
1119#endif
1120
1121
1122
1123
1124
1125
1126
1127static int nfs_check_verifier(struct inode *dir, struct dentry *dentry,
1128 int rcu_walk)
1129{
1130 if (IS_ROOT(dentry))
1131 return 1;
1132 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
1133 return 0;
1134 if (!nfs_verify_change_attribute(dir, dentry->d_time))
1135 return 0;
1136
1137 if (nfs_mapping_need_revalidate_inode(dir)) {
1138 if (rcu_walk)
1139 return 0;
1140 if (__nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0)
1141 return 0;
1142 }
1143 if (!nfs_verify_change_attribute(dir, dentry->d_time))
1144 return 0;
1145 return 1;
1146}
1147
1148
1149
1150
1151
1152static int nfs_is_exclusive_create(struct inode *dir, unsigned int flags)
1153{
1154 if (NFS_PROTO(dir)->version == 2)
1155 return 0;
1156 return flags & LOOKUP_EXCL;
1157}
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167static
1168int nfs_lookup_verify_inode(struct inode *inode, unsigned int flags)
1169{
1170 struct nfs_server *server = NFS_SERVER(inode);
1171 int ret;
1172
1173 if (IS_AUTOMOUNT(inode))
1174 return 0;
1175
1176 if (flags & LOOKUP_OPEN) {
1177 switch (inode->i_mode & S_IFMT) {
1178 case S_IFREG:
1179
1180 if (server->caps & NFS_CAP_ATOMIC_OPEN)
1181 goto out;
1182 fallthrough;
1183 case S_IFDIR:
1184 if (server->flags & NFS_MOUNT_NOCTO)
1185 break;
1186
1187 goto out_force;
1188 }
1189 }
1190
1191
1192 if (flags & LOOKUP_REVAL)
1193 goto out_force;
1194out:
1195 return (inode->i_nlink == 0) ? -ESTALE : 0;
1196out_force:
1197 if (flags & LOOKUP_RCU)
1198 return -ECHILD;
1199 ret = __nfs_revalidate_inode(server, inode);
1200 if (ret != 0)
1201 return ret;
1202 goto out;
1203}
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218static inline
1219int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
1220 unsigned int flags)
1221{
1222 if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
1223 return 0;
1224 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
1225 return 1;
1226 return !nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU);
1227}
1228
1229static int
1230nfs_lookup_revalidate_done(struct inode *dir, struct dentry *dentry,
1231 struct inode *inode, int error)
1232{
1233 switch (error) {
1234 case 1:
1235 dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is valid\n",
1236 __func__, dentry);
1237 return 1;
1238 case 0:
1239 nfs_mark_for_revalidate(dir);
1240 if (inode && S_ISDIR(inode->i_mode)) {
1241
1242 nfs_zap_caches(inode);
1243
1244
1245
1246
1247
1248
1249 if (IS_ROOT(dentry))
1250 return 1;
1251 }
1252 dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is invalid\n",
1253 __func__, dentry);
1254 return 0;
1255 }
1256 dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) lookup returned error %d\n",
1257 __func__, dentry, error);
1258 return error;
1259}
1260
1261static int
1262nfs_lookup_revalidate_negative(struct inode *dir, struct dentry *dentry,
1263 unsigned int flags)
1264{
1265 int ret = 1;
1266 if (nfs_neg_need_reval(dir, dentry, flags)) {
1267 if (flags & LOOKUP_RCU)
1268 return -ECHILD;
1269 ret = 0;
1270 }
1271 return nfs_lookup_revalidate_done(dir, dentry, NULL, ret);
1272}
1273
1274static int
1275nfs_lookup_revalidate_delegated(struct inode *dir, struct dentry *dentry,
1276 struct inode *inode)
1277{
1278 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1279 return nfs_lookup_revalidate_done(dir, dentry, inode, 1);
1280}
1281
1282static int
1283nfs_lookup_revalidate_dentry(struct inode *dir, struct dentry *dentry,
1284 struct inode *inode)
1285{
1286 struct nfs_fh *fhandle;
1287 struct nfs_fattr *fattr;
1288 struct nfs4_label *label;
1289 unsigned long dir_verifier;
1290 int ret;
1291
1292 ret = -ENOMEM;
1293 fhandle = nfs_alloc_fhandle();
1294 fattr = nfs_alloc_fattr();
1295 label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
1296 if (fhandle == NULL || fattr == NULL || IS_ERR(label))
1297 goto out;
1298
1299 dir_verifier = nfs_save_change_attribute(dir);
1300 ret = NFS_PROTO(dir)->lookup(dir, dentry, fhandle, fattr, label);
1301 if (ret < 0) {
1302 switch (ret) {
1303 case -ESTALE:
1304 case -ENOENT:
1305 ret = 0;
1306 break;
1307 case -ETIMEDOUT:
1308 if (NFS_SERVER(inode)->flags & NFS_MOUNT_SOFTREVAL)
1309 ret = 1;
1310 }
1311 goto out;
1312 }
1313 ret = 0;
1314 if (nfs_compare_fh(NFS_FH(inode), fhandle))
1315 goto out;
1316 if (nfs_refresh_inode(inode, fattr) < 0)
1317 goto out;
1318
1319 nfs_setsecurity(inode, fattr, label);
1320 nfs_set_verifier(dentry, dir_verifier);
1321
1322
1323 nfs_force_use_readdirplus(dir);
1324 ret = 1;
1325out:
1326 nfs_free_fattr(fattr);
1327 nfs_free_fhandle(fhandle);
1328 nfs4_label_free(label);
1329 return nfs_lookup_revalidate_done(dir, dentry, inode, ret);
1330}
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343static int
1344nfs_do_lookup_revalidate(struct inode *dir, struct dentry *dentry,
1345 unsigned int flags)
1346{
1347 struct inode *inode;
1348 int error;
1349
1350 nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
1351 inode = d_inode(dentry);
1352
1353 if (!inode)
1354 return nfs_lookup_revalidate_negative(dir, dentry, flags);
1355
1356 if (is_bad_inode(inode)) {
1357 dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n",
1358 __func__, dentry);
1359 goto out_bad;
1360 }
1361
1362 if (nfs_verifier_is_delegated(dentry))
1363 return nfs_lookup_revalidate_delegated(dir, dentry, inode);
1364
1365
1366 if (!(flags & (LOOKUP_EXCL | LOOKUP_REVAL)) &&
1367 nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU)) {
1368 error = nfs_lookup_verify_inode(inode, flags);
1369 if (error) {
1370 if (error == -ESTALE)
1371 nfs_zap_caches(dir);
1372 goto out_bad;
1373 }
1374 nfs_advise_use_readdirplus(dir);
1375 goto out_valid;
1376 }
1377
1378 if (flags & LOOKUP_RCU)
1379 return -ECHILD;
1380
1381 if (NFS_STALE(inode))
1382 goto out_bad;
1383
1384 trace_nfs_lookup_revalidate_enter(dir, dentry, flags);
1385 error = nfs_lookup_revalidate_dentry(dir, dentry, inode);
1386 trace_nfs_lookup_revalidate_exit(dir, dentry, flags, error);
1387 return error;
1388out_valid:
1389 return nfs_lookup_revalidate_done(dir, dentry, inode, 1);
1390out_bad:
1391 if (flags & LOOKUP_RCU)
1392 return -ECHILD;
1393 return nfs_lookup_revalidate_done(dir, dentry, inode, 0);
1394}
1395
1396static int
1397__nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags,
1398 int (*reval)(struct inode *, struct dentry *, unsigned int))
1399{
1400 struct dentry *parent;
1401 struct inode *dir;
1402 int ret;
1403
1404 if (flags & LOOKUP_RCU) {
1405 parent = READ_ONCE(dentry->d_parent);
1406 dir = d_inode_rcu(parent);
1407 if (!dir)
1408 return -ECHILD;
1409 ret = reval(dir, dentry, flags);
1410 if (parent != READ_ONCE(dentry->d_parent))
1411 return -ECHILD;
1412 } else {
1413 parent = dget_parent(dentry);
1414 ret = reval(d_inode(parent), dentry, flags);
1415 dput(parent);
1416 }
1417 return ret;
1418}
1419
1420static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
1421{
1422 return __nfs_lookup_revalidate(dentry, flags, nfs_do_lookup_revalidate);
1423}
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434static int nfs_weak_revalidate(struct dentry *dentry, unsigned int flags)
1435{
1436 struct inode *inode = d_inode(dentry);
1437 int error = 0;
1438
1439
1440
1441
1442
1443
1444 if (!inode) {
1445 dfprintk(LOOKUPCACHE, "%s: %pd2 has negative inode\n",
1446 __func__, dentry);
1447 return 1;
1448 }
1449
1450 if (is_bad_inode(inode)) {
1451 dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n",
1452 __func__, dentry);
1453 return 0;
1454 }
1455
1456 error = nfs_lookup_verify_inode(inode, flags);
1457 dfprintk(LOOKUPCACHE, "NFS: %s: inode %lu is %s\n",
1458 __func__, inode->i_ino, error ? "invalid" : "valid");
1459 return !error;
1460}
1461
1462
1463
1464
1465static int nfs_dentry_delete(const struct dentry *dentry)
1466{
1467 dfprintk(VFS, "NFS: dentry_delete(%pd2, %x)\n",
1468 dentry, dentry->d_flags);
1469
1470
1471 if (d_really_is_positive(dentry) && NFS_STALE(d_inode(dentry)))
1472 return 1;
1473
1474 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1475
1476 return 1;
1477 }
1478 if (!(dentry->d_sb->s_flags & SB_ACTIVE)) {
1479
1480
1481 return 1;
1482 }
1483 return 0;
1484
1485}
1486
1487
1488static void nfs_drop_nlink(struct inode *inode)
1489{
1490 spin_lock(&inode->i_lock);
1491
1492 if (inode->i_nlink > 0)
1493 drop_nlink(inode);
1494 NFS_I(inode)->attr_gencount = nfs_inc_attr_generation_counter();
1495 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_CHANGE
1496 | NFS_INO_INVALID_CTIME
1497 | NFS_INO_INVALID_OTHER
1498 | NFS_INO_REVAL_FORCED;
1499 spin_unlock(&inode->i_lock);
1500}
1501
1502
1503
1504
1505
1506static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode)
1507{
1508 if (S_ISDIR(inode->i_mode))
1509
1510 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
1511
1512 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1513 nfs_complete_unlink(dentry, inode);
1514 nfs_drop_nlink(inode);
1515 }
1516 iput(inode);
1517}
1518
1519static void nfs_d_release(struct dentry *dentry)
1520{
1521
1522 if (unlikely(dentry->d_fsdata)) {
1523 if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
1524 WARN_ON(1);
1525 else
1526 kfree(dentry->d_fsdata);
1527 }
1528}
1529
1530const struct dentry_operations nfs_dentry_operations = {
1531 .d_revalidate = nfs_lookup_revalidate,
1532 .d_weak_revalidate = nfs_weak_revalidate,
1533 .d_delete = nfs_dentry_delete,
1534 .d_iput = nfs_dentry_iput,
1535 .d_automount = nfs_d_automount,
1536 .d_release = nfs_d_release,
1537};
1538EXPORT_SYMBOL_GPL(nfs_dentry_operations);
1539
1540struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
1541{
1542 struct dentry *res;
1543 struct inode *inode = NULL;
1544 struct nfs_fh *fhandle = NULL;
1545 struct nfs_fattr *fattr = NULL;
1546 struct nfs4_label *label = NULL;
1547 unsigned long dir_verifier;
1548 int error;
1549
1550 dfprintk(VFS, "NFS: lookup(%pd2)\n", dentry);
1551 nfs_inc_stats(dir, NFSIOS_VFSLOOKUP);
1552
1553 if (unlikely(dentry->d_name.len > NFS_SERVER(dir)->namelen))
1554 return ERR_PTR(-ENAMETOOLONG);
1555
1556
1557
1558
1559
1560 if (nfs_is_exclusive_create(dir, flags) || flags & LOOKUP_RENAME_TARGET)
1561 return NULL;
1562
1563 res = ERR_PTR(-ENOMEM);
1564 fhandle = nfs_alloc_fhandle();
1565 fattr = nfs_alloc_fattr();
1566 if (fhandle == NULL || fattr == NULL)
1567 goto out;
1568
1569 label = nfs4_label_alloc(NFS_SERVER(dir), GFP_NOWAIT);
1570 if (IS_ERR(label))
1571 goto out;
1572
1573 dir_verifier = nfs_save_change_attribute(dir);
1574 trace_nfs_lookup_enter(dir, dentry, flags);
1575 error = NFS_PROTO(dir)->lookup(dir, dentry, fhandle, fattr, label);
1576 if (error == -ENOENT)
1577 goto no_entry;
1578 if (error < 0) {
1579 res = ERR_PTR(error);
1580 goto out_label;
1581 }
1582 inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
1583 res = ERR_CAST(inode);
1584 if (IS_ERR(res))
1585 goto out_label;
1586
1587
1588 nfs_force_use_readdirplus(dir);
1589
1590no_entry:
1591 res = d_splice_alias(inode, dentry);
1592 if (res != NULL) {
1593 if (IS_ERR(res))
1594 goto out_label;
1595 dentry = res;
1596 }
1597 nfs_set_verifier(dentry, dir_verifier);
1598out_label:
1599 trace_nfs_lookup_exit(dir, dentry, flags, error);
1600 nfs4_label_free(label);
1601out:
1602 nfs_free_fattr(fattr);
1603 nfs_free_fhandle(fhandle);
1604 return res;
1605}
1606EXPORT_SYMBOL_GPL(nfs_lookup);
1607
1608#if IS_ENABLED(CONFIG_NFS_V4)
1609static int nfs4_lookup_revalidate(struct dentry *, unsigned int);
1610
1611const struct dentry_operations nfs4_dentry_operations = {
1612 .d_revalidate = nfs4_lookup_revalidate,
1613 .d_weak_revalidate = nfs_weak_revalidate,
1614 .d_delete = nfs_dentry_delete,
1615 .d_iput = nfs_dentry_iput,
1616 .d_automount = nfs_d_automount,
1617 .d_release = nfs_d_release,
1618};
1619EXPORT_SYMBOL_GPL(nfs4_dentry_operations);
1620
1621static fmode_t flags_to_mode(int flags)
1622{
1623 fmode_t res = (__force fmode_t)flags & FMODE_EXEC;
1624 if ((flags & O_ACCMODE) != O_WRONLY)
1625 res |= FMODE_READ;
1626 if ((flags & O_ACCMODE) != O_RDONLY)
1627 res |= FMODE_WRITE;
1628 return res;
1629}
1630
1631static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags, struct file *filp)
1632{
1633 return alloc_nfs_open_context(dentry, flags_to_mode(open_flags), filp);
1634}
1635
1636static int do_open(struct inode *inode, struct file *filp)
1637{
1638 nfs_fscache_open_file(inode, filp);
1639 return 0;
1640}
1641
1642static int nfs_finish_open(struct nfs_open_context *ctx,
1643 struct dentry *dentry,
1644 struct file *file, unsigned open_flags)
1645{
1646 int err;
1647
1648 err = finish_open(file, dentry, do_open);
1649 if (err)
1650 goto out;
1651 if (S_ISREG(file->f_path.dentry->d_inode->i_mode))
1652 nfs_file_set_open_context(file, ctx);
1653 else
1654 err = -EOPENSTALE;
1655out:
1656 return err;
1657}
1658
1659int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
1660 struct file *file, unsigned open_flags,
1661 umode_t mode)
1662{
1663 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
1664 struct nfs_open_context *ctx;
1665 struct dentry *res;
1666 struct iattr attr = { .ia_valid = ATTR_OPEN };
1667 struct inode *inode;
1668 unsigned int lookup_flags = 0;
1669 bool switched = false;
1670 int created = 0;
1671 int err;
1672
1673
1674 BUG_ON(d_inode(dentry));
1675
1676 dfprintk(VFS, "NFS: atomic_open(%s/%lu), %pd\n",
1677 dir->i_sb->s_id, dir->i_ino, dentry);
1678
1679 err = nfs_check_flags(open_flags);
1680 if (err)
1681 return err;
1682
1683
1684 if ((open_flags & O_DIRECTORY)) {
1685 if (!d_in_lookup(dentry)) {
1686
1687
1688
1689
1690
1691 return -ENOENT;
1692 }
1693 lookup_flags = LOOKUP_OPEN|LOOKUP_DIRECTORY;
1694 goto no_open;
1695 }
1696
1697 if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
1698 return -ENAMETOOLONG;
1699
1700 if (open_flags & O_CREAT) {
1701 struct nfs_server *server = NFS_SERVER(dir);
1702
1703 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
1704 mode &= ~current_umask();
1705
1706 attr.ia_valid |= ATTR_MODE;
1707 attr.ia_mode = mode;
1708 }
1709 if (open_flags & O_TRUNC) {
1710 attr.ia_valid |= ATTR_SIZE;
1711 attr.ia_size = 0;
1712 }
1713
1714 if (!(open_flags & O_CREAT) && !d_in_lookup(dentry)) {
1715 d_drop(dentry);
1716 switched = true;
1717 dentry = d_alloc_parallel(dentry->d_parent,
1718 &dentry->d_name, &wq);
1719 if (IS_ERR(dentry))
1720 return PTR_ERR(dentry);
1721 if (unlikely(!d_in_lookup(dentry)))
1722 return finish_no_open(file, dentry);
1723 }
1724
1725 ctx = create_nfs_open_context(dentry, open_flags, file);
1726 err = PTR_ERR(ctx);
1727 if (IS_ERR(ctx))
1728 goto out;
1729
1730 trace_nfs_atomic_open_enter(dir, ctx, open_flags);
1731 inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr, &created);
1732 if (created)
1733 file->f_mode |= FMODE_CREATED;
1734 if (IS_ERR(inode)) {
1735 err = PTR_ERR(inode);
1736 trace_nfs_atomic_open_exit(dir, ctx, open_flags, err);
1737 put_nfs_open_context(ctx);
1738 d_drop(dentry);
1739 switch (err) {
1740 case -ENOENT:
1741 d_splice_alias(NULL, dentry);
1742 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1743 break;
1744 case -EISDIR:
1745 case -ENOTDIR:
1746 goto no_open;
1747 case -ELOOP:
1748 if (!(open_flags & O_NOFOLLOW))
1749 goto no_open;
1750 break;
1751
1752 default:
1753 break;
1754 }
1755 goto out;
1756 }
1757
1758 err = nfs_finish_open(ctx, ctx->dentry, file, open_flags);
1759 trace_nfs_atomic_open_exit(dir, ctx, open_flags, err);
1760 put_nfs_open_context(ctx);
1761out:
1762 if (unlikely(switched)) {
1763 d_lookup_done(dentry);
1764 dput(dentry);
1765 }
1766 return err;
1767
1768no_open:
1769 res = nfs_lookup(dir, dentry, lookup_flags);
1770 if (switched) {
1771 d_lookup_done(dentry);
1772 if (!res)
1773 res = dentry;
1774 else
1775 dput(dentry);
1776 }
1777 if (IS_ERR(res))
1778 return PTR_ERR(res);
1779 return finish_no_open(file, res);
1780}
1781EXPORT_SYMBOL_GPL(nfs_atomic_open);
1782
1783static int
1784nfs4_do_lookup_revalidate(struct inode *dir, struct dentry *dentry,
1785 unsigned int flags)
1786{
1787 struct inode *inode;
1788
1789 if (!(flags & LOOKUP_OPEN) || (flags & LOOKUP_DIRECTORY))
1790 goto full_reval;
1791 if (d_mountpoint(dentry))
1792 goto full_reval;
1793
1794 inode = d_inode(dentry);
1795
1796
1797
1798
1799 if (inode == NULL)
1800 goto full_reval;
1801
1802 if (nfs_verifier_is_delegated(dentry))
1803 return nfs_lookup_revalidate_delegated(dir, dentry, inode);
1804
1805
1806 if (!S_ISREG(inode->i_mode))
1807 goto full_reval;
1808
1809
1810 if (flags & (LOOKUP_EXCL | LOOKUP_REVAL))
1811 goto reval_dentry;
1812
1813
1814 if (!nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU))
1815 goto reval_dentry;
1816
1817
1818 return 1;
1819reval_dentry:
1820 if (flags & LOOKUP_RCU)
1821 return -ECHILD;
1822 return nfs_lookup_revalidate_dentry(dir, dentry, inode);
1823
1824full_reval:
1825 return nfs_do_lookup_revalidate(dir, dentry, flags);
1826}
1827
1828static int nfs4_lookup_revalidate(struct dentry *dentry, unsigned int flags)
1829{
1830 return __nfs_lookup_revalidate(dentry, flags,
1831 nfs4_do_lookup_revalidate);
1832}
1833
1834#endif
1835
1836struct dentry *
1837nfs_add_or_obtain(struct dentry *dentry, struct nfs_fh *fhandle,
1838 struct nfs_fattr *fattr,
1839 struct nfs4_label *label)
1840{
1841 struct dentry *parent = dget_parent(dentry);
1842 struct inode *dir = d_inode(parent);
1843 struct inode *inode;
1844 struct dentry *d;
1845 int error;
1846
1847 d_drop(dentry);
1848
1849 if (fhandle->size == 0) {
1850 error = NFS_PROTO(dir)->lookup(dir, dentry, fhandle, fattr, NULL);
1851 if (error)
1852 goto out_error;
1853 }
1854 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1855 if (!(fattr->valid & NFS_ATTR_FATTR)) {
1856 struct nfs_server *server = NFS_SB(dentry->d_sb);
1857 error = server->nfs_client->rpc_ops->getattr(server, fhandle,
1858 fattr, NULL, NULL);
1859 if (error < 0)
1860 goto out_error;
1861 }
1862 inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
1863 d = d_splice_alias(inode, dentry);
1864out:
1865 dput(parent);
1866 return d;
1867out_error:
1868 nfs_mark_for_revalidate(dir);
1869 d = ERR_PTR(error);
1870 goto out;
1871}
1872EXPORT_SYMBOL_GPL(nfs_add_or_obtain);
1873
1874
1875
1876
1877int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
1878 struct nfs_fattr *fattr,
1879 struct nfs4_label *label)
1880{
1881 struct dentry *d;
1882
1883 d = nfs_add_or_obtain(dentry, fhandle, fattr, label);
1884 if (IS_ERR(d))
1885 return PTR_ERR(d);
1886
1887
1888 dput(d);
1889 return 0;
1890}
1891EXPORT_SYMBOL_GPL(nfs_instantiate);
1892
1893
1894
1895
1896
1897
1898
1899int nfs_create(struct inode *dir, struct dentry *dentry,
1900 umode_t mode, bool excl)
1901{
1902 struct iattr attr;
1903 int open_flags = excl ? O_CREAT | O_EXCL : O_CREAT;
1904 int error;
1905
1906 dfprintk(VFS, "NFS: create(%s/%lu), %pd\n",
1907 dir->i_sb->s_id, dir->i_ino, dentry);
1908
1909 attr.ia_mode = mode;
1910 attr.ia_valid = ATTR_MODE;
1911
1912 trace_nfs_create_enter(dir, dentry, open_flags);
1913 error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags);
1914 trace_nfs_create_exit(dir, dentry, open_flags, error);
1915 if (error != 0)
1916 goto out_err;
1917 return 0;
1918out_err:
1919 d_drop(dentry);
1920 return error;
1921}
1922EXPORT_SYMBOL_GPL(nfs_create);
1923
1924
1925
1926
1927int
1928nfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
1929{
1930 struct iattr attr;
1931 int status;
1932
1933 dfprintk(VFS, "NFS: mknod(%s/%lu), %pd\n",
1934 dir->i_sb->s_id, dir->i_ino, dentry);
1935
1936 attr.ia_mode = mode;
1937 attr.ia_valid = ATTR_MODE;
1938
1939 trace_nfs_mknod_enter(dir, dentry);
1940 status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev);
1941 trace_nfs_mknod_exit(dir, dentry, status);
1942 if (status != 0)
1943 goto out_err;
1944 return 0;
1945out_err:
1946 d_drop(dentry);
1947 return status;
1948}
1949EXPORT_SYMBOL_GPL(nfs_mknod);
1950
1951
1952
1953
1954int nfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
1955{
1956 struct iattr attr;
1957 int error;
1958
1959 dfprintk(VFS, "NFS: mkdir(%s/%lu), %pd\n",
1960 dir->i_sb->s_id, dir->i_ino, dentry);
1961
1962 attr.ia_valid = ATTR_MODE;
1963 attr.ia_mode = mode | S_IFDIR;
1964
1965 trace_nfs_mkdir_enter(dir, dentry);
1966 error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr);
1967 trace_nfs_mkdir_exit(dir, dentry, error);
1968 if (error != 0)
1969 goto out_err;
1970 return 0;
1971out_err:
1972 d_drop(dentry);
1973 return error;
1974}
1975EXPORT_SYMBOL_GPL(nfs_mkdir);
1976
1977static void nfs_dentry_handle_enoent(struct dentry *dentry)
1978{
1979 if (simple_positive(dentry))
1980 d_delete(dentry);
1981}
1982
1983int nfs_rmdir(struct inode *dir, struct dentry *dentry)
1984{
1985 int error;
1986
1987 dfprintk(VFS, "NFS: rmdir(%s/%lu), %pd\n",
1988 dir->i_sb->s_id, dir->i_ino, dentry);
1989
1990 trace_nfs_rmdir_enter(dir, dentry);
1991 if (d_really_is_positive(dentry)) {
1992 down_write(&NFS_I(d_inode(dentry))->rmdir_sem);
1993 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
1994
1995 switch (error) {
1996 case 0:
1997 clear_nlink(d_inode(dentry));
1998 break;
1999 case -ENOENT:
2000 nfs_dentry_handle_enoent(dentry);
2001 }
2002 up_write(&NFS_I(d_inode(dentry))->rmdir_sem);
2003 } else
2004 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
2005 trace_nfs_rmdir_exit(dir, dentry, error);
2006
2007 return error;
2008}
2009EXPORT_SYMBOL_GPL(nfs_rmdir);
2010
2011
2012
2013
2014
2015
2016
2017
2018static int nfs_safe_remove(struct dentry *dentry)
2019{
2020 struct inode *dir = d_inode(dentry->d_parent);
2021 struct inode *inode = d_inode(dentry);
2022 int error = -EBUSY;
2023
2024 dfprintk(VFS, "NFS: safe_remove(%pd2)\n", dentry);
2025
2026
2027 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
2028 error = 0;
2029 goto out;
2030 }
2031
2032 trace_nfs_remove_enter(dir, dentry);
2033 if (inode != NULL) {
2034 error = NFS_PROTO(dir)->remove(dir, dentry);
2035 if (error == 0)
2036 nfs_drop_nlink(inode);
2037 } else
2038 error = NFS_PROTO(dir)->remove(dir, dentry);
2039 if (error == -ENOENT)
2040 nfs_dentry_handle_enoent(dentry);
2041 trace_nfs_remove_exit(dir, dentry, error);
2042out:
2043 return error;
2044}
2045
2046
2047
2048
2049
2050
2051int nfs_unlink(struct inode *dir, struct dentry *dentry)
2052{
2053 int error;
2054 int need_rehash = 0;
2055
2056 dfprintk(VFS, "NFS: unlink(%s/%lu, %pd)\n", dir->i_sb->s_id,
2057 dir->i_ino, dentry);
2058
2059 trace_nfs_unlink_enter(dir, dentry);
2060 spin_lock(&dentry->d_lock);
2061 if (d_count(dentry) > 1) {
2062 spin_unlock(&dentry->d_lock);
2063
2064 write_inode_now(d_inode(dentry), 0);
2065 error = nfs_sillyrename(dir, dentry);
2066 goto out;
2067 }
2068 if (!d_unhashed(dentry)) {
2069 __d_drop(dentry);
2070 need_rehash = 1;
2071 }
2072 spin_unlock(&dentry->d_lock);
2073 error = nfs_safe_remove(dentry);
2074 if (!error || error == -ENOENT) {
2075 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
2076 } else if (need_rehash)
2077 d_rehash(dentry);
2078out:
2079 trace_nfs_unlink_exit(dir, dentry, error);
2080 return error;
2081}
2082EXPORT_SYMBOL_GPL(nfs_unlink);
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
2100{
2101 struct page *page;
2102 char *kaddr;
2103 struct iattr attr;
2104 unsigned int pathlen = strlen(symname);
2105 int error;
2106
2107 dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s)\n", dir->i_sb->s_id,
2108 dir->i_ino, dentry, symname);
2109
2110 if (pathlen > PAGE_SIZE)
2111 return -ENAMETOOLONG;
2112
2113 attr.ia_mode = S_IFLNK | S_IRWXUGO;
2114 attr.ia_valid = ATTR_MODE;
2115
2116 page = alloc_page(GFP_USER);
2117 if (!page)
2118 return -ENOMEM;
2119
2120 kaddr = page_address(page);
2121 memcpy(kaddr, symname, pathlen);
2122 if (pathlen < PAGE_SIZE)
2123 memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen);
2124
2125 trace_nfs_symlink_enter(dir, dentry);
2126 error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr);
2127 trace_nfs_symlink_exit(dir, dentry, error);
2128 if (error != 0) {
2129 dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s) error %d\n",
2130 dir->i_sb->s_id, dir->i_ino,
2131 dentry, symname, error);
2132 d_drop(dentry);
2133 __free_page(page);
2134 return error;
2135 }
2136
2137
2138
2139
2140
2141 if (!add_to_page_cache_lru(page, d_inode(dentry)->i_mapping, 0,
2142 GFP_KERNEL)) {
2143 SetPageUptodate(page);
2144 unlock_page(page);
2145
2146
2147
2148
2149 put_page(page);
2150 } else
2151 __free_page(page);
2152
2153 return 0;
2154}
2155EXPORT_SYMBOL_GPL(nfs_symlink);
2156
2157int
2158nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
2159{
2160 struct inode *inode = d_inode(old_dentry);
2161 int error;
2162
2163 dfprintk(VFS, "NFS: link(%pd2 -> %pd2)\n",
2164 old_dentry, dentry);
2165
2166 trace_nfs_link_enter(inode, dir, dentry);
2167 d_drop(dentry);
2168 error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
2169 if (error == 0) {
2170 ihold(inode);
2171 d_add(dentry, inode);
2172 }
2173 trace_nfs_link_exit(inode, dir, dentry, error);
2174 return error;
2175}
2176EXPORT_SYMBOL_GPL(nfs_link);
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
2203 struct inode *new_dir, struct dentry *new_dentry,
2204 unsigned int flags)
2205{
2206 struct inode *old_inode = d_inode(old_dentry);
2207 struct inode *new_inode = d_inode(new_dentry);
2208 struct dentry *dentry = NULL, *rehash = NULL;
2209 struct rpc_task *task;
2210 int error = -EBUSY;
2211
2212 if (flags)
2213 return -EINVAL;
2214
2215 dfprintk(VFS, "NFS: rename(%pd2 -> %pd2, ct=%d)\n",
2216 old_dentry, new_dentry,
2217 d_count(new_dentry));
2218
2219 trace_nfs_rename_enter(old_dir, old_dentry, new_dir, new_dentry);
2220
2221
2222
2223
2224
2225
2226 if (new_inode && !S_ISDIR(new_inode->i_mode)) {
2227
2228
2229
2230
2231 if (!d_unhashed(new_dentry)) {
2232 d_drop(new_dentry);
2233 rehash = new_dentry;
2234 }
2235
2236 if (d_count(new_dentry) > 2) {
2237 int err;
2238
2239
2240 dentry = d_alloc(new_dentry->d_parent,
2241 &new_dentry->d_name);
2242 if (!dentry)
2243 goto out;
2244
2245
2246 err = nfs_sillyrename(new_dir, new_dentry);
2247 if (err)
2248 goto out;
2249
2250 new_dentry = dentry;
2251 rehash = NULL;
2252 new_inode = NULL;
2253 }
2254 }
2255
2256 task = nfs_async_rename(old_dir, new_dir, old_dentry, new_dentry, NULL);
2257 if (IS_ERR(task)) {
2258 error = PTR_ERR(task);
2259 goto out;
2260 }
2261
2262 error = rpc_wait_for_completion_task(task);
2263 if (error != 0) {
2264 ((struct nfs_renamedata *)task->tk_calldata)->cancelled = 1;
2265
2266 smp_wmb();
2267 } else
2268 error = task->tk_status;
2269 rpc_put_task(task);
2270
2271 if (error == 0) {
2272 spin_lock(&old_inode->i_lock);
2273 NFS_I(old_inode)->attr_gencount = nfs_inc_attr_generation_counter();
2274 NFS_I(old_inode)->cache_validity |= NFS_INO_INVALID_CHANGE
2275 | NFS_INO_INVALID_CTIME
2276 | NFS_INO_REVAL_FORCED;
2277 spin_unlock(&old_inode->i_lock);
2278 }
2279out:
2280 if (rehash)
2281 d_rehash(rehash);
2282 trace_nfs_rename_exit(old_dir, old_dentry,
2283 new_dir, new_dentry, error);
2284 if (!error) {
2285 if (new_inode != NULL)
2286 nfs_drop_nlink(new_inode);
2287
2288
2289
2290
2291
2292
2293 d_move(old_dentry, new_dentry);
2294 nfs_set_verifier(old_dentry,
2295 nfs_save_change_attribute(new_dir));
2296 } else if (error == -ENOENT)
2297 nfs_dentry_handle_enoent(old_dentry);
2298
2299
2300 if (dentry)
2301 dput(dentry);
2302 return error;
2303}
2304EXPORT_SYMBOL_GPL(nfs_rename);
2305
2306static DEFINE_SPINLOCK(nfs_access_lru_lock);
2307static LIST_HEAD(nfs_access_lru_list);
2308static atomic_long_t nfs_access_nr_entries;
2309
2310static unsigned long nfs_access_max_cachesize = 4*1024*1024;
2311module_param(nfs_access_max_cachesize, ulong, 0644);
2312MODULE_PARM_DESC(nfs_access_max_cachesize, "NFS access maximum total cache length");
2313
2314static void nfs_access_free_entry(struct nfs_access_entry *entry)
2315{
2316 put_cred(entry->cred);
2317 kfree_rcu(entry, rcu_head);
2318 smp_mb__before_atomic();
2319 atomic_long_dec(&nfs_access_nr_entries);
2320 smp_mb__after_atomic();
2321}
2322
2323static void nfs_access_free_list(struct list_head *head)
2324{
2325 struct nfs_access_entry *cache;
2326
2327 while (!list_empty(head)) {
2328 cache = list_entry(head->next, struct nfs_access_entry, lru);
2329 list_del(&cache->lru);
2330 nfs_access_free_entry(cache);
2331 }
2332}
2333
2334static unsigned long
2335nfs_do_access_cache_scan(unsigned int nr_to_scan)
2336{
2337 LIST_HEAD(head);
2338 struct nfs_inode *nfsi, *next;
2339 struct nfs_access_entry *cache;
2340 long freed = 0;
2341
2342 spin_lock(&nfs_access_lru_lock);
2343 list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) {
2344 struct inode *inode;
2345
2346 if (nr_to_scan-- == 0)
2347 break;
2348 inode = &nfsi->vfs_inode;
2349 spin_lock(&inode->i_lock);
2350 if (list_empty(&nfsi->access_cache_entry_lru))
2351 goto remove_lru_entry;
2352 cache = list_entry(nfsi->access_cache_entry_lru.next,
2353 struct nfs_access_entry, lru);
2354 list_move(&cache->lru, &head);
2355 rb_erase(&cache->rb_node, &nfsi->access_cache);
2356 freed++;
2357 if (!list_empty(&nfsi->access_cache_entry_lru))
2358 list_move_tail(&nfsi->access_cache_inode_lru,
2359 &nfs_access_lru_list);
2360 else {
2361remove_lru_entry:
2362 list_del_init(&nfsi->access_cache_inode_lru);
2363 smp_mb__before_atomic();
2364 clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags);
2365 smp_mb__after_atomic();
2366 }
2367 spin_unlock(&inode->i_lock);
2368 }
2369 spin_unlock(&nfs_access_lru_lock);
2370 nfs_access_free_list(&head);
2371 return freed;
2372}
2373
2374unsigned long
2375nfs_access_cache_scan(struct shrinker *shrink, struct shrink_control *sc)
2376{
2377 int nr_to_scan = sc->nr_to_scan;
2378 gfp_t gfp_mask = sc->gfp_mask;
2379
2380 if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL)
2381 return SHRINK_STOP;
2382 return nfs_do_access_cache_scan(nr_to_scan);
2383}
2384
2385
2386unsigned long
2387nfs_access_cache_count(struct shrinker *shrink, struct shrink_control *sc)
2388{
2389 return vfs_pressure_ratio(atomic_long_read(&nfs_access_nr_entries));
2390}
2391
2392static void
2393nfs_access_cache_enforce_limit(void)
2394{
2395 long nr_entries = atomic_long_read(&nfs_access_nr_entries);
2396 unsigned long diff;
2397 unsigned int nr_to_scan;
2398
2399 if (nr_entries < 0 || nr_entries <= nfs_access_max_cachesize)
2400 return;
2401 nr_to_scan = 100;
2402 diff = nr_entries - nfs_access_max_cachesize;
2403 if (diff < nr_to_scan)
2404 nr_to_scan = diff;
2405 nfs_do_access_cache_scan(nr_to_scan);
2406}
2407
2408static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head)
2409{
2410 struct rb_root *root_node = &nfsi->access_cache;
2411 struct rb_node *n;
2412 struct nfs_access_entry *entry;
2413
2414
2415 while ((n = rb_first(root_node)) != NULL) {
2416 entry = rb_entry(n, struct nfs_access_entry, rb_node);
2417 rb_erase(n, root_node);
2418 list_move(&entry->lru, head);
2419 }
2420 nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS;
2421}
2422
2423void nfs_access_zap_cache(struct inode *inode)
2424{
2425 LIST_HEAD(head);
2426
2427 if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0)
2428 return;
2429
2430 spin_lock(&nfs_access_lru_lock);
2431 if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
2432 list_del_init(&NFS_I(inode)->access_cache_inode_lru);
2433
2434 spin_lock(&inode->i_lock);
2435 __nfs_access_zap_cache(NFS_I(inode), &head);
2436 spin_unlock(&inode->i_lock);
2437 spin_unlock(&nfs_access_lru_lock);
2438 nfs_access_free_list(&head);
2439}
2440EXPORT_SYMBOL_GPL(nfs_access_zap_cache);
2441
2442static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, const struct cred *cred)
2443{
2444 struct rb_node *n = NFS_I(inode)->access_cache.rb_node;
2445
2446 while (n != NULL) {
2447 struct nfs_access_entry *entry =
2448 rb_entry(n, struct nfs_access_entry, rb_node);
2449 int cmp = cred_fscmp(cred, entry->cred);
2450
2451 if (cmp < 0)
2452 n = n->rb_left;
2453 else if (cmp > 0)
2454 n = n->rb_right;
2455 else
2456 return entry;
2457 }
2458 return NULL;
2459}
2460
2461static int nfs_access_get_cached_locked(struct inode *inode, const struct cred *cred, struct nfs_access_entry *res, bool may_block)
2462{
2463 struct nfs_inode *nfsi = NFS_I(inode);
2464 struct nfs_access_entry *cache;
2465 bool retry = true;
2466 int err;
2467
2468 spin_lock(&inode->i_lock);
2469 for(;;) {
2470 if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
2471 goto out_zap;
2472 cache = nfs_access_search_rbtree(inode, cred);
2473 err = -ENOENT;
2474 if (cache == NULL)
2475 goto out;
2476
2477 if (!nfs_check_cache_invalid(inode, NFS_INO_INVALID_ACCESS))
2478 break;
2479 if (!retry)
2480 break;
2481 err = -ECHILD;
2482 if (!may_block)
2483 goto out;
2484 spin_unlock(&inode->i_lock);
2485 err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
2486 if (err)
2487 return err;
2488 spin_lock(&inode->i_lock);
2489 retry = false;
2490 }
2491 res->cred = cache->cred;
2492 res->mask = cache->mask;
2493 list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru);
2494 err = 0;
2495out:
2496 spin_unlock(&inode->i_lock);
2497 return err;
2498out_zap:
2499 spin_unlock(&inode->i_lock);
2500 nfs_access_zap_cache(inode);
2501 return -ENOENT;
2502}
2503
2504static int nfs_access_get_cached_rcu(struct inode *inode, const struct cred *cred, struct nfs_access_entry *res)
2505{
2506
2507
2508
2509 struct nfs_inode *nfsi = NFS_I(inode);
2510 struct nfs_access_entry *cache;
2511 int err = -ECHILD;
2512 struct list_head *lh;
2513
2514 rcu_read_lock();
2515 if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
2516 goto out;
2517 lh = rcu_dereference(list_tail_rcu(&nfsi->access_cache_entry_lru));
2518 cache = list_entry(lh, struct nfs_access_entry, lru);
2519 if (lh == &nfsi->access_cache_entry_lru ||
2520 cred_fscmp(cred, cache->cred) != 0)
2521 cache = NULL;
2522 if (cache == NULL)
2523 goto out;
2524 if (nfs_check_cache_invalid(inode, NFS_INO_INVALID_ACCESS))
2525 goto out;
2526 res->cred = cache->cred;
2527 res->mask = cache->mask;
2528 err = 0;
2529out:
2530 rcu_read_unlock();
2531 return err;
2532}
2533
2534int nfs_access_get_cached(struct inode *inode, const struct cred *cred, struct
2535nfs_access_entry *res, bool may_block)
2536{
2537 int status;
2538
2539 status = nfs_access_get_cached_rcu(inode, cred, res);
2540 if (status != 0)
2541 status = nfs_access_get_cached_locked(inode, cred, res,
2542 may_block);
2543
2544 return status;
2545}
2546EXPORT_SYMBOL_GPL(nfs_access_get_cached);
2547
2548static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set)
2549{
2550 struct nfs_inode *nfsi = NFS_I(inode);
2551 struct rb_root *root_node = &nfsi->access_cache;
2552 struct rb_node **p = &root_node->rb_node;
2553 struct rb_node *parent = NULL;
2554 struct nfs_access_entry *entry;
2555 int cmp;
2556
2557 spin_lock(&inode->i_lock);
2558 while (*p != NULL) {
2559 parent = *p;
2560 entry = rb_entry(parent, struct nfs_access_entry, rb_node);
2561 cmp = cred_fscmp(set->cred, entry->cred);
2562
2563 if (cmp < 0)
2564 p = &parent->rb_left;
2565 else if (cmp > 0)
2566 p = &parent->rb_right;
2567 else
2568 goto found;
2569 }
2570 rb_link_node(&set->rb_node, parent, p);
2571 rb_insert_color(&set->rb_node, root_node);
2572 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2573 spin_unlock(&inode->i_lock);
2574 return;
2575found:
2576 rb_replace_node(parent, &set->rb_node, root_node);
2577 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2578 list_del(&entry->lru);
2579 spin_unlock(&inode->i_lock);
2580 nfs_access_free_entry(entry);
2581}
2582
2583void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)
2584{
2585 struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL);
2586 if (cache == NULL)
2587 return;
2588 RB_CLEAR_NODE(&cache->rb_node);
2589 cache->cred = get_cred(set->cred);
2590 cache->mask = set->mask;
2591
2592
2593
2594
2595
2596 smp_wmb();
2597 nfs_access_add_rbtree(inode, cache);
2598
2599
2600 smp_mb__before_atomic();
2601 atomic_long_inc(&nfs_access_nr_entries);
2602 smp_mb__after_atomic();
2603
2604
2605 if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) {
2606 spin_lock(&nfs_access_lru_lock);
2607 if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
2608 list_add_tail(&NFS_I(inode)->access_cache_inode_lru,
2609 &nfs_access_lru_list);
2610 spin_unlock(&nfs_access_lru_lock);
2611 }
2612 nfs_access_cache_enforce_limit();
2613}
2614EXPORT_SYMBOL_GPL(nfs_access_add_cache);
2615
2616#define NFS_MAY_READ (NFS_ACCESS_READ)
2617#define NFS_MAY_WRITE (NFS_ACCESS_MODIFY | \
2618 NFS_ACCESS_EXTEND | \
2619 NFS_ACCESS_DELETE)
2620#define NFS_FILE_MAY_WRITE (NFS_ACCESS_MODIFY | \
2621 NFS_ACCESS_EXTEND)
2622#define NFS_DIR_MAY_WRITE NFS_MAY_WRITE
2623#define NFS_MAY_LOOKUP (NFS_ACCESS_LOOKUP)
2624#define NFS_MAY_EXECUTE (NFS_ACCESS_EXECUTE)
2625static int
2626nfs_access_calc_mask(u32 access_result, umode_t umode)
2627{
2628 int mask = 0;
2629
2630 if (access_result & NFS_MAY_READ)
2631 mask |= MAY_READ;
2632 if (S_ISDIR(umode)) {
2633 if ((access_result & NFS_DIR_MAY_WRITE) == NFS_DIR_MAY_WRITE)
2634 mask |= MAY_WRITE;
2635 if ((access_result & NFS_MAY_LOOKUP) == NFS_MAY_LOOKUP)
2636 mask |= MAY_EXEC;
2637 } else if (S_ISREG(umode)) {
2638 if ((access_result & NFS_FILE_MAY_WRITE) == NFS_FILE_MAY_WRITE)
2639 mask |= MAY_WRITE;
2640 if ((access_result & NFS_MAY_EXECUTE) == NFS_MAY_EXECUTE)
2641 mask |= MAY_EXEC;
2642 } else if (access_result & NFS_MAY_WRITE)
2643 mask |= MAY_WRITE;
2644 return mask;
2645}
2646
2647void nfs_access_set_mask(struct nfs_access_entry *entry, u32 access_result)
2648{
2649 entry->mask = access_result;
2650}
2651EXPORT_SYMBOL_GPL(nfs_access_set_mask);
2652
2653static int nfs_do_access(struct inode *inode, const struct cred *cred, int mask)
2654{
2655 struct nfs_access_entry cache;
2656 bool may_block = (mask & MAY_NOT_BLOCK) == 0;
2657 int cache_mask = -1;
2658 int status;
2659
2660 trace_nfs_access_enter(inode);
2661
2662 status = nfs_access_get_cached(inode, cred, &cache, may_block);
2663 if (status == 0)
2664 goto out_cached;
2665
2666 status = -ECHILD;
2667 if (!may_block)
2668 goto out;
2669
2670
2671
2672
2673 cache.mask = NFS_ACCESS_READ | NFS_ACCESS_MODIFY | NFS_ACCESS_EXTEND;
2674 if (nfs_server_capable(inode, NFS_CAP_XATTR)) {
2675 cache.mask |= NFS_ACCESS_XAREAD | NFS_ACCESS_XAWRITE |
2676 NFS_ACCESS_XALIST;
2677 }
2678 if (S_ISDIR(inode->i_mode))
2679 cache.mask |= NFS_ACCESS_DELETE | NFS_ACCESS_LOOKUP;
2680 else
2681 cache.mask |= NFS_ACCESS_EXECUTE;
2682 cache.cred = cred;
2683 status = NFS_PROTO(inode)->access(inode, &cache);
2684 if (status != 0) {
2685 if (status == -ESTALE) {
2686 if (!S_ISDIR(inode->i_mode))
2687 nfs_set_inode_stale(inode);
2688 else
2689 nfs_zap_caches(inode);
2690 }
2691 goto out;
2692 }
2693 nfs_access_add_cache(inode, &cache);
2694out_cached:
2695 cache_mask = nfs_access_calc_mask(cache.mask, inode->i_mode);
2696 if ((mask & ~cache_mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) != 0)
2697 status = -EACCES;
2698out:
2699 trace_nfs_access_exit(inode, mask, cache_mask, status);
2700 return status;
2701}
2702
2703static int nfs_open_permission_mask(int openflags)
2704{
2705 int mask = 0;
2706
2707 if (openflags & __FMODE_EXEC) {
2708
2709 mask = MAY_EXEC;
2710 } else {
2711 if ((openflags & O_ACCMODE) != O_WRONLY)
2712 mask |= MAY_READ;
2713 if ((openflags & O_ACCMODE) != O_RDONLY)
2714 mask |= MAY_WRITE;
2715 }
2716
2717 return mask;
2718}
2719
2720int nfs_may_open(struct inode *inode, const struct cred *cred, int openflags)
2721{
2722 return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags));
2723}
2724EXPORT_SYMBOL_GPL(nfs_may_open);
2725
2726static int nfs_execute_ok(struct inode *inode, int mask)
2727{
2728 struct nfs_server *server = NFS_SERVER(inode);
2729 int ret = 0;
2730
2731 if (S_ISDIR(inode->i_mode))
2732 return 0;
2733 if (nfs_check_cache_invalid(inode, NFS_INO_INVALID_OTHER)) {
2734 if (mask & MAY_NOT_BLOCK)
2735 return -ECHILD;
2736 ret = __nfs_revalidate_inode(server, inode);
2737 }
2738 if (ret == 0 && !execute_ok(inode))
2739 ret = -EACCES;
2740 return ret;
2741}
2742
2743int nfs_permission(struct inode *inode, int mask)
2744{
2745 const struct cred *cred = current_cred();
2746 int res = 0;
2747
2748 nfs_inc_stats(inode, NFSIOS_VFSACCESS);
2749
2750 if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
2751 goto out;
2752
2753 if (mask & (MAY_ACCESS | MAY_CHDIR))
2754 goto force_lookup;
2755
2756 switch (inode->i_mode & S_IFMT) {
2757 case S_IFLNK:
2758 goto out;
2759 case S_IFREG:
2760 if ((mask & MAY_OPEN) &&
2761 nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN))
2762 return 0;
2763 break;
2764 case S_IFDIR:
2765
2766
2767
2768
2769 if ((mask & MAY_WRITE) && !(mask & MAY_READ))
2770 goto out;
2771 }
2772
2773force_lookup:
2774 if (!NFS_PROTO(inode)->access)
2775 goto out_notsup;
2776
2777 res = nfs_do_access(inode, cred, mask);
2778out:
2779 if (!res && (mask & MAY_EXEC))
2780 res = nfs_execute_ok(inode, mask);
2781
2782 dfprintk(VFS, "NFS: permission(%s/%lu), mask=0x%x, res=%d\n",
2783 inode->i_sb->s_id, inode->i_ino, mask, res);
2784 return res;
2785out_notsup:
2786 if (mask & MAY_NOT_BLOCK)
2787 return -ECHILD;
2788
2789 res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
2790 if (res == 0)
2791 res = generic_permission(inode, mask);
2792 goto out;
2793}
2794EXPORT_SYMBOL_GPL(nfs_permission);
2795
2796
2797
2798
2799
2800
2801
2802