linux/fs/nfs/inode.c
<<
>>
Prefs
   1/*
   2 *  linux/fs/nfs/inode.c
   3 *
   4 *  Copyright (C) 1992  Rick Sladkey
   5 *
   6 *  nfs inode and superblock handling functions
   7 *
   8 *  Modularised by Alan Cox <alan@lxorguk.ukuu.org.uk>, while hacking some
   9 *  experimental NFS changes. Modularisation taken straight from SYS5 fs.
  10 *
  11 *  Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
  12 *  J.S.Peatfield@damtp.cam.ac.uk
  13 *
  14 */
  15
  16#include <linux/module.h>
  17#include <linux/init.h>
  18#include <linux/sched.h>
  19#include <linux/time.h>
  20#include <linux/kernel.h>
  21#include <linux/mm.h>
  22#include <linux/string.h>
  23#include <linux/stat.h>
  24#include <linux/errno.h>
  25#include <linux/unistd.h>
  26#include <linux/sunrpc/clnt.h>
  27#include <linux/sunrpc/stats.h>
  28#include <linux/sunrpc/metrics.h>
  29#include <linux/nfs_fs.h>
  30#include <linux/nfs_mount.h>
  31#include <linux/nfs4_mount.h>
  32#include <linux/lockd/bind.h>
  33#include <linux/seq_file.h>
  34#include <linux/mount.h>
  35#include <linux/vfs.h>
  36#include <linux/inet.h>
  37#include <linux/nfs_xdr.h>
  38#include <linux/slab.h>
  39#include <linux/compat.h>
  40#include <linux/freezer.h>
  41#include <linux/crc32.h>
  42
  43#include <asm/uaccess.h>
  44
  45#include "nfs4_fs.h"
  46#include "callback.h"
  47#include "delegation.h"
  48#include "iostat.h"
  49#include "internal.h"
  50#include "fscache.h"
  51#include "dns_resolve.h"
  52#include "pnfs.h"
  53#include "nfs.h"
  54#include "netns.h"
  55
  56#define NFSDBG_FACILITY         NFSDBG_VFS
  57
  58#define NFS_64_BIT_INODE_NUMBERS_ENABLED        1
  59
  60/* Default is to see 64-bit inode numbers */
  61static bool enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
  62
  63static void nfs_invalidate_inode(struct inode *);
  64static int nfs_update_inode(struct inode *, struct nfs_fattr *);
  65
  66static struct kmem_cache * nfs_inode_cachep;
  67
  68static inline unsigned long
  69nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
  70{
  71        return nfs_fileid_to_ino_t(fattr->fileid);
  72}
  73
  74/**
  75 * nfs_wait_bit_killable - helper for functions that are sleeping on bit locks
  76 * @word: long word containing the bit lock
  77 */
  78int nfs_wait_bit_killable(void *word)
  79{
  80        if (fatal_signal_pending(current))
  81                return -ERESTARTSYS;
  82        freezable_schedule();
  83        return 0;
  84}
  85EXPORT_SYMBOL_GPL(nfs_wait_bit_killable);
  86
  87/**
  88 * nfs_compat_user_ino64 - returns the user-visible inode number
  89 * @fileid: 64-bit fileid
  90 *
  91 * This function returns a 32-bit inode number if the boot parameter
  92 * nfs.enable_ino64 is zero.
  93 */
  94u64 nfs_compat_user_ino64(u64 fileid)
  95{
  96#ifdef CONFIG_COMPAT
  97        compat_ulong_t ino;
  98#else   
  99        unsigned long ino;
 100#endif
 101
 102        if (enable_ino64)
 103                return fileid;
 104        ino = fileid;
 105        if (sizeof(ino) < sizeof(fileid))
 106                ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8;
 107        return ino;
 108}
 109
 110void nfs_clear_inode(struct inode *inode)
 111{
 112        /*
 113         * The following should never happen...
 114         */
 115        BUG_ON(nfs_have_writebacks(inode));
 116        BUG_ON(!list_empty(&NFS_I(inode)->open_files));
 117        nfs_zap_acl_cache(inode);
 118        nfs_access_zap_cache(inode);
 119        nfs_fscache_release_inode_cookie(inode);
 120}
 121EXPORT_SYMBOL_GPL(nfs_clear_inode);
 122
 123void nfs_evict_inode(struct inode *inode)
 124{
 125        truncate_inode_pages(&inode->i_data, 0);
 126        clear_inode(inode);
 127        nfs_clear_inode(inode);
 128}
 129
 130/**
 131 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
 132 */
 133int nfs_sync_mapping(struct address_space *mapping)
 134{
 135        int ret = 0;
 136
 137        if (mapping->nrpages != 0) {
 138                unmap_mapping_range(mapping, 0, 0, 0);
 139                ret = nfs_wb_all(mapping->host);
 140        }
 141        return ret;
 142}
 143
 144/*
 145 * Invalidate the local caches
 146 */
 147static void nfs_zap_caches_locked(struct inode *inode)
 148{
 149        struct nfs_inode *nfsi = NFS_I(inode);
 150        int mode = inode->i_mode;
 151
 152        nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
 153
 154        nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
 155        nfsi->attrtimeo_timestamp = jiffies;
 156
 157        memset(NFS_I(inode)->cookieverf, 0, sizeof(NFS_I(inode)->cookieverf));
 158        if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))
 159                nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
 160        else
 161                nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
 162}
 163
 164void nfs_zap_caches(struct inode *inode)
 165{
 166        spin_lock(&inode->i_lock);
 167        nfs_zap_caches_locked(inode);
 168        spin_unlock(&inode->i_lock);
 169}
 170
 171void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
 172{
 173        if (mapping->nrpages != 0) {
 174                spin_lock(&inode->i_lock);
 175                NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
 176                spin_unlock(&inode->i_lock);
 177        }
 178}
 179
 180void nfs_zap_acl_cache(struct inode *inode)
 181{
 182        void (*clear_acl_cache)(struct inode *);
 183
 184        clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
 185        if (clear_acl_cache != NULL)
 186                clear_acl_cache(inode);
 187        spin_lock(&inode->i_lock);
 188        NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
 189        spin_unlock(&inode->i_lock);
 190}
 191EXPORT_SYMBOL_GPL(nfs_zap_acl_cache);
 192
 193void nfs_invalidate_atime(struct inode *inode)
 194{
 195        spin_lock(&inode->i_lock);
 196        NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATIME;
 197        spin_unlock(&inode->i_lock);
 198}
 199EXPORT_SYMBOL_GPL(nfs_invalidate_atime);
 200
 201/*
 202 * Invalidate, but do not unhash, the inode.
 203 * NB: must be called with inode->i_lock held!
 204 */
 205static void nfs_invalidate_inode(struct inode *inode)
 206{
 207        set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
 208        nfs_zap_caches_locked(inode);
 209}
 210
 211struct nfs_find_desc {
 212        struct nfs_fh           *fh;
 213        struct nfs_fattr        *fattr;
 214};
 215
 216/*
 217 * In NFSv3 we can have 64bit inode numbers. In order to support
 218 * this, and re-exported directories (also seen in NFSv2)
 219 * we are forced to allow 2 different inodes to have the same
 220 * i_ino.
 221 */
 222static int
 223nfs_find_actor(struct inode *inode, void *opaque)
 224{
 225        struct nfs_find_desc    *desc = (struct nfs_find_desc *)opaque;
 226        struct nfs_fh           *fh = desc->fh;
 227        struct nfs_fattr        *fattr = desc->fattr;
 228
 229        if (NFS_FILEID(inode) != fattr->fileid)
 230                return 0;
 231        if (nfs_compare_fh(NFS_FH(inode), fh))
 232                return 0;
 233        if (is_bad_inode(inode) || NFS_STALE(inode))
 234                return 0;
 235        return 1;
 236}
 237
 238static int
 239nfs_init_locked(struct inode *inode, void *opaque)
 240{
 241        struct nfs_find_desc    *desc = (struct nfs_find_desc *)opaque;
 242        struct nfs_fattr        *fattr = desc->fattr;
 243
 244        set_nfs_fileid(inode, fattr->fileid);
 245        nfs_copy_fh(NFS_FH(inode), desc->fh);
 246        return 0;
 247}
 248
 249/*
 250 * This is our front-end to iget that looks up inodes by file handle
 251 * instead of inode number.
 252 */
 253struct inode *
 254nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
 255{
 256        struct nfs_find_desc desc = {
 257                .fh     = fh,
 258                .fattr  = fattr
 259        };
 260        struct inode *inode = ERR_PTR(-ENOENT);
 261        unsigned long hash;
 262
 263        nfs_attr_check_mountpoint(sb, fattr);
 264
 265        if (((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0) &&
 266            !nfs_attr_use_mounted_on_fileid(fattr))
 267                goto out_no_inode;
 268        if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0)
 269                goto out_no_inode;
 270
 271        hash = nfs_fattr_to_ino_t(fattr);
 272
 273        inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
 274        if (inode == NULL) {
 275                inode = ERR_PTR(-ENOMEM);
 276                goto out_no_inode;
 277        }
 278
 279        if (inode->i_state & I_NEW) {
 280                struct nfs_inode *nfsi = NFS_I(inode);
 281                unsigned long now = jiffies;
 282
 283                /* We set i_ino for the few things that still rely on it,
 284                 * such as stat(2) */
 285                inode->i_ino = hash;
 286
 287                /* We can't support update_atime(), since the server will reset it */
 288                inode->i_flags |= S_NOATIME|S_NOCMTIME;
 289                inode->i_mode = fattr->mode;
 290                if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0
 291                                && nfs_server_capable(inode, NFS_CAP_MODE))
 292                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
 293                /* Why so? Because we want revalidate for devices/FIFOs, and
 294                 * that's precisely what we have in nfs_file_inode_operations.
 295                 */
 296                inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
 297                if (S_ISREG(inode->i_mode)) {
 298                        inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops;
 299                        inode->i_data.a_ops = &nfs_file_aops;
 300                        inode->i_data.backing_dev_info = &NFS_SB(sb)->backing_dev_info;
 301                } else if (S_ISDIR(inode->i_mode)) {
 302                        inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
 303                        inode->i_fop = &nfs_dir_operations;
 304                        inode->i_data.a_ops = &nfs_dir_aops;
 305                        /* Deal with crossing mountpoints */
 306                        if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT ||
 307                                        fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
 308                                if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
 309                                        inode->i_op = &nfs_referral_inode_operations;
 310                                else
 311                                        inode->i_op = &nfs_mountpoint_inode_operations;
 312                                inode->i_fop = NULL;
 313                                inode->i_flags |= S_AUTOMOUNT;
 314                        }
 315                } else if (S_ISLNK(inode->i_mode))
 316                        inode->i_op = &nfs_symlink_inode_operations;
 317                else
 318                        init_special_inode(inode, inode->i_mode, fattr->rdev);
 319
 320                memset(&inode->i_atime, 0, sizeof(inode->i_atime));
 321                memset(&inode->i_mtime, 0, sizeof(inode->i_mtime));
 322                memset(&inode->i_ctime, 0, sizeof(inode->i_ctime));
 323                inode->i_version = 0;
 324                inode->i_size = 0;
 325                clear_nlink(inode);
 326                inode->i_uid = -2;
 327                inode->i_gid = -2;
 328                inode->i_blocks = 0;
 329                memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
 330                nfsi->write_io = 0;
 331                nfsi->read_io = 0;
 332
 333                nfsi->read_cache_jiffies = fattr->time_start;
 334                nfsi->attr_gencount = fattr->gencount;
 335                if (fattr->valid & NFS_ATTR_FATTR_ATIME)
 336                        inode->i_atime = fattr->atime;
 337                else if (nfs_server_capable(inode, NFS_CAP_ATIME))
 338                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
 339                if (fattr->valid & NFS_ATTR_FATTR_MTIME)
 340                        inode->i_mtime = fattr->mtime;
 341                else if (nfs_server_capable(inode, NFS_CAP_MTIME))
 342                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
 343                if (fattr->valid & NFS_ATTR_FATTR_CTIME)
 344                        inode->i_ctime = fattr->ctime;
 345                else if (nfs_server_capable(inode, NFS_CAP_CTIME))
 346                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
 347                if (fattr->valid & NFS_ATTR_FATTR_CHANGE)
 348                        inode->i_version = fattr->change_attr;
 349                else if (nfs_server_capable(inode, NFS_CAP_CHANGE_ATTR))
 350                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
 351                if (fattr->valid & NFS_ATTR_FATTR_SIZE)
 352                        inode->i_size = nfs_size_to_loff_t(fattr->size);
 353                else
 354                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR
 355                                | NFS_INO_REVAL_PAGECACHE;
 356                if (fattr->valid & NFS_ATTR_FATTR_NLINK)
 357                        set_nlink(inode, fattr->nlink);
 358                else if (nfs_server_capable(inode, NFS_CAP_NLINK))
 359                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
 360                if (fattr->valid & NFS_ATTR_FATTR_OWNER)
 361                        inode->i_uid = fattr->uid;
 362                else if (nfs_server_capable(inode, NFS_CAP_OWNER))
 363                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
 364                if (fattr->valid & NFS_ATTR_FATTR_GROUP)
 365                        inode->i_gid = fattr->gid;
 366                else if (nfs_server_capable(inode, NFS_CAP_OWNER_GROUP))
 367                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
 368                if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
 369                        inode->i_blocks = fattr->du.nfs2.blocks;
 370                if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
 371                        /*
 372                         * report the blocks in 512byte units
 373                         */
 374                        inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
 375                }
 376                nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
 377                nfsi->attrtimeo_timestamp = now;
 378                nfsi->access_cache = RB_ROOT;
 379
 380                nfs_fscache_init_inode_cookie(inode);
 381
 382                unlock_new_inode(inode);
 383        } else
 384                nfs_refresh_inode(inode, fattr);
 385        dprintk("NFS: nfs_fhget(%s/%Ld fh_crc=0x%08x ct=%d)\n",
 386                inode->i_sb->s_id,
 387                (long long)NFS_FILEID(inode),
 388                nfs_display_fhandle_hash(fh),
 389                atomic_read(&inode->i_count));
 390
 391out:
 392        return inode;
 393
 394out_no_inode:
 395        dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
 396        goto out;
 397}
 398EXPORT_SYMBOL_GPL(nfs_fhget);
 399
 400#define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET|ATTR_FILE|ATTR_OPEN)
 401
 402int
 403nfs_setattr(struct dentry *dentry, struct iattr *attr)
 404{
 405        struct inode *inode = dentry->d_inode;
 406        struct nfs_fattr *fattr;
 407        int error = -ENOMEM;
 408
 409        nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
 410
 411        /* skip mode change if it's just for clearing setuid/setgid */
 412        if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
 413                attr->ia_valid &= ~ATTR_MODE;
 414
 415        if (attr->ia_valid & ATTR_SIZE) {
 416                if (!S_ISREG(inode->i_mode) || attr->ia_size == i_size_read(inode))
 417                        attr->ia_valid &= ~ATTR_SIZE;
 418        }
 419
 420        /* Optimization: if the end result is no change, don't RPC */
 421        attr->ia_valid &= NFS_VALID_ATTRS;
 422        if ((attr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0)
 423                return 0;
 424
 425        /* Write all dirty data */
 426        if (S_ISREG(inode->i_mode)) {
 427                nfs_inode_dio_wait(inode);
 428                nfs_wb_all(inode);
 429        }
 430
 431        fattr = nfs_alloc_fattr();
 432        if (fattr == NULL)
 433                goto out;
 434        /*
 435         * Return any delegations if we're going to change ACLs
 436         */
 437        if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
 438                NFS_PROTO(inode)->return_delegation(inode);
 439        error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
 440        if (error == 0)
 441                nfs_refresh_inode(inode, fattr);
 442        nfs_free_fattr(fattr);
 443out:
 444        return error;
 445}
 446EXPORT_SYMBOL_GPL(nfs_setattr);
 447
 448/**
 449 * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall
 450 * @inode: inode of the file used
 451 * @offset: file offset to start truncating
 452 *
 453 * This is a copy of the common vmtruncate, but with the locking
 454 * corrected to take into account the fact that NFS requires
 455 * inode->i_size to be updated under the inode->i_lock.
 456 */
 457static int nfs_vmtruncate(struct inode * inode, loff_t offset)
 458{
 459        loff_t oldsize;
 460        int err;
 461
 462        err = inode_newsize_ok(inode, offset);
 463        if (err)
 464                goto out;
 465
 466        spin_lock(&inode->i_lock);
 467        oldsize = inode->i_size;
 468        i_size_write(inode, offset);
 469        spin_unlock(&inode->i_lock);
 470
 471        truncate_pagecache(inode, oldsize, offset);
 472out:
 473        return err;
 474}
 475
 476/**
 477 * nfs_setattr_update_inode - Update inode metadata after a setattr call.
 478 * @inode: pointer to struct inode
 479 * @attr: pointer to struct iattr
 480 *
 481 * Note: we do this in the *proc.c in order to ensure that
 482 *       it works for things like exclusive creates too.
 483 */
 484void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr)
 485{
 486        if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
 487                spin_lock(&inode->i_lock);
 488                if ((attr->ia_valid & ATTR_MODE) != 0) {
 489                        int mode = attr->ia_mode & S_IALLUGO;
 490                        mode |= inode->i_mode & ~S_IALLUGO;
 491                        inode->i_mode = mode;
 492                }
 493                if ((attr->ia_valid & ATTR_UID) != 0)
 494                        inode->i_uid = attr->ia_uid;
 495                if ((attr->ia_valid & ATTR_GID) != 0)
 496                        inode->i_gid = attr->ia_gid;
 497                NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
 498                spin_unlock(&inode->i_lock);
 499        }
 500        if ((attr->ia_valid & ATTR_SIZE) != 0) {
 501                nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
 502                nfs_vmtruncate(inode, attr->ia_size);
 503        }
 504}
 505EXPORT_SYMBOL_GPL(nfs_setattr_update_inode);
 506
 507int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 508{
 509        struct inode *inode = dentry->d_inode;
 510        int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
 511        int err;
 512
 513        /* Flush out writes to the server in order to update c/mtime.  */
 514        if (S_ISREG(inode->i_mode)) {
 515                nfs_inode_dio_wait(inode);
 516                err = filemap_write_and_wait(inode->i_mapping);
 517                if (err)
 518                        goto out;
 519        }
 520
 521        /*
 522         * We may force a getattr if the user cares about atime.
 523         *
 524         * Note that we only have to check the vfsmount flags here:
 525         *  - NFS always sets S_NOATIME by so checking it would give a
 526         *    bogus result
 527         *  - NFS never sets MS_NOATIME or MS_NODIRATIME so there is
 528         *    no point in checking those.
 529         */
 530        if ((mnt->mnt_flags & MNT_NOATIME) ||
 531            ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
 532                need_atime = 0;
 533
 534        if (need_atime)
 535                err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
 536        else
 537                err = nfs_revalidate_inode(NFS_SERVER(inode), inode);
 538        if (!err) {
 539                generic_fillattr(inode, stat);
 540                stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
 541        }
 542out:
 543        return err;
 544}
 545EXPORT_SYMBOL_GPL(nfs_getattr);
 546
 547static void nfs_init_lock_context(struct nfs_lock_context *l_ctx)
 548{
 549        atomic_set(&l_ctx->count, 1);
 550        l_ctx->lockowner.l_owner = current->files;
 551        l_ctx->lockowner.l_pid = current->tgid;
 552        INIT_LIST_HEAD(&l_ctx->list);
 553}
 554
 555static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx)
 556{
 557        struct nfs_lock_context *pos;
 558
 559        list_for_each_entry(pos, &ctx->lock_context.list, list) {
 560                if (pos->lockowner.l_owner != current->files)
 561                        continue;
 562                if (pos->lockowner.l_pid != current->tgid)
 563                        continue;
 564                atomic_inc(&pos->count);
 565                return pos;
 566        }
 567        return NULL;
 568}
 569
 570struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
 571{
 572        struct nfs_lock_context *res, *new = NULL;
 573        struct inode *inode = ctx->dentry->d_inode;
 574
 575        spin_lock(&inode->i_lock);
 576        res = __nfs_find_lock_context(ctx);
 577        if (res == NULL) {
 578                spin_unlock(&inode->i_lock);
 579                new = kmalloc(sizeof(*new), GFP_KERNEL);
 580                if (new == NULL)
 581                        return ERR_PTR(-ENOMEM);
 582                nfs_init_lock_context(new);
 583                spin_lock(&inode->i_lock);
 584                res = __nfs_find_lock_context(ctx);
 585                if (res == NULL) {
 586                        list_add_tail(&new->list, &ctx->lock_context.list);
 587                        new->open_context = ctx;
 588                        res = new;
 589                        new = NULL;
 590                }
 591        }
 592        spin_unlock(&inode->i_lock);
 593        kfree(new);
 594        return res;
 595}
 596
 597void nfs_put_lock_context(struct nfs_lock_context *l_ctx)
 598{
 599        struct nfs_open_context *ctx = l_ctx->open_context;
 600        struct inode *inode = ctx->dentry->d_inode;
 601
 602        if (!atomic_dec_and_lock(&l_ctx->count, &inode->i_lock))
 603                return;
 604        list_del(&l_ctx->list);
 605        spin_unlock(&inode->i_lock);
 606        kfree(l_ctx);
 607}
 608
 609/**
 610 * nfs_close_context - Common close_context() routine NFSv2/v3
 611 * @ctx: pointer to context
 612 * @is_sync: is this a synchronous close
 613 *
 614 * always ensure that the attributes are up to date if we're mounted
 615 * with close-to-open semantics
 616 */
 617void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
 618{
 619        struct inode *inode;
 620        struct nfs_server *server;
 621
 622        if (!(ctx->mode & FMODE_WRITE))
 623                return;
 624        if (!is_sync)
 625                return;
 626        inode = ctx->dentry->d_inode;
 627        if (!list_empty(&NFS_I(inode)->open_files))
 628                return;
 629        server = NFS_SERVER(inode);
 630        if (server->flags & NFS_MOUNT_NOCTO)
 631                return;
 632        nfs_revalidate_inode(server, inode);
 633}
 634EXPORT_SYMBOL_GPL(nfs_close_context);
 635
 636struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f_mode)
 637{
 638        struct nfs_open_context *ctx;
 639        struct rpc_cred *cred = rpc_lookup_cred();
 640        if (IS_ERR(cred))
 641                return ERR_CAST(cred);
 642
 643        ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
 644        if (!ctx) {
 645                put_rpccred(cred);
 646                return ERR_PTR(-ENOMEM);
 647        }
 648        nfs_sb_active(dentry->d_sb);
 649        ctx->dentry = dget(dentry);
 650        ctx->cred = cred;
 651        ctx->state = NULL;
 652        ctx->mode = f_mode;
 653        ctx->flags = 0;
 654        ctx->error = 0;
 655        nfs_init_lock_context(&ctx->lock_context);
 656        ctx->lock_context.open_context = ctx;
 657        INIT_LIST_HEAD(&ctx->list);
 658        ctx->mdsthreshold = NULL;
 659        return ctx;
 660}
 661EXPORT_SYMBOL_GPL(alloc_nfs_open_context);
 662
 663struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
 664{
 665        if (ctx != NULL)
 666                atomic_inc(&ctx->lock_context.count);
 667        return ctx;
 668}
 669EXPORT_SYMBOL_GPL(get_nfs_open_context);
 670
 671static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
 672{
 673        struct inode *inode = ctx->dentry->d_inode;
 674        struct super_block *sb = ctx->dentry->d_sb;
 675
 676        if (!list_empty(&ctx->list)) {
 677                if (!atomic_dec_and_lock(&ctx->lock_context.count, &inode->i_lock))
 678                        return;
 679                list_del(&ctx->list);
 680                spin_unlock(&inode->i_lock);
 681        } else if (!atomic_dec_and_test(&ctx->lock_context.count))
 682                return;
 683        if (inode != NULL)
 684                NFS_PROTO(inode)->close_context(ctx, is_sync);
 685        if (ctx->cred != NULL)
 686                put_rpccred(ctx->cred);
 687        dput(ctx->dentry);
 688        if (is_sync)
 689                nfs_sb_deactive(sb);
 690        else
 691                nfs_sb_deactive_async(sb);
 692        kfree(ctx->mdsthreshold);
 693        kfree(ctx);
 694}
 695
 696void put_nfs_open_context(struct nfs_open_context *ctx)
 697{
 698        __put_nfs_open_context(ctx, 0);
 699}
 700EXPORT_SYMBOL_GPL(put_nfs_open_context);
 701
 702/*
 703 * Ensure that mmap has a recent RPC credential for use when writing out
 704 * shared pages
 705 */
 706void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
 707{
 708        struct inode *inode = filp->f_path.dentry->d_inode;
 709        struct nfs_inode *nfsi = NFS_I(inode);
 710
 711        filp->private_data = get_nfs_open_context(ctx);
 712        spin_lock(&inode->i_lock);
 713        list_add(&ctx->list, &nfsi->open_files);
 714        spin_unlock(&inode->i_lock);
 715}
 716EXPORT_SYMBOL_GPL(nfs_file_set_open_context);
 717
 718/*
 719 * Given an inode, search for an open context with the desired characteristics
 720 */
 721struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode)
 722{
 723        struct nfs_inode *nfsi = NFS_I(inode);
 724        struct nfs_open_context *pos, *ctx = NULL;
 725
 726        spin_lock(&inode->i_lock);
 727        list_for_each_entry(pos, &nfsi->open_files, list) {
 728                if (cred != NULL && pos->cred != cred)
 729                        continue;
 730                if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode)
 731                        continue;
 732                ctx = get_nfs_open_context(pos);
 733                break;
 734        }
 735        spin_unlock(&inode->i_lock);
 736        return ctx;
 737}
 738
 739static void nfs_file_clear_open_context(struct file *filp)
 740{
 741        struct inode *inode = filp->f_path.dentry->d_inode;
 742        struct nfs_open_context *ctx = nfs_file_open_context(filp);
 743
 744        if (ctx) {
 745                filp->private_data = NULL;
 746                spin_lock(&inode->i_lock);
 747                list_move_tail(&ctx->list, &NFS_I(inode)->open_files);
 748                spin_unlock(&inode->i_lock);
 749                __put_nfs_open_context(ctx, filp->f_flags & O_DIRECT ? 0 : 1);
 750        }
 751}
 752
 753/*
 754 * These allocate and release file read/write context information.
 755 */
 756int nfs_open(struct inode *inode, struct file *filp)
 757{
 758        struct nfs_open_context *ctx;
 759
 760        ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode);
 761        if (IS_ERR(ctx))
 762                return PTR_ERR(ctx);
 763        nfs_file_set_open_context(filp, ctx);
 764        put_nfs_open_context(ctx);
 765        nfs_fscache_set_inode_cookie(inode, filp);
 766        return 0;
 767}
 768
 769int nfs_release(struct inode *inode, struct file *filp)
 770{
 771        nfs_file_clear_open_context(filp);
 772        return 0;
 773}
 774
 775/*
 776 * This function is called whenever some part of NFS notices that
 777 * the cached attributes have to be refreshed.
 778 */
 779int
 780__nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
 781{
 782        int              status = -ESTALE;
 783        struct nfs_fattr *fattr = NULL;
 784        struct nfs_inode *nfsi = NFS_I(inode);
 785
 786        dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n",
 787                inode->i_sb->s_id, (long long)NFS_FILEID(inode));
 788
 789        if (is_bad_inode(inode))
 790                goto out;
 791        if (NFS_STALE(inode))
 792                goto out;
 793
 794        status = -ENOMEM;
 795        fattr = nfs_alloc_fattr();
 796        if (fattr == NULL)
 797                goto out;
 798
 799        nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
 800        status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr);
 801        if (status != 0) {
 802                dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
 803                         inode->i_sb->s_id,
 804                         (long long)NFS_FILEID(inode), status);
 805                if (status == -ESTALE) {
 806                        nfs_zap_caches(inode);
 807                        if (!S_ISDIR(inode->i_mode))
 808                                set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
 809                }
 810                goto out;
 811        }
 812
 813        status = nfs_refresh_inode(inode, fattr);
 814        if (status) {
 815                dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
 816                         inode->i_sb->s_id,
 817                         (long long)NFS_FILEID(inode), status);
 818                goto out;
 819        }
 820
 821        if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
 822                nfs_zap_acl_cache(inode);
 823
 824        dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n",
 825                inode->i_sb->s_id,
 826                (long long)NFS_FILEID(inode));
 827
 828 out:
 829        nfs_free_fattr(fattr);
 830        return status;
 831}
 832
 833int nfs_attribute_timeout(struct inode *inode)
 834{
 835        struct nfs_inode *nfsi = NFS_I(inode);
 836
 837        return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
 838}
 839
 840static int nfs_attribute_cache_expired(struct inode *inode)
 841{
 842        if (nfs_have_delegated_attributes(inode))
 843                return 0;
 844        return nfs_attribute_timeout(inode);
 845}
 846
 847/**
 848 * nfs_revalidate_inode - Revalidate the inode attributes
 849 * @server - pointer to nfs_server struct
 850 * @inode - pointer to inode struct
 851 *
 852 * Updates inode attribute information by retrieving the data from the server.
 853 */
 854int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
 855{
 856        if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
 857                        && !nfs_attribute_cache_expired(inode))
 858                return NFS_STALE(inode) ? -ESTALE : 0;
 859        return __nfs_revalidate_inode(server, inode);
 860}
 861EXPORT_SYMBOL_GPL(nfs_revalidate_inode);
 862
 863static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
 864{
 865        struct nfs_inode *nfsi = NFS_I(inode);
 866        
 867        if (mapping->nrpages != 0) {
 868                int ret = invalidate_inode_pages2(mapping);
 869                if (ret < 0)
 870                        return ret;
 871        }
 872        spin_lock(&inode->i_lock);
 873        nfsi->cache_validity &= ~NFS_INO_INVALID_DATA;
 874        if (S_ISDIR(inode->i_mode))
 875                memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
 876        spin_unlock(&inode->i_lock);
 877        nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
 878        nfs_fscache_reset_inode_cookie(inode);
 879        dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n",
 880                        inode->i_sb->s_id, (long long)NFS_FILEID(inode));
 881        return 0;
 882}
 883
 884static bool nfs_mapping_need_revalidate_inode(struct inode *inode)
 885{
 886        if (nfs_have_delegated_attributes(inode))
 887                return false;
 888        return (NFS_I(inode)->cache_validity & NFS_INO_REVAL_PAGECACHE)
 889                || nfs_attribute_timeout(inode)
 890                || NFS_STALE(inode);
 891}
 892
 893/**
 894 * nfs_revalidate_mapping - Revalidate the pagecache
 895 * @inode - pointer to host inode
 896 * @mapping - pointer to mapping
 897 */
 898int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
 899{
 900        struct nfs_inode *nfsi = NFS_I(inode);
 901        int ret = 0;
 902
 903        /* swapfiles are not supposed to be shared. */
 904        if (IS_SWAPFILE(inode))
 905                goto out;
 906
 907        if (nfs_mapping_need_revalidate_inode(inode)) {
 908                ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
 909                if (ret < 0)
 910                        goto out;
 911        }
 912        if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
 913                ret = nfs_invalidate_mapping(inode, mapping);
 914out:
 915        return ret;
 916}
 917
 918static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
 919{
 920        struct nfs_inode *nfsi = NFS_I(inode);
 921        unsigned long ret = 0;
 922
 923        if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
 924                        && (fattr->valid & NFS_ATTR_FATTR_CHANGE)
 925                        && inode->i_version == fattr->pre_change_attr) {
 926                inode->i_version = fattr->change_attr;
 927                if (S_ISDIR(inode->i_mode))
 928                        nfsi->cache_validity |= NFS_INO_INVALID_DATA;
 929                ret |= NFS_INO_INVALID_ATTR;
 930        }
 931        /* If we have atomic WCC data, we may update some attributes */
 932        if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME)
 933                        && (fattr->valid & NFS_ATTR_FATTR_CTIME)
 934                        && timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) {
 935                memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
 936                ret |= NFS_INO_INVALID_ATTR;
 937        }
 938
 939        if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
 940                        && (fattr->valid & NFS_ATTR_FATTR_MTIME)
 941                        && timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
 942                memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
 943                if (S_ISDIR(inode->i_mode))
 944                        nfsi->cache_validity |= NFS_INO_INVALID_DATA;
 945                ret |= NFS_INO_INVALID_ATTR;
 946        }
 947        if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE)
 948                        && (fattr->valid & NFS_ATTR_FATTR_SIZE)
 949                        && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)
 950                        && nfsi->npages == 0) {
 951                i_size_write(inode, nfs_size_to_loff_t(fattr->size));
 952                ret |= NFS_INO_INVALID_ATTR;
 953        }
 954        return ret;
 955}
 956
 957/**
 958 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
 959 * @inode - pointer to inode
 960 * @fattr - updated attributes
 961 *
 962 * Verifies the attribute cache. If we have just changed the attributes,
 963 * so that fattr carries weak cache consistency data, then it may
 964 * also update the ctime/mtime/change_attribute.
 965 */
 966static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
 967{
 968        struct nfs_inode *nfsi = NFS_I(inode);
 969        loff_t cur_size, new_isize;
 970        unsigned long invalid = 0;
 971
 972
 973        if (nfs_have_delegated_attributes(inode))
 974                return 0;
 975        /* Has the inode gone and changed behind our back? */
 976        if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
 977                return -EIO;
 978        if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
 979                return -EIO;
 980
 981        if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
 982                        inode->i_version != fattr->change_attr)
 983                invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
 984
 985        /* Verify a few of the more important attributes */
 986        if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec_equal(&inode->i_mtime, &fattr->mtime))
 987                invalid |= NFS_INO_INVALID_ATTR;
 988
 989        if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
 990                cur_size = i_size_read(inode);
 991                new_isize = nfs_size_to_loff_t(fattr->size);
 992                if (cur_size != new_isize && nfsi->npages == 0)
 993                        invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
 994        }
 995
 996        /* Have any file permissions changed? */
 997        if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO))
 998                invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
 999        if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && inode->i_uid != fattr->uid)
