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