[PATCH] NFS: Add support for NFSv3 ACLs
[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/smp_lock.h>
33 #include <linux/namei.h>
34
35 #include "nfs4_fs.h"
36 #include "delegation.h"
37
38 #define NFS_PARANOIA 1
39 /* #define NFS_DEBUG_VERBOSE 1 */
40
41 static int nfs_opendir(struct inode *, struct file *);
42 static int nfs_readdir(struct file *, void *, filldir_t);
43 static struct dentry *nfs_lookup(struct inode *, struct dentry *, struct nameidata *);
44 static int nfs_create(struct inode *, struct dentry *, int, struct nameidata *);
45 static int nfs_mkdir(struct inode *, struct dentry *, int);
46 static int nfs_rmdir(struct inode *, struct dentry *);
47 static int nfs_unlink(struct inode *, struct dentry *);
48 static int nfs_symlink(struct inode *, struct dentry *, const char *);
49 static int nfs_link(struct dentry *, struct inode *, struct dentry *);
50 static int nfs_mknod(struct inode *, struct dentry *, int, dev_t);
51 static int nfs_rename(struct inode *, struct dentry *,
52                       struct inode *, struct dentry *);
53 static int nfs_fsync_dir(struct file *, struct dentry *, int);
54
55 struct file_operations nfs_dir_operations = {
56         .read           = generic_read_dir,
57         .readdir        = nfs_readdir,
58         .open           = nfs_opendir,
59         .release        = nfs_release,
60         .fsync          = nfs_fsync_dir,
61 };
62
63 struct inode_operations nfs_dir_inode_operations = {
64         .create         = nfs_create,
65         .lookup         = nfs_lookup,
66         .link           = nfs_link,
67         .unlink         = nfs_unlink,
68         .symlink        = nfs_symlink,
69         .mkdir          = nfs_mkdir,
70         .rmdir          = nfs_rmdir,
71         .mknod          = nfs_mknod,
72         .rename         = nfs_rename,
73         .permission     = nfs_permission,
74         .getattr        = nfs_getattr,
75         .setattr        = nfs_setattr,
76 };
77
78 #ifdef CONFIG_NFS_V3
79 struct inode_operations nfs3_dir_inode_operations = {
80         .create         = nfs_create,
81         .lookup         = nfs_lookup,
82         .link           = nfs_link,
83         .unlink         = nfs_unlink,
84         .symlink        = nfs_symlink,
85         .mkdir          = nfs_mkdir,
86         .rmdir          = nfs_rmdir,
87         .mknod          = nfs_mknod,
88         .rename         = nfs_rename,
89         .permission     = nfs_permission,
90         .getattr        = nfs_getattr,
91         .setattr        = nfs_setattr,
92         .listxattr      = nfs3_listxattr,
93         .getxattr       = nfs3_getxattr,
94         .setxattr       = nfs3_setxattr,
95         .removexattr    = nfs3_removexattr,
96 };
97 #endif  /* CONFIG_NFS_V3 */
98
99 #ifdef CONFIG_NFS_V4
100
101 static struct dentry *nfs_atomic_lookup(struct inode *, struct dentry *, struct nameidata *);
102 struct inode_operations nfs4_dir_inode_operations = {
103         .create         = nfs_create,
104         .lookup         = nfs_atomic_lookup,
105         .link           = nfs_link,
106         .unlink         = nfs_unlink,
107         .symlink        = nfs_symlink,
108         .mkdir          = nfs_mkdir,
109         .rmdir          = nfs_rmdir,
110         .mknod          = nfs_mknod,
111         .rename         = nfs_rename,
112         .permission     = nfs_permission,
113         .getattr        = nfs_getattr,
114         .setattr        = nfs_setattr,
115         .getxattr       = nfs4_getxattr,
116         .setxattr       = nfs4_setxattr,
117         .listxattr      = nfs4_listxattr,
118 };
119
120 #endif /* CONFIG_NFS_V4 */
121
122 /*
123  * Open file
124  */
125 static int
126 nfs_opendir(struct inode *inode, struct file *filp)
127 {
128         int res = 0;
129
130         lock_kernel();
131         /* Call generic open code in order to cache credentials */
132         if (!res)
133                 res = nfs_open(inode, filp);
134         unlock_kernel();
135         return res;
136 }
137
138 typedef u32 * (*decode_dirent_t)(u32 *, struct nfs_entry *, int);
139 typedef struct {
140         struct file     *file;
141         struct page     *page;
142         unsigned long   page_index;
143         u32             *ptr;
144         u64             target;
145         struct nfs_entry *entry;
146         decode_dirent_t decode;
147         int             plus;
148         int             error;
149 } nfs_readdir_descriptor_t;
150
151 /* Now we cache directories properly, by stuffing the dirent
152  * data directly in the page cache.
153  *
154  * Inode invalidation due to refresh etc. takes care of
155  * _everything_, no sloppy entry flushing logic, no extraneous
156  * copying, network direct to page cache, the way it was meant
157  * to be.
158  *
159  * NOTE: Dirent information verification is done always by the
160  *       page-in of the RPC reply, nowhere else, this simplies
161  *       things substantially.
162  */
163 static
164 int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page *page)
165 {
166         struct file     *file = desc->file;
167         struct inode    *inode = file->f_dentry->d_inode;
168         struct rpc_cred *cred = nfs_file_cred(file);
169         unsigned long   timestamp;
170         int             error;
171
172         dfprintk(VFS, "NFS: nfs_readdir_filler() reading cookie %Lu into page %lu.\n", (long long)desc->entry->cookie, page->index);
173
174  again:
175         timestamp = jiffies;
176         error = NFS_PROTO(inode)->readdir(file->f_dentry, cred, desc->entry->cookie, page,
177                                           NFS_SERVER(inode)->dtsize, desc->plus);
178         if (error < 0) {
179                 /* We requested READDIRPLUS, but the server doesn't grok it */
180                 if (error == -ENOTSUPP && desc->plus) {
181                         NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS;
182                         NFS_FLAGS(inode) &= ~NFS_INO_ADVISE_RDPLUS;
183                         desc->plus = 0;
184                         goto again;
185                 }
186                 goto error;
187         }
188         SetPageUptodate(page);
189         NFS_FLAGS(inode) |= NFS_INO_INVALID_ATIME;
190         /* Ensure consistent page alignment of the data.
191          * Note: assumes we have exclusive access to this mapping either
192          *       through inode->i_sem or some other mechanism.
193          */
194         if (page->index == 0)
195                 invalidate_inode_pages2_range(inode->i_mapping, PAGE_CACHE_SIZE, -1);
196         unlock_page(page);
197         return 0;
198  error:
199         SetPageError(page);
200         unlock_page(page);
201         nfs_zap_caches(inode);
202         desc->error = error;
203         return -EIO;
204 }
205
206 static inline
207 int dir_decode(nfs_readdir_descriptor_t *desc)
208 {
209         u32     *p = desc->ptr;
210         p = desc->decode(p, desc->entry, desc->plus);
211         if (IS_ERR(p))
212                 return PTR_ERR(p);
213         desc->ptr = p;
214         return 0;
215 }
216
217 static inline
218 void dir_page_release(nfs_readdir_descriptor_t *desc)
219 {
220         kunmap(desc->page);
221         page_cache_release(desc->page);
222         desc->page = NULL;
223         desc->ptr = NULL;
224 }
225
226 /*
227  * Given a pointer to a buffer that has already been filled by a call
228  * to readdir, find the next entry.
229  *
230  * If the end of the buffer has been reached, return -EAGAIN, if not,
231  * return the offset within the buffer of the next entry to be
232  * read.
233  */
234 static inline
235 int find_dirent(nfs_readdir_descriptor_t *desc, struct page *page)
236 {
237         struct nfs_entry *entry = desc->entry;
238         int             loop_count = 0,
239                         status;
240
241         while((status = dir_decode(desc)) == 0) {
242                 dfprintk(VFS, "NFS: found cookie %Lu\n", (long long)entry->cookie);
243                 if (entry->prev_cookie == desc->target)
244                         break;
245                 if (loop_count++ > 200) {
246                         loop_count = 0;
247                         schedule();
248                 }
249         }
250         dfprintk(VFS, "NFS: find_dirent() returns %d\n", status);
251         return status;
252 }
253
254 /*
255  * Find the given page, and call find_dirent() in order to try to
256  * return the next entry.
257  */
258 static inline
259 int find_dirent_page(nfs_readdir_descriptor_t *desc)
260 {
261         struct inode    *inode = desc->file->f_dentry->d_inode;
262         struct page     *page;
263         int             status;
264
265         dfprintk(VFS, "NFS: find_dirent_page() searching directory page %ld\n", desc->page_index);
266
267         page = read_cache_page(inode->i_mapping, desc->page_index,
268                                (filler_t *)nfs_readdir_filler, desc);
269         if (IS_ERR(page)) {
270                 status = PTR_ERR(page);
271                 goto out;
272         }
273         if (!PageUptodate(page))
274                 goto read_error;
275
276         /* NOTE: Someone else may have changed the READDIRPLUS flag */
277         desc->page = page;
278         desc->ptr = kmap(page);         /* matching kunmap in nfs_do_filldir */
279         status = find_dirent(desc, page);
280         if (status < 0)
281                 dir_page_release(desc);
282  out:
283         dfprintk(VFS, "NFS: find_dirent_page() returns %d\n", status);
284         return status;
285  read_error:
286         page_cache_release(page);
287         return -EIO;
288 }
289
290 /*
291  * Recurse through the page cache pages, and return a
292  * filled nfs_entry structure of the next directory entry if possible.
293  *
294  * The target for the search is 'desc->target'.
295  */
296 static inline
297 int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
298 {
299         int             loop_count = 0;
300         int             res;
301
302         dfprintk(VFS, "NFS: readdir_search_pagecache() searching for cookie %Lu\n", (long long)desc->target);
303         for (;;) {
304                 res = find_dirent_page(desc);
305                 if (res != -EAGAIN)
306                         break;
307                 /* Align to beginning of next page */
308                 desc->page_index ++;
309                 if (loop_count++ > 200) {
310                         loop_count = 0;
311                         schedule();
312                 }
313         }
314         dfprintk(VFS, "NFS: readdir_search_pagecache() returned %d\n", res);
315         return res;
316 }
317
318 static inline unsigned int dt_type(struct inode *inode)
319 {
320         return (inode->i_mode >> 12) & 15;
321 }
322
323 static struct dentry *nfs_readdir_lookup(nfs_readdir_descriptor_t *desc);
324
325 /*
326  * Once we've found the start of the dirent within a page: fill 'er up...
327  */
328 static 
329 int nfs_do_filldir(nfs_readdir_descriptor_t *desc, void *dirent,
330                    filldir_t filldir)
331 {
332         struct file     *file = desc->file;
333         struct nfs_entry *entry = desc->entry;
334         struct dentry   *dentry = NULL;
335         unsigned long   fileid;
336         int             loop_count = 0,
337                         res;
338
339         dfprintk(VFS, "NFS: nfs_do_filldir() filling starting @ cookie %Lu\n", (long long)desc->target);
340
341         for(;;) {
342                 unsigned d_type = DT_UNKNOWN;
343                 /* Note: entry->prev_cookie contains the cookie for
344                  *       retrieving the current dirent on the server */
345                 fileid = nfs_fileid_to_ino_t(entry->ino);
346
347                 /* Get a dentry if we have one */
348                 if (dentry != NULL)
349                         dput(dentry);
350                 dentry = nfs_readdir_lookup(desc);
351
352                 /* Use readdirplus info */
353                 if (dentry != NULL && dentry->d_inode != NULL) {
354                         d_type = dt_type(dentry->d_inode);
355                         fileid = dentry->d_inode->i_ino;
356                 }
357
358                 res = filldir(dirent, entry->name, entry->len, 
359                               entry->prev_cookie, fileid, d_type);
360                 if (res < 0)
361                         break;
362                 file->f_pos = desc->target = entry->cookie;
363                 if (dir_decode(desc) != 0) {
364                         desc->page_index ++;
365                         break;
366                 }
367                 if (loop_count++ > 200) {
368                         loop_count = 0;
369                         schedule();
370                 }
371         }
372         dir_page_release(desc);
373         if (dentry != NULL)
374                 dput(dentry);
375         dfprintk(VFS, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n", (long long)desc->target, res);
376         return res;
377 }
378
379 /*
380  * If we cannot find a cookie in our cache, we suspect that this is
381  * because it points to a deleted file, so we ask the server to return
382  * whatever it thinks is the next entry. We then feed this to filldir.
383  * If all goes well, we should then be able to find our way round the
384  * cache on the next call to readdir_search_pagecache();
385  *
386  * NOTE: we cannot add the anonymous page to the pagecache because
387  *       the data it contains might not be page aligned. Besides,
388  *       we should already have a complete representation of the
389  *       directory in the page cache by the time we get here.
390  */
391 static inline
392 int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
393                      filldir_t filldir)
394 {
395         struct file     *file = desc->file;
396         struct inode    *inode = file->f_dentry->d_inode;
397         struct rpc_cred *cred = nfs_file_cred(file);
398         struct page     *page = NULL;
399         int             status;
400
401         dfprintk(VFS, "NFS: uncached_readdir() searching for cookie %Lu\n", (long long)desc->target);
402
403         page = alloc_page(GFP_HIGHUSER);
404         if (!page) {
405                 status = -ENOMEM;
406                 goto out;
407         }
408         desc->error = NFS_PROTO(inode)->readdir(file->f_dentry, cred, desc->target,
409                                                 page,
410                                                 NFS_SERVER(inode)->dtsize,
411                                                 desc->plus);
412         NFS_FLAGS(inode) |= NFS_INO_INVALID_ATIME;
413         desc->page = page;
414         desc->ptr = kmap(page);         /* matching kunmap in nfs_do_filldir */
415         if (desc->error >= 0) {
416                 if ((status = dir_decode(desc)) == 0)
417                         desc->entry->prev_cookie = desc->target;
418         } else
419                 status = -EIO;
420         if (status < 0)
421                 goto out_release;
422
423         status = nfs_do_filldir(desc, dirent, filldir);
424
425         /* Reset read descriptor so it searches the page cache from
426          * the start upon the next call to readdir_search_pagecache() */
427         desc->page_index = 0;
428         desc->entry->cookie = desc->entry->prev_cookie = 0;
429         desc->entry->eof = 0;
430  out:
431         dfprintk(VFS, "NFS: uncached_readdir() returns %d\n", status);
432         return status;
433  out_release:
434         dir_page_release(desc);
435         goto out;
436 }
437
438 /* The file offset position is now represented as a true offset into the
439  * page cache as is the case in most of the other filesystems.
440  */
441 static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
442 {
443         struct dentry   *dentry = filp->f_dentry;
444         struct inode    *inode = dentry->d_inode;
445         nfs_readdir_descriptor_t my_desc,
446                         *desc = &my_desc;
447         struct nfs_entry my_entry;
448         struct nfs_fh    fh;
449         struct nfs_fattr fattr;
450         long            res;
451
452         lock_kernel();
453
454         res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
455         if (res < 0) {
456                 unlock_kernel();
457                 return res;
458         }
459
460         /*
461          * filp->f_pos points to the file offset in the page cache.
462          * but if the cache has meanwhile been zapped, we need to
463          * read from the last dirent to revalidate f_pos
464          * itself.
465          */
466         memset(desc, 0, sizeof(*desc));
467
468         desc->file = filp;
469         desc->target = filp->f_pos;
470         desc->decode = NFS_PROTO(inode)->decode_dirent;
471         desc->plus = NFS_USE_READDIRPLUS(inode);
472
473         my_entry.cookie = my_entry.prev_cookie = 0;
474         my_entry.eof = 0;
475         my_entry.fh = &fh;
476         my_entry.fattr = &fattr;
477         desc->entry = &my_entry;
478
479         while(!desc->entry->eof) {
480                 res = readdir_search_pagecache(desc);
481                 if (res == -EBADCOOKIE) {
482                         /* This means either end of directory */
483                         if (desc->entry->cookie != desc->target) {
484                                 /* Or that the server has 'lost' a cookie */
485                                 res = uncached_readdir(desc, dirent, filldir);
486                                 if (res >= 0)
487                                         continue;
488                         }
489                         res = 0;
490                         break;
491                 }
492                 if (res == -ETOOSMALL && desc->plus) {
493                         NFS_FLAGS(inode) &= ~NFS_INO_ADVISE_RDPLUS;
494                         nfs_zap_caches(inode);
495                         desc->plus = 0;
496                         desc->entry->eof = 0;
497                         continue;
498                 }
499                 if (res < 0)
500                         break;
501
502                 res = nfs_do_filldir(desc, dirent, filldir);
503                 if (res < 0) {
504                         res = 0;
505                         break;
506                 }
507         }
508         unlock_kernel();
509         if (desc->error < 0)
510                 return desc->error;
511         if (res < 0)
512                 return res;
513         return 0;
514 }
515
516 /*
517  * All directory operations under NFS are synchronous, so fsync()
518  * is a dummy operation.
519  */
520 int nfs_fsync_dir(struct file *filp, struct dentry *dentry, int datasync)
521 {
522         return 0;
523 }
524
525 /*
526  * A check for whether or not the parent directory has changed.
527  * In the case it has, we assume that the dentries are untrustworthy
528  * and may need to be looked up again.
529  */
530 static inline int nfs_check_verifier(struct inode *dir, struct dentry *dentry)
531 {
532         if (IS_ROOT(dentry))
533                 return 1;
534         if ((NFS_FLAGS(dir) & NFS_INO_INVALID_ATTR) != 0
535                         || nfs_attribute_timeout(dir))
536                 return 0;
537         return nfs_verify_change_attribute(dir, (unsigned long)dentry->d_fsdata);
538 }
539
540 static inline void nfs_set_verifier(struct dentry * dentry, unsigned long verf)
541 {
542         dentry->d_fsdata = (void *)verf;
543 }
544
545 /*
546  * Whenever an NFS operation succeeds, we know that the dentry
547  * is valid, so we update the revalidation timestamp.
548  */
549 static inline void nfs_renew_times(struct dentry * dentry)
550 {
551         dentry->d_time = jiffies;
552 }
553
554 /*
555  * Return the intent data that applies to this particular path component
556  *
557  * Note that the current set of intents only apply to the very last
558  * component of the path.
559  * We check for this using LOOKUP_CONTINUE and LOOKUP_PARENT.
560  */
561 static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd, unsigned int mask)
562 {
563         if (nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT))
564                 return 0;
565         return nd->flags & mask;
566 }
567
568 /*
569  * Inode and filehandle revalidation for lookups.
570  *
571  * We force revalidation in the cases where the VFS sets LOOKUP_REVAL,
572  * or if the intent information indicates that we're about to open this
573  * particular file and the "nocto" mount flag is not set.
574  *
575  */
576 static inline
577 int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd)
578 {
579         struct nfs_server *server = NFS_SERVER(inode);
580
581         if (nd != NULL) {
582                 /* VFS wants an on-the-wire revalidation */
583                 if (nd->flags & LOOKUP_REVAL)
584                         goto out_force;
585                 /* This is an open(2) */
586                 if (nfs_lookup_check_intent(nd, LOOKUP_OPEN) != 0 &&
587                                 !(server->flags & NFS_MOUNT_NOCTO))
588                         goto out_force;
589         }
590         return nfs_revalidate_inode(server, inode);
591 out_force:
592         return __nfs_revalidate_inode(server, inode);
593 }
594
595 /*
596  * We judge how long we want to trust negative
597  * dentries by looking at the parent inode mtime.
598  *
599  * If parent mtime has changed, we revalidate, else we wait for a
600  * period corresponding to the parent's attribute cache timeout value.
601  */
602 static inline
603 int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
604                        struct nameidata *nd)
605 {
606         /* Don't revalidate a negative dentry if we're creating a new file */
607         if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0)
608                 return 0;
609         return !nfs_check_verifier(dir, dentry);
610 }
611
612 /*
613  * This is called every time the dcache has a lookup hit,
614  * and we should check whether we can really trust that
615  * lookup.
616  *
617  * NOTE! The hit can be a negative hit too, don't assume
618  * we have an inode!
619  *
620  * If the parent directory is seen to have changed, we throw out the
621  * cached dentry and do a new lookup.
622  */
623 static int nfs_lookup_revalidate(struct dentry * dentry, struct nameidata *nd)
624 {
625         struct inode *dir;
626         struct inode *inode;
627         struct dentry *parent;
628         int error;
629         struct nfs_fh fhandle;
630         struct nfs_fattr fattr;
631         unsigned long verifier;
632
633         parent = dget_parent(dentry);
634         lock_kernel();
635         dir = parent->d_inode;
636         inode = dentry->d_inode;
637
638         if (!inode) {
639                 if (nfs_neg_need_reval(dir, dentry, nd))
640                         goto out_bad;
641                 goto out_valid;
642         }
643
644         if (is_bad_inode(inode)) {
645                 dfprintk(VFS, "nfs_lookup_validate: %s/%s has dud inode\n",
646                         dentry->d_parent->d_name.name, dentry->d_name.name);
647                 goto out_bad;
648         }
649
650         /* Revalidate parent directory attribute cache */
651         if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0)
652                 goto out_zap_parent;
653
654         /* Force a full look up iff the parent directory has changed */
655         if (nfs_check_verifier(dir, dentry)) {
656                 if (nfs_lookup_verify_inode(inode, nd))
657                         goto out_zap_parent;
658                 goto out_valid;
659         }
660
661         if (NFS_STALE(inode))
662                 goto out_bad;
663
664         verifier = nfs_save_change_attribute(dir);
665         error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, &fhandle, &fattr);
666         if (error)
667                 goto out_bad;
668         if (nfs_compare_fh(NFS_FH(inode), &fhandle))
669                 goto out_bad;
670         if ((error = nfs_refresh_inode(inode, &fattr)) != 0)
671                 goto out_bad;
672
673         nfs_renew_times(dentry);
674         nfs_set_verifier(dentry, verifier);
675  out_valid:
676         unlock_kernel();
677         dput(parent);
678         return 1;
679 out_zap_parent:
680         nfs_zap_caches(dir);
681  out_bad:
682         NFS_CACHEINV(dir);
683         if (inode && S_ISDIR(inode->i_mode)) {
684                 /* Purge readdir caches. */
685                 nfs_zap_caches(inode);
686                 /* If we have submounts, don't unhash ! */
687                 if (have_submounts(dentry))
688                         goto out_valid;
689                 shrink_dcache_parent(dentry);
690         }
691         d_drop(dentry);
692         unlock_kernel();
693         dput(parent);
694         return 0;
695 }
696
697 /*
698  * This is called from dput() when d_count is going to 0.
699  */
700 static int nfs_dentry_delete(struct dentry *dentry)
701 {
702         dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n",
703                 dentry->d_parent->d_name.name, dentry->d_name.name,
704                 dentry->d_flags);
705
706         if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
707                 /* Unhash it, so that ->d_iput() would be called */
708                 return 1;
709         }
710         if (!(dentry->d_sb->s_flags & MS_ACTIVE)) {
711                 /* Unhash it, so that ancestors of killed async unlink
712                  * files will be cleaned up during umount */
713                 return 1;
714         }
715         return 0;
716
717 }
718
719 /*
720  * Called when the dentry loses inode.
721  * We use it to clean up silly-renamed files.
722  */
723 static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode)
724 {
725         if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
726                 lock_kernel();
727                 inode->i_nlink--;
728                 nfs_complete_unlink(dentry);
729                 unlock_kernel();
730         }
731         /* When creating a negative dentry, we want to renew d_time */
732         nfs_renew_times(dentry);
733         iput(inode);
734 }
735
736 struct dentry_operations nfs_dentry_operations = {
737         .d_revalidate   = nfs_lookup_revalidate,
738         .d_delete       = nfs_dentry_delete,
739         .d_iput         = nfs_dentry_iput,
740 };
741
742 /*
743  * Use intent information to check whether or not we're going to do
744  * an O_EXCL create using this path component.
745  */
746 static inline
747 int nfs_is_exclusive_create(struct inode *dir, struct nameidata *nd)
748 {
749         if (NFS_PROTO(dir)->version == 2)
750                 return 0;
751         if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_CREATE) == 0)
752                 return 0;
753         return (nd->intent.open.flags & O_EXCL) != 0;
754 }
755
756 static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
757 {
758         struct dentry *res;
759         struct inode *inode = NULL;
760         int error;
761         struct nfs_fh fhandle;
762         struct nfs_fattr fattr;
763
764         dfprintk(VFS, "NFS: lookup(%s/%s)\n",
765                 dentry->d_parent->d_name.name, dentry->d_name.name);
766
767         res = ERR_PTR(-ENAMETOOLONG);
768         if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
769                 goto out;
770
771         res = ERR_PTR(-ENOMEM);
772         dentry->d_op = NFS_PROTO(dir)->dentry_ops;
773
774         lock_kernel();
775         /* Revalidate parent directory attribute cache */
776         error = nfs_revalidate_inode(NFS_SERVER(dir), dir);
777         if (error < 0) {
778                 res = ERR_PTR(error);
779                 goto out_unlock;
780         }
781
782         /* If we're doing an exclusive create, optimize away the lookup */
783         if (nfs_is_exclusive_create(dir, nd))
784                 goto no_entry;
785
786         error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, &fhandle, &fattr);
787         if (error == -ENOENT)
788                 goto no_entry;
789         if (error < 0) {
790                 res = ERR_PTR(error);
791                 goto out_unlock;
792         }
793         res = ERR_PTR(-EACCES);
794         inode = nfs_fhget(dentry->d_sb, &fhandle, &fattr);
795         if (!inode)
796                 goto out_unlock;
797 no_entry:
798         res = d_add_unique(dentry, inode);
799         if (res != NULL)
800                 dentry = res;
801         nfs_renew_times(dentry);
802         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
803 out_unlock:
804         unlock_kernel();
805 out:
806         return res;
807 }
808
809 #ifdef CONFIG_NFS_V4
810 static int nfs_open_revalidate(struct dentry *, struct nameidata *);
811
812 struct dentry_operations nfs4_dentry_operations = {
813         .d_revalidate   = nfs_open_revalidate,
814         .d_delete       = nfs_dentry_delete,
815         .d_iput         = nfs_dentry_iput,
816 };
817
818 /*
819  * Use intent information to determine whether we need to substitute
820  * the NFSv4-style stateful OPEN for the LOOKUP call
821  */
822 static int is_atomic_open(struct inode *dir, struct nameidata *nd)
823 {
824         if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_OPEN) == 0)
825                 return 0;
826         /* NFS does not (yet) have a stateful open for directories */
827         if (nd->flags & LOOKUP_DIRECTORY)
828                 return 0;
829         /* Are we trying to write to a read only partition? */
830         if (IS_RDONLY(dir) && (nd->intent.open.flags & (O_CREAT|O_TRUNC|FMODE_WRITE)))
831                 return 0;
832         return 1;
833 }
834
835 static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
836 {
837         struct dentry *res = NULL;
838         struct inode *inode = NULL;
839         int error;
840
841         /* Check that we are indeed trying to open this file */
842         if (!is_atomic_open(dir, nd))
843                 goto no_open;
844
845         if (dentry->d_name.len > NFS_SERVER(dir)->namelen) {
846                 res = ERR_PTR(-ENAMETOOLONG);
847                 goto out;
848         }
849         dentry->d_op = NFS_PROTO(dir)->dentry_ops;
850
851         /* Let vfs_create() deal with O_EXCL */
852         if (nd->intent.open.flags & O_EXCL)
853                 goto no_entry;
854
855         /* Open the file on the server */
856         lock_kernel();
857         /* Revalidate parent directory attribute cache */
858         error = nfs_revalidate_inode(NFS_SERVER(dir), dir);
859         if (error < 0) {
860                 res = ERR_PTR(error);
861                 goto out;
862         }
863
864         if (nd->intent.open.flags & O_CREAT) {
865                 nfs_begin_data_update(dir);
866                 inode = nfs4_atomic_open(dir, dentry, nd);
867                 nfs_end_data_update(dir);
868         } else
869                 inode = nfs4_atomic_open(dir, dentry, nd);
870         unlock_kernel();
871         if (IS_ERR(inode)) {
872                 error = PTR_ERR(inode);
873                 switch (error) {
874                         /* Make a negative dentry */
875                         case -ENOENT:
876                                 inode = NULL;
877                                 break;
878                         /* This turned out not to be a regular file */
879                         case -ELOOP:
880                                 if (!(nd->intent.open.flags & O_NOFOLLOW))
881                                         goto no_open;
882                         /* case -EISDIR: */
883                         /* case -EINVAL: */
884                         default:
885                                 res = ERR_PTR(error);
886                                 goto out;
887                 }
888         }
889 no_entry:
890         res = d_add_unique(dentry, inode);
891         if (res != NULL)
892                 dentry = res;
893         nfs_renew_times(dentry);
894         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
895 out:
896         return res;
897 no_open:
898         return nfs_lookup(dir, dentry, nd);
899 }
900
901 static int nfs_open_revalidate(struct dentry *dentry, struct nameidata *nd)
902 {
903         struct dentry *parent = NULL;
904         struct inode *inode = dentry->d_inode;
905         struct inode *dir;
906         unsigned long verifier;
907         int openflags, ret = 0;
908
909         parent = dget_parent(dentry);
910         dir = parent->d_inode;
911         if (!is_atomic_open(dir, nd))
912                 goto no_open;
913         /* We can't create new files in nfs_open_revalidate(), so we
914          * optimize away revalidation of negative dentries.
915          */
916         if (inode == NULL)
917                 goto out;
918         /* NFS only supports OPEN on regular files */
919         if (!S_ISREG(inode->i_mode))
920                 goto no_open;
921         openflags = nd->intent.open.flags;
922         /* We cannot do exclusive creation on a positive dentry */
923         if ((openflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL))
924                 goto no_open;
925         /* We can't create new files, or truncate existing ones here */
926         openflags &= ~(O_CREAT|O_TRUNC);
927
928         /*
929          * Note: we're not holding inode->i_sem and so may be racing with
930          * operations that change the directory. We therefore save the
931          * change attribute *before* we do the RPC call.
932          */
933         lock_kernel();
934         verifier = nfs_save_change_attribute(dir);
935         ret = nfs4_open_revalidate(dir, dentry, openflags);
936         if (!ret)
937                 nfs_set_verifier(dentry, verifier);
938         unlock_kernel();
939 out:
940         dput(parent);
941         if (!ret)
942                 d_drop(dentry);
943         return ret;
944 no_open:
945         dput(parent);
946         if (inode != NULL && nfs_have_delegation(inode, FMODE_READ))
947                 return 1;
948         return nfs_lookup_revalidate(dentry, nd);
949 }
950 #endif /* CONFIG_NFSV4 */
951
952 static struct dentry *nfs_readdir_lookup(nfs_readdir_descriptor_t *desc)
953 {
954         struct dentry *parent = desc->file->f_dentry;
955         struct inode *dir = parent->d_inode;
956         struct nfs_entry *entry = desc->entry;
957         struct dentry *dentry, *alias;
958         struct qstr name = {
959                 .name = entry->name,
960                 .len = entry->len,
961         };
962         struct inode *inode;
963
964         switch (name.len) {
965                 case 2:
966                         if (name.name[0] == '.' && name.name[1] == '.')
967                                 return dget_parent(parent);
968                         break;
969                 case 1:
970                         if (name.name[0] == '.')
971                                 return dget(parent);
972         }
973         name.hash = full_name_hash(name.name, name.len);
974         dentry = d_lookup(parent, &name);
975         if (dentry != NULL)
976                 return dentry;
977         if (!desc->plus || !(entry->fattr->valid & NFS_ATTR_FATTR))
978                 return NULL;
979         /* Note: caller is already holding the dir->i_sem! */
980         dentry = d_alloc(parent, &name);
981         if (dentry == NULL)
982                 return NULL;
983         dentry->d_op = NFS_PROTO(dir)->dentry_ops;
984         inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr);
985         if (!inode) {
986                 dput(dentry);
987                 return NULL;
988         }
989         alias = d_add_unique(dentry, inode);
990         if (alias != NULL) {
991                 dput(dentry);
992                 dentry = alias;
993         }
994         nfs_renew_times(dentry);
995         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
996         return dentry;
997 }
998
999 /*
1000  * Code common to create, mkdir, and mknod.
1001  */
1002 int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
1003                                 struct nfs_fattr *fattr)
1004 {
1005         struct inode *inode;
1006         int error = -EACCES;
1007
1008         /* We may have been initialized further down */
1009         if (dentry->d_inode)
1010                 return 0;
1011         if (fhandle->size == 0) {
1012                 struct inode *dir = dentry->d_parent->d_inode;
1013                 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
1014                 if (error)
1015                         goto out_err;
1016         }
1017         if (!(fattr->valid & NFS_ATTR_FATTR)) {
1018                 struct nfs_server *server = NFS_SB(dentry->d_sb);
1019                 error = server->rpc_ops->getattr(server, fhandle, fattr);
1020                 if (error < 0)
1021                         goto out_err;
1022         }
1023         error = -ENOMEM;
1024         inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
1025         if (inode == NULL)
1026                 goto out_err;
1027         d_instantiate(dentry, inode);
1028         return 0;
1029 out_err:
1030         d_drop(dentry);
1031         return error;
1032 }
1033
1034 /*
1035  * Following a failed create operation, we drop the dentry rather
1036  * than retain a negative dentry. This avoids a problem in the event
1037  * that the operation succeeded on the server, but an error in the
1038  * reply path made it appear to have failed.
1039  */
1040 static int nfs_create(struct inode *dir, struct dentry *dentry, int mode,
1041                 struct nameidata *nd)
1042 {
1043         struct iattr attr;
1044         int error;
1045         int open_flags = 0;
1046
1047         dfprintk(VFS, "NFS: create(%s/%ld, %s\n", dir->i_sb->s_id, 
1048                 dir->i_ino, dentry->d_name.name);
1049
1050         attr.ia_mode = mode;
1051         attr.ia_valid = ATTR_MODE;
1052
1053         if (nd && (nd->flags & LOOKUP_CREATE))
1054                 open_flags = nd->intent.open.flags;
1055
1056         lock_kernel();
1057         nfs_begin_data_update(dir);
1058         error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags);
1059         nfs_end_data_update(dir);
1060         if (error != 0)
1061                 goto out_err;
1062         nfs_renew_times(dentry);
1063         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1064         unlock_kernel();
1065         return 0;
1066 out_err:
1067         unlock_kernel();
1068         d_drop(dentry);
1069         return error;
1070 }
1071
1072 /*
1073  * See comments for nfs_proc_create regarding failed operations.
1074  */
1075 static int
1076 nfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
1077 {
1078         struct iattr attr;
1079         int status;
1080
1081         dfprintk(VFS, "NFS: mknod(%s/%ld, %s\n", dir->i_sb->s_id,
1082                 dir->i_ino, dentry->d_name.name);
1083
1084         if (!new_valid_dev(rdev))
1085                 return -EINVAL;
1086
1087         attr.ia_mode = mode;
1088         attr.ia_valid = ATTR_MODE;
1089
1090         lock_kernel();
1091         nfs_begin_data_update(dir);
1092         status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev);
1093         nfs_end_data_update(dir);
1094         if (status != 0)
1095                 goto out_err;
1096         nfs_renew_times(dentry);
1097         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1098         unlock_kernel();
1099         return 0;
1100 out_err:
1101         unlock_kernel();
1102         d_drop(dentry);
1103         return status;
1104 }
1105
1106 /*
1107  * See comments for nfs_proc_create regarding failed operations.
1108  */
1109 static int nfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
1110 {
1111         struct iattr attr;
1112         int error;
1113
1114         dfprintk(VFS, "NFS: mkdir(%s/%ld, %s\n", dir->i_sb->s_id,
1115                 dir->i_ino, dentry->d_name.name);
1116
1117         attr.ia_valid = ATTR_MODE;
1118         attr.ia_mode = mode | S_IFDIR;
1119
1120         lock_kernel();
1121         nfs_begin_data_update(dir);
1122         error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr);
1123         nfs_end_data_update(dir);
1124         if (error != 0)
1125                 goto out_err;
1126         nfs_renew_times(dentry);
1127         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1128         unlock_kernel();
1129         return 0;
1130 out_err:
1131         d_drop(dentry);
1132         unlock_kernel();
1133         return error;
1134 }
1135
1136 static int nfs_rmdir(struct inode *dir, struct dentry *dentry)
1137 {
1138         int error;
1139
1140         dfprintk(VFS, "NFS: rmdir(%s/%ld, %s\n", dir->i_sb->s_id,
1141                 dir->i_ino, dentry->d_name.name);
1142
1143         lock_kernel();
1144         nfs_begin_data_update(dir);
1145         error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
1146         /* Ensure the VFS deletes this inode */
1147         if (error == 0 && dentry->d_inode != NULL)
1148                 dentry->d_inode->i_nlink = 0;
1149         nfs_end_data_update(dir);
1150         unlock_kernel();
1151
1152         return error;
1153 }
1154
1155 static int nfs_sillyrename(struct inode *dir, struct dentry *dentry)
1156 {
1157         static unsigned int sillycounter;
1158         const int      i_inosize  = sizeof(dir->i_ino)*2;
1159         const int      countersize = sizeof(sillycounter)*2;
1160         const int      slen       = sizeof(".nfs") + i_inosize + countersize - 1;
1161         char           silly[slen+1];
1162         struct qstr    qsilly;
1163         struct dentry *sdentry;
1164         int            error = -EIO;
1165
1166         dfprintk(VFS, "NFS: silly-rename(%s/%s, ct=%d)\n",
1167                 dentry->d_parent->d_name.name, dentry->d_name.name, 
1168                 atomic_read(&dentry->d_count));
1169
1170 #ifdef NFS_PARANOIA
1171 if (!dentry->d_inode)
1172 printk("NFS: silly-renaming %s/%s, negative dentry??\n",
1173 dentry->d_parent->d_name.name, dentry->d_name.name);
1174 #endif
1175         /*
1176          * We don't allow a dentry to be silly-renamed twice.
1177          */
1178         error = -EBUSY;
1179         if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
1180                 goto out;
1181
1182         sprintf(silly, ".nfs%*.*lx",
1183                 i_inosize, i_inosize, dentry->d_inode->i_ino);
1184
1185         sdentry = NULL;
1186         do {
1187                 char *suffix = silly + slen - countersize;
1188
1189                 dput(sdentry);
1190                 sillycounter++;
1191                 sprintf(suffix, "%*.*x", countersize, countersize, sillycounter);
1192
1193                 dfprintk(VFS, "trying to rename %s to %s\n",
1194                          dentry->d_name.name, silly);
1195                 
1196                 sdentry = lookup_one_len(silly, dentry->d_parent, slen);
1197                 /*
1198                  * N.B. Better to return EBUSY here ... it could be
1199                  * dangerous to delete the file while it's in use.
1200                  */
1201                 if (IS_ERR(sdentry))
1202                         goto out;
1203         } while(sdentry->d_inode != NULL); /* need negative lookup */
1204
1205         qsilly.name = silly;
1206         qsilly.len  = strlen(silly);
1207         nfs_begin_data_update(dir);
1208         if (dentry->d_inode) {
1209                 nfs_begin_data_update(dentry->d_inode);
1210                 error = NFS_PROTO(dir)->rename(dir, &dentry->d_name,
1211                                 dir, &qsilly);
1212                 nfs_end_data_update(dentry->d_inode);
1213         } else
1214                 error = NFS_PROTO(dir)->rename(dir, &dentry->d_name,
1215                                 dir, &qsilly);
1216         nfs_end_data_update(dir);
1217         if (!error) {
1218                 nfs_renew_times(dentry);
1219                 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1220                 d_move(dentry, sdentry);
1221                 error = nfs_async_unlink(dentry);
1222                 /* If we return 0 we don't unlink */
1223         }
1224         dput(sdentry);
1225 out:
1226         return error;
1227 }
1228
1229 /*
1230  * Remove a file after making sure there are no pending writes,
1231  * and after checking that the file has only one user. 
1232  *
1233  * We invalidate the attribute cache and free the inode prior to the operation
1234  * to avoid possible races if the server reuses the inode.
1235  */
1236 static int nfs_safe_remove(struct dentry *dentry)
1237 {
1238         struct inode *dir = dentry->d_parent->d_inode;
1239         struct inode *inode = dentry->d_inode;
1240         int error = -EBUSY;
1241                 
1242         dfprintk(VFS, "NFS: safe_remove(%s/%s)\n",
1243                 dentry->d_parent->d_name.name, dentry->d_name.name);
1244
1245         /* If the dentry was sillyrenamed, we simply call d_delete() */
1246         if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1247                 error = 0;
1248                 goto out;
1249         }
1250
1251         nfs_begin_data_update(dir);
1252         if (inode != NULL) {
1253                 nfs_begin_data_update(inode);
1254                 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1255                 /* The VFS may want to delete this inode */
1256                 if (error == 0)
1257                         inode->i_nlink--;
1258                 nfs_end_data_update(inode);
1259         } else
1260                 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1261         nfs_end_data_update(dir);
1262 out:
1263         return error;
1264 }
1265
1266 /*  We do silly rename. In case sillyrename() returns -EBUSY, the inode
1267  *  belongs to an active ".nfs..." file and we return -EBUSY.
1268  *
1269  *  If sillyrename() returns 0, we do nothing, otherwise we unlink.
1270  */
1271 static int nfs_unlink(struct inode *dir, struct dentry *dentry)
1272 {
1273         int error;
1274         int need_rehash = 0;
1275
1276         dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id,
1277                 dir->i_ino, dentry->d_name.name);
1278
1279         lock_kernel();
1280         spin_lock(&dcache_lock);
1281         spin_lock(&dentry->d_lock);
1282         if (atomic_read(&dentry->d_count) > 1) {
1283                 spin_unlock(&dentry->d_lock);
1284                 spin_unlock(&dcache_lock);
1285                 error = nfs_sillyrename(dir, dentry);
1286                 unlock_kernel();
1287                 return error;
1288         }
1289         if (!d_unhashed(dentry)) {
1290                 __d_drop(dentry);
1291                 need_rehash = 1;
1292         }
1293         spin_unlock(&dentry->d_lock);
1294         spin_unlock(&dcache_lock);
1295         error = nfs_safe_remove(dentry);
1296         if (!error) {
1297                 nfs_renew_times(dentry);
1298                 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1299         } else if (need_rehash)
1300                 d_rehash(dentry);
1301         unlock_kernel();
1302         return error;
1303 }
1304
1305 static int
1306 nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1307 {
1308         struct iattr attr;
1309         struct nfs_fattr sym_attr;
1310         struct nfs_fh sym_fh;
1311         struct qstr qsymname;
1312         int error;
1313
1314         dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id,
1315                 dir->i_ino, dentry->d_name.name, symname);
1316
1317 #ifdef NFS_PARANOIA
1318 if (dentry->d_inode)
1319 printk("nfs_proc_symlink: %s/%s not negative!\n",
1320 dentry->d_parent->d_name.name, dentry->d_name.name);
1321 #endif
1322         /*
1323          * Fill in the sattr for the call.
1324          * Note: SunOS 4.1.2 crashes if the mode isn't initialized!
1325          */
1326         attr.ia_valid = ATTR_MODE;
1327         attr.ia_mode = S_IFLNK | S_IRWXUGO;
1328
1329         qsymname.name = symname;
1330         qsymname.len  = strlen(symname);
1331
1332         lock_kernel();
1333         nfs_begin_data_update(dir);
1334         error = NFS_PROTO(dir)->symlink(dir, &dentry->d_name, &qsymname,
1335                                           &attr, &sym_fh, &sym_attr);
1336         nfs_end_data_update(dir);
1337         if (!error) {
1338                 error = nfs_instantiate(dentry, &sym_fh, &sym_attr);
1339         } else {
1340                 if (error == -EEXIST)
1341                         printk("nfs_proc_symlink: %s/%s already exists??\n",
1342                                dentry->d_parent->d_name.name, dentry->d_name.name);
1343                 d_drop(dentry);
1344         }
1345         unlock_kernel();
1346         return error;
1347 }
1348
1349 static int 
1350 nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
1351 {
1352         struct inode *inode = old_dentry->d_inode;
1353         int error;
1354
1355         dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n",
1356                 old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
1357                 dentry->d_parent->d_name.name, dentry->d_name.name);
1358
1359         /*
1360          * Drop the dentry in advance to force a new lookup.
1361          * Since nfs_proc_link doesn't return a file handle,
1362          * we can't use the existing dentry.
1363          */
1364         lock_kernel();
1365         d_drop(dentry);
1366
1367         nfs_begin_data_update(dir);
1368         nfs_begin_data_update(inode);
1369         error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
1370         nfs_end_data_update(inode);
1371         nfs_end_data_update(dir);
1372         unlock_kernel();
1373         return error;
1374 }
1375
1376 /*
1377  * RENAME
1378  * FIXME: Some nfsds, like the Linux user space nfsd, may generate a
1379  * different file handle for the same inode after a rename (e.g. when
1380  * moving to a different directory). A fail-safe method to do so would
1381  * be to look up old_dir/old_name, create a link to new_dir/new_name and
1382  * rename the old file using the sillyrename stuff. This way, the original
1383  * file in old_dir will go away when the last process iput()s the inode.
1384  *
1385  * FIXED.
1386  * 
1387  * It actually works quite well. One needs to have the possibility for
1388  * at least one ".nfs..." file in each directory the file ever gets
1389  * moved or linked to which happens automagically with the new
1390  * implementation that only depends on the dcache stuff instead of
1391  * using the inode layer
1392  *
1393  * Unfortunately, things are a little more complicated than indicated
1394  * above. For a cross-directory move, we want to make sure we can get
1395  * rid of the old inode after the operation.  This means there must be
1396  * no pending writes (if it's a file), and the use count must be 1.
1397  * If these conditions are met, we can drop the dentries before doing
1398  * the rename.
1399  */
1400 static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1401                       struct inode *new_dir, struct dentry *new_dentry)
1402 {
1403         struct inode *old_inode = old_dentry->d_inode;
1404         struct inode *new_inode = new_dentry->d_inode;
1405         struct dentry *dentry = NULL, *rehash = NULL;
1406         int error = -EBUSY;
1407
1408         /*
1409          * To prevent any new references to the target during the rename,
1410          * we unhash the dentry and free the inode in advance.
1411          */
1412         lock_kernel();
1413         if (!d_unhashed(new_dentry)) {
1414                 d_drop(new_dentry);
1415                 rehash = new_dentry;
1416         }
1417
1418         dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n",
1419                  old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
1420                  new_dentry->d_parent->d_name.name, new_dentry->d_name.name,
1421                  atomic_read(&new_dentry->d_count));
1422
1423         /*
1424          * First check whether the target is busy ... we can't
1425          * safely do _any_ rename if the target is in use.
1426          *
1427          * For files, make a copy of the dentry and then do a 
1428          * silly-rename. If the silly-rename succeeds, the
1429          * copied dentry is hashed and becomes the new target.
1430          */
1431         if (!new_inode)
1432                 goto go_ahead;
1433         if (S_ISDIR(new_inode->i_mode))
1434                 goto out;
1435         else if (atomic_read(&new_dentry->d_count) > 2) {
1436                 int err;
1437                 /* copy the target dentry's name */
1438                 dentry = d_alloc(new_dentry->d_parent,
1439                                  &new_dentry->d_name);
1440                 if (!dentry)
1441                         goto out;
1442
1443                 /* silly-rename the existing target ... */
1444                 err = nfs_sillyrename(new_dir, new_dentry);
1445                 if (!err) {
1446                         new_dentry = rehash = dentry;
1447                         new_inode = NULL;
1448                         /* instantiate the replacement target */
1449                         d_instantiate(new_dentry, NULL);
1450                 } else if (atomic_read(&new_dentry->d_count) > 1) {
1451                 /* dentry still busy? */
1452 #ifdef NFS_PARANOIA
1453                         printk("nfs_rename: target %s/%s busy, d_count=%d\n",
1454                                new_dentry->d_parent->d_name.name,
1455                                new_dentry->d_name.name,
1456                                atomic_read(&new_dentry->d_count));
1457 #endif
1458                         goto out;
1459                 }
1460         }
1461
1462 go_ahead:
1463         /*
1464          * ... prune child dentries and writebacks if needed.
1465          */
1466         if (atomic_read(&old_dentry->d_count) > 1) {
1467                 nfs_wb_all(old_inode);
1468                 shrink_dcache_parent(old_dentry);
1469         }
1470
1471         if (new_inode)
1472                 d_delete(new_dentry);
1473
1474         nfs_begin_data_update(old_dir);
1475         nfs_begin_data_update(new_dir);
1476         nfs_begin_data_update(old_inode);
1477         error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name,
1478                                            new_dir, &new_dentry->d_name);
1479         nfs_end_data_update(old_inode);
1480         nfs_end_data_update(new_dir);
1481         nfs_end_data_update(old_dir);
1482 out:
1483         if (rehash)
1484                 d_rehash(rehash);
1485         if (!error) {
1486                 if (!S_ISDIR(old_inode->i_mode))
1487                         d_move(old_dentry, new_dentry);
1488                 nfs_renew_times(new_dentry);
1489                 nfs_set_verifier(new_dentry, nfs_save_change_attribute(new_dir));
1490         }
1491
1492         /* new dentry created? */
1493         if (dentry)
1494                 dput(dentry);
1495         unlock_kernel();
1496         return error;
1497 }
1498
1499 int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res)
1500 {
1501         struct nfs_access_entry *cache = &NFS_I(inode)->cache_access;
1502
1503         if (cache->cred != cred
1504                         || time_after(jiffies, cache->jiffies + NFS_ATTRTIMEO(inode))
1505                         || (NFS_FLAGS(inode) & NFS_INO_INVALID_ACCESS))
1506                 return -ENOENT;
1507         memcpy(res, cache, sizeof(*res));
1508         return 0;
1509 }
1510
1511 void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)
1512 {
1513         struct nfs_access_entry *cache = &NFS_I(inode)->cache_access;
1514
1515         if (cache->cred != set->cred) {
1516                 if (cache->cred)
1517                         put_rpccred(cache->cred);
1518                 cache->cred = get_rpccred(set->cred);
1519         }
1520         NFS_FLAGS(inode) &= ~NFS_INO_INVALID_ACCESS;
1521         cache->jiffies = set->jiffies;
1522         cache->mask = set->mask;
1523 }
1524
1525 static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask)
1526 {
1527         struct nfs_access_entry cache;
1528         int status;
1529
1530         status = nfs_access_get_cached(inode, cred, &cache);
1531         if (status == 0)
1532                 goto out;
1533
1534         /* Be clever: ask server to check for all possible rights */
1535         cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ;
1536         cache.cred = cred;
1537         cache.jiffies = jiffies;
1538         status = NFS_PROTO(inode)->access(inode, &cache);
1539         if (status != 0)
1540                 return status;
1541         nfs_access_add_cache(inode, &cache);
1542 out:
1543         if ((cache.mask & mask) == mask)
1544                 return 0;
1545         return -EACCES;
1546 }
1547
1548 int nfs_permission(struct inode *inode, int mask, struct nameidata *nd)
1549 {
1550         struct rpc_cred *cred;
1551         int res = 0;
1552
1553         if (mask == 0)
1554                 goto out;
1555         /* Is this sys_access() ? */
1556         if (nd != NULL && (nd->flags & LOOKUP_ACCESS))
1557                 goto force_lookup;
1558
1559         switch (inode->i_mode & S_IFMT) {
1560                 case S_IFLNK:
1561                         goto out;
1562                 case S_IFREG:
1563                         /* NFSv4 has atomic_open... */
1564                         if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN)
1565                                         && nd != NULL
1566                                         && (nd->flags & LOOKUP_OPEN))
1567                                 goto out;
1568                         break;
1569                 case S_IFDIR:
1570                         /*
1571                          * Optimize away all write operations, since the server
1572                          * will check permissions when we perform the op.
1573                          */
1574                         if ((mask & MAY_WRITE) && !(mask & MAY_READ))
1575                                 goto out;
1576         }
1577
1578 force_lookup:
1579         lock_kernel();
1580
1581         if (!NFS_PROTO(inode)->access)
1582                 goto out_notsup;
1583
1584         cred = rpcauth_lookupcred(NFS_CLIENT(inode)->cl_auth, 0);
1585         if (!IS_ERR(cred)) {
1586                 res = nfs_do_access(inode, cred, mask);
1587                 put_rpccred(cred);
1588         } else
1589                 res = PTR_ERR(cred);
1590         unlock_kernel();
1591 out:
1592         return res;
1593 out_notsup:
1594         res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
1595         if (res == 0)
1596                 res = generic_permission(inode, mask, NULL);
1597         unlock_kernel();
1598         return res;
1599 }
1600
1601 /*
1602  * Local variables:
1603  *  version-control: t
1604  *  kept-new-versions: 5
1605  * End:
1606  */