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