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