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