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