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->intent.open.flags & (O_CREAT|O_TRUNC|FMODE_WRITE)))
 782                 return 0;
 783         return 1;
 784 }
 785
 786 static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
 787 {
 788         struct inode *inode = NULL;
 789         int error = 0;
 790
 791         /* Check that we are indeed trying to open this file */
 792         if (!is_atomic_open(dir, nd))
 793                 goto no_open;
 794
 795         if (dentry->d_name.len > NFS_SERVER(dir)->namelen) {
 796                 error = -ENAMETOOLONG;
 797                 goto out;
 798         }
 799         dentry->d_op = NFS_PROTO(dir)->dentry_ops;
 800
 801         /* Let vfs_create() deal with O_EXCL */
 802         if (nd->intent.open.flags & O_EXCL)
 803                 goto no_entry;
 804
 805         /* Open the file on the server */
 806         lock_kernel();
 807         /* Revalidate parent directory attribute cache */
 808         nfs_revalidate_inode(NFS_SERVER(dir), dir);
 809
 810         if (nd->intent.open.flags & O_CREAT) {
 811                 nfs_begin_data_update(dir);
 812                 inode = nfs4_atomic_open(dir, dentry, nd);
 813                 nfs_end_data_update(dir);
 814         } else
 815                 inode = nfs4_atomic_open(dir, dentry, nd);
 816         unlock_kernel();
 817         if (IS_ERR(inode)) {
 818                 error = PTR_ERR(inode);
 819                 switch (error) {
 820                         /* Make a negative dentry */
 821                         case -ENOENT:
 822                                 inode = NULL;
 823                                 break;
 824                         /* This turned out not to be a regular file */
 825                         case -ELOOP:
 826                                 if (!(nd->intent.open.flags & O_NOFOLLOW))
 827                                         goto no_open;
 828                         /* case -EISDIR: */
 829                         /* case -EINVAL: */
 830                         default:
 831                                 goto out;
 832                 }
 833         }
 834 no_entry:
 835         d_add(dentry, inode);
 836         nfs_renew_times(dentry);
 837         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
 838 out:
 839         BUG_ON(error > 0);
 840         return ERR_PTR(error);
 841 no_open:
 842         return nfs_lookup(dir, dentry, nd);
 843 }
 844
 845 static int nfs_open_revalidate(struct dentry *dentry, struct nameidata *nd)
 846 {
 847         struct dentry *parent = NULL;
 848         struct inode *inode = dentry->d_inode;
 849         struct inode *dir;
 850         unsigned long verifier;
 851         int openflags, ret = 0;
 852
 853         /* NFS only supports OPEN for regular files */
 854         if (inode && !S_ISREG(inode->i_mode))
 855                 goto no_open;
 856         parent = dget_parent(dentry);
 857         dir = parent->d_inode;
 858         if (!is_atomic_open(dir, nd))
 859                 goto no_open;
 860         openflags = nd->intent.open.flags;
 861         if (openflags & O_CREAT) {
 862                 /* If this is a negative dentry, just drop it */
 863                 if (!inode)
 864                         goto out;
 865                 /* If this is exclusive open, just revalidate */
 866                 if (openflags & O_EXCL)
 867                         goto no_open;
 868         }
 869         /* We can't create new files, or truncate existing ones here */
 870         openflags &= ~(O_CREAT|O_TRUNC);
 871
 872         /*
 873          * Note: we're not holding inode->i_sem and so may be racing with
 874          * operations that change the directory. We therefore save the
 875          * change attribute *before* we do the RPC call.
 876          */
 877         lock_kernel();
 878         verifier = nfs_save_change_attribute(dir);
 879         ret = nfs4_open_revalidate(dir, dentry, openflags);
 880         if (!ret)
 881                 nfs_set_verifier(dentry, verifier);
 882         unlock_kernel();
 883 out:
 884         dput(parent);
 885         if (!ret)
 886                 d_drop(dentry);
 887         return ret;
 888 no_open:
 889         dput(parent);
 890         return nfs_lookup_revalidate(dentry, nd);
 891 }
 892 #endif /* CONFIG_NFSV4 */
 893
 894 static inline
 895 int find_dirent_name(nfs_readdir_descriptor_t *desc, struct page *page, struct dentry *dentry)
 896 {
 897         struct nfs_entry *entry = desc->entry;
 898         int              status;
 899
 900         while((status = dir_decode(desc)) == 0) {
 901                 if (entry->len != dentry->d_name.len)
 902                         continue;
 903                 if (memcmp(entry->name, dentry->d_name.name, entry->len))
 904                         continue;
 905                 if (!(entry->fattr->valid & NFS_ATTR_FATTR))
 906                         continue;
 907                 break;
 908         }
 909         return status;
 910 }
 911
 912 /*
 913  * Use the cached Readdirplus results in order to avoid a LOOKUP call
 914  * whenever we believe that the parent directory has not changed.
 915  *
 916  * We assume that any file creation/rename changes the directory mtime.
 917  * As this results in a page cache invalidation whenever it occurs,
 918  * we don't require any other tests for cache coherency.
 919  */
 920 static
 921 int nfs_cached_lookup(struct inode *dir, struct dentry *dentry,
 922                         struct nfs_fh *fh, struct nfs_fattr *fattr)
 923 {
 924         nfs_readdir_descriptor_t desc;
 925         struct nfs_server *server;
 926         struct nfs_entry entry;
 927         struct page *page;
 928         unsigned long timestamp;
 929         int res;
 930
 931         if (!NFS_USE_READDIRPLUS(dir))
 932                 return -ENOENT;
 933         server = NFS_SERVER(dir);
 934         /* Don't use readdirplus unless the cache is stable */
 935         if ((server->flags & NFS_MOUNT_NOAC) != 0
 936                         || nfs_caches_unstable(dir)
 937                         || nfs_attribute_timeout(dir))
 938                 return -ENOENT;
 939         if ((NFS_FLAGS(dir) & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA)) != 0)
 940                 return -ENOENT;
 941         timestamp = NFS_I(dir)->readdir_timestamp;
 942
 943         entry.fh = fh;
 944         entry.fattr = fattr;
 945
 946         desc.decode = NFS_PROTO(dir)->decode_dirent;
 947         desc.entry = &entry;
 948         desc.page_index = 0;
 949         desc.plus = 1;
 950
 951         for(;(page = find_get_page(dir->i_mapping, desc.page_index)); desc.page_index++) {
 952
 953                 res = -EIO;
 954                 if (PageUptodate(page)) {
 955                         void * kaddr = kmap_atomic(page, KM_USER0);
 956                         desc.ptr = kaddr;
 957                         res = find_dirent_name(&desc, page, dentry);
 958                         kunmap_atomic(kaddr, KM_USER0);
 959                 }
 960                 page_cache_release(page);
 961
 962                 if (res == 0)
 963                         goto out_found;
 964                 if (res != -EAGAIN)
 965                         break;
 966         }
 967         return -ENOENT;
 968  out_found:
 969         fattr->timestamp = timestamp;
 970         return 0;
 971 }
 972
 973 /*
 974  * Code common to create, mkdir, and mknod.
 975  */
 976 static int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
 977                                 struct nfs_fattr *fattr)
 978 {
 979         struct inode *inode;
 980         int error = -EACCES;
 981
 982         /* We may have been initialized further down */
 983         if (dentry->d_inode)
 984                 return 0;
 985         if (fhandle->size == 0 || !(fattr->valid & NFS_ATTR_FATTR)) {
 986                 struct inode *dir = dentry->d_parent->d_inode;
 987                 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
 988                 if (error)
 989                         goto out_err;
 990         }
 991         inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
 992         if (inode) {
 993                 d_instantiate(dentry, inode);
 994                 nfs_renew_times(dentry);
 995                 nfs_set_verifier(dentry, nfs_save_change_attribute(dentry->d_parent->d_inode));
 996                 return 0;
 997         }
 998         error = -ENOMEM;
 999 out_err:
1000         d_drop(dentry);
1001         return error;
1002 }
1003
1004 /*
1005  * Following a failed create operation, we drop the dentry rather
1006  * than retain a negative dentry. This avoids a problem in the event
1007  * that the operation succeeded on the server, but an error in the
1008  * reply path made it appear to have failed.
1009  */
1010 static int nfs_create(struct inode *dir, struct dentry *dentry, int mode,
1011                 struct nameidata *nd)
1012 {
1013         struct iattr attr;
1014         struct inode *inode;
1015         int error;
1016         int open_flags = 0;
1017
1018         dfprintk(VFS, "NFS: create(%s/%ld, %s\n", dir->i_sb->s_id,
1019                 dir->i_ino, dentry->d_name.name);
1020
1021         attr.ia_mode = mode;
1022         attr.ia_valid = ATTR_MODE;
1023
1024         if (nd && (nd->flags & LOOKUP_CREATE))
1025                 open_flags = nd->intent.open.flags;
1026
1027         /*
1028          * The 0 argument passed into the create function should one day
1029          * contain the O_EXCL flag if requested. This allows NFSv3 to
1030          * select the appropriate create strategy. Currently open_namei
1031          * does not pass the create flags.
1032          */
1033         lock_kernel();
1034         nfs_begin_data_update(dir);
1035         inode = NFS_PROTO(dir)->create(dir, &dentry->d_name, &attr, open_flags);
1036         nfs_end_data_update(dir);
1037         if (!IS_ERR(inode)) {
1038                 d_instantiate(dentry, inode);
1039                 nfs_renew_times(dentry);
1040                 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1041                 error = 0;
1042         } else {
1043                 error = PTR_ERR(inode);
1044                 d_drop(dentry);
1045         }
1046         unlock_kernel();
1047         return error;
1048 }
1049
1050 /*
1051  * See comments for nfs_proc_create regarding failed operations.
1052  */
1053 static int
1054 nfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
1055 {
1056         struct iattr attr;
1057         struct nfs_fattr fattr;
1058         struct nfs_fh fhandle;
1059         int error;
1060
1061         dfprintk(VFS, "NFS: mknod(%s/%ld, %s\n", dir->i_sb->s_id,
1062                 dir->i_ino, dentry->d_name.name);
1063
1064         if (!new_valid_dev(rdev))
1065                 return -EINVAL;
1066
1067         attr.ia_mode = mode;
1068         attr.ia_valid = ATTR_MODE;
1069
1070         lock_kernel();
1071         nfs_begin_data_update(dir);
1072         error = NFS_PROTO(dir)->mknod(dir, &dentry->d_name, &attr, rdev,
1073                                         &fhandle, &fattr);
1074         nfs_end_data_update(dir);
1075         if (!error)
1076                 error = nfs_instantiate(dentry, &fhandle, &fattr);
1077         else
1078                 d_drop(dentry);
1079         unlock_kernel();
1080         return error;
1081 }
1082
1083 /*
1084  * See comments for nfs_proc_create regarding failed operations.
1085  */
1086 static int nfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
1087 {
1088         struct iattr attr;
1089         struct nfs_fattr fattr;
1090         struct nfs_fh fhandle;
1091         int error;
1092
1093         dfprintk(VFS, "NFS: mkdir(%s/%ld, %s\n", dir->i_sb->s_id,
1094                 dir->i_ino, dentry->d_name.name);
1095
1096         attr.ia_valid = ATTR_MODE;
1097         attr.ia_mode = mode | S_IFDIR;
1098
1099         lock_kernel();
1100 #if 0
1101         /*
1102          * Always drop the dentry, we can't always depend on
1103          * the fattr returned by the server (AIX seems to be
1104          * broken). We're better off doing another lookup than
1105          * depending on potentially bogus information.
1106          */
1107         d_drop(dentry);
1108 #endif
1109         nfs_begin_data_update(dir);
1110         error = NFS_PROTO(dir)->mkdir(dir, &dentry->d_name, &attr, &fhandle,
1111                                         &fattr);
1112         nfs_end_data_update(dir);
1113         if (!error)
1114                 error = nfs_instantiate(dentry, &fhandle, &fattr);
1115         else
1116                 d_drop(dentry);
1117         unlock_kernel();
1118         return error;
1119 }
1120
1121 static int nfs_rmdir(struct inode *dir, struct dentry *dentry)
1122 {
1123         int error;
1124
1125         dfprintk(VFS, "NFS: rmdir(%s/%ld, %s\n", dir->i_sb->s_id,
1126                 dir->i_ino, dentry->d_name.name);
1127
1128         lock_kernel();
1129         nfs_begin_data_update(dir);
1130         error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
1131         /* Ensure the VFS deletes this inode */
1132         if (error == 0 && dentry->d_inode != NULL)
1133                 dentry->d_inode->i_nlink = 0;
1134         nfs_end_data_update(dir);
1135         unlock_kernel();
1136
1137         return error;
1138 }
1139
1140 static int nfs_sillyrename(struct inode *dir, struct dentry *dentry)
1141 {
1142         static unsigned int sillycounter;
1143         const int      i_inosize  = sizeof(dir->i_ino)*2;
1144         const int      countersize = sizeof(sillycounter)*2;
1145         const int      slen       = strlen(".nfs") + i_inosize + countersize;
1146         char           silly[slen+1];
1147         struct qstr    qsilly;
1148         struct dentry *sdentry;
1149         int            error = -EIO;
1150
1151         dfprintk(VFS, "NFS: silly-rename(%s/%s, ct=%d)\n",
1152                 dentry->d_parent->d_name.name, dentry->d_name.name,
1153                 atomic_read(&dentry->d_count));
1154
1155 #ifdef NFS_PARANOIA
1156 if (!dentry->d_inode)
1157 printk("NFS: silly-renaming %s/%s, negative dentry??\n",
1158 dentry->d_parent->d_name.name, dentry->d_name.name);
1159 #endif
1160         /*
1161          * We don't allow a dentry to be silly-renamed twice.
1162          */
1163         error = -EBUSY;
1164         if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
1165                 goto out;
1166
1167         sprintf(silly, ".nfs%*.*lx",
1168                 i_inosize, i_inosize, dentry->d_inode->i_ino);
1169
1170         sdentry = NULL;
1171         do {
1172                 char *suffix = silly + slen - countersize;
1173
1174                 dput(sdentry);
1175                 sillycounter++;
1176                 sprintf(suffix, "%*.*x", countersize, countersize, sillycounter);
1177
1178                 dfprintk(VFS, "trying to rename %s to %s\n",
1179                          dentry->d_name.name, silly);
1180
1181                 sdentry = lookup_one_len(silly, dentry->d_parent, slen);
1182                 /*
1183                  * N.B. Better to return EBUSY here ... it could be
1184                  * dangerous to delete the file while it's in use.
1185                  */
1186                 if (IS_ERR(sdentry))
1187                         goto out;
1188         } while(sdentry->d_inode != NULL); /* need negative lookup */
1189
1190         qsilly.name = silly;
1191         qsilly.len  = strlen(silly);
1192         nfs_begin_data_update(dir);
1193         if (dentry->d_inode) {
1194                 nfs_begin_data_update(dentry->d_inode);
1195                 error = NFS_PROTO(dir)->rename(dir, &dentry->d_name,
1196                                 dir, &qsilly);
1197                 nfs_end_data_update(dentry->d_inode);
1198         } else
1199                 error = NFS_PROTO(dir)->rename(dir, &dentry->d_name,
1200                                 dir, &qsilly);
1201         nfs_end_data_update(dir);
1202         if (!error) {
1203                 nfs_renew_times(dentry);
1204                 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1205                 d_move(dentry, sdentry);
1206                 error = nfs_async_unlink(dentry);
1207                 /* If we return 0 we don't unlink */
1208         }
1209         dput(sdentry);
1210 out:
1211         return error;
1212 }
1213
1214 /*
1215  * Remove a file after making sure there are no pending writes,
1216  * and after checking that the file has only one user.
1217  *
1218  * We invalidate the attribute cache and free the inode prior to the operation
1219  * to avoid possible races if the server reuses the inode.
1220  */
1221 static int nfs_safe_remove(struct dentry *dentry)
1222 {
1223         struct inode *dir = dentry->d_parent->d_inode;
1224         struct inode *inode = dentry->d_inode;
1225         int error = -EBUSY;
1226
1227         dfprintk(VFS, "NFS: safe_remove(%s/%s)\n",
1228                 dentry->d_parent->d_name.name, dentry->d_name.name);
1229
1230         /* If the dentry was sillyrenamed, we simply call d_delete() */
1231         if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1232                 error = 0;
1233                 goto out;
1234         }
1235
1236         nfs_begin_data_update(dir);
1237         if (inode != NULL) {
1238                 nfs_begin_data_update(inode);
1239                 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1240                 /* The VFS may want to delete this inode */
1241                 if (error == 0)
1242                         inode->i_nlink--;
1243                 nfs_end_data_update(inode);
1244         } else
1245                 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1246         nfs_end_data_update(dir);
1247 out:
1248         return error;
1249 }
1250
1251 /*  We do silly rename. In case sillyrename() returns -EBUSY, the inode
1252  *  belongs to an active ".nfs..." file and we return -EBUSY.
1253  *
1254  *  If sillyrename() returns 0, we do nothing, otherwise we unlink.
1255  */
1256 static int nfs_unlink(struct inode *dir, struct dentry *dentry)
1257 {
1258         int error;
1259         int need_rehash = 0;
1260
1261         dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id,
1262                 dir->i_ino, dentry->d_name.name);
1263
1264         lock_kernel();
1265         spin_lock(&dcache_lock);
1266         spin_lock(&dentry->d_lock);
1267         if (atomic_read(&dentry->d_count) > 1) {
1268                 spin_unlock(&dentry->d_lock);
1269                 spin_unlock(&dcache_lock);
1270                 error = nfs_sillyrename(dir, dentry);
1271                 unlock_kernel();
1272                 return error;
1273         }
1274         if (!d_unhashed(dentry)) {
1275                 __d_drop(dentry);
1276                 need_rehash = 1;
1277         }
1278         spin_unlock(&dentry->d_lock);
1279         spin_unlock(&dcache_lock);
1280         error = nfs_safe_remove(dentry);
1281         if (!error) {
1282                 nfs_renew_times(dentry);
1283                 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1284         } else if (need_rehash)
1285                 d_rehash(dentry);
1286         unlock_kernel();
1287         return error;
1288 }
1289
1290 static int
1291 nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1292 {
1293         struct iattr attr;
1294         struct nfs_fattr sym_attr;
1295         struct nfs_fh sym_fh;
1296         struct qstr qsymname;
1297         int error;
1298
1299         dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id,
1300                 dir->i_ino, dentry->d_name.name, symname);
1301
1302         error = -ENAMETOOLONG;
1303         switch (NFS_PROTO(dir)->version) {
1304                 case 2:
1305                         if (strlen(symname) > NFS2_MAXPATHLEN)
1306                                 goto out;
1307                         break;
1308                 case 3:
1309                         if (strlen(symname) > NFS3_MAXPATHLEN)
1310                                 goto out;
1311                 default:
1312                         break;
1313         }
1314
1315 #ifdef NFS_PARANOIA
1316 if (dentry->d_inode)
1317 printk("nfs_proc_symlink: %s/%s not negative!\n",
1318 dentry->d_parent->d_name.name, dentry->d_name.name);
1319 #endif
1320         /*
1321          * Fill in the sattr for the call.
1322          * Note: SunOS 4.1.2 crashes if the mode isn't initialized!
1323          */
1324         attr.ia_valid = ATTR_MODE;
1325         attr.ia_mode = S_IFLNK | S_IRWXUGO;
1326
1327         qsymname.name = symname;
1328         qsymname.len  = strlen(symname);
1329
1330         lock_kernel();
1331         nfs_begin_data_update(dir);
1332         error = NFS_PROTO(dir)->symlink(dir, &dentry->d_name, &qsymname,
1333                                           &attr, &sym_fh, &sym_attr);
1334         nfs_end_data_update(dir);
1335         if (!error) {
1336                 error = nfs_instantiate(dentry, &sym_fh, &sym_attr);
1337         } else {
1338                 if (error == -EEXIST)
1339                         printk("nfs_proc_symlink: %s/%s already exists??\n",
1340                                dentry->d_parent->d_name.name, dentry->d_name.name);
1341                 d_drop(dentry);
1342         }
1343         unlock_kernel();
1344
1345 out:
1346         return error;
1347 }
1348
1349 static int
1350 nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
1351 {
1352         struct inode *inode = old_dentry->d_inode;
1353         int error;
1354
1355         dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n",
1356                 old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
1357                 dentry->d_parent->d_name.name, dentry->d_name.name);
1358
1359         /*
1360          * Drop the dentry in advance to force a new lookup.
1361          * Since nfs_proc_link doesn't return a file handle,
1362          * we can't use the existing dentry.
1363          */
1364         lock_kernel();
1365         d_drop(dentry);
1366
1367         nfs_begin_data_update(dir);
1368         nfs_begin_data_update(inode);
1369         error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
1370         nfs_end_data_update(inode);
1371         nfs_end_data_update(dir);
1372         unlock_kernel();
1373         return error;
1374 }
1375
1376 /*
1377  * RENAME
1378  * FIXME: Some nfsds, like the Linux user space nfsd, may generate a
1379  * different file handle for the same inode after a rename (e.g. when
1380  * moving to a different directory). A fail-safe method to do so would
1381  * be to look up old_dir/old_name, create a link to new_dir/new_name and
1382  * rename the old file using the sillyrename stuff. This way, the original
1383  * file in old_dir will go away when the last process iput()s the inode.
1384  *
1385  * FIXED.
1386  *
1387  * It actually works quite well. One needs to have the possibility for
1388  * at least one ".nfs..." file in each directory the file ever gets
1389  * moved or linked to which happens automagically with the new
1390  * implementation that only depends on the dcache stuff instead of
1391  * using the inode layer
1392  *
1393  * Unfortunately, things are a little more complicated than indicated
1394  * above. For a cross-directory move, we want to make sure we can get
1395  * rid of the old inode after the operation.  This means there must be
1396  * no pending writes (if it's a file), and the use count must be 1.
1397  * If these conditions are met, we can drop the dentries before doing
1398  * the rename.
1399  */
1400 static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1401                       struct inode *new_dir, struct dentry *new_dentry)
1402 {
1403         struct inode *old_inode = old_dentry->d_inode;
1404         struct inode *new_inode = new_dentry->d_inode;
1405         struct dentry *dentry = NULL, *rehash = NULL;
1406         int error = -EBUSY;
1407
1408         /*
1409          * To prevent any new references to the target during the rename,
1410          * we unhash the dentry and free the inode in advance.
1411          */
1412         lock_kernel();
1413         if (!d_unhashed(new_dentry)) {
1414                 d_drop(new_dentry);
1415                 rehash = new_dentry;
1416         }
1417
1418         dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n",
1419                  old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
1420                  new_dentry->d_parent->d_name.name, new_dentry->d_name.name,
1421                  atomic_read(&new_dentry->d_count));
1422
1423         /*
1424          * First check whether the target is busy ... we can't
1425          * safely do _any_ rename if the target is in use.
1426          *
1427          * For files, make a copy of the dentry and then do a
1428          * silly-rename. If the silly-rename succeeds, the
1429          * copied dentry is hashed and becomes the new target.
1430          */
1431         if (!new_inode)
1432                 goto go_ahead;
1433         if (S_ISDIR(new_inode->i_mode))
1434                 goto out;
1435         else if (atomic_read(&new_dentry->d_count) > 1) {
1436                 int err;
1437                 /* copy the target dentry's name */
1438                 dentry = d_alloc(new_dentry->d_parent,
1439                                  &new_dentry->d_name);
1440                 if (!dentry)
1441                         goto out;
1442
1443                 /* silly-rename the existing target ... */
1444                 err = nfs_sillyrename(new_dir, new_dentry);
1445                 if (!err) {
1446                         new_dentry = rehash = dentry;
1447                         new_inode = NULL;
1448                         /* instantiate the replacement target */
1449                         d_instantiate(new_dentry, NULL);
1450                 }
1451
1452                 /* dentry still busy? */
1453                 if (atomic_read(&new_dentry->d_count) > 1) {
1454 #ifdef NFS_PARANOIA
1455                         printk("nfs_rename: target %s/%s busy, d_count=%d\n",
1456                                new_dentry->d_parent->d_name.name,
1457                                new_dentry->d_name.name,
1458                                atomic_read(&new_dentry->d_count));
1459 #endif
1460                         goto out;
1461                 }
1462         }
1463
1464 go_ahead:
1465         /*
1466          * ... prune child dentries and writebacks if needed.
1467          */
1468         if (atomic_read(&old_dentry->d_count) > 1) {
1469                 nfs_wb_all(old_inode);
1470                 shrink_dcache_parent(old_dentry);
1471         }
1472
1473         if (new_inode)
1474                 d_delete(new_dentry);
1475
1476         nfs_begin_data_update(old_dir);
1477         nfs_begin_data_update(new_dir);
1478         nfs_begin_data_update(old_inode);
1479         error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name,
1480                                            new_dir, &new_dentry->d_name);
1481         nfs_end_data_update(old_inode);
1482         nfs_end_data_update(new_dir);
1483         nfs_end_data_update(old_dir);
1484 out:
1485         if (rehash)
1486                 d_rehash(rehash);
1487         if (!error) {
1488                 if (!S_ISDIR(old_inode->i_mode))
1489                         d_move(old_dentry, new_dentry);
1490                 nfs_renew_times(new_dentry);
1491                 nfs_set_verifier(new_dentry, nfs_save_change_attribute(new_dir));
1492         }
1493
1494         /* new dentry created? */
1495         if (dentry)
1496                 dput(dentry);
1497         unlock_kernel();
1498         return error;
1499 }
1500
1501 int
1502 nfs_permission(struct inode *inode, int mask, struct nameidata *nd)
1503 {
1504         struct nfs_access_cache *cache = &NFS_I(inode)->cache_access;
1505         struct rpc_cred *cred;
1506         int mode = inode->i_mode;
1507         int res;
1508
1509         if (mask == 0)
1510                 return 0;
1511         if (mask & MAY_WRITE) {
1512                 /*
1513                  *
1514                  * Nobody gets write access to a read-only fs.
1515                  *
1516                  */
1517                 if (IS_RDONLY(inode) &&
1518                     (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
1519                         return -EROFS;
1520
1521                 /*
1522                  *
1523                  * Nobody gets write access to an immutable file.
1524                  *
1525                  */
1526                 if (IS_IMMUTABLE(inode))
1527                         return -EACCES;
1528         }
1529         /* Are we checking permissions on anything other than lookup/execute? */
1530         if ((mask & MAY_EXEC) == 0) {
1531                 /* We only need to check permissions on file open() and access() */
1532                 if (!nd || !(nd->flags & (LOOKUP_OPEN|LOOKUP_ACCESS)))
1533                         return 0;
1534                 /* NFSv4 has atomic_open... */
1535                 if (NFS_PROTO(inode)->version > 3 && (nd->flags & LOOKUP_OPEN))
1536                         return 0;
1537         }
1538
1539         lock_kernel();
1540
1541         if (!NFS_PROTO(inode)->access)
1542                 goto out_notsup;
1543
1544         cred = rpcauth_lookupcred(NFS_CLIENT(inode)->cl_auth, 0);
1545         if (cache->cred == cred
1546             && time_before(jiffies, cache->jiffies + NFS_ATTRTIMEO(inode))
1547             && !(NFS_FLAGS(inode) & NFS_INO_INVALID_ATTR)) {
1548                 if (!(res = cache->err)) {
1549                         /* Is the mask a subset of an accepted mask? */
1550                         if ((cache->mask & mask) == mask)
1551                                 goto out;
1552                 } else {
1553                         /* ...or is it a superset of a rejected mask? */
1554                         if ((cache->mask & mask) == cache->mask)
1555                                 goto out;
1556                 }
1557         }
1558
1559         res = NFS_PROTO(inode)->access(inode, cred, mask);
1560         if (!res || res == -EACCES)
1561                 goto add_cache;
1562 out:
1563         put_rpccred(cred);
1564         unlock_kernel();
1565         return res;
1566 out_notsup:
1567         nfs_revalidate_inode(NFS_SERVER(inode), inode);
1568         res = vfs_permission(inode, mask);
1569         unlock_kernel();
1570         return res;
1571 add_cache:
1572         cache->jiffies = jiffies;
1573         if (cache->cred)
1574                 put_rpccred(cache->cred);
1575         cache->cred = cred;
1576         cache->mask = mask;
1577         cache->err = res;
1578         unlock_kernel();
1579         return res;
1580 }
1581
1582 /*
1583  * Local variables:
1584  *  version-control: t
1585  *  kept-new-versions: 5
1586  * End:
1587  */