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