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  */