fs/nfs/dir.c

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