1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/module.h>
21#include <linux/time.h>
22#include <linux/errno.h>
23#include <linux/stat.h>
24#include <linux/fcntl.h>
25#include <linux/string.h>
26#include <linux/kernel.h>
27#include <linux/slab.h>
28#include <linux/mm.h>
29#include <linux/sunrpc/clnt.h>
30#include <linux/nfs_fs.h>
31#include <linux/nfs_mount.h>
32#include <linux/pagemap.h>
33#include <linux/pagevec.h>
34#include <linux/namei.h>
35#include <linux/mount.h>
36#include <linux/swap.h>
37#include <linux/sched.h>
38#include <linux/kmemleak.h>
39#include <linux/xattr.h>
40
41#include "delegation.h"
42#include "iostat.h"
43#include "internal.h"
44#include "fscache.h"
45
46#include "nfstrace.h"
47
48
49
50static int nfs_opendir(struct inode *, struct file *);
51static int nfs_closedir(struct inode *, struct file *);
52static int nfs_readdir(struct file *, struct dir_context *);
53static int nfs_fsync_dir(struct file *, loff_t, loff_t, int);
54static loff_t nfs_llseek_dir(struct file *, loff_t, int);
55static void nfs_readdir_clear_array(struct page*);
56
57const struct file_operations nfs_dir_operations = {
58 .llseek = nfs_llseek_dir,
59 .read = generic_read_dir,
60 .iterate = nfs_readdir,
61 .open = nfs_opendir,
62 .release = nfs_closedir,
63 .fsync = nfs_fsync_dir,
64};
65
66const struct address_space_operations nfs_dir_aops = {
67 .freepage = nfs_readdir_clear_array,
68};
69
70static struct nfs_open_dir_context *alloc_nfs_open_dir_context(struct inode *dir, struct rpc_cred *cred)
71{
72 struct nfs_inode *nfsi = NFS_I(dir);
73 struct nfs_open_dir_context *ctx;
74 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
75 if (ctx != NULL) {
76 ctx->duped = 0;
77 ctx->attr_gencount = nfsi->attr_gencount;
78 ctx->dir_cookie = 0;
79 ctx->dup_cookie = 0;
80 ctx->cred = get_rpccred(cred);
81 spin_lock(&dir->i_lock);
82 list_add(&ctx->list, &nfsi->open_files);
83 spin_unlock(&dir->i_lock);
84 return ctx;
85 }
86 return ERR_PTR(-ENOMEM);
87}
88
89static void put_nfs_open_dir_context(struct inode *dir, struct nfs_open_dir_context *ctx)
90{
91 spin_lock(&dir->i_lock);
92 list_del(&ctx->list);
93 spin_unlock(&dir->i_lock);
94 put_rpccred(ctx->cred);
95 kfree(ctx);
96}
97
98
99
100
101static int
102nfs_opendir(struct inode *inode, struct file *filp)
103{
104 int res = 0;
105 struct nfs_open_dir_context *ctx;
106 struct rpc_cred *cred;
107
108 dfprintk(FILE, "NFS: open dir(%pD2)\n", filp);
109
110 nfs_inc_stats(inode, NFSIOS_VFSOPEN);
111
112 cred = rpc_lookup_cred();
113 if (IS_ERR(cred))
114 return PTR_ERR(cred);
115 ctx = alloc_nfs_open_dir_context(inode, cred);
116 if (IS_ERR(ctx)) {
117 res = PTR_ERR(ctx);
118 goto out;
119 }
120 filp->private_data = ctx;
121 if (filp->f_path.dentry == filp->f_path.mnt->mnt_root) {
122
123
124
125
126 __nfs_revalidate_inode(NFS_SERVER(inode), inode);
127 }
128out:
129 put_rpccred(cred);
130 return res;
131}
132
133static int
134nfs_closedir(struct inode *inode, struct file *filp)
135{
136 put_nfs_open_dir_context(filp->f_path.dentry->d_inode, filp->private_data);
137 return 0;
138}
139
140struct nfs_cache_array_entry {
141 u64 cookie;
142 u64 ino;
143 struct qstr string;
144 unsigned char d_type;
145};
146
147struct nfs_cache_array {
148 int size;
149 int eof_index;
150 u64 last_cookie;
151 struct nfs_cache_array_entry array[0];
152};
153
154typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int);
155typedef struct {
156 struct file *file;
157 struct page *page;
158 struct dir_context *ctx;
159 unsigned long page_index;
160 u64 *dir_cookie;
161 u64 last_cookie;
162 loff_t current_index;
163 decode_dirent_t decode;
164
165 unsigned long timestamp;
166 unsigned long gencount;
167 unsigned int cache_entry_index;
168 unsigned int plus:1;
169 unsigned int eof:1;
170} nfs_readdir_descriptor_t;
171
172
173
174
175static
176struct nfs_cache_array *nfs_readdir_get_array(struct page *page)
177{
178 void *ptr;
179 if (page == NULL)
180 return ERR_PTR(-EIO);
181 ptr = kmap(page);
182 if (ptr == NULL)
183 return ERR_PTR(-ENOMEM);
184 return ptr;
185}
186
187static
188void nfs_readdir_release_array(struct page *page)
189{
190 kunmap(page);
191}
192
193
194
195
196static
197void nfs_readdir_clear_array(struct page *page)
198{
199 struct nfs_cache_array *array;
200 int i;
201
202 array = kmap_atomic(page);
203 for (i = 0; i < array->size; i++)
204 kfree(array->array[i].string.name);
205 kunmap_atomic(array);
206}
207
208
209
210
211
212
213static
214int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len)
215{
216 string->len = len;
217 string->name = kmemdup(name, len, GFP_KERNEL);
218 if (string->name == NULL)
219 return -ENOMEM;
220
221
222
223
224 kmemleak_not_leak(string->name);
225 string->hash = full_name_hash(name, len);
226 return 0;
227}
228
229static
230int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page)
231{
232 struct nfs_cache_array *array = nfs_readdir_get_array(page);
233 struct nfs_cache_array_entry *cache_entry;
234 int ret;
235
236 if (IS_ERR(array))
237 return PTR_ERR(array);
238
239 cache_entry = &array->array[array->size];
240
241
242 ret = -ENOSPC;
243 if ((char *)&cache_entry[1] - (char *)page_address(page) > PAGE_SIZE)
244 goto out;
245
246 cache_entry->cookie = entry->prev_cookie;
247 cache_entry->ino = entry->ino;
248 cache_entry->d_type = entry->d_type;
249 ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len);
250 if (ret)
251 goto out;
252 array->last_cookie = entry->cookie;
253 array->size++;
254 if (entry->eof != 0)
255 array->eof_index = array->size;
256out:
257 nfs_readdir_release_array(page);
258 return ret;
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 = 1;
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->ctx->pos) {
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 desc->ctx->pos = new_pos;
327 desc->cache_entry_index = i;
328 return 0;
329 }
330 }
331 if (array->eof_index >= 0) {
332 status = -EBADCOOKIE;
333 if (*desc->dir_cookie == array->last_cookie)
334 desc->eof = 1;
335 }
336out:
337 return status;
338}
339
340static
341int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc)
342{
343 struct nfs_cache_array *array;
344 int status;
345
346 array = nfs_readdir_get_array(desc->page);
347 if (IS_ERR(array)) {
348 status = PTR_ERR(array);
349 goto out;
350 }
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 nfs_readdir_release_array(desc->page);
363out:
364 return status;
365}
366
367
368static
369int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc,
370 struct nfs_entry *entry, struct file *file, struct inode *inode)
371{
372 struct nfs_open_dir_context *ctx = file->private_data;
373 struct rpc_cred *cred = ctx->cred;
374 unsigned long timestamp, gencount;
375 int error;
376
377 again:
378 timestamp = jiffies;
379 gencount = nfs_inc_attr_generation_counter();
380 error = NFS_PROTO(inode)->readdir(file->f_path.dentry, 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 = 0;
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 int error;
402
403 error = desc->decode(xdr, entry, desc->plus);
404 if (error)
405 return error;
406 entry->fattr->time_start = desc->timestamp;
407 entry->fattr->gencount = desc->gencount;
408 return 0;
409}
410
411static
412int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry)
413{
414 if (dentry->d_inode == NULL)
415 goto different;
416 if (nfs_compare_fh(entry->fh, NFS_FH(dentry->d_inode)) != 0)
417 goto different;
418 return 1;
419different:
420 return 0;
421}
422
423static
424bool nfs_use_readdirplus(struct inode *dir, struct dir_context *ctx)
425{
426 if (!nfs_server_capable(dir, NFS_CAP_READDIRPLUS))
427 return false;
428 if (test_and_clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags))
429 return true;
430 if (ctx->pos == 0)
431 return true;
432 return false;
433}
434
435
436
437
438
439
440static
441void nfs_advise_use_readdirplus(struct inode *dir)
442{
443 set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags);
444}
445
446
447
448
449
450
451
452
453
454void nfs_force_use_readdirplus(struct inode *dir)
455{
456 if (!list_empty(&NFS_I(dir)->open_files)) {
457 nfs_advise_use_readdirplus(dir);
458 nfs_zap_mapping(dir, dir->i_mapping);
459 }
460}
461
462static
463void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
464{
465 struct qstr filename = QSTR_INIT(entry->name, entry->len);
466 struct dentry *dentry;
467 struct dentry *alias;
468 struct inode *dir = parent->d_inode;
469 struct inode *inode;
470 int status;
471
472 if (filename.name[0] == '.') {
473 if (filename.len == 1)
474 return;
475 if (filename.len == 2 && filename.name[1] == '.')
476 return;
477 }
478 filename.hash = full_name_hash(filename.name, filename.len);
479
480 dentry = d_lookup(parent, &filename);
481 if (dentry != NULL) {
482 if (nfs_same_file(dentry, entry)) {
483 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
484 status = nfs_refresh_inode(dentry->d_inode, entry->fattr);
485 if (!status)
486 nfs_setsecurity(dentry->d_inode, entry->fattr, entry->label);
487 goto out;
488 } else {
489 if (d_invalidate(dentry) != 0)
490 goto out;
491 dput(dentry);
492 }
493 }
494
495 dentry = d_alloc(parent, &filename);
496 if (dentry == NULL)
497 return;
498
499 inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr, entry->label);
500 if (IS_ERR(inode))
501 goto out;
502
503 alias = d_materialise_unique(dentry, inode);
504 if (IS_ERR(alias))
505 goto out;
506 else if (alias) {
507 nfs_set_verifier(alias, nfs_save_change_attribute(dir));
508 dput(alias);
509 } else
510 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
511
512out:
513 dput(dentry);
514}
515
516
517static
518int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry,
519 struct page **xdr_pages, struct page *page, unsigned int buflen)
520{
521 struct xdr_stream stream;
522 struct xdr_buf buf;
523 struct page *scratch;
524 struct nfs_cache_array *array;
525 unsigned int count = 0;
526 int status;
527
528 scratch = alloc_page(GFP_KERNEL);
529 if (scratch == NULL)
530 return -ENOMEM;
531
532 xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen);
533 xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
534
535 do {
536 status = xdr_decode(desc, entry, &stream);
537 if (status != 0) {
538 if (status == -EAGAIN)
539 status = 0;
540 break;
541 }
542
543 count++;
544
545 if (desc->plus != 0)
546 nfs_prime_dcache(desc->file->f_path.dentry, entry);
547
548 status = nfs_readdir_add_to_array(entry, page);
549 if (status != 0)
550 break;
551 } while (!entry->eof);
552
553 if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) {
554 array = nfs_readdir_get_array(page);
555 if (!IS_ERR(array)) {
556 array->eof_index = array->size;
557 status = 0;
558 nfs_readdir_release_array(page);
559 } else
560 status = PTR_ERR(array);
561 }
562
563 put_page(scratch);
564 return status;
565}
566
567static
568void nfs_readdir_free_pagearray(struct page **pages, unsigned int npages)
569{
570 unsigned int i;
571 for (i = 0; i < npages; i++)
572 put_page(pages[i]);
573}
574
575static
576void nfs_readdir_free_large_page(void *ptr, struct page **pages,
577 unsigned int npages)
578{
579 nfs_readdir_free_pagearray(pages, npages);
580}
581
582
583
584
585
586static
587int nfs_readdir_large_page(struct page **pages, unsigned int npages)
588{
589 unsigned int i;
590
591 for (i = 0; i < npages; i++) {
592 struct page *page = alloc_page(GFP_KERNEL);
593 if (page == NULL)
594 goto out_freepages;
595 pages[i] = page;
596 }
597 return 0;
598
599out_freepages:
600 nfs_readdir_free_pagearray(pages, i);
601 return -ENOMEM;
602}
603
604static
605int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode)
606{
607 struct page *pages[NFS_MAX_READDIR_PAGES];
608 void *pages_ptr = NULL;
609 struct nfs_entry entry;
610 struct file *file = desc->file;
611 struct nfs_cache_array *array;
612 int status = -ENOMEM;
613 unsigned int array_size = ARRAY_SIZE(pages);
614
615 entry.prev_cookie = 0;
616 entry.cookie = desc->last_cookie;
617 entry.eof = 0;
618 entry.fh = nfs_alloc_fhandle();
619 entry.fattr = nfs_alloc_fattr();
620 entry.server = NFS_SERVER(inode);
621 if (entry.fh == NULL || entry.fattr == NULL)
622 goto out;
623
624 entry.label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
625 if (IS_ERR(entry.label)) {
626 status = PTR_ERR(entry.label);
627 goto out;
628 }
629
630 array = nfs_readdir_get_array(page);
631 if (IS_ERR(array)) {
632 status = PTR_ERR(array);
633 goto out_label_free;
634 }
635 memset(array, 0, sizeof(struct nfs_cache_array));
636 array->eof_index = -1;
637
638 status = nfs_readdir_large_page(pages, array_size);
639 if (status < 0)
640 goto out_release_array;
641 do {
642 unsigned int pglen;
643 status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode);
644
645 if (status < 0)
646 break;
647 pglen = status;
648 status = nfs_readdir_page_filler(desc, &entry, pages, page, pglen);
649 if (status < 0) {
650 if (status == -ENOSPC)
651 status = 0;
652 break;
653 }
654 } while (array->eof_index < 0);
655
656 nfs_readdir_free_large_page(pages_ptr, pages, array_size);
657out_release_array:
658 nfs_readdir_release_array(page);
659out_label_free:
660 nfs4_label_free(entry.label);
661out:
662 nfs_free_fattr(entry.fattr);
663 nfs_free_fhandle(entry.fh);
664 return status;
665}
666
667
668
669
670
671
672
673static
674int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page)
675{
676 struct inode *inode = file_inode(desc->file);
677 int ret;
678
679 ret = nfs_readdir_xdr_to_array(desc, page, inode);
680 if (ret < 0)
681 goto error;
682 SetPageUptodate(page);
683
684 if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) {
685
686 nfs_zap_mapping(inode, inode->i_mapping);
687 }
688 unlock_page(page);
689 return 0;
690 error:
691 unlock_page(page);
692 return ret;
693}
694
695static
696void cache_page_release(nfs_readdir_descriptor_t *desc)
697{
698 if (!desc->page->mapping)
699 nfs_readdir_clear_array(desc->page);
700 page_cache_release(desc->page);
701 desc->page = NULL;
702}
703
704static
705struct page *get_cache_page(nfs_readdir_descriptor_t *desc)
706{
707 return read_cache_page(file_inode(desc->file)->i_mapping,
708 desc->page_index, (filler_t *)nfs_readdir_filler, desc);
709}
710
711
712
713
714static
715int find_cache_page(nfs_readdir_descriptor_t *desc)
716{
717 int res;
718
719 desc->page = get_cache_page(desc);
720 if (IS_ERR(desc->page))
721 return PTR_ERR(desc->page);
722
723 res = nfs_readdir_search_array(desc);
724 if (res != 0)
725 cache_page_release(desc);
726 return res;
727}
728
729
730static inline
731int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
732{
733 int res;
734
735 if (desc->page_index == 0) {
736 desc->current_index = 0;
737 desc->last_cookie = 0;
738 }
739 do {
740 res = find_cache_page(desc);
741 } while (res == -EAGAIN);
742 return res;
743}
744
745
746
747
748static
749int nfs_do_filldir(nfs_readdir_descriptor_t *desc)
750{
751 struct file *file = desc->file;
752 int i = 0;
753 int res = 0;
754 struct nfs_cache_array *array = NULL;
755 struct nfs_open_dir_context *ctx = file->private_data;
756
757 array = nfs_readdir_get_array(desc->page);
758 if (IS_ERR(array)) {
759 res = PTR_ERR(array);
760 goto out;
761 }
762
763 for (i = desc->cache_entry_index; i < array->size; i++) {
764 struct nfs_cache_array_entry *ent;
765
766 ent = &array->array[i];
767 if (!dir_emit(desc->ctx, ent->string.name, ent->string.len,
768 nfs_compat_user_ino64(ent->ino), ent->d_type)) {
769 desc->eof = 1;
770 break;
771 }
772 desc->ctx->pos++;
773 if (i < (array->size-1))
774 *desc->dir_cookie = array->array[i+1].cookie;
775 else
776 *desc->dir_cookie = array->last_cookie;
777 if (ctx->duped != 0)
778 ctx->duped = 1;
779 }
780 if (array->eof_index >= 0)
781 desc->eof = 1;
782
783 nfs_readdir_release_array(desc->page);
784out:
785 cache_page_release(desc);
786 dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n",
787 (unsigned long long)*desc->dir_cookie, res);
788 return res;
789}
790
791
792
793
794
795
796
797
798
799
800
801
802
803static inline
804int uncached_readdir(nfs_readdir_descriptor_t *desc)
805{
806 struct page *page = NULL;
807 int status;
808 struct inode *inode = file_inode(desc->file);
809 struct nfs_open_dir_context *ctx = desc->file->private_data;
810
811 dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
812 (unsigned long long)*desc->dir_cookie);
813
814 page = alloc_page(GFP_HIGHUSER);
815 if (!page) {
816 status = -ENOMEM;
817 goto out;
818 }
819
820 desc->page_index = 0;
821 desc->last_cookie = *desc->dir_cookie;
822 desc->page = page;
823 ctx->duped = 0;
824
825 status = nfs_readdir_xdr_to_array(desc, page, inode);
826 if (status < 0)
827 goto out_release;
828
829 status = nfs_do_filldir(desc);
830
831 out:
832 dfprintk(DIRCACHE, "NFS: %s: returns %d\n",
833 __func__, status);
834 return status;
835 out_release:
836 cache_page_release(desc);
837 goto out;
838}
839
840static bool nfs_dir_mapping_need_revalidate(struct inode *dir)
841{
842 struct nfs_inode *nfsi = NFS_I(dir);
843
844 if (nfs_attribute_cache_expired(dir))
845 return true;
846 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
847 return true;
848 return false;
849}
850
851
852
853
854
855static int nfs_readdir(struct file *file, struct dir_context *ctx)
856{
857 struct dentry *dentry = file->f_path.dentry;
858 struct inode *inode = dentry->d_inode;
859 nfs_readdir_descriptor_t my_desc,
860 *desc = &my_desc;
861 struct nfs_open_dir_context *dir_ctx = file->private_data;
862 int res = 0;
863
864 dfprintk(FILE, "NFS: readdir(%pD2) starting at cookie %llu\n",
865 file, (long long)ctx->pos);
866 nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);
867
868
869
870
871
872
873
874 memset(desc, 0, sizeof(*desc));
875
876 desc->file = file;
877 desc->ctx = ctx;
878 desc->dir_cookie = &dir_ctx->dir_cookie;
879 desc->decode = NFS_PROTO(inode)->decode_dirent;
880 desc->plus = nfs_use_readdirplus(inode, ctx) ? 1 : 0;
881
882 nfs_block_sillyrename(dentry);
883 if (ctx->pos == 0 || nfs_dir_mapping_need_revalidate(inode))
884 res = nfs_revalidate_mapping(inode, file->f_mapping);
885 if (res < 0)
886 goto out;
887
888 do {
889 res = readdir_search_pagecache(desc);
890
891 if (res == -EBADCOOKIE) {
892 res = 0;
893
894 if (*desc->dir_cookie && desc->eof == 0) {
895
896 res = uncached_readdir(desc);
897 if (res == 0)
898 continue;
899 }
900 break;
901 }
902 if (res == -ETOOSMALL && desc->plus) {
903 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
904 nfs_zap_caches(inode);
905 desc->page_index = 0;
906 desc->plus = 0;
907 desc->eof = 0;
908 continue;
909 }
910 if (res < 0)
911 break;
912
913 res = nfs_do_filldir(desc);
914 if (res < 0)
915 break;
916 } while (!desc->eof);
917out:
918 nfs_unblock_sillyrename(dentry);
919 if (res > 0)
920 res = 0;
921 dfprintk(FILE, "NFS: readdir(%pD2) returns %d\n", file, res);
922 return res;
923}
924
925static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int whence)
926{
927 struct inode *inode = file_inode(filp);
928 struct nfs_open_dir_context *dir_ctx = filp->private_data;
929
930 dfprintk(FILE, "NFS: llseek dir(%pD2, %lld, %d)\n",
931 filp, offset, whence);
932
933 mutex_lock(&inode->i_mutex);
934 switch (whence) {
935 case 1:
936 offset += filp->f_pos;
937 case 0:
938 if (offset >= 0)
939 break;
940 default:
941 offset = -EINVAL;
942 goto out;
943 }
944 if (offset != filp->f_pos) {
945 filp->f_pos = offset;
946 dir_ctx->dir_cookie = 0;
947 dir_ctx->duped = 0;
948 }
949out:
950 mutex_unlock(&inode->i_mutex);
951 return offset;
952}
953
954
955
956
957
958static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
959 int datasync)
960{
961 struct inode *inode = file_inode(filp);
962
963 dfprintk(FILE, "NFS: fsync dir(%pD2) datasync %d\n", filp, datasync);
964
965 mutex_lock(&inode->i_mutex);
966 nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
967 mutex_unlock(&inode->i_mutex);
968 return 0;
969}
970
971
972
973
974
975
976
977
978
979
980
981void nfs_force_lookup_revalidate(struct inode *dir)
982{
983 NFS_I(dir)->cache_change_attribute++;
984}
985EXPORT_SYMBOL_GPL(nfs_force_lookup_revalidate);
986
987
988
989
990
991
992static int nfs_check_verifier(struct inode *dir, struct dentry *dentry)
993{
994 if (IS_ROOT(dentry))
995 return 1;
996 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
997 return 0;
998 if (!nfs_verify_change_attribute(dir, dentry->d_time))
999 return 0;
1000
1001 if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0)
1002 return 0;
1003 if (!nfs_verify_change_attribute(dir, dentry->d_time))
1004 return 0;
1005 return 1;
1006}
1007
1008
1009
1010
1011
1012static int nfs_is_exclusive_create(struct inode *dir, unsigned int flags)
1013{
1014 if (NFS_PROTO(dir)->version == 2)
1015 return 0;
1016 return flags & LOOKUP_EXCL;
1017}
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027static
1028int nfs_lookup_verify_inode(struct inode *inode, unsigned int flags)
1029{
1030 struct nfs_server *server = NFS_SERVER(inode);
1031 int ret;
1032
1033 if (IS_AUTOMOUNT(inode))
1034 return 0;
1035
1036 if (flags & LOOKUP_REVAL)
1037 goto out_force;
1038
1039 if ((flags & LOOKUP_OPEN) && !(server->flags & NFS_MOUNT_NOCTO) &&
1040 (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)))
1041 goto out_force;
1042out:
1043 return (inode->i_nlink == 0) ? -ENOENT : 0;
1044out_force:
1045 ret = __nfs_revalidate_inode(server, inode);
1046 if (ret != 0)
1047 return ret;
1048 goto out;
1049}
1050
1051
1052
1053
1054
1055
1056
1057
1058static inline
1059int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
1060 unsigned int flags)
1061{
1062
1063 if (flags & LOOKUP_CREATE)
1064 return 0;
1065 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
1066 return 1;
1067 return !nfs_check_verifier(dir, dentry);
1068}
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
1082{
1083 struct inode *dir;
1084 struct inode *inode;
1085 struct dentry *parent;
1086 struct nfs_fh *fhandle = NULL;
1087 struct nfs_fattr *fattr = NULL;
1088 struct nfs4_label *label = NULL;
1089 int error;
1090
1091 if (flags & LOOKUP_RCU)
1092 return -ECHILD;
1093
1094 parent = dget_parent(dentry);
1095 dir = parent->d_inode;
1096 nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
1097 inode = dentry->d_inode;
1098
1099 if (!inode) {
1100 if (nfs_neg_need_reval(dir, dentry, flags))
1101 goto out_bad;
1102 goto out_valid_noent;
1103 }
1104
1105 if (is_bad_inode(inode)) {
1106 dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n",
1107 __func__, dentry);
1108 goto out_bad;
1109 }
1110
1111 if (NFS_PROTO(dir)->have_delegation(inode, FMODE_READ))
1112 goto out_set_verifier;
1113
1114
1115 if (!nfs_is_exclusive_create(dir, flags) && nfs_check_verifier(dir, dentry)) {
1116 if (nfs_lookup_verify_inode(inode, flags))
1117 goto out_zap_parent;
1118 goto out_valid;
1119 }
1120
1121 if (NFS_STALE(inode))
1122 goto out_bad;
1123
1124 error = -ENOMEM;
1125 fhandle = nfs_alloc_fhandle();
1126 fattr = nfs_alloc_fattr();
1127 if (fhandle == NULL || fattr == NULL)
1128 goto out_error;
1129
1130 label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
1131 if (IS_ERR(label))
1132 goto out_error;
1133
1134 trace_nfs_lookup_revalidate_enter(dir, dentry, flags);
1135 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
1136 trace_nfs_lookup_revalidate_exit(dir, dentry, flags, error);
1137 if (error)
1138 goto out_bad;
1139 if (nfs_compare_fh(NFS_FH(inode), fhandle))
1140 goto out_bad;
1141 if ((error = nfs_refresh_inode(inode, fattr)) != 0)
1142 goto out_bad;
1143
1144 nfs_setsecurity(inode, fattr, label);
1145
1146 nfs_free_fattr(fattr);
1147 nfs_free_fhandle(fhandle);
1148 nfs4_label_free(label);
1149
1150out_set_verifier:
1151 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1152 out_valid:
1153
1154 nfs_advise_use_readdirplus(dir);
1155 out_valid_noent:
1156 dput(parent);
1157 dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is valid\n",
1158 __func__, dentry);
1159 return 1;
1160out_zap_parent:
1161 nfs_zap_caches(dir);
1162 out_bad:
1163 nfs_free_fattr(fattr);
1164 nfs_free_fhandle(fhandle);
1165 nfs4_label_free(label);
1166 nfs_mark_for_revalidate(dir);
1167 if (inode && S_ISDIR(inode->i_mode)) {
1168
1169 nfs_zap_caches(inode);
1170
1171
1172
1173
1174
1175
1176 if (IS_ROOT(dentry))
1177 goto out_valid;
1178 }
1179
1180 if (check_submounts_and_drop(dentry) != 0)
1181 goto out_valid;
1182
1183 dput(parent);
1184 dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is invalid\n",
1185 __func__, dentry);
1186 return 0;
1187out_error:
1188 nfs_free_fattr(fattr);
1189 nfs_free_fhandle(fhandle);
1190 nfs4_label_free(label);
1191 dput(parent);
1192 dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) lookup returned error %d\n",
1193 __func__, dentry, error);
1194 return error;
1195}
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206static int nfs_weak_revalidate(struct dentry *dentry, unsigned int flags)
1207{
1208 int error;
1209 struct inode *inode = dentry->d_inode;
1210
1211
1212
1213
1214
1215
1216 if (!inode) {
1217 dfprintk(LOOKUPCACHE, "%s: %pd2 has negative inode\n",
1218 __func__, dentry);
1219 return 1;
1220 }
1221
1222 if (is_bad_inode(inode)) {
1223 dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n",
1224 __func__, dentry);
1225 return 0;
1226 }
1227
1228 error = nfs_revalidate_inode(NFS_SERVER(inode), inode);
1229 dfprintk(LOOKUPCACHE, "NFS: %s: inode %lu is %s\n",
1230 __func__, inode->i_ino, error ? "invalid" : "valid");
1231 return !error;
1232}
1233
1234
1235
1236
1237static int nfs_dentry_delete(const struct dentry *dentry)
1238{
1239 dfprintk(VFS, "NFS: dentry_delete(%pd2, %x)\n",
1240 dentry, dentry->d_flags);
1241
1242
1243 if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode))
1244 return 1;
1245
1246 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1247
1248 return 1;
1249 }
1250 if (!(dentry->d_sb->s_flags & MS_ACTIVE)) {
1251
1252
1253 return 1;
1254 }
1255 return 0;
1256
1257}
1258
1259
1260static void nfs_drop_nlink(struct inode *inode)
1261{
1262 spin_lock(&inode->i_lock);
1263
1264 if (inode->i_nlink == 1)
1265 clear_nlink(inode);
1266 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;
1267 spin_unlock(&inode->i_lock);
1268}
1269
1270
1271
1272
1273
1274static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode)
1275{
1276 if (S_ISDIR(inode->i_mode))
1277
1278 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
1279
1280 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1281 nfs_complete_unlink(dentry, inode);
1282 nfs_drop_nlink(inode);
1283 }
1284 iput(inode);
1285}
1286
1287static void nfs_d_release(struct dentry *dentry)
1288{
1289
1290 if (unlikely(dentry->d_fsdata)) {
1291 if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
1292 WARN_ON(1);
1293 else
1294 kfree(dentry->d_fsdata);
1295 }
1296}
1297
1298const struct dentry_operations nfs_dentry_operations = {
1299 .d_revalidate = nfs_lookup_revalidate,
1300 .d_weak_revalidate = nfs_weak_revalidate,
1301 .d_delete = nfs_dentry_delete,
1302 .d_iput = nfs_dentry_iput,
1303 .d_automount = nfs_d_automount,
1304 .d_release = nfs_d_release,
1305};
1306EXPORT_SYMBOL_GPL(nfs_dentry_operations);
1307
1308struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
1309{
1310 struct dentry *res;
1311 struct dentry *parent;
1312 struct inode *inode = NULL;
1313 struct nfs_fh *fhandle = NULL;
1314 struct nfs_fattr *fattr = NULL;
1315 struct nfs4_label *label = NULL;
1316 int error;
1317
1318 dfprintk(VFS, "NFS: lookup(%pd2)\n", dentry);
1319 nfs_inc_stats(dir, NFSIOS_VFSLOOKUP);
1320
1321 res = ERR_PTR(-ENAMETOOLONG);
1322 if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
1323 goto out;
1324
1325
1326
1327
1328
1329 if (nfs_is_exclusive_create(dir, flags)) {
1330 d_instantiate(dentry, NULL);
1331 res = NULL;
1332 goto out;
1333 }
1334
1335 res = ERR_PTR(-ENOMEM);
1336 fhandle = nfs_alloc_fhandle();
1337 fattr = nfs_alloc_fattr();
1338 if (fhandle == NULL || fattr == NULL)
1339 goto out;
1340
1341 label = nfs4_label_alloc(NFS_SERVER(dir), GFP_NOWAIT);
1342 if (IS_ERR(label))
1343 goto out;
1344
1345 parent = dentry->d_parent;
1346
1347 trace_nfs_lookup_enter(dir, dentry, flags);
1348 nfs_block_sillyrename(parent);
1349 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
1350 if (error == -ENOENT)
1351 goto no_entry;
1352 if (error < 0) {
1353 res = ERR_PTR(error);
1354 goto out_unblock_sillyrename;
1355 }
1356 inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
1357 res = ERR_CAST(inode);
1358 if (IS_ERR(res))
1359 goto out_unblock_sillyrename;
1360
1361
1362 nfs_advise_use_readdirplus(dir);
1363
1364no_entry:
1365 res = d_materialise_unique(dentry, inode);
1366 if (res != NULL) {
1367 if (IS_ERR(res))
1368 goto out_unblock_sillyrename;
1369 dentry = res;
1370 }
1371 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1372out_unblock_sillyrename:
1373 nfs_unblock_sillyrename(parent);
1374 trace_nfs_lookup_exit(dir, dentry, flags, error);
1375 nfs4_label_free(label);
1376out:
1377 nfs_free_fattr(fattr);
1378 nfs_free_fhandle(fhandle);
1379 return res;
1380}
1381EXPORT_SYMBOL_GPL(nfs_lookup);
1382
1383#if IS_ENABLED(CONFIG_NFS_V4)
1384static int nfs4_lookup_revalidate(struct dentry *, unsigned int);
1385
1386const struct dentry_operations nfs4_dentry_operations = {
1387 .d_revalidate = nfs4_lookup_revalidate,
1388 .d_delete = nfs_dentry_delete,
1389 .d_iput = nfs_dentry_iput,
1390 .d_automount = nfs_d_automount,
1391 .d_release = nfs_d_release,
1392};
1393EXPORT_SYMBOL_GPL(nfs4_dentry_operations);
1394
1395static fmode_t flags_to_mode(int flags)
1396{
1397 fmode_t res = (__force fmode_t)flags & FMODE_EXEC;
1398 if ((flags & O_ACCMODE) != O_WRONLY)
1399 res |= FMODE_READ;
1400 if ((flags & O_ACCMODE) != O_RDONLY)
1401 res |= FMODE_WRITE;
1402 return res;
1403}
1404
1405static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags)
1406{
1407 return alloc_nfs_open_context(dentry, flags_to_mode(open_flags));
1408}
1409
1410static int do_open(struct inode *inode, struct file *filp)
1411{
1412 nfs_fscache_open_file(inode, filp);
1413 return 0;
1414}
1415
1416static int nfs_finish_open(struct nfs_open_context *ctx,
1417 struct dentry *dentry,
1418 struct file *file, unsigned open_flags,
1419 int *opened)
1420{
1421 int err;
1422
1423 if ((open_flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
1424 *opened |= FILE_CREATED;
1425
1426 err = finish_open(file, dentry, do_open, opened);
1427 if (err)
1428 goto out;
1429 nfs_file_set_open_context(file, ctx);
1430
1431out:
1432 return err;
1433}
1434
1435int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
1436 struct file *file, unsigned open_flags,
1437 umode_t mode, int *opened)
1438{
1439 struct nfs_open_context *ctx;
1440 struct dentry *res;
1441 struct iattr attr = { .ia_valid = ATTR_OPEN };
1442 struct inode *inode;
1443 unsigned int lookup_flags = 0;
1444 int err;
1445
1446
1447 BUG_ON(dentry->d_inode);
1448
1449 dfprintk(VFS, "NFS: atomic_open(%s/%lu), %pd\n",
1450 dir->i_sb->s_id, dir->i_ino, dentry);
1451
1452 err = nfs_check_flags(open_flags);
1453 if (err)
1454 return err;
1455
1456
1457 if ((open_flags & O_DIRECTORY)) {
1458 if (!d_unhashed(dentry)) {
1459
1460
1461
1462
1463
1464 return -ENOENT;
1465 }
1466 lookup_flags = LOOKUP_OPEN|LOOKUP_DIRECTORY;
1467 goto no_open;
1468 }
1469
1470 if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
1471 return -ENAMETOOLONG;
1472
1473 if (open_flags & O_CREAT) {
1474 attr.ia_valid |= ATTR_MODE;
1475 attr.ia_mode = mode & ~current_umask();
1476 }
1477 if (open_flags & O_TRUNC) {
1478 attr.ia_valid |= ATTR_SIZE;
1479 attr.ia_size = 0;
1480 }
1481
1482 ctx = create_nfs_open_context(dentry, open_flags);
1483 err = PTR_ERR(ctx);
1484 if (IS_ERR(ctx))
1485 goto out;
1486
1487 trace_nfs_atomic_open_enter(dir, ctx, open_flags);
1488 nfs_block_sillyrename(dentry->d_parent);
1489 inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr, opened);
1490 nfs_unblock_sillyrename(dentry->d_parent);
1491 if (IS_ERR(inode)) {
1492 err = PTR_ERR(inode);
1493 trace_nfs_atomic_open_exit(dir, ctx, open_flags, err);
1494 put_nfs_open_context(ctx);
1495 switch (err) {
1496 case -ENOENT:
1497 d_drop(dentry);
1498 d_add(dentry, NULL);
1499 break;
1500 case -EISDIR:
1501 case -ENOTDIR:
1502 goto no_open;
1503 case -ELOOP:
1504 if (!(open_flags & O_NOFOLLOW))
1505 goto no_open;
1506 break;
1507
1508 default:
1509 break;
1510 }
1511 goto out;
1512 }
1513
1514 err = nfs_finish_open(ctx, ctx->dentry, file, open_flags, opened);
1515 trace_nfs_atomic_open_exit(dir, ctx, open_flags, err);
1516 put_nfs_open_context(ctx);
1517out:
1518 return err;
1519
1520no_open:
1521 res = nfs_lookup(dir, dentry, lookup_flags);
1522 err = PTR_ERR(res);
1523 if (IS_ERR(res))
1524 goto out;
1525
1526 return finish_no_open(file, res);
1527}
1528EXPORT_SYMBOL_GPL(nfs_atomic_open);
1529
1530static int nfs4_lookup_revalidate(struct dentry *dentry, unsigned int flags)
1531{
1532 struct dentry *parent = NULL;
1533 struct inode *inode;
1534 struct inode *dir;
1535 int ret = 0;
1536
1537 if (flags & LOOKUP_RCU)
1538 return -ECHILD;
1539
1540 if (!(flags & LOOKUP_OPEN) || (flags & LOOKUP_DIRECTORY))
1541 goto no_open;
1542 if (d_mountpoint(dentry))
1543 goto no_open;
1544 if (NFS_SB(dentry->d_sb)->caps & NFS_CAP_ATOMIC_OPEN_V1)
1545 goto no_open;
1546
1547 inode = dentry->d_inode;
1548 parent = dget_parent(dentry);
1549 dir = parent->d_inode;
1550
1551
1552
1553
1554 if (inode == NULL) {
1555 if (!nfs_neg_need_reval(dir, dentry, flags))
1556 ret = 1;
1557 goto out;
1558 }
1559
1560
1561 if (!S_ISREG(inode->i_mode))
1562 goto no_open_dput;
1563
1564 if (flags & LOOKUP_EXCL)
1565 goto no_open_dput;
1566
1567
1568 ret = 1;
1569
1570out:
1571 dput(parent);
1572 return ret;
1573
1574no_open_dput:
1575 dput(parent);
1576no_open:
1577 return nfs_lookup_revalidate(dentry, flags);
1578}
1579
1580#endif
1581
1582
1583
1584
1585int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
1586 struct nfs_fattr *fattr,
1587 struct nfs4_label *label)
1588{
1589 struct dentry *parent = dget_parent(dentry);
1590 struct inode *dir = parent->d_inode;
1591 struct inode *inode;
1592 int error = -EACCES;
1593
1594 d_drop(dentry);
1595
1596
1597 if (dentry->d_inode)
1598 goto out;
1599 if (fhandle->size == 0) {
1600 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, NULL);
1601 if (error)
1602 goto out_error;
1603 }
1604 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1605 if (!(fattr->valid & NFS_ATTR_FATTR)) {
1606 struct nfs_server *server = NFS_SB(dentry->d_sb);
1607 error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr, NULL);
1608 if (error < 0)
1609 goto out_error;
1610 }
1611 inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
1612 error = PTR_ERR(inode);
1613 if (IS_ERR(inode))
1614 goto out_error;
1615 d_add(dentry, inode);
1616out:
1617 dput(parent);
1618 return 0;
1619out_error:
1620 nfs_mark_for_revalidate(dir);
1621 dput(parent);
1622 return error;
1623}
1624EXPORT_SYMBOL_GPL(nfs_instantiate);
1625
1626
1627
1628
1629
1630
1631
1632int nfs_create(struct inode *dir, struct dentry *dentry,
1633 umode_t mode, bool excl)
1634{
1635 struct iattr attr;
1636 int open_flags = excl ? O_CREAT | O_EXCL : O_CREAT;
1637 int error;
1638
1639 dfprintk(VFS, "NFS: create(%s/%lu), %pd\n",
1640 dir->i_sb->s_id, dir->i_ino, dentry);
1641
1642 attr.ia_mode = mode;
1643 attr.ia_valid = ATTR_MODE;
1644
1645 trace_nfs_create_enter(dir, dentry, open_flags);
1646 error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags);
1647 trace_nfs_create_exit(dir, dentry, open_flags, error);
1648 if (error != 0)
1649 goto out_err;
1650 return 0;
1651out_err:
1652 d_drop(dentry);
1653 return error;
1654}
1655EXPORT_SYMBOL_GPL(nfs_create);
1656
1657
1658
1659
1660int
1661nfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
1662{
1663 struct iattr attr;
1664 int status;
1665
1666 dfprintk(VFS, "NFS: mknod(%s/%lu), %pd\n",
1667 dir->i_sb->s_id, dir->i_ino, dentry);
1668
1669 if (!new_valid_dev(rdev))
1670 return -EINVAL;
1671
1672 attr.ia_mode = mode;
1673 attr.ia_valid = ATTR_MODE;
1674
1675 trace_nfs_mknod_enter(dir, dentry);
1676 status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev);
1677 trace_nfs_mknod_exit(dir, dentry, status);
1678 if (status != 0)
1679 goto out_err;
1680 return 0;
1681out_err:
1682 d_drop(dentry);
1683 return status;
1684}
1685EXPORT_SYMBOL_GPL(nfs_mknod);
1686
1687
1688
1689
1690int nfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
1691{
1692 struct iattr attr;
1693 int error;
1694
1695 dfprintk(VFS, "NFS: mkdir(%s/%lu), %pd\n",
1696 dir->i_sb->s_id, dir->i_ino, dentry);
1697
1698 attr.ia_valid = ATTR_MODE;
1699 attr.ia_mode = mode | S_IFDIR;
1700
1701 trace_nfs_mkdir_enter(dir, dentry);
1702 error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr);
1703 trace_nfs_mkdir_exit(dir, dentry, error);
1704 if (error != 0)
1705 goto out_err;
1706 return 0;
1707out_err:
1708 d_drop(dentry);
1709 return error;
1710}
1711EXPORT_SYMBOL_GPL(nfs_mkdir);
1712
1713static void nfs_dentry_handle_enoent(struct dentry *dentry)
1714{
1715 if (dentry->d_inode != NULL && !d_unhashed(dentry))
1716 d_delete(dentry);
1717}
1718
1719int nfs_rmdir(struct inode *dir, struct dentry *dentry)
1720{
1721 int error;
1722
1723 dfprintk(VFS, "NFS: rmdir(%s/%lu), %pd\n",
1724 dir->i_sb->s_id, dir->i_ino, dentry);
1725
1726 trace_nfs_rmdir_enter(dir, dentry);
1727 if (dentry->d_inode) {
1728 nfs_wait_on_sillyrename(dentry);
1729 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
1730
1731 switch (error) {
1732 case 0:
1733 clear_nlink(dentry->d_inode);
1734 break;
1735 case -ENOENT:
1736 nfs_dentry_handle_enoent(dentry);
1737 }
1738 } else
1739 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
1740 trace_nfs_rmdir_exit(dir, dentry, error);
1741
1742 return error;
1743}
1744EXPORT_SYMBOL_GPL(nfs_rmdir);
1745
1746
1747
1748
1749
1750
1751
1752
1753static int nfs_safe_remove(struct dentry *dentry)
1754{
1755 struct inode *dir = dentry->d_parent->d_inode;
1756 struct inode *inode = dentry->d_inode;
1757 int error = -EBUSY;
1758
1759 dfprintk(VFS, "NFS: safe_remove(%pd2)\n", dentry);
1760
1761
1762 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1763 error = 0;
1764 goto out;
1765 }
1766
1767 trace_nfs_remove_enter(dir, dentry);
1768 if (inode != NULL) {
1769 NFS_PROTO(inode)->return_delegation(inode);
1770 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1771 if (error == 0)
1772 nfs_drop_nlink(inode);
1773 } else
1774 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1775 if (error == -ENOENT)
1776 nfs_dentry_handle_enoent(dentry);
1777 trace_nfs_remove_exit(dir, dentry, error);
1778out:
1779 return error;
1780}
1781
1782
1783
1784
1785
1786
1787int nfs_unlink(struct inode *dir, struct dentry *dentry)
1788{
1789 int error;
1790 int need_rehash = 0;
1791
1792 dfprintk(VFS, "NFS: unlink(%s/%lu, %pd)\n", dir->i_sb->s_id,
1793 dir->i_ino, dentry);
1794
1795 trace_nfs_unlink_enter(dir, dentry);
1796 spin_lock(&dentry->d_lock);
1797 if (d_count(dentry) > 1) {
1798 spin_unlock(&dentry->d_lock);
1799
1800 write_inode_now(dentry->d_inode, 0);
1801 error = nfs_sillyrename(dir, dentry);
1802 goto out;
1803 }
1804 if (!d_unhashed(dentry)) {
1805 __d_drop(dentry);
1806 need_rehash = 1;
1807 }
1808 spin_unlock(&dentry->d_lock);
1809 error = nfs_safe_remove(dentry);
1810 if (!error || error == -ENOENT) {
1811 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1812 } else if (need_rehash)
1813 d_rehash(dentry);
1814out:
1815 trace_nfs_unlink_exit(dir, dentry, error);
1816 return error;
1817}
1818EXPORT_SYMBOL_GPL(nfs_unlink);
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1836{
1837 struct page *page;
1838 char *kaddr;
1839 struct iattr attr;
1840 unsigned int pathlen = strlen(symname);
1841 int error;
1842
1843 dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s)\n", dir->i_sb->s_id,
1844 dir->i_ino, dentry, symname);
1845
1846 if (pathlen > PAGE_SIZE)
1847 return -ENAMETOOLONG;
1848
1849 attr.ia_mode = S_IFLNK | S_IRWXUGO;
1850 attr.ia_valid = ATTR_MODE;
1851
1852 page = alloc_page(GFP_HIGHUSER);
1853 if (!page)
1854 return -ENOMEM;
1855
1856 kaddr = kmap_atomic(page);
1857 memcpy(kaddr, symname, pathlen);
1858 if (pathlen < PAGE_SIZE)
1859 memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen);
1860 kunmap_atomic(kaddr);
1861
1862 trace_nfs_symlink_enter(dir, dentry);
1863 error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr);
1864 trace_nfs_symlink_exit(dir, dentry, error);
1865 if (error != 0) {
1866 dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s) error %d\n",
1867 dir->i_sb->s_id, dir->i_ino,
1868 dentry, symname, error);
1869 d_drop(dentry);
1870 __free_page(page);
1871 return error;
1872 }
1873
1874
1875
1876
1877
1878 if (!add_to_page_cache_lru(page, dentry->d_inode->i_mapping, 0,
1879 GFP_KERNEL)) {
1880 SetPageUptodate(page);
1881 unlock_page(page);
1882
1883
1884
1885
1886 page_cache_release(page);
1887 } else
1888 __free_page(page);
1889
1890 return 0;
1891}
1892EXPORT_SYMBOL_GPL(nfs_symlink);
1893
1894int
1895nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
1896{
1897 struct inode *inode = old_dentry->d_inode;
1898 int error;
1899
1900 dfprintk(VFS, "NFS: link(%pd2 -> %pd2)\n",
1901 old_dentry, dentry);
1902
1903 trace_nfs_link_enter(inode, dir, dentry);
1904 NFS_PROTO(inode)->return_delegation(inode);
1905
1906 d_drop(dentry);
1907 error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
1908 if (error == 0) {
1909 ihold(inode);
1910 d_add(dentry, inode);
1911 }
1912 trace_nfs_link_exit(inode, dir, dentry, error);
1913 return error;
1914}
1915EXPORT_SYMBOL_GPL(nfs_link);
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1942 struct inode *new_dir, struct dentry *new_dentry)
1943{
1944 struct inode *old_inode = old_dentry->d_inode;
1945 struct inode *new_inode = new_dentry->d_inode;
1946 struct dentry *dentry = NULL, *rehash = NULL;
1947 struct rpc_task *task;
1948 int error = -EBUSY;
1949
1950 dfprintk(VFS, "NFS: rename(%pd2 -> %pd2, ct=%d)\n",
1951 old_dentry, new_dentry,
1952 d_count(new_dentry));
1953
1954 trace_nfs_rename_enter(old_dir, old_dentry, new_dir, new_dentry);
1955
1956
1957
1958
1959
1960
1961 if (new_inode && !S_ISDIR(new_inode->i_mode)) {
1962
1963
1964
1965
1966 if (!d_unhashed(new_dentry)) {
1967 d_drop(new_dentry);
1968 rehash = new_dentry;
1969 }
1970
1971 if (d_count(new_dentry) > 2) {
1972 int err;
1973
1974
1975 dentry = d_alloc(new_dentry->d_parent,
1976 &new_dentry->d_name);
1977 if (!dentry)
1978 goto out;
1979
1980
1981 err = nfs_sillyrename(new_dir, new_dentry);
1982 if (err)
1983 goto out;
1984
1985 new_dentry = dentry;
1986 rehash = NULL;
1987 new_inode = NULL;
1988 }
1989 }
1990
1991 NFS_PROTO(old_inode)->return_delegation(old_inode);
1992 if (new_inode != NULL)
1993 NFS_PROTO(new_inode)->return_delegation(new_inode);
1994
1995 task = nfs_async_rename(old_dir, new_dir, old_dentry, new_dentry, NULL);
1996 if (IS_ERR(task)) {
1997 error = PTR_ERR(task);
1998 goto out;
1999 }
2000
2001 error = rpc_wait_for_completion_task(task);
2002 if (error == 0)
2003 error = task->tk_status;
2004 rpc_put_task(task);
2005 nfs_mark_for_revalidate(old_inode);
2006out:
2007 if (rehash)
2008 d_rehash(rehash);
2009 trace_nfs_rename_exit(old_dir, old_dentry,
2010 new_dir, new_dentry, error);
2011 if (!error) {
2012 if (new_inode != NULL)
2013 nfs_drop_nlink(new_inode);
2014 d_move(old_dentry, new_dentry);
2015 nfs_set_verifier(new_dentry,
2016 nfs_save_change_attribute(new_dir));
2017 } else if (error == -ENOENT)
2018 nfs_dentry_handle_enoent(old_dentry);
2019
2020
2021 if (dentry)
2022 dput(dentry);
2023 return error;
2024}
2025EXPORT_SYMBOL_GPL(nfs_rename);
2026
2027static DEFINE_SPINLOCK(nfs_access_lru_lock);
2028static LIST_HEAD(nfs_access_lru_list);
2029static atomic_long_t nfs_access_nr_entries;
2030
2031static void nfs_access_free_entry(struct nfs_access_entry *entry)
2032{
2033 put_rpccred(entry->cred);
2034 kfree(entry);
2035 smp_mb__before_atomic_dec();
2036 atomic_long_dec(&nfs_access_nr_entries);
2037 smp_mb__after_atomic_dec();
2038}
2039
2040static void nfs_access_free_list(struct list_head *head)
2041{
2042 struct nfs_access_entry *cache;
2043
2044 while (!list_empty(head)) {
2045 cache = list_entry(head->next, struct nfs_access_entry, lru);
2046 list_del(&cache->lru);
2047 nfs_access_free_entry(cache);
2048 }
2049}
2050
2051unsigned long
2052nfs_access_cache_scan(struct shrinker *shrink, struct shrink_control *sc)
2053{
2054 LIST_HEAD(head);
2055 struct nfs_inode *nfsi, *next;
2056 struct nfs_access_entry *cache;
2057 int nr_to_scan = sc->nr_to_scan;
2058 gfp_t gfp_mask = sc->gfp_mask;
2059 long freed = 0;
2060
2061 if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL)
2062 return SHRINK_STOP;
2063
2064 spin_lock(&nfs_access_lru_lock);
2065 list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) {
2066 struct inode *inode;
2067
2068 if (nr_to_scan-- == 0)
2069 break;
2070 inode = &nfsi->vfs_inode;
2071 spin_lock(&inode->i_lock);
2072 if (list_empty(&nfsi->access_cache_entry_lru))
2073 goto remove_lru_entry;
2074 cache = list_entry(nfsi->access_cache_entry_lru.next,
2075 struct nfs_access_entry, lru);
2076 list_move(&cache->lru, &head);
2077 rb_erase(&cache->rb_node, &nfsi->access_cache);
2078 freed++;
2079 if (!list_empty(&nfsi->access_cache_entry_lru))
2080 list_move_tail(&nfsi->access_cache_inode_lru,
2081 &nfs_access_lru_list);
2082 else {
2083remove_lru_entry:
2084 list_del_init(&nfsi->access_cache_inode_lru);
2085 smp_mb__before_clear_bit();
2086 clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags);
2087 smp_mb__after_clear_bit();
2088 }
2089 spin_unlock(&inode->i_lock);
2090 }
2091 spin_unlock(&nfs_access_lru_lock);
2092 nfs_access_free_list(&head);
2093 return freed;
2094}
2095
2096unsigned long
2097nfs_access_cache_count(struct shrinker *shrink, struct shrink_control *sc)
2098{
2099 return vfs_pressure_ratio(atomic_long_read(&nfs_access_nr_entries));
2100}
2101
2102static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head)
2103{
2104 struct rb_root *root_node = &nfsi->access_cache;
2105 struct rb_node *n;
2106 struct nfs_access_entry *entry;
2107
2108
2109 while ((n = rb_first(root_node)) != NULL) {
2110 entry = rb_entry(n, struct nfs_access_entry, rb_node);
2111 rb_erase(n, root_node);
2112 list_move(&entry->lru, head);
2113 }
2114 nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS;
2115}
2116
2117void nfs_access_zap_cache(struct inode *inode)
2118{
2119 LIST_HEAD(head);
2120
2121 if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0)
2122 return;
2123
2124 spin_lock(&nfs_access_lru_lock);
2125 if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
2126 list_del_init(&NFS_I(inode)->access_cache_inode_lru);
2127
2128 spin_lock(&inode->i_lock);
2129 __nfs_access_zap_cache(NFS_I(inode), &head);
2130 spin_unlock(&inode->i_lock);
2131 spin_unlock(&nfs_access_lru_lock);
2132 nfs_access_free_list(&head);
2133}
2134EXPORT_SYMBOL_GPL(nfs_access_zap_cache);
2135
2136static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred)
2137{
2138 struct rb_node *n = NFS_I(inode)->access_cache.rb_node;
2139 struct nfs_access_entry *entry;
2140
2141 while (n != NULL) {
2142 entry = rb_entry(n, struct nfs_access_entry, rb_node);
2143
2144 if (cred < entry->cred)
2145 n = n->rb_left;
2146 else if (cred > entry->cred)
2147 n = n->rb_right;
2148 else
2149 return entry;
2150 }
2151 return NULL;
2152}
2153
2154static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res)
2155{
2156 struct nfs_inode *nfsi = NFS_I(inode);
2157 struct nfs_access_entry *cache;
2158 int err = -ENOENT;
2159
2160 spin_lock(&inode->i_lock);
2161 if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
2162 goto out_zap;
2163 cache = nfs_access_search_rbtree(inode, cred);
2164 if (cache == NULL)
2165 goto out;
2166 if (!nfs_have_delegated_attributes(inode) &&
2167 !time_in_range_open(jiffies, cache->jiffies, cache->jiffies + nfsi->attrtimeo))
2168 goto out_stale;
2169 res->jiffies = cache->jiffies;
2170 res->cred = cache->cred;
2171 res->mask = cache->mask;
2172 list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru);
2173 err = 0;
2174out:
2175 spin_unlock(&inode->i_lock);
2176 return err;
2177out_stale:
2178 rb_erase(&cache->rb_node, &nfsi->access_cache);
2179 list_del(&cache->lru);
2180 spin_unlock(&inode->i_lock);
2181 nfs_access_free_entry(cache);
2182 return -ENOENT;
2183out_zap:
2184 spin_unlock(&inode->i_lock);
2185 nfs_access_zap_cache(inode);
2186 return -ENOENT;
2187}
2188
2189static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set)
2190{
2191 struct nfs_inode *nfsi = NFS_I(inode);
2192 struct rb_root *root_node = &nfsi->access_cache;
2193 struct rb_node **p = &root_node->rb_node;
2194 struct rb_node *parent = NULL;
2195 struct nfs_access_entry *entry;
2196
2197 spin_lock(&inode->i_lock);
2198 while (*p != NULL) {
2199 parent = *p;
2200 entry = rb_entry(parent, struct nfs_access_entry, rb_node);
2201
2202 if (set->cred < entry->cred)
2203 p = &parent->rb_left;
2204 else if (set->cred > entry->cred)
2205 p = &parent->rb_right;
2206 else
2207 goto found;
2208 }
2209 rb_link_node(&set->rb_node, parent, p);
2210 rb_insert_color(&set->rb_node, root_node);
2211 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2212 spin_unlock(&inode->i_lock);
2213 return;
2214found:
2215 rb_replace_node(parent, &set->rb_node, root_node);
2216 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2217 list_del(&entry->lru);
2218 spin_unlock(&inode->i_lock);
2219 nfs_access_free_entry(entry);
2220}
2221
2222void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)
2223{
2224 struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL);
2225 if (cache == NULL)
2226 return;
2227 RB_CLEAR_NODE(&cache->rb_node);
2228 cache->jiffies = set->jiffies;
2229 cache->cred = get_rpccred(set->cred);
2230 cache->mask = set->mask;
2231
2232 nfs_access_add_rbtree(inode, cache);
2233
2234
2235 smp_mb__before_atomic_inc();
2236 atomic_long_inc(&nfs_access_nr_entries);
2237 smp_mb__after_atomic_inc();
2238
2239
2240 if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) {
2241 spin_lock(&nfs_access_lru_lock);
2242 if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
2243 list_add_tail(&NFS_I(inode)->access_cache_inode_lru,
2244 &nfs_access_lru_list);
2245 spin_unlock(&nfs_access_lru_lock);
2246 }
2247}
2248EXPORT_SYMBOL_GPL(nfs_access_add_cache);
2249
2250void nfs_access_set_mask(struct nfs_access_entry *entry, u32 access_result)
2251{
2252 entry->mask = 0;
2253 if (access_result & NFS4_ACCESS_READ)
2254 entry->mask |= MAY_READ;
2255 if (access_result &
2256 (NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE))
2257 entry->mask |= MAY_WRITE;
2258 if (access_result & (NFS4_ACCESS_LOOKUP|NFS4_ACCESS_EXECUTE))
2259 entry->mask |= MAY_EXEC;
2260}
2261EXPORT_SYMBOL_GPL(nfs_access_set_mask);
2262
2263static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask)
2264{
2265 struct nfs_access_entry cache;
2266 int status;
2267
2268 trace_nfs_access_enter(inode);
2269
2270 status = nfs_access_get_cached(inode, cred, &cache);
2271 if (status == 0)
2272 goto out_cached;
2273
2274
2275 cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ;
2276 cache.cred = cred;
2277 cache.jiffies = jiffies;
2278 status = NFS_PROTO(inode)->access(inode, &cache);
2279 if (status != 0) {
2280 if (status == -ESTALE) {
2281 nfs_zap_caches(inode);
2282 if (!S_ISDIR(inode->i_mode))
2283 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
2284 }
2285 goto out;
2286 }
2287 nfs_access_add_cache(inode, &cache);
2288out_cached:
2289 if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) != 0)
2290 status = -EACCES;
2291out:
2292 trace_nfs_access_exit(inode, status);
2293 return status;
2294}
2295
2296static int nfs_open_permission_mask(int openflags)
2297{
2298 int mask = 0;
2299
2300 if (openflags & __FMODE_EXEC) {
2301
2302 mask = MAY_EXEC;
2303 } else {
2304 if ((openflags & O_ACCMODE) != O_WRONLY)
2305 mask |= MAY_READ;
2306 if ((openflags & O_ACCMODE) != O_RDONLY)
2307 mask |= MAY_WRITE;
2308 }
2309
2310 return mask;
2311}
2312
2313int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags)
2314{
2315 return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags));
2316}
2317EXPORT_SYMBOL_GPL(nfs_may_open);
2318
2319int nfs_permission(struct inode *inode, int mask)
2320{
2321 struct rpc_cred *cred;
2322 int res = 0;
2323
2324 if (mask & MAY_NOT_BLOCK)
2325 return -ECHILD;
2326
2327 nfs_inc_stats(inode, NFSIOS_VFSACCESS);
2328
2329 if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
2330 goto out;
2331
2332 if (mask & (MAY_ACCESS | MAY_CHDIR))
2333 goto force_lookup;
2334
2335 switch (inode->i_mode & S_IFMT) {
2336 case S_IFLNK:
2337 goto out;
2338 case S_IFREG:
2339 break;
2340 case S_IFDIR:
2341
2342
2343
2344
2345 if ((mask & MAY_WRITE) && !(mask & MAY_READ))
2346 goto out;
2347 }
2348
2349force_lookup:
2350 if (!NFS_PROTO(inode)->access)
2351 goto out_notsup;
2352
2353 cred = rpc_lookup_cred();
2354 if (!IS_ERR(cred)) {
2355 res = nfs_do_access(inode, cred, mask);
2356 put_rpccred(cred);
2357 } else
2358 res = PTR_ERR(cred);
2359out:
2360 if (!res && (mask & MAY_EXEC) && !execute_ok(inode))
2361 res = -EACCES;
2362
2363 dfprintk(VFS, "NFS: permission(%s/%lu), mask=0x%x, res=%d\n",
2364 inode->i_sb->s_id, inode->i_ino, mask, res);
2365 return res;
2366out_notsup:
2367 res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
2368 if (res == 0)
2369 res = generic_permission(inode, mask);
2370 goto out;
2371}
2372EXPORT_SYMBOL_GPL(nfs_permission);
2373
2374
2375
2376
2377
2378
2379
2380