1000                invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
1001        if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && inode->i_gid != fattr->gid)
1002                invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
1003
1004        /* Has the link count changed? */
1005        if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)
1006                invalid |= NFS_INO_INVALID_ATTR;
1007
1008        if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime))
1009                invalid |= NFS_INO_INVALID_ATIME;
1010
1011        if (invalid != 0)
1012                nfsi->cache_validity |= invalid;
1013
1014        nfsi->read_cache_jiffies = fattr->time_start;
1015        return 0;
1016}
1017
1018static int nfs_ctime_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
1019{
1020        if (!(fattr->valid & NFS_ATTR_FATTR_CTIME))
1021                return 0;
1022        return timespec_compare(&fattr->ctime, &inode->i_ctime) > 0;
1023}
1024
1025static int nfs_size_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
1026{
1027        if (!(fattr->valid & NFS_ATTR_FATTR_SIZE))
1028                return 0;
1029        return nfs_size_to_loff_t(fattr->size) > i_size_read(inode);
1030}
1031
1032static atomic_long_t nfs_attr_generation_counter;
1033
1034static unsigned long nfs_read_attr_generation_counter(void)
1035{
1036        return atomic_long_read(&nfs_attr_generation_counter);
1037}
1038
1039unsigned long nfs_inc_attr_generation_counter(void)
1040{
1041        return atomic_long_inc_return(&nfs_attr_generation_counter);
1042}
1043
1044void nfs_fattr_init(struct nfs_fattr *fattr)
1045{
1046        fattr->valid = 0;
1047        fattr->time_start = jiffies;
1048        fattr->gencount = nfs_inc_attr_generation_counter();
1049        fattr->owner_name = NULL;
1050        fattr->group_name = NULL;
1051}
1052EXPORT_SYMBOL_GPL(nfs_fattr_init);
1053
1054struct nfs_fattr *nfs_alloc_fattr(void)
1055{
1056        struct nfs_fattr *fattr;
1057
1058        fattr = kmalloc(sizeof(*fattr), GFP_NOFS);
1059        if (fattr != NULL)
1060                nfs_fattr_init(fattr);
1061        return fattr;
1062}
1063EXPORT_SYMBOL_GPL(nfs_alloc_fattr);
1064
1065struct nfs_fh *nfs_alloc_fhandle(void)
1066{
1067        struct nfs_fh *fh;
1068
1069        fh = kmalloc(sizeof(struct nfs_fh), GFP_NOFS);
1070        if (fh != NULL)
1071                fh->size = 0;
1072        return fh;
1073}
1074EXPORT_SYMBOL_GPL(nfs_alloc_fhandle);
1075
1076#ifdef NFS_DEBUG
1077/*
1078 * _nfs_display_fhandle_hash - calculate the crc32 hash for the filehandle
1079 *                             in the same way that wireshark does
1080 *
1081 * @fh: file handle
1082 *
1083 * For debugging only.
1084 */
1085u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh)
1086{
1087        /* wireshark uses 32-bit AUTODIN crc and does a bitwise
1088         * not on the result */
1089        return ~crc32(0xFFFFFFFF, &fh->data[0], fh->size);
1090}
1091
1092/*
1093 * _nfs_display_fhandle - display an NFS file handle on the console
1094 *
1095 * @fh: file handle to display
1096 * @caption: display caption
1097 *
1098 * For debugging only.
1099 */
1100void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption)
1101{
1102        unsigned short i;
1103
1104        if (fh == NULL || fh->size == 0) {
1105                printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh);
1106                return;
1107        }
1108
1109        printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n",
1110               caption, fh, fh->size, _nfs_display_fhandle_hash(fh));
1111        for (i = 0; i < fh->size; i += 16) {
1112                __be32 *pos = (__be32 *)&fh->data[i];
1113
1114                switch ((fh->size - i - 1) >> 2) {
1115                case 0:
1116                        printk(KERN_DEFAULT " %08x\n",
1117                                be32_to_cpup(pos));
1118                        break;
1119                case 1:
1120                        printk(KERN_DEFAULT " %08x %08x\n",
1121                                be32_to_cpup(pos), be32_to_cpup(pos + 1));
1122                        break;
1123                case 2:
1124                        printk(KERN_DEFAULT " %08x %08x %08x\n",
1125                                be32_to_cpup(pos), be32_to_cpup(pos + 1),
1126                                be32_to_cpup(pos + 2));
1127                        break;
1128                default:
1129                        printk(KERN_DEFAULT " %08x %08x %08x %08x\n",
1130                                be32_to_cpup(pos), be32_to_cpup(pos + 1),
1131                                be32_to_cpup(pos + 2), be32_to_cpup(pos + 3));
1132                }
1133        }
1134}
1135#endif
1136
1137/**
1138 * nfs_inode_attrs_need_update - check if the inode attributes need updating
1139 * @inode - pointer to inode
1140 * @fattr - attributes
1141 *
1142 * Attempt to divine whether or not an RPC call reply carrying stale
1143 * attributes got scheduled after another call carrying updated ones.
1144 *
1145 * To do so, the function first assumes that a more recent ctime means
1146 * that the attributes in fattr are newer, however it also attempt to
1147 * catch the case where ctime either didn't change, or went backwards
1148 * (if someone reset the clock on the server) by looking at whether
1149 * or not this RPC call was started after the inode was last updated.
1150 * Note also the check for wraparound of 'attr_gencount'
1151 *
1152 * The function returns 'true' if it thinks the attributes in 'fattr' are
1153 * more recent than the ones cached in the inode.
1154 *
1155 */
1156static int nfs_inode_attrs_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
1157{
1158        const struct nfs_inode *nfsi = NFS_I(inode);
1159
1160        return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 ||
1161                nfs_ctime_need_update(inode, fattr) ||
1162                nfs_size_need_update(inode, fattr) ||
1163                ((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);
1164}
1165
1166static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
1167{
1168        if (nfs_inode_attrs_need_update(inode, fattr))
1169                return nfs_update_inode(inode, fattr);
1170        return nfs_check_inode_attributes(inode, fattr);
1171}
1172
1173/**
1174 * nfs_refresh_inode - try to update the inode attribute cache
1175 * @inode - pointer to inode
1176 * @fattr - updated attributes
1177 *
1178 * Check that an RPC call that returned attributes has not overlapped with
1179 * other recent updates of the inode metadata, then decide whether it is
1180 * safe to do a full update of the inode attributes, or whether just to
1181 * call nfs_check_inode_attributes.
1182 */
1183int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
1184{
1185        int status;
1186
1187        if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1188                return 0;
1189        spin_lock(&inode->i_lock);
1190        status = nfs_refresh_inode_locked(inode, fattr);
1191        spin_unlock(&inode->i_lock);
1192
1193        return status;
1194}
1195EXPORT_SYMBOL_GPL(nfs_refresh_inode);
1196
1197static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
1198{
1199        struct nfs_inode *nfsi = NFS_I(inode);
1200
1201        nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
1202        if (S_ISDIR(inode->i_mode))
1203                nfsi->cache_validity |= NFS_INO_INVALID_DATA;
1204        if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1205                return 0;
1206        return nfs_refresh_inode_locked(inode, fattr);
1207}
1208
1209/**
1210 * nfs_post_op_update_inode - try to update the inode attribute cache
1211 * @inode - pointer to inode
1212 * @fattr - updated attributes
1213 *
1214 * After an operation that has changed the inode metadata, mark the
1215 * attribute cache as being invalid, then try to update it.
1216 *
1217 * NB: if the server didn't return any post op attributes, this
1218 * function will force the retrieval of attributes before the next
1219 * NFS request.  Thus it should be used only for operations that
1220 * are expected to change one or more attributes, to avoid
1221 * unnecessary NFS requests and trips through nfs_update_inode().
1222 */
1223int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1224{
1225        int status;
1226
1227        spin_lock(&inode->i_lock);
1228        status = nfs_post_op_update_inode_locked(inode, fattr);
1229        spin_unlock(&inode->i_lock);
1230        return status;
1231}
1232EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
1233
1234/**
1235 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
1236 * @inode - pointer to inode
1237 * @fattr - updated attributes
1238 *
1239 * After an operation that has changed the inode metadata, mark the
1240 * attribute cache as being invalid, then try to update it. Fake up
1241 * weak cache consistency data, if none exist.
1242 *
1243 * This function is mainly designed to be used by the ->write_done() functions.
1244 */
1245int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
1246{
1247        int status;
1248
1249        spin_lock(&inode->i_lock);
1250        /* Don't do a WCC update if these attributes are already stale */
1251        if ((fattr->valid & NFS_ATTR_FATTR) == 0 ||
1252                        !nfs_inode_attrs_need_update(inode, fattr)) {
1253                fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
1254                                | NFS_ATTR_FATTR_PRESIZE
1255                                | NFS_ATTR_FATTR_PREMTIME
1256                                | NFS_ATTR_FATTR_PRECTIME);
1257                goto out_noforce;
1258        }
1259        if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
1260                        (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
1261                fattr->pre_change_attr = inode->i_version;
1262                fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
1263        }
1264        if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
1265                        (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
1266                memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime));
1267                fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
1268        }
1269        if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
1270                        (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
1271                memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime));
1272                fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
1273        }
1274        if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
1275                        (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
1276                fattr->pre_size = i_size_read(inode);
1277                fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
1278        }
1279out_noforce:
1280        status = nfs_post_op_update_inode_locked(inode, fattr);
1281        spin_unlock(&inode->i_lock);
1282        return status;
1283}
1284EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc);
1285
1286/*
1287 * Many nfs protocol calls return the new file attributes after
1288 * an operation.  Here we update the inode to reflect the state
1289 * of the server's inode.
1290 *
1291 * This is a bit tricky because we have to make sure all dirty pages
1292 * have been sent off to the server before calling invalidate_inode_pages.
1293 * To make sure no other process adds more write requests while we try
1294 * our best to flush them, we make them sleep during the attribute refresh.
1295 *
1296 * A very similar scenario holds for the dir cache.
1297 */
1298static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1299{
1300        struct nfs_server *server;
1301        struct nfs_inode *nfsi = NFS_I(inode);
1302        loff_t cur_isize, new_isize;
1303        unsigned long invalid = 0;
1304        unsigned long now = jiffies;
1305        unsigned long save_cache_validity;
1306
1307        dfprintk(VFS, "NFS: %s(%s/%ld fh_crc=0x%08x ct=%d info=0x%x)\n",
1308                        __func__, inode->i_sb->s_id, inode->i_ino,
1309                        nfs_display_fhandle_hash(NFS_FH(inode)),
1310                        atomic_read(&inode->i_count), fattr->valid);
1311
1312        if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid) {
1313                printk(KERN_ERR "NFS: server %s error: fileid changed\n"
1314                        "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
1315                        NFS_SERVER(inode)->nfs_client->cl_hostname,
1316                        inode->i_sb->s_id, (long long)nfsi->fileid,
1317                        (long long)fattr->fileid);
1318                goto out_err;
1319        }
1320
1321        /*
1322         * Make sure the inode's type hasn't changed.
1323         */
1324        if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) {
1325                /*
1326                * Big trouble! The inode has become a different object.
1327                */
1328                printk(KERN_DEBUG "NFS: %s: inode %ld mode changed, %07o to %07o\n",
1329                                __func__, inode->i_ino, inode->i_mode, fattr->mode);
1330                goto out_err;
1331        }
1332
1333        server = NFS_SERVER(inode);
1334        /* Update the fsid? */
1335        if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
1336                        !nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
1337                        !IS_AUTOMOUNT(inode))
1338                server->fsid = fattr->fsid;
1339
1340        /*
1341         * Update the read time so we don't revalidate too often.
1342         */
1343        nfsi->read_cache_jiffies = fattr->time_start;
1344
1345        save_cache_validity = nfsi->cache_validity;
1346        nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
1347                        | NFS_INO_INVALID_ATIME
1348                        | NFS_INO_REVAL_FORCED
1349                        | NFS_INO_REVAL_PAGECACHE);
1350
1351        /* Do atomic weak cache consistency updates */
1352        invalid |= nfs_wcc_update_inode(inode, fattr);
1353
1354        /* More cache consistency checks */
1355        if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
1356                if (inode->i_version != fattr->change_attr) {
1357                        dprintk("NFS: change_attr change on server for file %s/%ld\n",
1358                                        inode->i_sb->s_id, inode->i_ino);
1359                        invalid |= NFS_INO_INVALID_ATTR
1360                                | NFS_INO_INVALID_DATA
1361                                | NFS_INO_INVALID_ACCESS
1362                                | NFS_INO_INVALID_ACL
1363                                | NFS_INO_REVAL_PAGECACHE;
1364                        if (S_ISDIR(inode->i_mode))
1365                                nfs_force_lookup_revalidate(inode);
1366                        inode->i_version = fattr->change_attr;
1367                }
1368        } else if (server->caps & NFS_CAP_CHANGE_ATTR)
1369                invalid |= save_cache_validity;
1370
1371        if (fattr->valid & NFS_ATTR_FATTR_MTIME) {
1372                memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
1373        } else if (server->caps & NFS_CAP_MTIME)
1374                invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1375                                | NFS_INO_REVAL_FORCED);
1376
1377        if (fattr->valid & NFS_ATTR_FATTR_CTIME) {
1378                memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
1379        } else if (server->caps & NFS_CAP_CTIME)
1380                invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1381                                | NFS_INO_REVAL_FORCED);
1382
1383        /* Check if our cached file size is stale */
1384        if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
1385                new_isize = nfs_size_to_loff_t(fattr->size);
1386                cur_isize = i_size_read(inode);
1387                if (new_isize != cur_isize) {
1388                        /* Do we perhaps have any outstanding writes, or has
1389                         * the file grown beyond our last write? */
1390                        if ((nfsi->npages == 0 && !test_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) ||
1391                             new_isize > cur_isize) {
1392                                i_size_write(inode, new_isize);
1393                                invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
1394                        }
1395                        dprintk("NFS: isize change on server for file %s/%ld "
1396                                        "(%Ld to %Ld)\n",
1397                                        inode->i_sb->s_id,
1398                                        inode->i_ino,
1399                                        (long long)cur_isize,
1400                                        (long long)new_isize);
1401                }
1402        } else
1403                invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1404                                | NFS_INO_REVAL_PAGECACHE
1405                                | NFS_INO_REVAL_FORCED);
1406
1407
1408        if (fattr->valid & NFS_ATTR_FATTR_ATIME)
1409                memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
1410        else if (server->caps & NFS_CAP_ATIME)
1411                invalid |= save_cache_validity & (NFS_INO_INVALID_ATIME
1412                                | NFS_INO_REVAL_FORCED);
1413
1414        if (fattr->valid & NFS_ATTR_FATTR_MODE) {
1415                if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
1416                        umode_t newmode = inode->i_mode & S_IFMT;
1417                        newmode |= fattr->mode & S_IALLUGO;
1418                        inode->i_mode = newmode;
1419                        invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1420                }
1421        } else if (server->caps & NFS_CAP_MODE)
1422                invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1423                                | NFS_INO_INVALID_ACCESS
1424                                | NFS_INO_INVALID_ACL
1425                                | NFS_INO_REVAL_FORCED);
1426
1427        if (fattr->valid & NFS_ATTR_FATTR_OWNER) {
1428                if (inode->i_uid != fattr->uid) {
1429                        invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1430                        inode->i_uid = fattr->uid;
1431                }
1432        } else if (server->caps & NFS_CAP_OWNER)
1433                invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1434                                | NFS_INO_INVALID_ACCESS
1435                                | NFS_INO_INVALID_ACL
1436                                | NFS_INO_REVAL_FORCED);
1437
1438        if (fattr->valid & NFS_ATTR_FATTR_GROUP) {
1439                if (inode->i_gid != fattr->gid) {
1440                        invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1441                        inode->i_gid = fattr->gid;
1442                }
1443        } else if (server->caps & NFS_CAP_OWNER_GROUP)
1444                invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1445                                | NFS_INO_INVALID_ACCESS
1446                                | NFS_INO_INVALID_ACL
1447                                | NFS_INO_REVAL_FORCED);
1448
1449        if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
1450                if (inode->i_nlink != fattr->nlink) {
1451                        invalid |= NFS_INO_INVALID_ATTR;
1452                        if (S_ISDIR(inode->i_mode))
1453                                invalid |= NFS_INO_INVALID_DATA;
1454                        set_nlink(inode, fattr->nlink);
1455                }
1456        } else if (server->caps & NFS_CAP_NLINK)
1457                invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1458                                | NFS_INO_REVAL_FORCED);
1459
1460        if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
1461                /*
1462                 * report the blocks in 512byte units
1463                 */
1464                inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
1465        }
1466        if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
1467                inode->i_blocks = fattr->du.nfs2.blocks;
1468
1469        /* Update attrtimeo value if we're out of the unstable period */
1470        if (invalid & NFS_INO_INVALID_ATTR) {
1471                nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
1472                nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
1473                nfsi->attrtimeo_timestamp = now;
1474                nfsi->attr_gencount = nfs_inc_attr_generation_counter();
1475        } else {
1476                if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
1477                        if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
1478                                nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
1479                        nfsi->attrtimeo_timestamp = now;
1480                }
1481        }
1482        invalid &= ~NFS_INO_INVALID_ATTR;
1483        /* Don't invalidate the data if we were to blame */
1484        if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
1485                                || S_ISLNK(inode->i_mode)))
1486                invalid &= ~NFS_INO_INVALID_DATA;
1487        if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ) ||
1488                        (save_cache_validity & NFS_INO_REVAL_FORCED))
1489                nfsi->cache_validity |= invalid;
1490
1491        return 0;
1492 out_err:
1493        /*
1494         * No need to worry about unhashing the dentry, as the
1495         * lookup validation will know that the inode is bad.
1496         * (But we fall through to invalidate the caches.)
1497         */
1498        nfs_invalidate_inode(inode);
1499        return -ESTALE;
1500}
1501
1502struct inode *nfs_alloc_inode(struct super_block *sb)
1503{
1504        struct nfs_inode *nfsi;
1505        nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
1506        if (!nfsi)
1507                return NULL;
1508        nfsi->flags = 0UL;
1509        nfsi->cache_validity = 0UL;
1510#ifdef CONFIG_NFS_V3_ACL
1511        nfsi->acl_access = ERR_PTR(-EAGAIN);
1512        nfsi->acl_default = ERR_PTR(-EAGAIN);
1513#endif
1514#if IS_ENABLED(CONFIG_NFS_V4)
1515        nfsi->nfs4_acl = NULL;
1516#endif /* CONFIG_NFS_V4 */
1517        return &nfsi->vfs_inode;
1518}
1519EXPORT_SYMBOL_GPL(nfs_alloc_inode);
1520
1521static void nfs_i_callback(struct rcu_head *head)
1522{
1523        struct inode *inode = container_of(head, struct inode, i_rcu);
1524        kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
1525}
1526
1527void nfs_destroy_inode(struct inode *inode)
1528{
1529        call_rcu(&inode->i_rcu, nfs_i_callback);
1530}
1531EXPORT_SYMBOL_GPL(nfs_destroy_inode);
1532
1533static inline void nfs4_init_once(struct nfs_inode *nfsi)
1534{
1535#if IS_ENABLED(CONFIG_NFS_V4)
1536        INIT_LIST_HEAD(&nfsi->open_states);
1537        nfsi->delegation = NULL;
1538        nfsi->delegation_state = 0;
1539        init_rwsem(&nfsi->rwsem);
1540        nfsi->layout = NULL;
1541#endif
1542}
1543
1544static void init_once(void *foo)
1545{
1546        struct nfs_inode *nfsi = (struct nfs_inode *) foo;
1547
1548        inode_init_once(&nfsi->vfs_inode);
1549        INIT_LIST_HEAD(&nfsi->open_files);
1550        INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
1551        INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
1552        INIT_LIST_HEAD(&nfsi->commit_info.list);
1553        nfsi->npages = 0;
1554        nfsi->commit_info.ncommit = 0;
1555        atomic_set(&nfsi->commit_info.rpcs_out, 0);
1556        atomic_set(&nfsi->silly_count, 1);
1557        INIT_HLIST_HEAD(&nfsi->silly_list);
1558        init_waitqueue_head(&nfsi->waitqueue);
1559        nfs4_init_once(nfsi);
1560}
1561
1562static int __init nfs_init_inodecache(void)
1563{
1564        nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
1565                                             sizeof(struct nfs_inode),
1566                                             0, (SLAB_RECLAIM_ACCOUNT|
1567                                                SLAB_MEM_SPREAD),
1568                                             init_once);
1569        if (nfs_inode_cachep == NULL)
1570                return -ENOMEM;
1571
1572        return 0;
1573}
1574
1575static void nfs_destroy_inodecache(void)
1576{
1577        /*
1578         * Make sure all delayed rcu free inodes are flushed before we
1579         * destroy cache.
1580         */
1581        rcu_barrier();
1582        kmem_cache_destroy(nfs_inode_cachep);
1583}
1584
1585struct workqueue_struct *nfsiod_workqueue;
1586EXPORT_SYMBOL_GPL(nfsiod_workqueue);
1587
1588/*
1589 * start up the nfsiod workqueue
1590 */
1591static int nfsiod_start(void)
1592{
1593        struct workqueue_struct *wq;
1594        dprintk("RPC:       creating workqueue nfsiod\n");
1595        wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM, 0);
1596        if (wq == NULL)
1597                return -ENOMEM;
1598        nfsiod_workqueue = wq;
1599        return 0;
1600}
1601
1602/*
1603 * Destroy the nfsiod workqueue
1604 */
1605static void nfsiod_stop(void)
1606{
1607        struct workqueue_struct *wq;
1608
1609        wq = nfsiod_workqueue;
1610        if (wq == NULL)
1611                return;
1612        nfsiod_workqueue = NULL;
1613        destroy_workqueue(wq);
1614}
1615
1616int nfs_net_id;
1617EXPORT_SYMBOL_GPL(nfs_net_id);
1618
1619static int nfs_net_init(struct net *net)
1620{
1621        nfs_clients_init(net);
1622        return nfs_dns_resolver_cache_init(net);
1623}
1624
1625static void nfs_net_exit(struct net *net)
1626{
1627        nfs_dns_resolver_cache_destroy(net);
1628        nfs_cleanup_cb_ident_idr(net);
1629}
1630
1631static struct pernet_operations nfs_net_ops = {
1632        .init = nfs_net_init,
1633        .exit = nfs_net_exit,
1634        .id   = &nfs_net_id,
1635        .size = sizeof(struct nfs_net),
1636};
1637
1638/*
1639 * Initialize NFS
1640 */
1641static int __init init_nfs_fs(void)
1642{
1643        int err;
1644
1645        err = nfs_dns_resolver_init();
1646        if (err < 0)
1647                goto out10;;
1648
1649        err = register_pernet_subsys(&nfs_net_ops);
1650        if (err < 0)
1651                goto out9;
1652
1653        err = nfs_fscache_register();
1654        if (err < 0)
1655                goto out8;
1656
1657        err = nfsiod_start();
1658        if (err)
1659                goto out7;
1660
1661        err = nfs_fs_proc_init();
1662        if (err)
1663                goto out6;
1664
1665        err = nfs_init_nfspagecache();
1666        if (err)
1667                goto out5;
1668
1669        err = nfs_init_inodecache();
1670        if (err)
1671                goto out4;
1672
1673        err = nfs_init_readpagecache();
1674        if (err)
1675                goto out3;
1676
1677        err = nfs_init_writepagecache();
1678        if (err)
1679                goto out2;
1680
1681        err = nfs_init_directcache();
1682        if (err)
1683                goto out1;
1684
1685#ifdef CONFIG_PROC_FS
1686        rpc_proc_register(&init_net, &nfs_rpcstat);
1687#endif
1688        if ((err = register_nfs_fs()) != 0)
1689                goto out0;
1690
1691        return 0;
1692out0:
1693#ifdef CONFIG_PROC_FS
1694        rpc_proc_unregister(&init_net, "nfs");
1695#endif
1696        nfs_destroy_directcache();
1697out1:
1698        nfs_destroy_writepagecache();
1699out2:
1700        nfs_destroy_readpagecache();
1701out3:
1702        nfs_destroy_inodecache();
1703out4:
1704        nfs_destroy_nfspagecache();
1705out5:
1706        nfs_fs_proc_exit();
1707out6:
1708        nfsiod_stop();
1709out7:
1710        nfs_fscache_unregister();
1711out8:
1712        unregister_pernet_subsys(&nfs_net_ops);
1713out9:
1714        nfs_dns_resolver_destroy();
1715out10:
1716        return err;
1717}
1718
1719static void __exit exit_nfs_fs(void)
1720{
1721        nfs_destroy_directcache();
1722        nfs_destroy_writepagecache();
1723        nfs_destroy_readpagecache();
1724        nfs_destroy_inodecache();
1725        nfs_destroy_nfspagecache();
1726        nfs_fscache_unregister();
1727        unregister_pernet_subsys(&nfs_net_ops);
1728        nfs_dns_resolver_destroy();
1729#ifdef CONFIG_PROC_FS
1730        rpc_proc_unregister(&init_net, "nfs");
1731#endif
1732        unregister_nfs_fs();
1733        nfs_fs_proc_exit();
1734        nfsiod_stop();
1735}
1736
1737/* Not quite true; I just maintain it */
1738MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
1739MODULE_LICENSE("GPL");
1740module_param(enable_ino64, bool, 0644);
1741
1742module_init(init_nfs_fs)
1743module_exit(exit_nfs_fs)
1744
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.