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/pagevec.h>
  33 #include <linux/namei.h>
  34 #include <linux/mount.h>
  35 #include <linux/sched.h>
  36 #include <linux/vmalloc.h>
  37
  38 #include "delegation.h"
  39 #include "iostat.h"
  40 #include "internal.h"
  41 #include "fscache.h"
  42
  43 /* #define NFS_DEBUG_VERBOSE 1 */
  44
  45 static int nfs_opendir(struct inode *, struct file *);
  46 static int nfs_readdir(struct file *, void *, filldir_t);
  47 static struct dentry *nfs_lookup(struct inode *, struct dentry *, struct nameidata *);
  48 static int nfs_create(struct inode *, struct dentry *, int, struct nameidata *);
  49 static int nfs_mkdir(struct inode *, struct dentry *, int);
  50 static int nfs_rmdir(struct inode *, struct dentry *);
  51 static int nfs_unlink(struct inode *, struct dentry *);
  52 static int nfs_symlink(struct inode *, struct dentry *, const char *);
  53 static int nfs_link(struct dentry *, struct inode *, struct dentry *);
  54 static int nfs_mknod(struct inode *, struct dentry *, int, dev_t);
  55 static int nfs_rename(struct inode *, struct dentry *,
  56                       struct inode *, struct dentry *);
  57 static int nfs_fsync_dir(struct file *, int);
  58 static loff_t nfs_llseek_dir(struct file *, loff_t, int);
  59 static int nfs_readdir_clear_array(struct page*, gfp_t);
  60
  61 const struct file_operations nfs_dir_operations = {
  62         .llseek         = nfs_llseek_dir,
  63         .read           = generic_read_dir,
  64         .readdir        = nfs_readdir,
  65         .open           = nfs_opendir,
  66         .release        = nfs_release,
  67         .fsync          = nfs_fsync_dir,
  68 };
  69
  70 const struct inode_operations nfs_dir_inode_operations = {
  71         .create         = nfs_create,
  72         .lookup         = nfs_lookup,
  73         .link           = nfs_link,
  74         .unlink         = nfs_unlink,
  75         .symlink        = nfs_symlink,
  76         .mkdir          = nfs_mkdir,
  77         .rmdir          = nfs_rmdir,
  78         .mknod          = nfs_mknod,
  79         .rename         = nfs_rename,
  80         .permission     = nfs_permission,
  81         .getattr        = nfs_getattr,
  82         .setattr        = nfs_setattr,
  83 };
  84
  85 const struct address_space_operations nfs_dir_addr_space_ops = {
  86         .releasepage = nfs_readdir_clear_array,
  87 };
  88
  89 #ifdef CONFIG_NFS_V3
  90 const struct inode_operations nfs3_dir_inode_operations = {
  91         .create         = nfs_create,
  92         .lookup         = nfs_lookup,
  93         .link           = nfs_link,
  94         .unlink         = nfs_unlink,
  95         .symlink        = nfs_symlink,
  96         .mkdir          = nfs_mkdir,
  97         .rmdir          = nfs_rmdir,
  98         .mknod          = nfs_mknod,
  99         .rename         = nfs_rename,
 100         .permission     = nfs_permission,
 101         .getattr        = nfs_getattr,
 102         .setattr        = nfs_setattr,
 103         .listxattr      = nfs3_listxattr,
 104         .getxattr       = nfs3_getxattr,
 105         .setxattr       = nfs3_setxattr,
 106         .removexattr    = nfs3_removexattr,
 107 };
 108 #endif  /* CONFIG_NFS_V3 */
 109
 110 #ifdef CONFIG_NFS_V4
 111
 112 static struct dentry *nfs_atomic_lookup(struct inode *, struct dentry *, struct nameidata *);
 113 static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd);
 114 const struct inode_operations nfs4_dir_inode_operations = {
 115         .create         = nfs_open_create,
 116         .lookup         = nfs_atomic_lookup,
 117         .link           = nfs_link,
 118         .unlink         = nfs_unlink,
 119         .symlink        = nfs_symlink,
 120         .mkdir          = nfs_mkdir,
 121         .rmdir          = nfs_rmdir,
 122         .mknod          = nfs_mknod,
 123         .rename         = nfs_rename,
 124         .permission     = nfs_permission,
 125         .getattr        = nfs_getattr,
 126         .setattr        = nfs_setattr,
 127         .getxattr       = nfs4_getxattr,
 128         .setxattr       = nfs4_setxattr,
 129         .listxattr      = nfs4_listxattr,
 130 };
 131
 132 #endif /* CONFIG_NFS_V4 */
 133
 134 /*
 135  * Open file
 136  */
 137 static int
 138 nfs_opendir(struct inode *inode, struct file *filp)
 139 {
 140         int res;
 141
 142         dfprintk(FILE, "NFS: open dir(%s/%s)\n",
 143                         filp->f_path.dentry->d_parent->d_name.name,
 144                         filp->f_path.dentry->d_name.name);
 145
 146         nfs_inc_stats(inode, NFSIOS_VFSOPEN);
 147
 148         /* Call generic open code in order to cache credentials */
 149         res = nfs_open(inode, filp);
 150         if (filp->f_path.dentry == filp->f_path.mnt->mnt_root) {
 151                 /* This is a mountpoint, so d_revalidate will never
 152                  * have been called, so we need to refresh the
 153                  * inode (for close-open consistency) ourselves.
 154                  */
 155                 __nfs_revalidate_inode(NFS_SERVER(inode), inode);
 156         }
 157         return res;
 158 }
 159
 160 struct nfs_cache_array_entry {
 161         u64 cookie;
 162         u64 ino;
 163         struct qstr string;
 164 };
 165
 166 struct nfs_cache_array {
 167         unsigned int size;
 168         int eof_index;
 169         u64 last_cookie;
 170         struct nfs_cache_array_entry array[0];
 171 };
 172
 173 #define MAX_READDIR_ARRAY ((PAGE_SIZE - sizeof(struct nfs_cache_array)) / sizeof(struct nfs_cache_array_entry))
 174
 175 typedef __be32 * (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, struct nfs_server *, int);
 176 typedef struct {
 177         struct file     *file;
 178         struct page     *page;
 179         unsigned long   page_index;
 180         u64             *dir_cookie;
 181         loff_t          current_index;
 182         decode_dirent_t decode;
 183
 184         unsigned long   timestamp;
 185         unsigned long   gencount;
 186         unsigned int    cache_entry_index;
 187         unsigned int    plus:1;
 188         unsigned int    eof:1;
 189 } nfs_readdir_descriptor_t;
 190
 191 /*
 192  * The caller is responsible for calling nfs_readdir_release_array(page)
 193  */
 194 static
 195 struct nfs_cache_array *nfs_readdir_get_array(struct page *page)
 196 {
 197         if (page == NULL)
 198                 return ERR_PTR(-EIO);
 199         return (struct nfs_cache_array *)kmap(page);
 200 }
 201
 202 static
 203 void nfs_readdir_release_array(struct page *page)
 204 {
 205         kunmap(page);
 206 }
 207
 208 /*
 209  * we are freeing strings created by nfs_add_to_readdir_array()
 210  */
 211 static
 212 int nfs_readdir_clear_array(struct page *page, gfp_t mask)
 213 {
 214         struct nfs_cache_array *array = nfs_readdir_get_array(page);
 215         int i;
 216         for (i = 0; i < array->size; i++)
 217                 kfree(array->array[i].string.name);
 218         nfs_readdir_release_array(page);
 219         return 0;
 220 }
 221
 222 /*
 223  * the caller is responsible for freeing qstr.name
 224  * when called by nfs_readdir_add_to_array, the strings will be freed in
 225  * nfs_clear_readdir_array()
 226  */
 227 static
 228 int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len)
 229 {
 230         string->len = len;
 231         string->name = kmemdup(name, len, GFP_KERNEL);
 232         if (string->name == NULL)
 233                 return -ENOMEM;
 234         string->hash = full_name_hash(name, len);
 235         return 0;
 236 }
 237
 238 static
 239 int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page)
 240 {
 241         struct nfs_cache_array *array = nfs_readdir_get_array(page);
 242         struct nfs_cache_array_entry *cache_entry;
 243         int ret;
 244
 245         if (IS_ERR(array))
 246                 return PTR_ERR(array);
 247         ret = -EIO;
 248         if (array->size >= MAX_READDIR_ARRAY)
 249                 goto out;
 250
 251         cache_entry = &array->array[array->size];
 252         cache_entry->cookie = entry->prev_cookie;
 253         cache_entry->ino = entry->ino;
 254         ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len);
 255         if (ret)
 256                 goto out;
 257         array->last_cookie = entry->cookie;
 258         if (entry->eof == 1)
 259                 array->eof_index = array->size;
 260         array->size++;
 261 out:
 262         nfs_readdir_release_array(page);
 263         return ret;
 264 }
 265
 266 static
 267 int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
 268 {
 269         loff_t diff = desc->file->f_pos - desc->current_index;
 270         unsigned int index;
 271
 272         if (diff < 0)
 273                 goto out_eof;
 274         if (diff >= array->size) {
 275                 if (array->eof_index > 0)
 276                         goto out_eof;
 277                 desc->current_index += array->size;
 278                 return -EAGAIN;
 279         }
 280
 281         index = (unsigned int)diff;
 282         *desc->dir_cookie = array->array[index].cookie;
 283         desc->cache_entry_index = index;
 284         if (index == array->eof_index)
 285                 desc->eof = 1;
 286         return 0;
 287 out_eof:
 288         desc->eof = 1;
 289         return -EBADCOOKIE;
 290 }
 291
 292 static
 293 int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
 294 {
 295         int i;
 296         int status = -EAGAIN;
 297
 298         for (i = 0; i < array->size; i++) {
 299                 if (i == array->eof_index) {
 300                         desc->eof = 1;
 301                         status = -EBADCOOKIE;
 302                 }
 303                 if (array->array[i].cookie == *desc->dir_cookie) {
 304                         desc->cache_entry_index = i;
 305                         status = 0;
 306                         break;
 307                 }
 308         }
 309
 310         return status;
 311 }
 312
 313 static
 314 int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc)
 315 {
 316         struct nfs_cache_array *array;
 317         int status = -EBADCOOKIE;
 318
 319         if (desc->dir_cookie == NULL)
 320                 goto out;
 321
 322         array = nfs_readdir_get_array(desc->page);
 323         if (IS_ERR(array)) {
 324                 status = PTR_ERR(array);
 325                 goto out;
 326         }
 327
 328         if (*desc->dir_cookie == 0)
 329                 status = nfs_readdir_search_for_pos(array, desc);
 330         else
 331                 status = nfs_readdir_search_for_cookie(array, desc);
 332
 333         nfs_readdir_release_array(desc->page);
 334 out:
 335         return status;
 336 }
 337
 338 /* Fill a page with xdr information before transferring to the cache page */
 339 static
 340 int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc,
 341                         struct nfs_entry *entry, struct file *file, struct inode *inode)
 342 {
 343         struct rpc_cred *cred = nfs_file_cred(file);
 344         unsigned long   timestamp, gencount;
 345         int             error;
 346
 347  again:
 348         timestamp = jiffies;
 349         gencount = nfs_inc_attr_generation_counter();
 350         error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, entry->cookie, pages,
 351                                           NFS_SERVER(inode)->dtsize, desc->plus);
 352         if (error < 0) {
 353                 /* We requested READDIRPLUS, but the server doesn't grok it */
 354                 if (error == -ENOTSUPP && desc->plus) {
 355                         NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS;
 356                         clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
 357                         desc->plus = 0;
 358                         goto again;
 359                 }
 360                 goto error;
 361         }
 362         desc->timestamp = timestamp;
 363         desc->gencount = gencount;
 364 error:
 365         return error;
 366 }
 367
 368 /* Fill in an entry based on the xdr code stored in desc->page */
 369 static
 370 int xdr_decode(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry, struct xdr_stream *stream)
 371 {
 372         __be32 *p = desc->decode(stream, entry, NFS_SERVER(desc->file->f_path.dentry->d_inode), desc->plus);
 373         if (IS_ERR(p))
 374                 return PTR_ERR(p);
 375
 376         entry->fattr->time_start = desc->timestamp;
 377         entry->fattr->gencount = desc->gencount;
 378         return 0;
 379 }
 380
 381 static
 382 int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry)
 383 {
 384         struct nfs_inode *node;
 385         if (dentry->d_inode == NULL)
 386                 goto different;
 387         node = NFS_I(dentry->d_inode);
 388         if (node->fh.size != entry->fh->size)
 389                 goto different;
 390         if (strncmp(node->fh.data, entry->fh->data, node->fh.size) != 0)
 391                 goto different;
 392         return 1;
 393 different:
 394         return 0;
 395 }
 396
 397 static
 398 void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
 399 {
 400         struct qstr filename = {
 401                 .len = entry->len,
 402                 .name = entry->name,
 403         };
 404         struct dentry *dentry;
 405         struct dentry *alias;
 406         struct inode *dir = parent->d_inode;
 407         struct inode *inode;
 408
 409         if (filename.name[0] == '.') {
 410                 if (filename.len == 1)
 411                         return;
 412                 if (filename.len == 2 && filename.name[1] == '.')
 413                         return;
 414         }
 415         filename.hash = full_name_hash(filename.name, filename.len);
 416
 417         dentry = d_lookup(parent, &filename);
 418         if (dentry != NULL) {
 419                 if (nfs_same_file(dentry, entry)) {
 420                         nfs_refresh_inode(dentry->d_inode, entry->fattr);
 421                         goto out;
 422                 } else {
 423                         d_drop(dentry);
 424                         dput(dentry);
 425                 }
 426         }
 427
 428         dentry = d_alloc(parent, &filename);
 429         if (dentry == NULL)
 430                 return;
 431
 432         dentry->d_op = NFS_PROTO(dir)->dentry_ops;
 433         inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr);
 434         if (IS_ERR(inode))
 435                 goto out;
 436
 437         alias = d_materialise_unique(dentry, inode);
 438         if (IS_ERR(alias))
 439                 goto out;
 440         else if (alias) {
 441                 nfs_set_verifier(alias, nfs_save_change_attribute(dir));
 442                 dput(alias);
 443         } else
 444                 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
 445
 446 out:
 447         dput(dentry);
 448 }
 449
 450 /* Perform conversion from xdr to cache array */
 451 static
 452 void nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry,
 453                                 void *xdr_page, struct page *page, unsigned int buflen)
 454 {
 455         struct xdr_stream stream;
 456         struct xdr_buf buf;
 457         __be32 *ptr = xdr_page;
 458         int status;
 459         struct nfs_cache_array *array;
 460
 461         buf.head->iov_base = xdr_page;
 462         buf.head->iov_len = buflen;
 463         buf.tail->iov_len = 0;
 464         buf.page_base = 0;
 465         buf.page_len = 0;
 466         buf.buflen = buf.head->iov_len;
 467         buf.len = buf.head->iov_len;
 468
 469         xdr_init_decode(&stream, &buf, ptr);
 470
 471
 472         do {
 473                 status = xdr_decode(desc, entry, &stream);
 474                 if (status != 0)
 475                         break;
 476
 477                 if (nfs_readdir_add_to_array(entry, page) == -1)
 478                         break;
 479                 if (desc->plus == 1)
 480                         nfs_prime_dcache(desc->file->f_path.dentry, entry);
 481         } while (!entry->eof);
 482
 483         if (status == -EBADCOOKIE && entry->eof) {
 484                 array = nfs_readdir_get_array(page);
 485                 array->eof_index = array->size - 1;
 486                 status = 0;
 487                 nfs_readdir_release_array(page);
 488         }
 489 }
 490
 491 static
 492 void nfs_readdir_free_pagearray(struct page **pages, unsigned int npages)
 493 {
 494         unsigned int i;
 495         for (i = 0; i < npages; i++)
 496                 put_page(pages[i]);
 497 }
 498
 499 static
 500 void nfs_readdir_free_large_page(void *ptr, struct page **pages,
 501                 unsigned int npages)
 502 {
 503         vm_unmap_ram(ptr, npages);
 504         nfs_readdir_free_pagearray(pages, npages);
 505 }
 506
 507 /*
 508  * nfs_readdir_large_page will allocate pages that must be freed with a call
 509  * to nfs_readdir_free_large_page
 510  */
 511 static
 512 void *nfs_readdir_large_page(struct page **pages, unsigned int npages)
 513 {
 514         void *ptr;
 515         unsigned int i;
 516
 517         for (i = 0; i < npages; i++) {
 518                 struct page *page = alloc_page(GFP_KERNEL);
 519                 if (page == NULL)
 520                         goto out_freepages;
 521                 pages[i] = page;
 522         }
 523
 524         ptr = vm_map_ram(pages, npages, 0, PAGE_KERNEL);
 525         if (!IS_ERR_OR_NULL(ptr))
 526                 return ptr;
 527 out_freepages:
 528         nfs_readdir_free_pagearray(pages, i);
 529         return NULL;
 530 }
 531
 532 static
 533 int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode)
 534 {
 535         struct page *pages[NFS_MAX_READDIR_PAGES];
 536         void *pages_ptr = NULL;
 537         struct nfs_entry entry;
 538         struct file     *file = desc->file;
 539         struct nfs_cache_array *array;
 540         int status = 0;
 541         unsigned int array_size = ARRAY_SIZE(pages);
 542
 543         entry.prev_cookie = 0;
 544         entry.cookie = *desc->dir_cookie;
 545         entry.eof = 0;
 546         entry.fh = nfs_alloc_fhandle();
 547         entry.fattr = nfs_alloc_fattr();
 548         if (entry.fh == NULL || entry.fattr == NULL)
 549                 goto out;
 550
 551         array = nfs_readdir_get_array(page);
 552         memset(array, 0, sizeof(struct nfs_cache_array));
 553         array->eof_index = -1;
 554
 555         pages_ptr = nfs_readdir_large_page(pages, array_size);
 556         if (!pages_ptr)
 557                 goto out_release_array;
 558         do {
 559                 status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode);
 560
 561                 if (status < 0)
 562                         break;
 563                 nfs_readdir_page_filler(desc, &entry, pages_ptr, page, array_size * PAGE_SIZE);
 564         } while (array->eof_index < 0 && array->size < MAX_READDIR_ARRAY);
 565
 566         nfs_readdir_free_large_page(pages_ptr, pages, array_size);
 567 out_release_array:
 568         nfs_readdir_release_array(page);
 569 out:
 570         nfs_free_fattr(entry.fattr);
 571         nfs_free_fhandle(entry.fh);
 572         return status;
 573 }
 574
 575 /*
 576  * Now we cache directories properly, by converting xdr information
 577  * to an array that can be used for lookups later.  This results in
 578  * fewer cache pages, since we can store more information on each page.
 579  * We only need to convert from xdr once so future lookups are much simpler
 580  */
 581 static
 582 int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page)
 583 {
 584         struct inode    *inode = desc->file->f_path.dentry->d_inode;
 585
 586         if (nfs_readdir_xdr_to_array(desc, page, inode) < 0)
 587                 goto error;
 588         SetPageUptodate(page);
 589
 590         if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) {
 591                 /* Should never happen */
 592                 nfs_zap_mapping(inode, inode->i_mapping);
 593         }
 594         unlock_page(page);
 595         return 0;
 596  error:
 597         unlock_page(page);
 598         return -EIO;
 599 }
 600
 601 static
 602 void cache_page_release(nfs_readdir_descriptor_t *desc)
 603 {
 604         page_cache_release(desc->page);
 605         desc->page = NULL;
 606 }
 607
 608 static
 609 struct page *get_cache_page(nfs_readdir_descriptor_t *desc)
 610 {
 611         struct page *page;
 612         page = read_cache_page(desc->file->f_path.dentry->d_inode->i_mapping,
 613                         desc->page_index, (filler_t *)nfs_readdir_filler, desc);
 614         if (IS_ERR(page))
 615                 desc->eof = 1;
 616         return page;
 617 }
 618
 619 /*
 620  * Returns 0 if desc->dir_cookie was found on page desc->page_index
 621  */
 622 static
 623 int find_cache_page(nfs_readdir_descriptor_t *desc)
 624 {
 625         int res;
 626
 627         desc->page = get_cache_page(desc);
 628         if (IS_ERR(desc->page))
 629                 return PTR_ERR(desc->page);
 630
 631         res = nfs_readdir_search_array(desc);
 632         if (res == 0)
 633                 return 0;
 634         cache_page_release(desc);
 635         return res;
 636 }
 637
 638 /* Search for desc->dir_cookie from the beginning of the page cache */
 639 static inline
 640 int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
 641 {
 642         int res = -EAGAIN;
 643
 644         while (1) {
 645                 res = find_cache_page(desc);
 646                 if (res != -EAGAIN)
 647                         break;
 648                 desc->page_index++;
 649         }
 650         return res;
 651 }
 652
 653 static inline unsigned int dt_type(struct inode *inode)
 654 {
 655         return (inode->i_mode >> 12) & 15;
 656 }
 657
 658 /*
 659  * Once we've found the start of the dirent within a page: fill 'er up...
 660  */
 661 static
 662 int nfs_do_filldir(nfs_readdir_descriptor_t *desc, void *dirent,
 663                    filldir_t filldir)
 664 {
 665         struct file     *file = desc->file;
 666         int i = 0;
 667         int res = 0;
 668         struct nfs_cache_array *array = NULL;
 669         unsigned int d_type = DT_UNKNOWN;
 670         struct dentry *dentry = NULL;
 671
 672         array = nfs_readdir_get_array(desc->page);
 673
 674         for (i = desc->cache_entry_index; i < array->size; i++) {
 675                 d_type = DT_UNKNOWN;
 676
 677                 res = filldir(dirent, array->array[i].string.name,
 678                         array->array[i].string.len, file->f_pos,
 679                         nfs_compat_user_ino64(array->array[i].ino), d_type);
 680                 if (res < 0)
 681                         break;
 682                 file->f_pos++;
 683                 desc->cache_entry_index = i;
 684                 if (i < (array->size-1))
 685                         *desc->dir_cookie = array->array[i+1].cookie;
 686                 else
 687                         *desc->dir_cookie = array->last_cookie;
 688                 if (i == array->eof_index) {
 689                         desc->eof = 1;
 690                         break;
 691                 }
 692         }
 693
 694         nfs_readdir_release_array(desc->page);
 695         cache_page_release(desc);
 696         if (dentry != NULL)
 697                 dput(dentry);
 698         dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n",
 699                         (unsigned long long)*desc->dir_cookie, res);
 700         return res;
 701 }
 702
 703 /*
 704  * If we cannot find a cookie in our cache, we suspect that this is
 705  * because it points to a deleted file, so we ask the server to return
 706  * whatever it thinks is the next entry. We then feed this to filldir.
 707  * If all goes well, we should then be able to find our way round the
 708  * cache on the next call to readdir_search_pagecache();
 709  *
 710  * NOTE: we cannot add the anonymous page to the pagecache because
 711  *       the data it contains might not be page aligned. Besides,
 712  *       we should already have a complete representation of the
 713  *       directory in the page cache by the time we get here.
 714  */
 715 static inline
 716 int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
 717                      filldir_t filldir)
 718 {
 719         struct page     *page = NULL;
 720         int             status;
 721         struct inode *inode = desc->file->f_path.dentry->d_inode;
 722
 723         dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
 724                         (unsigned long long)*desc->dir_cookie);
 725
 726         page = alloc_page(GFP_HIGHUSER);
 727         if (!page) {
 728                 status = -ENOMEM;
 729                 goto out;
 730         }
 731
 732         if (nfs_readdir_xdr_to_array(desc, page, inode) == -1) {
 733                 status = -EIO;
 734                 goto out_release;
 735         }
 736
 737         desc->page_index = 0;
 738         desc->page = page;
 739         status = nfs_do_filldir(desc, dirent, filldir);
 740
 741  out:
 742         dfprintk(DIRCACHE, "NFS: %s: returns %d\n",
 743                         __func__, status);
 744         return status;
 745  out_release:
 746         cache_page_release(desc);
 747         goto out;
 748 }
 749
 750 /* The file offset position represents the dirent entry number.  A
 751    last cookie cache takes care of the common case of reading the
 752    whole directory.
 753  */
 754 static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 755 {
 756         struct dentry   *dentry = filp->f_path.dentry;
 757         struct inode    *inode = dentry->d_inode;
 758         nfs_readdir_descriptor_t my_desc,
 759                         *desc = &my_desc;
 760         int res = -ENOMEM;
 761
 762         dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu\n",
 763                         dentry->d_parent->d_name.name, dentry->d_name.name,
 764                         (long long)filp->f_pos);
 765         nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);
 766
 767         /*
 768          * filp->f_pos points to the dirent entry number.
 769          * *desc->dir_cookie has the cookie for the next entry. We have
 770          * to either find the entry with the appropriate number or
 771          * revalidate the cookie.
 772          */
 773         memset(desc, 0, sizeof(*desc));
 774
 775         desc->file = filp;
 776         desc->dir_cookie = &nfs_file_open_context(filp)->dir_cookie;
 777         desc->decode = NFS_PROTO(inode)->decode_dirent;
 778         desc->plus = NFS_USE_READDIRPLUS(inode);
 779
 780         nfs_block_sillyrename(dentry);
 781         res = nfs_revalidate_mapping(inode, filp->f_mapping);
 782         if (res < 0)
 783                 goto out;
 784
 785         while (desc->eof != 1) {
 786                 res = readdir_search_pagecache(desc);
 787
 788                 if (res == -EBADCOOKIE) {
 789                         /* This means either end of directory */
 790                         if (*desc->dir_cookie && desc->eof == 0) {
 791                                 /* Or that the server has 'lost' a cookie */
 792                                 res = uncached_readdir(desc, dirent, filldir);
 793                                 if (res >= 0)
 794                                         continue;
 795                         }
 796                         res = 0;
 797                         break;
 798                 }
 799                 if (res == -ETOOSMALL && desc->plus) {
 800                         clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
 801                         nfs_zap_caches(inode);
 802                         desc->page_index = 0;
 803                         desc->plus = 0;
 804                         desc->eof = 0;
 805                         continue;
 806                 }
 807                 if (res < 0)
 808                         break;
 809
 810                 res = nfs_do_filldir(desc, dirent, filldir);
 811                 if (res < 0) {
 812                         res = 0;
 813                         break;
 814                 }
 815         }
 816 out:
 817         nfs_unblock_sillyrename(dentry);
 818         if (res > 0)
 819                 res = 0;
 820         dfprintk(FILE, "NFS: readdir(%s/%s) returns %d\n",
 821                         dentry->d_parent->d_name.name, dentry->d_name.name,
 822                         res);
 823         return res;
 824 }
 825
 826 static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
 827 {
 828         struct dentry *dentry = filp->f_path.dentry;
 829         struct inode *inode = dentry->d_inode;
 830
 831         dfprintk(FILE, "NFS: llseek dir(%s/%s, %lld, %d)\n",
 832                         dentry->d_parent->d_name.name,
 833                         dentry->d_name.name,
 834                         offset, origin);
 835
 836         mutex_lock(&inode->i_mutex);
 837         switch (origin) {
 838                 case 1:
 839                         offset += filp->f_pos;
 840                 case 0:
 841                         if (offset >= 0)
 842                                 break;
 843                 default:
 844                         offset = -EINVAL;
 845                         goto out;
 846         }
 847         if (offset != filp->f_pos) {
 848                 filp->f_pos = offset;
 849                 nfs_file_open_context(filp)->dir_cookie = 0;
 850         }
 851 out:
 852         mutex_unlock(&inode->i_mutex);
 853         return offset;
 854 }
 855
 856 /*
 857  * All directory operations under NFS are synchronous, so fsync()
 858  * is a dummy operation.
 859  */
 860 static int nfs_fsync_dir(struct file *filp, int datasync)
 861 {
 862         struct dentry *dentry = filp->f_path.dentry;
 863
 864         dfprintk(FILE, "NFS: fsync dir(%s/%s) datasync %d\n",
 865                         dentry->d_parent->d_name.name, dentry->d_name.name,
 866                         datasync);
 867
 868         nfs_inc_stats(dentry->d_inode, NFSIOS_VFSFSYNC);
 869         return 0;
 870 }
 871
 872 /**
 873  * nfs_force_lookup_revalidate - Mark the directory as having changed
 874  * @dir - pointer to directory inode
 875  *
 876  * This forces the revalidation code in nfs_lookup_revalidate() to do a
 877  * full lookup on all child dentries of 'dir' whenever a change occurs
 878  * on the server that might have invalidated our dcache.
 879  *
 880  * The caller should be holding dir->i_lock
 881  */
 882 void nfs_force_lookup_revalidate(struct inode *dir)
 883 {
 884         NFS_I(dir)->cache_change_attribute++;
 885 }
 886
 887 /*
 888  * A check for whether or not the parent directory has changed.
 889  * In the case it has, we assume that the dentries are untrustworthy
 890  * and may need to be looked up again.
 891  */
 892 static int nfs_check_verifier(struct inode *dir, struct dentry *dentry)
 893 {
 894         if (IS_ROOT(dentry))
 895                 return 1;
 896         if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
 897                 return 0;
 898         if (!nfs_verify_change_attribute(dir, dentry->d_time))
 899                 return 0;
 900         /* Revalidate nfsi->cache_change_attribute before we declare a match */
 901         if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0)
 902                 return 0;
 903         if (!nfs_verify_change_attribute(dir, dentry->d_time))
 904                 return 0;
 905         return 1;
 906 }
 907
 908 /*
 909  * Return the intent data that applies to this particular path component
 910  *
 911  * Note that the current set of intents only apply to the very last
 912  * component of the path.
 913  * We check for this using LOOKUP_CONTINUE and LOOKUP_PARENT.
 914  */
 915 static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd, unsigned int mask)
 916 {
 917         if (nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT))
 918                 return 0;
 919         return nd->flags & mask;
 920 }
 921
 922 /*
 923  * Use intent information to check whether or not we're going to do
 924  * an O_EXCL create using this path component.
 925  */
 926 static int nfs_is_exclusive_create(struct inode *dir, struct nameidata *nd)
 927 {
 928         if (NFS_PROTO(dir)->version == 2)
 929                 return 0;
 930         return nd && nfs_lookup_check_intent(nd, LOOKUP_EXCL);
 931 }
 932
 933 /*
 934  * Inode and filehandle revalidation for lookups.
 935  *
 936  * We force revalidation in the cases where the VFS sets LOOKUP_REVAL,
 937  * or if the intent information indicates that we're about to open this
 938  * particular file and the "nocto" mount flag is not set.
 939  *
 940  */
 941 static inline
 942 int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd)
 943 {
 944         struct nfs_server *server = NFS_SERVER(inode);
 945
 946         if (test_bit(NFS_INO_MOUNTPOINT, &NFS_I(inode)->flags))
 947                 return 0;
 948         if (nd != NULL) {
 949                 /* VFS wants an on-the-wire revalidation */
 950                 if (nd->flags & LOOKUP_REVAL)
 951                         goto out_force;
 952                 /* This is an open(2) */
 953                 if (nfs_lookup_check_intent(nd, LOOKUP_OPEN) != 0 &&
 954                                 !(server->flags & NFS_MOUNT_NOCTO) &&
 955                                 (S_ISREG(inode->i_mode) ||
 956                                  S_ISDIR(inode->i_mode)))
 957                         goto out_force;
 958                 return 0;
 959         }
 960         return nfs_revalidate_inode(server, inode);
 961 out_force:
 962         return __nfs_revalidate_inode(server, inode);
 963 }
 964
 965 /*
 966  * We judge how long we want to trust negative
 967  * dentries by looking at the parent inode mtime.
 968  *
 969  * If parent mtime has changed, we revalidate, else we wait for a
 970  * period corresponding to the parent's attribute cache timeout value.
 971  */
 972 static inline
 973 int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
 974                        struct nameidata *nd)
 975 {
 976         /* Don't revalidate a negative dentry if we're creating a new file */
 977         if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0)
 978                 return 0;
 979         if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
 980                 return 1;
 981         return !nfs_check_verifier(dir, dentry);
 982 }
 983
 984 /*
 985  * This is called every time the dcache has a lookup hit,
 986  * and we should check whether we can really trust that
 987  * lookup.
 988  *
 989  * NOTE! The hit can be a negative hit too, don't assume
 990  * we have an inode!
 991  *
 992  * If the parent directory is seen to have changed, we throw out the
 993  * cached dentry and do a new lookup.
 994  */
 995 static int nfs_lookup_revalidate(struct dentry * dentry, struct nameidata *nd)
 996 {
 997         struct inode *dir;
 998         struct inode *inode;
 999         struct dentry *parent;
1000         struct nfs_fh *fhandle = NULL;
1001         struct nfs_fattr *fattr = NULL;
1002         int error;
1003
1004         parent = dget_parent(dentry);
1005         dir = parent->d_inode;
1006         nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
1007         inode = dentry->d_inode;
1008
1009         if (!inode) {
1010                 if (nfs_neg_need_reval(dir, dentry, nd))
1011                         goto out_bad;
1012                 goto out_valid;
1013         }
1014
1015         if (is_bad_inode(inode)) {
1016                 dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n",
1017                                 __func__, dentry->d_parent->d_name.name,
1018                                 dentry->d_name.name);
1019                 goto out_bad;
1020         }
1021
1022         if (nfs_have_delegation(inode, FMODE_READ))
1023                 goto out_set_verifier;
1024
1025         /* Force a full look up iff the parent directory has changed */
1026         if (!nfs_is_exclusive_create(dir, nd) && nfs_check_verifier(dir, dentry)) {
1027                 if (nfs_lookup_verify_inode(inode, nd))
1028                         goto out_zap_parent;
1029                 goto out_valid;
1030         }
1031
1032         if (NFS_STALE(inode))
1033                 goto out_bad;
1034
1035         error = -ENOMEM;
1036         fhandle = nfs_alloc_fhandle();
1037         fattr = nfs_alloc_fattr();
1038         if (fhandle == NULL || fattr == NULL)
1039                 goto out_error;
1040
1041         error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
1042         if (error)
1043                 goto out_bad;
1044         if (nfs_compare_fh(NFS_FH(inode), fhandle))
1045                 goto out_bad;
1046         if ((error = nfs_refresh_inode(inode, fattr)) != 0)
1047                 goto out_bad;
1048
1049         nfs_free_fattr(fattr);
1050         nfs_free_fhandle(fhandle);
1051 out_set_verifier:
1052         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1053  out_valid:
1054         dput(parent);
1055         dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n",
1056                         __func__, dentry->d_parent->d_name.name,
1057                         dentry->d_name.name);
1058         return 1;
1059 out_zap_parent:
1060         nfs_zap_caches(dir);
1061  out_bad:
1062         nfs_mark_for_revalidate(dir);
1063         if (inode && S_ISDIR(inode->i_mode)) {
1064                 /* Purge readdir caches. */
1065                 nfs_zap_caches(inode);
1066                 /* If we have submounts, don't unhash ! */
1067                 if (have_submounts(dentry))
1068                         goto out_valid;
1069                 if (dentry->d_flags & DCACHE_DISCONNECTED)
1070                         goto out_valid;
1071                 shrink_dcache_parent(dentry);
1072         }
1073         d_drop(dentry);
1074         nfs_free_fattr(fattr);
1075         nfs_free_fhandle(fhandle);
1076         dput(parent);
1077         dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n",
1078                         __func__, dentry->d_parent->d_name.name,
1079                         dentry->d_name.name);
1080         return 0;
1081 out_error:
1082         nfs_free_fattr(fattr);
1083         nfs_free_fhandle(fhandle);
1084         dput(parent);
1085         dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d\n",
1086                         __func__, dentry->d_parent->d_name.name,
1087                         dentry->d_name.name, error);
1088         return error;
1089 }
1090
1091 /*
1092  * This is called from dput() when d_count is going to 0.
1093  */
1094 static int nfs_dentry_delete(struct dentry *dentry)
1095 {
1096         dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n",
1097                 dentry->d_parent->d_name.name, dentry->d_name.name,
1098                 dentry->d_flags);
1099
1100         /* Unhash any dentry with a stale inode */
1101         if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode))
1102                 return 1;
1103
1104         if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1105                 /* Unhash it, so that ->d_iput() would be called */
1106                 return 1;
1107         }
1108         if (!(dentry->d_sb->s_flags & MS_ACTIVE)) {
1109                 /* Unhash it, so that ancestors of killed async unlink
1110                  * files will be cleaned up during umount */
1111                 return 1;
1112         }
1113         return 0;
1114
1115 }
1116
1117 static void nfs_drop_nlink(struct inode *inode)
1118 {
1119         spin_lock(&inode->i_lock);
1120         if (inode->i_nlink > 0)
1121                 drop_nlink(inode);
1122         spin_unlock(&inode->i_lock);
1123 }
1124
1125 /*
1126  * Called when the dentry loses inode.
1127  * We use it to clean up silly-renamed files.
1128  */
1129 static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode)
1130 {
1131         if (S_ISDIR(inode->i_mode))
1132                 /* drop any readdir cache as it could easily be old */
1133                 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
1134
1135         if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1136                 drop_nlink(inode);
1137                 nfs_complete_unlink(dentry, inode);
1138         }
1139         iput(inode);
1140 }
1141
1142 const struct dentry_operations nfs_dentry_operations = {
1143         .d_revalidate   = nfs_lookup_revalidate,
1144         .d_delete       = nfs_dentry_delete,
1145         .d_iput         = nfs_dentry_iput,
1146 };
1147
1148 static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
1149 {
1150         struct dentry *res;
1151         struct dentry *parent;
1152         struct inode *inode = NULL;
1153         struct nfs_fh *fhandle = NULL;
1154         struct nfs_fattr *fattr = NULL;
1155         int error;
1156
1157         dfprintk(VFS, "NFS: lookup(%s/%s)\n",
1158                 dentry->d_parent->d_name.name, dentry->d_name.name);
1159         nfs_inc_stats(dir, NFSIOS_VFSLOOKUP);
1160
1161         res = ERR_PTR(-ENAMETOOLONG);
1162         if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
1163                 goto out;
1164
1165         dentry->d_op = NFS_PROTO(dir)->dentry_ops;
1166
1167         /*
1168          * If we're doing an exclusive create, optimize away the lookup
1169          * but don't hash the dentry.
1170          */
1171         if (nfs_is_exclusive_create(dir, nd)) {
1172                 d_instantiate(dentry, NULL);
1173                 res = NULL;
1174                 goto out;
1175         }
1176
1177         res = ERR_PTR(-ENOMEM);
1178         fhandle = nfs_alloc_fhandle();
1179         fattr = nfs_alloc_fattr();
1180         if (fhandle == NULL || fattr == NULL)
1181                 goto out;
1182
1183         parent = dentry->d_parent;
1184         /* Protect against concurrent sillydeletes */
1185         nfs_block_sillyrename(parent);
1186         error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
1187         if (error == -ENOENT)
1188                 goto no_entry;
1189         if (error < 0) {
1190                 res = ERR_PTR(error);
1191                 goto out_unblock_sillyrename;
1192         }
1193         inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
1194         res = (struct dentry *)inode;
1195         if (IS_ERR(res))
1196                 goto out_unblock_sillyrename;
1197
1198 no_entry:
1199         res = d_materialise_unique(dentry, inode);
1200         if (res != NULL) {
1201                 if (IS_ERR(res))
1202                         goto out_unblock_sillyrename;
1203                 dentry = res;
1204         }
1205         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1206 out_unblock_sillyrename:
1207         nfs_unblock_sillyrename(parent);
1208 out:
1209         nfs_free_fattr(fattr);
1210         nfs_free_fhandle(fhandle);
1211         return res;
1212 }
1213
1214 #ifdef CONFIG_NFS_V4
1215 static int nfs_open_revalidate(struct dentry *, struct nameidata *);
1216
1217 const struct dentry_operations nfs4_dentry_operations = {
1218         .d_revalidate   = nfs_open_revalidate,
1219         .d_delete       = nfs_dentry_delete,
1220         .d_iput         = nfs_dentry_iput,
1221 };
1222
1223 /*
1224  * Use intent information to determine whether we need to substitute
1225  * the NFSv4-style stateful OPEN for the LOOKUP call
1226  */
1227 static int is_atomic_open(struct nameidata *nd)
1228 {
1229         if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_OPEN) == 0)
1230                 return 0;
1231         /* NFS does not (yet) have a stateful open for directories */
1232         if (nd->flags & LOOKUP_DIRECTORY)
1233                 return 0;
1234         /* Are we trying to write to a read only partition? */
1235         if (__mnt_is_readonly(nd->path.mnt) &&
1236             (nd->intent.open.flags & (O_CREAT|O_TRUNC|FMODE_WRITE)))
1237                 return 0;
1238         return 1;
1239 }
1240
1241 static struct nfs_open_context *nameidata_to_nfs_open_context(struct dentry *dentry, struct nameidata *nd)
1242 {
1243         struct path path = {
1244                 .mnt = nd->path.mnt,
1245                 .dentry = dentry,
1246         };
1247         struct nfs_open_context *ctx;
1248         struct rpc_cred *cred;
1249         fmode_t fmode = nd->intent.open.flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC);
1250
1251         cred = rpc_lookup_cred();
1252         if (IS_ERR(cred))
1253                 return ERR_CAST(cred);
1254         ctx = alloc_nfs_open_context(&path, cred, fmode);
1255         put_rpccred(cred);
1256         if (ctx == NULL)
1257                 return ERR_PTR(-ENOMEM);
1258         return ctx;
1259 }
1260
1261 static int do_open(struct inode *inode, struct file *filp)
1262 {
1263         nfs_fscache_set_inode_cookie(inode, filp);
1264         return 0;
1265 }
1266
1267 static int nfs_intent_set_file(struct nameidata *nd, struct nfs_open_context *ctx)
1268 {
1269         struct file *filp;
1270         int ret = 0;
1271
1272         /* If the open_intent is for execute, we have an extra check to make */
1273         if (ctx->mode & FMODE_EXEC) {
1274                 ret = nfs_may_open(ctx->path.dentry->d_inode,
1275                                 ctx->cred,
1276                                 nd->intent.open.flags);
1277                 if (ret < 0)
1278                         goto out;
1279         }
1280         filp = lookup_instantiate_filp(nd, ctx->path.dentry, do_open);
1281         if (IS_ERR(filp))
1282                 ret = PTR_ERR(filp);
1283         else
1284                 nfs_file_set_open_context(filp, ctx);
1285 out:
1286         put_nfs_open_context(ctx);
1287         return ret;
1288 }
1289
1290 static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
1291 {
1292         struct nfs_open_context *ctx;
1293         struct iattr attr;
1294         struct dentry *res = NULL;
1295         struct inode *inode;
1296         int open_flags;
1297         int err;
1298
1299         dfprintk(VFS, "NFS: atomic_lookup(%s/%ld), %s\n",
1300                         dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1301
1302         /* Check that we are indeed trying to open this file */
1303         if (!is_atomic_open(nd))
1304                 goto no_open;
1305
1306         if (dentry->d_name.len > NFS_SERVER(dir)->namelen) {
1307                 res = ERR_PTR(-ENAMETOOLONG);
1308                 goto out;
1309         }
1310         dentry->d_op = NFS_PROTO(dir)->dentry_ops;
1311
1312         /* Let vfs_create() deal with O_EXCL. Instantiate, but don't hash
1313          * the dentry. */
1314         if (nd->flags & LOOKUP_EXCL) {
1315                 d_instantiate(dentry, NULL);
1316                 goto out;
1317         }
1318
1319         ctx = nameidata_to_nfs_open_context(dentry, nd);
1320         res = ERR_CAST(ctx);
1321         if (IS_ERR(ctx))
1322                 goto out;
1323
1324         open_flags = nd->intent.open.flags;
1325         if (nd->flags & LOOKUP_CREATE) {
1326                 attr.ia_mode = nd->intent.open.create_mode;
1327                 attr.ia_valid = ATTR_MODE;
1328                 if (!IS_POSIXACL(dir))
1329                         attr.ia_mode &= ~current_umask();
1330         } else {
1331                 open_flags &= ~(O_EXCL | O_CREAT);
1332                 attr.ia_valid = 0;
1333         }
1334
1335         /* Open the file on the server */
1336         nfs_block_sillyrename(dentry->d_parent);
1337         inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr);
1338         if (IS_ERR(inode)) {
1339                 nfs_unblock_sillyrename(dentry->d_parent);
1340                 put_nfs_open_context(ctx);
1341                 switch (PTR_ERR(inode)) {
1342                         /* Make a negative dentry */
1343                         case -ENOENT:
1344                                 d_add(dentry, NULL);
1345                                 res = NULL;
1346                                 goto out;
1347                         /* This turned out not to be a regular file */
1348                         case -EISDIR:
1349                         case -ENOTDIR:
1350                                 goto no_open;
1351                         case -ELOOP:
1352                                 if (!(nd->intent.open.flags & O_NOFOLLOW))
1353                                         goto no_open;
1354                         /* case -EINVAL: */
1355                         default:
1356                                 res = ERR_CAST(inode);
1357                                 goto out;
1358                 }
1359         }
1360         res = d_add_unique(dentry, inode);
1361         nfs_unblock_sillyrename(dentry->d_parent);
1362         if (res != NULL) {
1363                 dput(ctx->path.dentry);
1364                 ctx->path.dentry = dget(res);
1365                 dentry = res;
1366         }
1367         err = nfs_intent_set_file(nd, ctx);
1368         if (err < 0) {
1369                 if (res != NULL)
1370                         dput(res);
1371                 return ERR_PTR(err);
1372         }
1373 out:
1374         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1375         return res;
1376 no_open:
1377         return nfs_lookup(dir, dentry, nd);
1378 }
1379
1380 static int nfs_open_revalidate(struct dentry *dentry, struct nameidata *nd)
1381 {
1382         struct dentry *parent = NULL;
1383         struct inode *inode = dentry->d_inode;
1384         struct inode *dir;
1385         struct nfs_open_context *ctx;
1386         int openflags, ret = 0;
1387
1388         if (!is_atomic_open(nd) || d_mountpoint(dentry))
1389                 goto no_open;
1390
1391         parent = dget_parent(dentry);
1392         dir = parent->d_inode;
1393
1394         /* We can't create new files in nfs_open_revalidate(), so we
1395          * optimize away revalidation of negative dentries.
1396          */
1397         if (inode == NULL) {
1398                 if (!nfs_neg_need_reval(dir, dentry, nd))
1399                         ret = 1;
1400                 goto out;
1401         }
1402
1403         /* NFS only supports OPEN on regular files */
1404         if (!S_ISREG(inode->i_mode))
1405                 goto no_open_dput;
1406         openflags = nd->intent.open.flags;
1407         /* We cannot do exclusive creation on a positive dentry */
1408         if ((openflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL))
1409                 goto no_open_dput;
1410         /* We can't create new files, or truncate existing ones here */
1411         openflags &= ~(O_CREAT|O_EXCL|O_TRUNC);
1412
1413         ctx = nameidata_to_nfs_open_context(dentry, nd);
1414         ret = PTR_ERR(ctx);
1415         if (IS_ERR(ctx))
1416                 goto out;
1417         /*
1418          * Note: we're not holding inode->i_mutex and so may be racing with
1419          * operations that change the directory. We therefore save the
1420          * change attribute *before* we do the RPC call.
1421          */
1422         inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, NULL);
1423         if (IS_ERR(inode)) {
1424                 ret = PTR_ERR(inode);
1425                 switch (ret) {
1426                 case -EPERM:
1427                 case -EACCES:
1428                 case -EDQUOT:
1429                 case -ENOSPC:
1430                 case -EROFS:
1431                         goto out_put_ctx;
1432                 default:
1433                         goto out_drop;
1434                 }
1435         }
1436         iput(inode);
1437         if (inode != dentry->d_inode)
1438                 goto out_drop;
1439
1440         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1441         ret = nfs_intent_set_file(nd, ctx);
1442         if (ret >= 0)
1443                 ret = 1;
1444 out:
1445         dput(parent);
1446         return ret;
1447 out_drop:
1448         d_drop(dentry);
1449         ret = 0;
1450 out_put_ctx:
1451         put_nfs_open_context(ctx);
1452         goto out;
1453
1454 no_open_dput:
1455         dput(parent);
1456 no_open:
1457         return nfs_lookup_revalidate(dentry, nd);
1458 }
1459
1460 static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode,
1461                 struct nameidata *nd)
1462 {
1463         struct nfs_open_context *ctx = NULL;
1464         struct iattr attr;
1465         int error;
1466         int open_flags = 0;
1467
1468         dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
1469                         dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1470
1471         attr.ia_mode = mode;
1472         attr.ia_valid = ATTR_MODE;
1473
1474         if ((nd->flags & LOOKUP_CREATE) != 0) {
1475                 open_flags = nd->intent.open.flags;
1476
1477                 ctx = nameidata_to_nfs_open_context(dentry, nd);
1478                 error = PTR_ERR(ctx);
1479                 if (IS_ERR(ctx))
1480                         goto out_err_drop;
1481         }
1482
1483         error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, ctx);
1484         if (error != 0)
1485                 goto out_put_ctx;
1486         if (ctx != NULL) {
1487                 error = nfs_intent_set_file(nd, ctx);
1488                 if (error < 0)
1489                         goto out_err;
1490         }
1491         return 0;
1492 out_put_ctx:
1493         if (ctx != NULL)
1494                 put_nfs_open_context(ctx);
1495 out_err_drop:
1496         d_drop(dentry);
1497 out_err:
1498         return error;
1499 }
1500
1501 #endif /* CONFIG_NFSV4 */
1502
1503 /*
1504  * Code common to create, mkdir, and mknod.
1505  */
1506 int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
1507                                 struct nfs_fattr *fattr)
1508 {
1509         struct dentry *parent = dget_parent(dentry);
1510         struct inode *dir = parent->d_inode;
1511         struct inode *inode;
1512         int error = -EACCES;
1513
1514         d_drop(dentry);
1515
1516         /* We may have been initialized further down */
1517         if (dentry->d_inode)
1518                 goto out;
1519         if (fhandle->size == 0) {
1520                 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
1521                 if (error)
1522                         goto out_error;
1523         }
1524         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1525         if (!(fattr->valid & NFS_ATTR_FATTR)) {
1526                 struct nfs_server *server = NFS_SB(dentry->d_sb);
1527                 error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr);
1528                 if (error < 0)
1529                         goto out_error;
1530         }
1531         inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
1532         error = PTR_ERR(inode);
1533         if (IS_ERR(inode))
1534                 goto out_error;
1535         d_add(dentry, inode);
1536 out:
1537         dput(parent);
1538         return 0;
1539 out_error:
1540         nfs_mark_for_revalidate(dir);
1541         dput(parent);
1542         return error;
1543 }
1544
1545 /*
1546  * Following a failed create operation, we drop the dentry rather
1547  * than retain a negative dentry. This avoids a problem in the event
1548  * that the operation succeeded on the server, but an error in the
1549  * reply path made it appear to have failed.
1550  */
1551 static int nfs_create(struct inode *dir, struct dentry *dentry, int mode,
1552                 struct nameidata *nd)
1553 {
1554         struct iattr attr;
1555         int error;
1556
1557         dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
1558                         dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1559
1560         attr.ia_mode = mode;
1561         attr.ia_valid = ATTR_MODE;
1562
1563         error = NFS_PROTO(dir)->create(dir, dentry, &attr, 0, NULL);
1564         if (error != 0)
1565                 goto out_err;
1566         return 0;
1567 out_err:
1568         d_drop(dentry);
1569         return error;
1570 }
1571
1572 /*
1573  * See comments for nfs_proc_create regarding failed operations.
1574  */
1575 static int
1576 nfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
1577 {
1578         struct iattr attr;
1579         int status;
1580
1581         dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n",
1582                         dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1583
1584         if (!new_valid_dev(rdev))
1585                 return -EINVAL;
1586
1587         attr.ia_mode = mode;
1588         attr.ia_valid = ATTR_MODE;
1589
1590         status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev);
1591         if (status != 0)
1592                 goto out_err;
1593         return 0;
1594 out_err:
1595         d_drop(dentry);
1596         return status;
1597 }
1598
1599 /*
1600  * See comments for nfs_proc_create regarding failed operations.
1601  */
1602 static int nfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
1603 {
1604         struct iattr attr;
1605         int error;
1606
1607         dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n",
1608                         dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1609
1610         attr.ia_valid = ATTR_MODE;
1611         attr.ia_mode = mode | S_IFDIR;
1612
1613         error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr);
1614         if (error != 0)
1615                 goto out_err;
1616         return 0;
1617 out_err:
1618         d_drop(dentry);
1619         return error;
1620 }
1621
1622 static void nfs_dentry_handle_enoent(struct dentry *dentry)
1623 {
1624         if (dentry->d_inode != NULL && !d_unhashed(dentry))
1625                 d_delete(dentry);
1626 }
1627
1628 static int nfs_rmdir(struct inode *dir, struct dentry *dentry)
1629 {
1630         int error;
1631
1632         dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n",
1633                         dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1634
1635         error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
1636         /* Ensure the VFS deletes this inode */
1637         if (error == 0 && dentry->d_inode != NULL)
1638                 clear_nlink(dentry->d_inode);
1639         else if (error == -ENOENT)
1640                 nfs_dentry_handle_enoent(dentry);
1641
1642         return error;
1643 }
1644
1645 /*
1646  * Remove a file after making sure there are no pending writes,
1647  * and after checking that the file has only one user.
1648  *
1649  * We invalidate the attribute cache and free the inode prior to the operation
1650  * to avoid possible races if the server reuses the inode.
1651  */
1652 static int nfs_safe_remove(struct dentry *dentry)
1653 {
1654         struct inode *dir = dentry->d_parent->d_inode;
1655         struct inode *inode = dentry->d_inode;
1656         int error = -EBUSY;
1657
1658         dfprintk(VFS, "NFS: safe_remove(%s/%s)\n",
1659                 dentry->d_parent->d_name.name, dentry->d_name.name);
1660
1661         /* If the dentry was sillyrenamed, we simply call d_delete() */
1662         if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1663                 error = 0;
1664                 goto out;
1665         }
1666
1667         if (inode != NULL) {
1668                 nfs_inode_return_delegation(inode);
1669                 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1670                 /* The VFS may want to delete this inode */
1671                 if (error == 0)
1672                         nfs_drop_nlink(inode);
1673                 nfs_mark_for_revalidate(inode);
1674         } else
1675                 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1676         if (error == -ENOENT)
1677                 nfs_dentry_handle_enoent(dentry);
1678 out:
1679         return error;
1680 }
1681
1682 /*  We do silly rename. In case sillyrename() returns -EBUSY, the inode
1683  *  belongs to an active ".nfs..." file and we return -EBUSY.
1684  *
1685  *  If sillyrename() returns 0, we do nothing, otherwise we unlink.
1686  */
1687 static int nfs_unlink(struct inode *dir, struct dentry *dentry)
1688 {
1689         int error;
1690         int need_rehash = 0;
1691
1692         dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id,
1693                 dir->i_ino, dentry->d_name.name);
1694
1695         spin_lock(&dcache_lock);
1696         spin_lock(&dentry->d_lock);
1697         if (atomic_read(&dentry->d_count) > 1) {
1698                 spin_unlock(&dentry->d_lock);
1699                 spin_unlock(&dcache_lock);
1700                 /* Start asynchronous writeout of the inode */
1701                 write_inode_now(dentry->d_inode, 0);
1702                 error = nfs_sillyrename(dir, dentry);
1703                 return error;
1704         }
1705         if (!d_unhashed(dentry)) {
1706                 __d_drop(dentry);
1707                 need_rehash = 1;
1708         }
1709         spin_unlock(&dentry->d_lock);
1710         spin_unlock(&dcache_lock);
1711         error = nfs_safe_remove(dentry);
1712         if (!error || error == -ENOENT) {
1713                 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1714         } else if (need_rehash)
1715                 d_rehash(dentry);
1716         return error;
1717 }
1718
1719 /*
1720  * To create a symbolic link, most file systems instantiate a new inode,
1721  * add a page to it containing the path, then write it out to the disk
1722  * using prepare_write/commit_write.
1723  *
1724  * Unfortunately the NFS client can't create the in-core inode first
1725  * because it needs a file handle to create an in-core inode (see
1726  * fs/nfs/inode.c:nfs_fhget).  We only have a file handle *after* the
1727  * symlink request has completed on the server.
1728  *
1729  * So instead we allocate a raw page, copy the symname into it, then do
1730  * the SYMLINK request with the page as the buffer.  If it succeeds, we
1731  * now have a new file handle and can instantiate an in-core NFS inode
1732  * and move the raw page into its mapping.
1733  */
1734 static int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1735 {
1736         struct pagevec lru_pvec;
1737         struct page *page;
1738         char *kaddr;
1739         struct iattr attr;
1740         unsigned int pathlen = strlen(symname);
1741         int error;
1742
1743         dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id,
1744                 dir->i_ino, dentry->d_name.name, symname);
1745
1746         if (pathlen > PAGE_SIZE)
1747                 return -ENAMETOOLONG;
1748
1749         attr.ia_mode = S_IFLNK | S_IRWXUGO;
1750         attr.ia_valid = ATTR_MODE;
1751
1752         page = alloc_page(GFP_HIGHUSER);
1753         if (!page)
1754                 return -ENOMEM;
1755
1756         kaddr = kmap_atomic(page, KM_USER0);
1757         memcpy(kaddr, symname, pathlen);
1758         if (pathlen < PAGE_SIZE)
1759                 memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen);
1760         kunmap_atomic(kaddr, KM_USER0);
1761
1762         error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr);
1763         if (error != 0) {
1764                 dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s) error %d\n",
1765                         dir->i_sb->s_id, dir->i_ino,
1766                         dentry->d_name.name, symname, error);
1767                 d_drop(dentry);
1768                 __free_page(page);
1769                 return error;
1770         }
1771
1772         /*
1773          * No big deal if we can't add this page to the page cache here.
1774          * READLINK will get the missing page from the server if needed.
1775          */
1776         pagevec_init(&lru_pvec, 0);
1777         if (!add_to_page_cache(page, dentry->d_inode->i_mapping, 0,
1778                                                         GFP_KERNEL)) {
1779                 pagevec_add(&lru_pvec, page);
1780                 pagevec_lru_add_file(&lru_pvec);
1781                 SetPageUptodate(page);
1782                 unlock_page(page);
1783         } else
1784                 __free_page(page);
1785
1786         return 0;
1787 }
1788
1789 static int
1790 nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
1791 {
1792         struct inode *inode = old_dentry->d_inode;
1793         int error;
1794
1795         dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n",
1796                 old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
1797                 dentry->d_parent->d_name.name, dentry->d_name.name);
1798
1799         nfs_inode_return_delegation(inode);
1800
1801         d_drop(dentry);
1802         error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
1803         if (error == 0) {
1804                 ihold(inode);
1805                 d_add(dentry, inode);
1806         }
1807         return error;
1808 }
1809
1810 /*
1811  * RENAME
1812  * FIXME: Some nfsds, like the Linux user space nfsd, may generate a
1813  * different file handle for the same inode after a rename (e.g. when
1814  * moving to a different directory). A fail-safe method to do so would
1815  * be to look up old_dir/old_name, create a link to new_dir/new_name and
1816  * rename the old file using the sillyrename stuff. This way, the original
1817  * file in old_dir will go away when the last process iput()s the inode.
1818  *
1819  * FIXED.
1820  *
1821  * It actually works quite well. One needs to have the possibility for
1822  * at least one ".nfs..." file in each directory the file ever gets
1823  * moved or linked to which happens automagically with the new
1824  * implementation that only depends on the dcache stuff instead of
1825  * using the inode layer
1826  *
1827  * Unfortunately, things are a little more complicated than indicated
1828  * above. For a cross-directory move, we want to make sure we can get
1829  * rid of the old inode after the operation.  This means there must be
1830  * no pending writes (if it's a file), and the use count must be 1.
1831  * If these conditions are met, we can drop the dentries before doing
1832  * the rename.
1833  */
1834 static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1835                       struct inode *new_dir, struct dentry *new_dentry)
1836 {
1837         struct inode *old_inode = old_dentry->d_inode;
1838         struct inode *new_inode = new_dentry->d_inode;
1839         struct dentry *dentry = NULL, *rehash = NULL;
1840         int error = -EBUSY;
1841
1842         dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n",
1843                  old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
1844                  new_dentry->d_parent->d_name.name, new_dentry->d_name.name,
1845                  atomic_read(&new_dentry->d_count));
1846
1847         /*
1848          * For non-directories, check whether the target is busy and if so,
1849          * make a copy of the dentry and then do a silly-rename. If the
1850          * silly-rename succeeds, the copied dentry is hashed and becomes
1851          * the new target.
1852          */
1853         if (new_inode && !S_ISDIR(new_inode->i_mode)) {
1854                 /*
1855                  * To prevent any new references to the target during the
1856                  * rename, we unhash the dentry in advance.
1857                  */
1858                 if (!d_unhashed(new_dentry)) {
1859                         d_drop(new_dentry);
1860                         rehash = new_dentry;
1861                 }
1862
1863                 if (atomic_read(&new_dentry->d_count) > 2) {
1864                         int err;
1865
1866                         /* copy the target dentry's name */
1867                         dentry = d_alloc(new_dentry->d_parent,
1868                                          &new_dentry->d_name);
1869                         if (!dentry)
1870                                 goto out;
1871
1872                         /* silly-rename the existing target ... */
1873                         err = nfs_sillyrename(new_dir, new_dentry);
1874                         if (err)
1875                                 goto out;
1876
1877                         new_dentry = dentry;
1878                         rehash = NULL;
1879                         new_inode = NULL;
1880                 }
1881         }
1882
1883         nfs_inode_return_delegation(old_inode);
1884         if (new_inode != NULL)
1885                 nfs_inode_return_delegation(new_inode);
1886
1887         error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name,
1888                                            new_dir, &new_dentry->d_name);
1889         nfs_mark_for_revalidate(old_inode);
1890 out:
1891         if (rehash)
1892                 d_rehash(rehash);
1893         if (!error) {
1894                 if (new_inode != NULL)
1895                         nfs_drop_nlink(new_inode);
1896                 d_move(old_dentry, new_dentry);
1897                 nfs_set_verifier(new_dentry,
1898                                         nfs_save_change_attribute(new_dir));
1899         } else if (error == -ENOENT)
1900                 nfs_dentry_handle_enoent(old_dentry);
1901
1902         /* new dentry created? */
1903         if (dentry)
1904                 dput(dentry);
1905         return error;
1906 }
1907
1908 static DEFINE_SPINLOCK(nfs_access_lru_lock);
1909 static LIST_HEAD(nfs_access_lru_list);
1910 static atomic_long_t nfs_access_nr_entries;
1911
1912 static void nfs_access_free_entry(struct nfs_access_entry *entry)
1913 {
1914         put_rpccred(entry->cred);
1915         kfree(entry);
1916         smp_mb__before_atomic_dec();
1917         atomic_long_dec(&nfs_access_nr_entries);
1918         smp_mb__after_atomic_dec();
1919 }
1920
1921 static void nfs_access_free_list(struct list_head *head)
1922 {
1923         struct nfs_access_entry *cache;
1924
1925         while (!list_empty(head)) {
1926                 cache = list_entry(head->next, struct nfs_access_entry, lru);
1927                 list_del(&cache->lru);
1928                 nfs_access_free_entry(cache);
1929         }
1930 }
1931
1932 int nfs_access_cache_shrinker(struct shrinker *shrink, int nr_to_scan, gfp_t gfp_mask)
1933 {
1934         LIST_HEAD(head);
1935         struct nfs_inode *nfsi, *next;
1936         struct nfs_access_entry *cache;
1937
1938         if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL)
1939                 return (nr_to_scan == 0) ? 0 : -1;
1940
1941         spin_lock(&nfs_access_lru_lock);
1942         list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) {
1943                 struct inode *inode;
1944
1945                 if (nr_to_scan-- == 0)
1946                         break;
1947                 inode = &nfsi->vfs_inode;
1948                 spin_lock(&inode->i_lock);
1949                 if (list_empty(&nfsi->access_cache_entry_lru))
1950                         goto remove_lru_entry;
1951                 cache = list_entry(nfsi->access_cache_entry_lru.next,
1952                                 struct nfs_access_entry, lru);
1953                 list_move(&cache->lru, &head);
1954                 rb_erase(&cache->rb_node, &nfsi->access_cache);
1955                 if (!list_empty(&nfsi->access_cache_entry_lru))
1956                         list_move_tail(&nfsi->access_cache_inode_lru,
1957                                         &nfs_access_lru_list);
1958                 else {
1959 remove_lru_entry:
1960                         list_del_init(&nfsi->access_cache_inode_lru);
1961                         smp_mb__before_clear_bit();
1962                         clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags);
1963                         smp_mb__after_clear_bit();
1964                 }
1965                 spin_unlock(&inode->i_lock);
1966         }
1967         spin_unlock(&nfs_access_lru_lock);
1968         nfs_access_free_list(&head);
1969         return (atomic_long_read(&nfs_access_nr_entries) / 100) * sysctl_vfs_cache_pressure;
1970 }
1971
1972 static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head)
1973 {
1974         struct rb_root *root_node = &nfsi->access_cache;
1975         struct rb_node *n;
1976         struct nfs_access_entry *entry;
1977
1978         /* Unhook entries from the cache */
1979         while ((n = rb_first(root_node)) != NULL) {
1980                 entry = rb_entry(n, struct nfs_access_entry, rb_node);
1981                 rb_erase(n, root_node);
1982                 list_move(&entry->lru, head);
1983         }
1984         nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS;
1985 }
1986
1987 void nfs_access_zap_cache(struct inode *inode)
1988 {
1989         LIST_HEAD(head);
1990
1991         if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0)
1992                 return;
1993         /* Remove from global LRU init */
1994         spin_lock(&nfs_access_lru_lock);
1995         if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
1996                 list_del_init(&NFS_I(inode)->access_cache_inode_lru);
1997
1998         spin_lock(&inode->i_lock);
1999         __nfs_access_zap_cache(NFS_I(inode), &head);
2000         spin_unlock(&inode->i_lock);
2001         spin_unlock(&nfs_access_lru_lock);
2002         nfs_access_free_list(&head);
2003 }
2004
2005 static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred)
2006 {
2007         struct rb_node *n = NFS_I(inode)->access_cache.rb_node;
2008         struct nfs_access_entry *entry;
2009
2010         while (n != NULL) {
2011                 entry = rb_entry(n, struct nfs_access_entry, rb_node);
2012
2013                 if (cred < entry->cred)
2014                         n = n->rb_left;
2015                 else if (cred > entry->cred)
2016                         n = n->rb_right;
2017                 else
2018                         return entry;
2019         }
2020         return NULL;
2021 }
2022
2023 static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res)
2024 {
2025         struct nfs_inode *nfsi = NFS_I(inode);
2026         struct nfs_access_entry *cache;
2027         int err = -ENOENT;
2028
2029         spin_lock(&inode->i_lock);
2030         if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
2031                 goto out_zap;
2032         cache = nfs_access_search_rbtree(inode, cred);
2033         if (cache == NULL)
2034                 goto out;
2035         if (!nfs_have_delegated_attributes(inode) &&
2036             !time_in_range_open(jiffies, cache->jiffies, cache->jiffies + nfsi->attrtimeo))
2037                 goto out_stale;
2038         res->jiffies = cache->jiffies;
2039         res->cred = cache->cred;
2040         res->mask = cache->mask;
2041         list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru);
2042         err = 0;
2043 out:
2044         spin_unlock(&inode->i_lock);
2045         return err;
2046 out_stale:
2047         rb_erase(&cache->rb_node, &nfsi->access_cache);
2048         list_del(&cache->lru);
2049         spin_unlock(&inode->i_lock);
2050         nfs_access_free_entry(cache);
2051         return -ENOENT;
2052 out_zap:
2053         spin_unlock(&inode->i_lock);
2054         nfs_access_zap_cache(inode);
2055         return -ENOENT;
2056 }
2057
2058 static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set)
2059 {
2060         struct nfs_inode *nfsi = NFS_I(inode);
2061         struct rb_root *root_node = &nfsi->access_cache;
2062         struct rb_node **p = &root_node->rb_node;
2063         struct rb_node *parent = NULL;
2064         struct nfs_access_entry *entry;
2065
2066         spin_lock(&inode->i_lock);
2067         while (*p != NULL) {
2068                 parent = *p;
2069                 entry = rb_entry(parent, struct nfs_access_entry, rb_node);
2070
2071                 if (set->cred < entry->cred)
2072                         p = &parent->rb_left;
2073                 else if (set->cred > entry->cred)
2074                         p = &parent->rb_right;
2075                 else
2076                         goto found;
2077         }
2078         rb_link_node(&set->rb_node, parent, p);
2079         rb_insert_color(&set->rb_node, root_node);
2080         list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2081         spin_unlock(&inode->i_lock);
2082         return;
2083 found:
2084         rb_replace_node(parent, &set->rb_node, root_node);
2085         list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2086         list_del(&entry->lru);
2087         spin_unlock(&inode->i_lock);
2088         nfs_access_free_entry(entry);
2089 }
2090
2091 static void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)
2092 {
2093         struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL);
2094         if (cache == NULL)
2095                 return;
2096         RB_CLEAR_NODE(&cache->rb_node);
2097         cache->jiffies = set->jiffies;
2098         cache->cred = get_rpccred(set->cred);
2099         cache->mask = set->mask;
2100
2101         nfs_access_add_rbtree(inode, cache);
2102
2103         /* Update accounting */
2104         smp_mb__before_atomic_inc();
2105         atomic_long_inc(&nfs_access_nr_entries);
2106         smp_mb__after_atomic_inc();
2107
2108         /* Add inode to global LRU list */
2109         if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) {
2110                 spin_lock(&nfs_access_lru_lock);
2111                 if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
2112                         list_add_tail(&NFS_I(inode)->access_cache_inode_lru,
2113                                         &nfs_access_lru_list);
2114                 spin_unlock(&nfs_access_lru_lock);
2115         }
2116 }
2117
2118 static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask)
2119 {
2120         struct nfs_access_entry cache;
2121         int status;
2122
2123         status = nfs_access_get_cached(inode, cred, &cache);
2124         if (status == 0)
2125                 goto out;
2126
2127         /* Be clever: ask server to check for all possible rights */
2128         cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ;
2129         cache.cred = cred;
2130         cache.jiffies = jiffies;
2131         status = NFS_PROTO(inode)->access(inode, &cache);
2132         if (status != 0) {
2133                 if (status == -ESTALE) {
2134                         nfs_zap_caches(inode);
2135                         if (!S_ISDIR(inode->i_mode))
2136                                 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
2137                 }
2138                 return status;
2139         }
2140         nfs_access_add_cache(inode, &cache);
2141 out:
2142         if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
2143                 return 0;
2144         return -EACCES;
2145 }
2146
2147 static int nfs_open_permission_mask(int openflags)
2148 {
2149         int mask = 0;
2150
2151         if (openflags & FMODE_READ)
2152                 mask |= MAY_READ;
2153         if (openflags & FMODE_WRITE)
2154                 mask |= MAY_WRITE;
2155         if (openflags & FMODE_EXEC)
2156                 mask |= MAY_EXEC;
2157         return mask;
2158 }
2159
2160 int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags)
2161 {
2162         return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags));
2163 }
2164
2165 int nfs_permission(struct inode *inode, int mask)
2166 {
2167         struct rpc_cred *cred;
2168         int res = 0;
2169
2170         nfs_inc_stats(inode, NFSIOS_VFSACCESS);
2171
2172         if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
2173                 goto out;
2174         /* Is this sys_access() ? */
2175         if (mask & (MAY_ACCESS | MAY_CHDIR))
2176                 goto force_lookup;
2177
2178         switch (inode->i_mode & S_IFMT) {
2179                 case S_IFLNK:
2180                         goto out;
2181                 case S_IFREG:
2182                         /* NFSv4 has atomic_open... */
2183                         if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN)
2184                                         && (mask & MAY_OPEN)
2185                                         && !(mask & MAY_EXEC))
2186                                 goto out;
2187                         break;
2188                 case S_IFDIR:
2189                         /*
2190                          * Optimize away all write operations, since the server
2191                          * will check permissions when we perform the op.
2192                          */
2193                         if ((mask & MAY_WRITE) && !(mask & MAY_READ))
2194                                 goto out;
2195         }
2196
2197 force_lookup:
2198         if (!NFS_PROTO(inode)->access)
2199                 goto out_notsup;
2200
2201         cred = rpc_lookup_cred();
2202         if (!IS_ERR(cred)) {
2203                 res = nfs_do_access(inode, cred, mask);
2204                 put_rpccred(cred);
2205         } else
2206                 res = PTR_ERR(cred);
2207 out:
2208         if (!res && (mask & MAY_EXEC) && !execute_ok(inode))
2209                 res = -EACCES;
2210
2211         dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n",
2212                 inode->i_sb->s_id, inode->i_ino, mask, res);
2213         return res;
2214 out_notsup:
2215         res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
2216         if (res == 0)
2217                 res = generic_permission(inode, mask, NULL);
2218         goto out;
2219 }
2220
2221 /*
2222  * Local variables:
2223  *  version-control: t
2224  *  kept-new-versions: 5
2225  * End:
2226  */