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