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